Claude
f9111c06a7
CI / lint (push) Successful in 3s
CI / extension-version (push) Successful in 4s
CI / frontend-build (push) Successful in 21s
extension / lint (push) Successful in 19s
CI / backend-lint-and-test (push) Successful in 43s
CI / integration (push) Successful in 3m53s
extension/ had no test harness at all -- web-ext lint was the only signal, so
the URL-normalization fix in 8214afe shipped with nothing exercising it.
Adds vitest (mirroring frontend/vitest.config.js) and three specs:
- url.spec.js normalizeApiUrl / webRootFromApiUrl, including the #2393
regression: instance-root input must reach /api/credentials,
idempotence, trailing-slash and whitespace handling, and
that empty input never yields a bare "/api" (which
isConfigured() would read as configured).
- platforms.spec.js getPlatformFromUrl / isArtistPage, pinning the #1485
regression -- all three Patreon creator URL shapes
(bare, /c/, /cw/) plus inner pages, with nav pages
excluded -- and table-integrity checks.
- version.spec.js manifest.json and package.json versions in lockstep,
AMO-safe version format, and url.js ordered before api.js
in background.scripts (classic scripts share one scope, so
a reorder is a runtime ReferenceError with no build signal).
Specs load lib/*.js by evaluating the real file as a classic script
(test/helpers/loadLib.js) instead of adding module.exports shims to production
code that would never run in the browser. The suite therefore exercises exactly
the bytes packaged into the XPI.
Two packaging consequences, both handled:
- web-ext would otherwise bundle test/ and vitest.config.js INTO the XPI;
both are now in --ignore-files across all four web-ext scripts.
- ci.yml's extension-version guard must ignore the same paths, or editing a
spec would demand a pointless version bump. The dangerous drift direction is
the opposite one -- a guard exclusion for a file that DOES ship would let a
real change pass unnoticed -- so version.spec.js asserts every :(exclude) in
ci.yml appears in --ignore-files.
extension.yml also triggers on ci.yml now, since version.spec.js reads it.
Refs #2393, #2397
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
72 lines
3.5 KiB
JavaScript
72 lines
3.5 KiB
JavaScript
import { describe, it, expect } from 'vitest'
|
|
import { readFileSync } from 'node:fs'
|
|
import { fileURLToPath } from 'node:url'
|
|
import path from 'node:path'
|
|
|
|
const EXT_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), '..')
|
|
const read = (name) => JSON.parse(readFileSync(path.join(EXT_DIR, name), 'utf8'))
|
|
|
|
describe('extension version consistency', () => {
|
|
// Duplicates check (1) of ci.yml's extension-version job, deliberately.
|
|
// That job is the gate that can't be bypassed; this spec is the one that
|
|
// fails in a second on the developer's own CI lane with a readable diff.
|
|
// The two version strings feed different systems and nothing else reconciles
|
|
// them:
|
|
// manifest.json -> what `web-ext sign` signs, so what Firefox installs
|
|
// (package.json is in --ignore-files, not in the XPI)
|
|
// package.json -> build.yml's AMO cache key, the ext-<version> release
|
|
// tag, the XPI filename, and therefore the version
|
|
// /api/extension/manifest reports to the update prompt
|
|
it('keeps manifest.json and package.json in lockstep', () => {
|
|
const manifest = read('manifest.json')
|
|
const pkg = read('package.json')
|
|
expect(manifest.version).toBe(pkg.version)
|
|
})
|
|
|
|
it('uses a plain dotted numeric version AMO will accept', () => {
|
|
// AMO rejects exotic version strings, and build.yml embeds this value in a
|
|
// release tag and a filename — so anything needing escaping breaks the
|
|
// publish path rather than the extension.
|
|
expect(read('package.json').version).toMatch(/^\d+(\.\d+)*$/)
|
|
})
|
|
|
|
it('declares manifest v3', () => {
|
|
expect(read('manifest.json').manifest_version).toBe(3)
|
|
})
|
|
|
|
it('never lets the CI guard ignore a file that actually ships', () => {
|
|
// ci.yml's extension-version job skips its bump check for paths it deems
|
|
// non-shipping. If it excludes something web-ext DOES package, a real
|
|
// change to shipped code passes the guard unnoticed — precisely the
|
|
// silent-stale-ship the guard exists to stop. The reverse drift (guard
|
|
// stricter than web-ext) only costs a needless bump, so it isn't asserted.
|
|
const ci = readFileSync(path.join(EXT_DIR, '..', '.forgejo', 'workflows', 'ci.yml'), 'utf8')
|
|
const lint = read('package.json').scripts.lint
|
|
const after = lint.split('--ignore-files')[1] ?? ''
|
|
const ignored = new Set(
|
|
after
|
|
.split(/\s+/)
|
|
.filter((tok) => tok && !tok.startsWith('--'))
|
|
.map((tok) => tok.replace(/^["']|["']$/g, ''))
|
|
)
|
|
expect(ignored.size, 'parsed --ignore-files from the lint script').toBeGreaterThan(0)
|
|
|
|
const guarded = [...ci.matchAll(/:\(exclude\)extension\/(\S+?)'/g)].map((m) => m[1])
|
|
expect(guarded.length, 'parsed :(exclude) entries from ci.yml').toBeGreaterThan(0)
|
|
for (const entry of guarded) {
|
|
expect(ignored, `ci.yml excludes "${entry}" but web-ext packages it`).toContain(entry)
|
|
}
|
|
})
|
|
|
|
it('lists every background script that exists, in dependency order', () => {
|
|
// url.js must load BEFORE api.js: api.js calls normalizeApiUrl at
|
|
// init()-time, and these are classic scripts sharing one scope, so a
|
|
// reordering here is a runtime ReferenceError with no build-time signal.
|
|
const scripts = read('manifest.json').background.scripts
|
|
for (const rel of scripts) {
|
|
expect(() => readFileSync(path.join(EXT_DIR, rel)), `missing ${rel}`).not.toThrow()
|
|
}
|
|
expect(scripts.indexOf('lib/url.js')).toBeLessThan(scripts.indexOf('lib/api.js'))
|
|
})
|
|
})
|