diff --git a/.github/workflows/ci-router-provider-drift.yaml b/.github/workflows/ci-router-provider-drift.yaml new file mode 100644 index 00000000000..aeda9fb08c2 --- /dev/null +++ b/.github/workflows/ci-router-provider-drift.yaml @@ -0,0 +1,101 @@ +# Published Router schemas and docs are external state, so this alarm runs on a +# schedule instead of gating unrelated pull requests. +name: 'Router Provider Drift' + +on: + schedule: + - cron: '37 13 * * *' + workflow_dispatch: + +permissions: + contents: read + issues: write + +env: + ISSUE_LABEL: 'area:testing' + ISSUE_MARKER: '' + ISSUE_TITLE: 'Router provider coverage has drifted from published sources' + +concurrency: + group: ${{ github.workflow }} + cancel-in-progress: true + +jobs: + drift-check: + if: github.repository == 'Comfy-Org/ComfyUI_frontend' + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@v7 + with: + persist-credentials: false + - uses: ./.github/actions/setup-frontend + - name: Compare checked-in coverage with published sources + id: drift + run: pnpm --filter @comfyorg/website check:router-provider-drift + - name: File or update the drift issue + if: failure() && steps.drift.outcome == 'failure' + uses: actions/github-script@v9 + with: + github-token: ${{ github.token }} + script: | + const title = process.env.ISSUE_TITLE + const marker = process.env.ISSUE_MARKER + const runUrl = `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}` + const body = `${marker}\nThe scheduled [Router Provider Drift](${runUrl}) check failed. The checked-in Router provider coverage may no longer match the published documentation or schemas, or a published source may be unavailable. See the run for the exact failure. This issue is maintained by \`.github/workflows/ci-router-provider-drift.yaml\` and closes itself after a passing run.` + const openIssues = await github.paginate(github.rest.issues.listForRepo, { + owner: context.repo.owner, + repo: context.repo.repo, + state: 'open', + labels: process.env.ISSUE_LABEL, + per_page: 100 + }) + const existing = openIssues.find((issue) => + !issue.pull_request && (issue.body ?? '').includes(marker) + ) + if (existing) { + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: existing.number, + body + }) + } else { + await github.rest.issues.create({ + owner: context.repo.owner, + repo: context.repo.repo, + title, + body, + labels: [process.env.ISSUE_LABEL] + }) + } + - name: Close the drift issue after recovery + if: success() + uses: actions/github-script@v9 + with: + github-token: ${{ github.token }} + script: | + const marker = process.env.ISSUE_MARKER + const openIssues = await github.paginate(github.rest.issues.listForRepo, { + owner: context.repo.owner, + repo: context.repo.repo, + state: 'open', + labels: process.env.ISSUE_LABEL, + per_page: 100 + }) + const existing = openIssues.find((issue) => + !issue.pull_request && (issue.body ?? '').includes(marker) + ) + if (!existing) return + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: existing.number, + body: 'Router provider coverage matches the published sources again. Closing.' + }) + await github.rest.issues.update({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: existing.number, + state: 'closed' + }) diff --git a/apps/website/README.md b/apps/website/README.md index 0f7082af6ca..ad40104109a 100644 --- a/apps/website/README.md +++ b/apps/website/README.md @@ -508,6 +508,7 @@ the hosted script once, and renders the documented embed container. - `pnpm build:e2e` — indexable build to `dist/`, the one e2e and screenshots run against - `pnpm typecheck` — `astro check` - `pnpm test:unit` — Vitest unit tests +- `pnpm check:router-provider-drift` — compare Router coverage with published sources (requires network access) - `pnpm test:e2e` — Playwright E2E tests (requires `pnpm build:e2e` first) - `pnpm ashby:refresh-snapshot` — refresh the committed careers snapshot - `pnpm cloud-nodes:refresh-snapshot` — refresh the committed cloud nodes snapshot diff --git a/apps/website/package.json b/apps/website/package.json index aefb63b92cd..35f67f9bc7c 100644 --- a/apps/website/package.json +++ b/apps/website/package.json @@ -15,6 +15,7 @@ "typecheck": "astro check && tsx ../../scripts/vue-tsc-native.ts --noEmit -p tsconfig.json", "test:unit": "vitest run", "test:router-models": "tsx ./scripts/test-router-models.ts", + "check:router-provider-drift": "tsx ./scripts/router-provider-drift.ts", "test:router-validation": "vitest run scripts/router-model-validation.test.ts src/config/workshop-input-validation.test.ts src/config/workshop-media-validation.test.ts src/config/workshop-media-metadata.test.ts", "test:workflow-pages": "tsx ./scripts/test-workflow-pages.ts", "test:workshop-upload": "tsx ./scripts/test-workshop-upload.ts", diff --git a/apps/website/scripts/README.md b/apps/website/scripts/README.md index 87aa403876a..2b3e6025fc0 100644 --- a/apps/website/scripts/README.md +++ b/apps/website/scripts/README.md @@ -1,5 +1,15 @@ # Website Scripts +## `router-provider-drift.ts` + +Compares the checked-in Router provider coverage with the published schemas and +documentation. The command requires network access and is also run by the +scheduled Router Provider Drift workflow: + +```sh +pnpm --filter @comfyorg/website check:router-provider-drift +``` + ## `generate-workshop-display.ts` Imports the content team's `workshop-display.json`, keyed by catalogue model ID, diff --git a/apps/website/scripts/router-provider-drift.test.ts b/apps/website/scripts/router-provider-drift.test.ts new file mode 100644 index 00000000000..145e58ab6db --- /dev/null +++ b/apps/website/scripts/router-provider-drift.test.ts @@ -0,0 +1,222 @@ +import { describe, expect, it, vi } from 'vitest' + +import { + ROUTER_COMFY_ONLY_PREVIEW, + ROUTER_PROVIDER_COVERAGE, + ROUTER_SERVING_PROVIDERS +} from '../src/config/router-providers' +import { + alternateProviders, + checkRouterProviderDrift, + fetchText, + parseCoverageTable +} from './router-provider-drift' + +describe('fetchText', () => { + it('recovers when a source fails once and then responds', async () => { + const fetchImpl = vi + .fn() + .mockRejectedValueOnce(new Error('offline')) + .mockResolvedValueOnce(new Response('providers')) + const sleep = vi.fn(async () => {}) + + await expect( + fetchText('https://example.com', { fetchImpl, sleep }) + ).resolves.toBe('providers') + expect(fetchImpl).toHaveBeenCalledTimes(2) + expect(sleep).toHaveBeenCalledOnce() + }) + + it('reports an unavailable source after every attempt', async () => { + const fetchImpl = vi + .fn() + .mockRejectedValue(new Error('offline')) + + await expect( + fetchText('https://example.com', { + fetchImpl, + sleep: async () => {} + }) + ).rejects.toThrow('Could not fetch https://example.com') + expect(fetchImpl).toHaveBeenCalledTimes(3) + }) + + it('reports an HTTP error as an unavailable source', async () => { + const fetchImpl = vi + .fn() + .mockResolvedValue(new Response('maintenance', { status: 503 })) + + await expect( + fetchText('https://example.com', { + fetchImpl, + sleep: async () => {} + }) + ).rejects.toThrow('Could not fetch https://example.com') + }) +}) + +it('reads alternate providers from a published model schema', () => { + expect( + alternateProviders( + JSON.stringify({ + 'x-comfy-router-alt-providers': [ + { provider: 'fal' }, + { provider: 'runware' } + ] + }) + ) + ).toEqual(['fal', 'runware']) +}) + +it('reads the provider coverage table from Markdown', () => { + const markdown = ` +## Provider coverage +| **Model / provider** | **Comfy (default)** | **fal** | +| --- | --- | --- | +| [Model](/models/model/code) | ✓ | ✓ | +` + + expect(parseCoverageTable(markdown)).toEqual({ + providers: ['fal'], + rows: [ + { + name: 'Model', + docsUrl: 'https://docs.comfy.org/models/model/code', + comfy: '✓' + } + ] + }) +}) + +describe('checkRouterProviderDrift', () => { + const coverageRows = ROUTER_PROVIDER_COVERAGE.map( + ({ docsName, docsUrl, name }) => + `| [${docsName ?? name}](${new URL(docsUrl).pathname}) | ✓ |` + ).join('\n') + const coverage = ` +## Provider coverage +| **Model / provider** | **Comfy (default)** | ${ROUTER_SERVING_PROVIDERS.map(({ name }) => `**${name}**`).join(' | ')} | +| --- | --- | --- | +${coverageRows} +` + const catalog = ROUTER_COMFY_ONLY_PREVIEW.map( + ({ docsUrl, name }) => `[${name}](${new URL(docsUrl).pathname})` + ).join('\n') + const [driftedRow] = ROUTER_PROVIDER_COVERAGE + const [driftedProvider] = ROUTER_SERVING_PROVIDERS + const [previewRow] = ROUTER_COMFY_ONLY_PREVIEW + + function createFetch({ + coverageMarkdown = coverage, + catalogMarkdown = catalog, + providerOverrides = {} + }: { + coverageMarkdown?: string + catalogMarkdown?: string + providerOverrides?: Readonly> + } = {}) { + return vi.fn(async (input) => { + const url = input instanceof Request ? input.url : String(input) + if (url.endsWith('/providers.md')) { + return new Response(coverageMarkdown) + } + if (url.endsWith('/models.md')) return new Response(catalogMarkdown) + const row = ROUTER_PROVIDER_COVERAGE.find(({ modelId }) => + url.endsWith(`/${modelId}.json`) + ) + const providers = row + ? (providerOverrides[row.modelId] ?? row.providers) + : [] + return new Response( + JSON.stringify({ + 'x-comfy-router-alt-providers': providers.map((provider) => ({ + provider + })) + }) + ) + }) + } + + it('accepts matching published sources', async () => { + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch(), + sleep: async () => {} + }) + ).resolves.toBeUndefined() + }) + + it('detects serving-provider header drift', async () => { + const coverageMarkdown = coverage.replace( + `**${driftedProvider.name}**`, + `**${driftedProvider.name}-drift**` + ) + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ coverageMarkdown }), + sleep: async () => {} + }) + ).rejects.toThrow(`${driftedProvider.name}-drift`) + }) + + it('detects alternate-provider drift', async () => { + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ + providerOverrides: { + [driftedRow.modelId]: [...driftedRow.providers, 'drift-provider'] + } + }), + sleep: async () => {} + }) + ).rejects.toThrow(/drift-provider/) + }) + + it('detects provider documentation row drift', async () => { + const coverageMarkdown = coverage.replace( + new URL(driftedRow.docsUrl).pathname, + `${new URL(driftedRow.docsUrl).pathname}-drift` + ) + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ coverageMarkdown }), + sleep: async () => {} + }) + ).rejects.toThrow(/-drift/) + }) + + it('detects a provider row not served by Comfy', async () => { + const coverageMarkdown = coverage.replace( + `| [${driftedRow.docsName ?? driftedRow.name}](${new URL(driftedRow.docsUrl).pathname}) | ✓ |`, + `| [${driftedRow.docsName ?? driftedRow.name}](${new URL(driftedRow.docsUrl).pathname}) | - |` + ) + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ coverageMarkdown }), + sleep: async () => {} + }) + ).rejects.toThrow('every provider coverage row must be served by Comfy') + }) + + it('detects a missing catalog link', async () => { + const catalogMarkdown = catalog.replace(`[${previewRow.name}]`, '[Drift]') + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ catalogMarkdown }), + sleep: async () => {} + }) + ).rejects.toThrow(previewRow.name) + }) + + it('detects a preview path in provider coverage', async () => { + const previewPath = new URL(previewRow.docsUrl).pathname + await expect( + checkRouterProviderDrift({ + fetchImpl: createFetch({ + coverageMarkdown: `${previewPath}\n${coverage}` + }), + sleep: async () => {} + }) + ).rejects.toThrow(previewPath) + }) +}) diff --git a/apps/website/scripts/router-provider-drift.ts b/apps/website/scripts/router-provider-drift.ts new file mode 100644 index 00000000000..40691953fc3 --- /dev/null +++ b/apps/website/scripts/router-provider-drift.ts @@ -0,0 +1,153 @@ +import assert from 'node:assert/strict' + +import { z } from 'zod' + +import { + ROUTER_COMFY_ONLY_PREVIEW, + ROUTER_PROVIDER_COVERAGE, + ROUTER_SERVING_PROVIDERS +} from '../src/config/router-providers' +import { isDirectExecution } from './script-entry-point' + +const DOCS_ORIGIN = 'https://docs.comfy.org' +const ROUTER_DOCS = `${DOCS_ORIGIN}/development/comfy-router` +const PROVIDERS_PAGE = `${ROUTER_DOCS}/providers.md` +const MODELS_PAGE = `${ROUTER_DOCS}/models.md` +const ROUTER_SCHEMAS = + 'https://raw.githubusercontent.com/Comfy-Org/docs/main/router-schemas' + +interface FetchTextOptions { + fetchImpl?: typeof fetch + sleep?: (milliseconds: number) => Promise +} + +const FETCH_ATTEMPTS = 3 +const FETCH_TIMEOUT_MS = 4_000 +const alternateProvidersSchema = z + .object({ + 'x-comfy-router-alt-providers': z + .array(z.object({ provider: z.string() })) + .default([]) + }) + .transform((schema) => + schema['x-comfy-router-alt-providers'].map(({ provider }) => provider) + ) + +interface DocsCoverageRow { + name: string + docsUrl: string + comfy: string +} + +export async function fetchText( + url: string, + { + fetchImpl = fetch, + sleep = (milliseconds) => + new Promise((resolve) => setTimeout(resolve, milliseconds)) + }: FetchTextOptions = {} +): Promise { + let lastError: unknown + for (let attempt = 0; attempt < FETCH_ATTEMPTS; attempt++) { + try { + const response = await fetchImpl(url, { + signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) + }) + if (!response.ok) throw new Error(`${url} responded ${response.status}`) + return await response.text() + } catch (error) { + lastError = error + if (attempt + 1 < FETCH_ATTEMPTS) await sleep(250 * 2 ** attempt) + } + } + throw new Error(`Could not fetch ${url}`, { cause: lastError }) +} + +export function alternateProviders(spec: string): string[] { + return alternateProvidersSchema.parse(JSON.parse(spec)) +} + +export function parseCoverageTable(markdown: string): { + providers: string[] + rows: DocsCoverageRow[] +} { + const section = markdown.slice(markdown.indexOf('## Provider coverage')) + const lines = section + .split('\n') + .map((line) => line.trim()) + .filter((line) => line.startsWith('|')) + const cells = (line: string) => + line + .split('|') + .slice(1, -1) + .map((cell) => cell.trim()) + const [header, , ...body] = lines + assert.ok(header, 'Provider coverage table is missing') + const columns = cells(header).map((column) => column.replaceAll('**', '')) + assert.deepEqual(columns.slice(0, 2), ['Model / provider', 'Comfy (default)']) + return { + providers: columns.slice(2), + rows: body.map((line) => { + const [model, comfy] = cells(line) + const link = /^\[(.+)\]\((.+)\)$/.exec(model) + assert.ok(link, `Unexpected model cell: ${model}`) + return { name: link[1], docsUrl: `${DOCS_ORIGIN}${link[2]}`, comfy } + }) + } +} + +export async function checkRouterProviderDrift( + options: FetchTextOptions = {} +): Promise { + const [coverageMarkdown, catalogMarkdown, ...specs] = await Promise.all([ + fetchText(PROVIDERS_PAGE, options), + fetchText(MODELS_PAGE, options), + ...ROUTER_PROVIDER_COVERAGE.map((row) => + fetchText(`${ROUTER_SCHEMAS}/${row.modelId}.json`, options) + ) + ]) + assert.deepEqual( + specs.map((spec) => alternateProviders(spec).sort()), + ROUTER_PROVIDER_COVERAGE.map((row) => [...row.providers].sort()) + ) + + const docs = parseCoverageTable(coverageMarkdown) + assert.deepEqual( + docs.providers, + ROUTER_SERVING_PROVIDERS.map((provider) => provider.name) + ) + assert.ok( + docs.rows.every((row) => row.comfy === '✓'), + 'every provider coverage row must be served by Comfy' + ) + const byDocsUrl = (a: { docsUrl: string }, b: { docsUrl: string }) => + a.docsUrl.localeCompare(b.docsUrl) + assert.deepEqual( + docs.rows.map(({ docsUrl, name }) => ({ docsUrl, name })).sort(byDocsUrl), + ROUTER_PROVIDER_COVERAGE.map((row) => ({ + docsUrl: row.docsUrl, + name: row.docsName ?? row.name + })).sort(byDocsUrl) + ) + + const missingCatalogLinks = ROUTER_COMFY_ONLY_PREVIEW.filter( + ({ name, docsUrl }) => + !catalogMarkdown.includes(`[${name}](${new URL(docsUrl).pathname})`) + ).map(({ name }) => name) + const previewPathsInCoverage = ROUTER_COMFY_ONLY_PREVIEW.map( + ({ docsUrl }) => new URL(docsUrl).pathname + ).filter((path) => coverageMarkdown.includes(path)) + assert.deepEqual(missingCatalogLinks, []) + assert.deepEqual(previewPathsInCoverage, []) +} + +if (isDirectExecution(process.argv[1], import.meta.filename)) { + checkRouterProviderDrift() + .then(() => { + console.warn('Router provider coverage matches the published sources.') + }) + .catch((error: unknown) => { + console.error(error) + process.exitCode = 1 + }) +} diff --git a/apps/website/src/config/router-providers.test.ts b/apps/website/src/config/router-providers.test.ts index 8b4408c854b..2876acc8f5e 100644 --- a/apps/website/src/config/router-providers.test.ts +++ b/apps/website/src/config/router-providers.test.ts @@ -1,82 +1,12 @@ // @vitest-environment node -import { z } from 'astro/zod' import { describe, expect, it } from 'vitest' import { - ROUTER_COMFY_ONLY_PREVIEW, ROUTER_PROVIDER_COVERAGE, - ROUTER_PROVIDER_COVERAGE_VERIFIED_AT, - ROUTER_SERVING_PROVIDERS + ROUTER_PROVIDER_COVERAGE_VERIFIED_AT } from './router-providers' -const DOCS_ORIGIN = 'https://docs.comfy.org' -const ROUTER_DOCS = `${DOCS_ORIGIN}/development/comfy-router` -const PROVIDERS_PAGE = `${ROUTER_DOCS}/providers.md` -const MODELS_PAGE = `${ROUTER_DOCS}/models.md` -// The per-model API spec, as the backend publishes it for the docs site. -const ROUTER_SCHEMAS = - 'https://raw.githubusercontent.com/Comfy-Org/docs/main/router-schemas' - -// The API spec and the docs are the source of truth and live outside this -// repository, so the drift checks reach the network. They run in CI and skip -// elsewhere, or when a source cannot be fetched, so an outage never fails a -// build: the day the spec changes, CI is where it shows. -const skipReason = process.env.CI - ? null - : 'checks the published API spec; runs in CI only (set CI=1 to run it here)' - -async function fetchDocs(url: string): Promise { - let response: Response - try { - response = await fetch(url, { signal: AbortSignal.timeout(15_000) }) - } catch { - return null - } - if (!response.ok) throw new Error(`${url} responded ${response.status}`) - return response.text() -} - -interface DocsCoverageRow { - name: string - docsUrl: string - comfy: string - providers: string[] -} - -/** Reads the "Provider coverage" table from the docs page's Markdown. */ -function parseCoverageTable(markdown: string): { - providers: string[] - rows: DocsCoverageRow[] -} { - const section = markdown.slice(markdown.indexOf('## Provider coverage')) - const lines = section - .split('\n') - .map((line) => line.trim()) - .filter((line) => line.startsWith('|')) - const cells = (line: string) => - line - .split('|') - .slice(1, -1) - .map((cell) => cell.trim()) - const [header, , ...body] = lines - const columns = cells(header).map((column) => column.replaceAll('**', '')) - expect(columns.slice(0, 2)).toEqual(['Model / provider', 'Comfy (default)']) - const providers = columns.slice(2) - const rows = body.map((line) => { - const [model, comfy, ...routes] = cells(line) - const link = /^\[(.+)\]\((.+)\)$/.exec(model) - if (!link) throw new Error(`Unexpected model cell: ${model}`) - return { - name: link[1], - docsUrl: `${DOCS_ORIGIN}${link[2]}`, - comfy, - providers: providers.filter((_, index) => routes[index] !== '-') - } - }) - return { providers, rows } -} - describe('Router provider coverage', () => { it('lists each model once, alphabetically', () => { const names = ROUTER_PROVIDER_COVERAGE.map((row) => row.name) @@ -84,68 +14,4 @@ describe('Router provider coverage', () => { expect(new Set(names).size).toBe(names.length) expect(ROUTER_PROVIDER_COVERAGE_VERIFIED_AT).toMatch(/^\d{4}-\d{2}-\d{2}$/) }) - - it("matches each model's alternate providers in the API spec", async (ctx) => { - if (skipReason) return ctx.skip(skipReason) - const specs = await Promise.all( - ROUTER_PROVIDER_COVERAGE.map((row) => - fetchDocs(`${ROUTER_SCHEMAS}/${row.modelId}.json`) - ) - ) - if (specs.includes(null)) return ctx.skip('could not fetch the API spec') - - const altProviders = z.object({ - 'x-comfy-router-alt-providers': z - .array(z.object({ provider: z.string() })) - .default([]) - }) - expect( - specs.map((spec) => - altProviders - .parse(JSON.parse(spec ?? '{}')) - ['x-comfy-router-alt-providers'].map(({ provider }) => provider) - .sort() - ) - ).toEqual(ROUTER_PROVIDER_COVERAGE.map((row) => [...row.providers].sort())) - }) - - it('lists every model the docs show with an alternate provider', async (ctx) => { - if (skipReason) return ctx.skip(skipReason) - const markdown = await fetchDocs(PROVIDERS_PAGE) - if (markdown === null) return ctx.skip(`could not fetch ${PROVIDERS_PAGE}`) - - const docs = parseCoverageTable(markdown) - expect(docs.providers).toEqual( - ROUTER_SERVING_PROVIDERS.map((provider) => provider.name) - ) - expect(docs.rows.every((row) => row.comfy === '✓')).toBe(true) - const byDocsUrl = (a: { docsUrl: string }, b: { docsUrl: string }) => - a.docsUrl.localeCompare(b.docsUrl) - expect( - docs.rows - .map((row) => ({ docsUrl: row.docsUrl, name: row.name })) - .sort(byDocsUrl) - ).toEqual( - ROUTER_PROVIDER_COVERAGE.map((row) => ({ - docsUrl: row.docsUrl, - name: row.docsName ?? row.name - })).sort(byDocsUrl) - ) - }) - - it('previews catalog models that only Comfy serves', async (ctx) => { - if (skipReason) return ctx.skip(skipReason) - const [catalog, coverage] = await Promise.all([ - fetchDocs(MODELS_PAGE), - fetchDocs(PROVIDERS_PAGE) - ]) - if (catalog === null || coverage === null) - return ctx.skip('could not fetch the docs catalog') - - for (const { name, docsUrl } of ROUTER_COMFY_ONLY_PREVIEW) { - const path = docsUrl.slice(DOCS_ORIGIN.length) - expect(catalog).toContain(`[${name}](${path})`) - expect(coverage).not.toContain(path) - } - }) }) diff --git a/apps/website/src/config/router-providers.ts b/apps/website/src/config/router-providers.ts index 0e6a84f08ed..d91ff18f354 100644 --- a/apps/website/src/config/router-providers.ts +++ b/apps/website/src/config/router-providers.ts @@ -4,10 +4,11 @@ * Every Router model runs through Comfy's default route. The rows below are the * only ones that also accept `model_provider`. They mirror the API spec: each * model's `x-comfy-router-alt-providers`, published per model under - * `router-schemas/` in the public Comfy-Org/docs repository. Reading the live - * spec needs an API key, so the rows are copied by hand; - * `router-providers.test.ts` compares them with the published spec and fails - * the day they drift. Update `ROUTER_PROVIDER_COVERAGE_VERIFIED_AT` with them. + * `router-schemas/` in the public Comfy-Org/docs repository. The rows are + * copied by hand; the scheduled Router Provider Drift workflow compares them + * with the published sources and opens or updates an `area:testing` issue when + * they drift or a source is unavailable. + * Update `ROUTER_PROVIDER_COVERAGE_VERIFIED_AT` with them. */ export const ROUTER_SERVING_PROVIDERS = [ diff --git a/apps/website/vitest.config.ts b/apps/website/vitest.config.ts index 8bbe9d8fdf4..7f86417647a 100644 --- a/apps/website/vitest.config.ts +++ b/apps/website/vitest.config.ts @@ -30,7 +30,11 @@ export default defineConfig({ }, include: ['src/**/*.{test,spec}.ts', 'scripts/**/*.{test,spec}.ts'], globals: false, - setupFiles: ['../../vitest.timer.setup.ts', './src/test/setup.ts'], + setupFiles: [ + '../../vitest.network.setup.ts', + '../../vitest.timer.setup.ts', + './src/test/setup.ts' + ], coverage: { provider: 'v8', reporter: ['text', 'lcov'],