test-station self-test

Assertions

• assert.equal(fs.existsSync(absolutePath), true, `missing ${relativePath}`);

Source

test('docker assets for the unified web/server image exist', () => {
  const expectedFiles = [
    '.dockerignore',
    'docker/Dockerfile',
    'docker/docker-entrypoint.sh',
    'docker/docker-compose.yml',
    '.github/workflows/image-build.yml',
    '.github/workflows/publish.yml',
  ];

  for (const relativePath…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/docker-image-workflow.test.js",
    "matched": true
  }
}

Assertions

• assert.match(workflow, /workflow_call:/);
• assert.match(workflow, /workflow_dispatch:/);
• assert.match(workflow, /image_tag:/);
• assert.match(workflow, /push_image:/);
• assert.match(workflow, /file:\s*docker\/Dockerfile/);
• assert.match(workflow, /Build and publish unified web\/server image/);
• assert.match(workflow, /CONTAINER_REGISTRY/);
• assert.match(workflow, /CONTAINER_IMAGE_REPOSITORY/);
• assert.match(workflow, /CONTAINER_REGISTRY_USERNAME/);
• assert.match(workflow, /secrets\.CONTAINER_REGISTRY_PASSWORD/);
• assert.match(workflow, /images:\s*\$\{\{ env\.CONTAINER_REGISTRY \}\}\/\$\{\{ env\.CONTAINER_IMAGE_REPOSITORY \}\}/);
• assert.match(workflow, /type=raw,value=\$\{\{ inputs\.image_tag \}\}/);

Source

test('image build workflow is reusable and uses the unified Dockerfile', () => {
  const workflow = fs.readFileSync(path.join(repoRoot, '.github/workflows/image-build.yml'), 'utf8');

  assert.match(workflow, /workflow_call:/);
  assert.match(workflow, /workflow_dispatch:/);
  assert.match(workflow, /image_tag:/);
  a…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/docker-image-workflow.test.js",
    "matched": true
  }
}

Assertions

• assert.match(workflow, /pull_request:/);
• assert.match(workflow, /yarn install --immutable/);
• assert.match(workflow, /yarn test:node/);
• assert.match(workflow, /yarn test:coverage/);
• assert.match(workflow, /tee "\$log_path"/);
• assert.match(workflow, /Captured log:/);
• assert.doesNotMatch(workflow, /push:\s*\n\s*branches:/);
• assert.doesNotMatch(workflow, /publish-ingest-report\.mjs/);
• assert.doesNotMatch(workflow, /docker build --file docker\/Dockerfile --tag test-station-ci \./);

Source

test('ci workflow only runs test validation for pull requests', () => {
  const workflow = fs.readFileSync(path.join(repoRoot, '.github', 'workflows', 'ci.yml'), 'utf8');

  assert.match(workflow, /pull_request:/);
  assert.match(workflow, /yarn install --immutable/);
  assert.match(workflow, /yarn test:node/);
  asse…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/docker-image-workflow.test.js",
    "matched": true
  }
}

Assertions

• assert.match(workflow, /name:\s*Main Release Pipeline/);
• assert.match(workflow, /branches:\s*\n\s*-\s*main/);
• assert.match(workflow, /needs:\s*validate/);
• assert.match(workflow, /needs:\s*npm-publish/);
• assert.match(workflow, /uses:\s*\.\/\.github\/workflows\/image-build\.yml/);
• assert.match(workflow, /image_tag:\s*main/);
• assert.match(workflow, /NPM_PUBLISH:\s*\$\{\{ \(\(github\.event_name == 'push' && github\.ref_name == 'main'\) \|\| inputs\.publish_npm\) && '1' \|\| '0' \}\}/);
• assert.match(workflow, /TEST_STATION_INGEST_SHARED_KEY/);
• assert.match(workflow, /S3_BUCKET/);
• assert.match(workflow, /tee "\$log_path"/);
• assert.match(workflow, /Captured log:/);
• assert.match(workflow, /azure\/setup-kubectl@v4/);
• assert.match(workflow, /FLEET_KUBECONFIG/);
• assert.match(workflow, /deploy-fleet\.sh --kubeconfig "\$KUBECONFIG_PATH" --restart/);

Source

test('main release workflow gates npm publish, image build, and fleet deployment behind validation', () => {
  const workflow = fs.readFileSync(path.join(repoRoot, '.github', 'workflows', 'publish.yml'), 'utf8');

  assert.match(workflow, /name:\s*Main Release Pipeline/);
  assert.match(workflow, /branches:\s*\n\s*-\s…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/docker-image-workflow.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(summary.projectName, 'varcad.io');
• assert.equal(summary.suiteCount, 5);
• assert.equal(report.schemaVersion, '1');

Source

test('core loads and summarizes the example config', async () => {
  const loaded = await loadConfig(exampleConfigPath);
  const summary = summarizeConfig(loaded.config);
  assert.equal(summary.projectName, 'varcad.io');
  assert.equal(summary.suiteCount, 5);
  const report = createPhase1ScaffoldReport(loaded.config);…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /Group by Module/);
• assert.match(html, /Group by Package/);
• assert.match(html, /Show detailed analysis/);
• assert.match(html, /Coverage by file/);
• assert.match(html, /core-team/);
• assert.match(html, /data-view=\"package\"/);
• assert.match(html, /Raw Artifacts/);
• assert.match(html, /href="raw\/core\/core-node\.log"/);
• assert.match(html, /coverage-table__metricBar/);
• assert.match(html, /coverage-table__statementIcon/);
• assert.match(html, /80\.0%/);
• assert.match(html, /Jump straight to the breakage/);
• assert.match(html, /Open in suite/);
• assert.match(html, /core • Core Node Tests • packages\/core\/src\/index\.js:24:4/);
• assert.match(html, /data-view-target="package"/);
• assert.match(html, /id="test-package-core-core-node-core-node-tests-core-fails-.*packages-core-src-index-js-24-1"/);

Source

test('renderer returns baseline html', () => {
  const html = renderHtmlReport(createSampleReport(), { title: 'example' });
  assert.match(html, /Group by Module/);
  assert.match(html, /Group by Package/);
  assert.match(html, /Show detailed analysis/);
  assert.match(html, /Coverage by file/);
  assert.match(html, /…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /class="hero__title">Workspace<\/h1>/);
• assert.match(html, /class="hero__reportKey">workspace:github-actions:1001<\/div>/);
• assert.match(html, /Structured Run Report/);
• assert.doesNotMatch(html, /<h1[^>]*>Workspace Report - workspace:github-actions:1001<\/h1>/);
• assert.match(html, /\.hero__title\s*\{[\s\S]*white-space:\s*nowrap;/);

Source

test('renderer splits a combined report title into a project headline and run key', () => {
  const report = createSampleReport();
  report.meta.projectName = 'Workspace';

  const html = renderHtmlReport(report, {
    title: 'Workspace Report - workspace:github-actions:1001',
  });

  assert.match(html, /class="hero_…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(moduleCard, /module-card__owner">core-team<\/span>\s*<span class="module-card__name">runtime<\/span>/);
• assert.doesNotMatch(moduleCard, /Owner: core-team/);
• assert.doesNotMatch(moduleCard, /owner-pill/);

Source

test('renderer shows owner as thin header text above the module card title', () => {
  const html = renderHtmlReport(createSampleReport(), { title: 'example' });
  const moduleCard = html.match(/<button type="button" class="module-card status-failed"[\s\S]*?<\/button>/)?.[0] || '';

  assert.match(moduleCard, /module-…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /class="test-row__aside"/);
• assert.match(html, /\.test-row__summary\s*\{\s*display:\s*grid;\s*grid-template-columns:\s*auto minmax\(0, 1fr\) auto;/);
• assert.match(html, /\.test-row__title\s*\{[\s\S]*white-space:\s*normal;/);
• assert.match(html, /\.detail-grid\s*\{[\s\S]*minmax\(min\(100%, 360px\), 1fr\)/);
• assert.match(html, /\.detail-card\s*\{[\s\S]*overflow:\s*visible;/);
• assert.match(html, /\.detail-card code\s*\{[\s\S]*overflow-wrap:\s*anywhere;/);
• assert.match(html, /\.detail-card pre\s*\{[\s\S]*overflow-wrap:\s*anywhere;/);
• assert.doesNotMatch(html, /overflow:\s*(auto|scroll)/);

Source

test('renderer wraps detailed test evidence without forcing horizontal overflow', () => {
  const html = renderHtmlReport(createSampleReport(), { title: 'example' });

  assert.match(html, /class="test-row__aside"/);
  assert.match(html, /\.test-row__summary\s*\{\s*display:\s*grid;\s*grid-template-columns:\s*auto minm…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /\.module-card__meta\s*\{[\s\S]*font-size:\s*0\.75rem;/);
• assert.match(moduleCard, /2 total • 1 passed • 1 failed • 0 skipped/);
• assert.match(moduleCard, /27ms • 1 package/);

Source

test('renderer keeps focused package cards compact and legible', () => {
  const html = renderHtmlReport(createSampleReport(), { title: 'example' });
  const moduleCard = html.match(/<button type="button" class="module-card status-failed"[\s\S]*?<\/button>/)?.[0] || '';

  assert.match(html, /\.module-card__meta\s*\{[…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /coverage-table__metricCol/);
• assert.match(html, /coverage-table__statementIcon--disabled/);
• assert.match(html, /coverage-table__statementIcon--active/);
• assert.match(html, /title="Statements: 80\.0% \(8\/10\)"/);
• assert.match(html, /37\.0%/);
• assert.match(html, /80\.2%/);

Source

test('renderer shows statement tooltip state and fixed-width file coverage metrics', () => {
  const report = createSampleReport();
  const files = [
    {
      path: path.join(repoRoot, 'packages', 'core', 'src', 'missing-statements.js'),
      lines: { covered: 10, total: 27, pct: 37.04 },
      branches: { covered…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /class="module-card status-failed" data-open-target="package-core"/);
• assert.match(html, /Suite failed before emitting test results/);
• assert.match(html, /Error: Failed to launch: Error: spawn \/bin\/sh ENOENT/);

Source

test('renderer keeps zero-test failed suites visibly failed', () => {
  const html = renderHtmlReport(createZeroTestSuiteFailureReport(), { title: 'example' });
  assert.match(html, /class="module-card status-failed" data-open-target="package-core"/);
  assert.match(html, /Suite failed before emitting test results/);…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(createNodeTestAdapter().id, 'node-test');
• assert.equal(createVitestAdapter().id, 'vitest');
• assert.equal(createPlaywrightAdapter().id, 'playwright');
• assert.equal(createShellAdapter().id, 'shell');
• assert.equal(createJestAdapter().id, 'jest');
• assert.equal(createNodeTestAdapter().phase, 3);
• assert.equal(createVitestAdapter().phase, 3);
• assert.equal(createPlaywrightAdapter().phase, 8);
• assert.equal(createShellAdapter().phase, 3);
• assert.equal(createJestAdapter().phase, 3);
• assert.equal(sourceAnalysisPlugin.id, 'source-analysis');
• assert.equal(sourceAnalysisPlugin.phase, 5);
• assert.equal(typeof sourceAnalysisPlugin.enrichTest, 'function');

Source

test('adapter and plugin scaffolds expose stable ids', () => {
  assert.equal(createNodeTestAdapter().id, 'node-test');
  assert.equal(createVitestAdapter().id, 'vitest');
  assert.equal(createPlaywrightAdapter().id, 'playwright');
  assert.equal(createShellAdapter().id, 'shell');
  assert.equal(createJestAdapter().id…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(payload.summary.projectName, 'varcad.io');

Source

test('cli inspect command loads config successfully', () => {
  const result = spawnSync(process.execPath, [cliPath, 'inspect', '--config', exampleConfigPath], {
    encoding: 'utf8',
    cwd: repoRoot,
  });
  assert.equal(result.status, 0, result.stderr || result.stdout);
  const payload = JSON.parse(result.stdout);…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(fs.existsSync(path.join(outputDir, 'index.html')), true);
• assert.match(html, /Group by Module/);
• assert.match(html, /core fails/);

Source

test('cli render command writes an html file', () => {
  const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-render-'));
  const inputPath = path.join(outputDir, 'report.json');

  try {
    fs.writeFileSync(inputPath, `${JSON.stringify(createSampleReport(), null, 2)}\n`);
    const result = spawnSyn…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(typeof configEntry.defineConfig, 'function');
• assert.equal(inspectResult.status, 0, inspectResult.stderr || inspectResult.stdout);
• assert.equal(payload.summary.projectName, 'varcad.io');

Source

test('root-level consumer entrypoints stay stable', async () => {
  const configEntry = await import(configEntryPath);
  assert.equal(typeof configEntry.defineConfig, 'function');

  const inspectResult = spawnSync(process.execPath, [rootCliPath, 'inspect', '--config', exampleConfigPath], {
    encoding: 'utf8',
    c…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/exports.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(fs.existsSync(path.join(repoRoot, relativePath)), true, `missing ${relativePath}`);

Source

test('fleet bundle files exist for unified web and server deployment', () => {
  const expectedFiles = [
    'fleet.yaml',
    'fleet/fleet.yaml',
    'fleet/README.md',
    'fleet/gitrepo.yml',
    'fleet/test-station/Chart.yaml',
    'fleet/test-station/values.yaml',
    '.env.fleet.example',
    '.env.fleet.config.…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/fleet-bundle.test.js",
    "matched": true
  }
}

Assertions

• assert.match(fleetYaml, /publicDomain:\s*test-station\.smysnk\.com/);
• assert.match(fleetYaml, /chart:\s*\.\/fleet\/test-station/);
• assert.match(scopedFleetYaml, /publicDomain:\s*test-station\.smysnk\.com/);
• assert.match(scopedFleetYaml, /chart:\s*\.\/test-station/);
• assert.match(fleetYaml, /image:\s*\n\s*tag:\s*main/);
• assert.match(fleetYaml, /existingSecret:\s*test-station-runtime-secret/);
• assert.match(fleetYaml, /className:\s*traefik/);
• assert.match(fleetYaml, /cert-manager\.io\/cluster-issuer:\s*letsencrypt-prod/);
• assert.match(fleetYaml, /tls:\s*\n\s*enabled:\s*true/);
• assert.match(fleetYaml, /enabled:\s*true/);
• assert.match(gitRepoYaml, /paths:\s*\n\s*-\s*fleet/);
• assert.match(gitRepoYaml, /branch:\s*main/);
• assert.doesNotMatch(gitRepoYaml, /helm:\s*\n\s*values:/);
• assert.match(valuesYaml, /publicDomain:\s*""/);
• assert.match(valuesYaml, /ingressPaths:\s*\n\s*-\s*path:\s*\/api\/ingest/);
• assert.match(valuesYaml, /INGEST_SHARED_KEY:\s*change-me/);
• assert.match(valuesYaml, /SERVER_JSON_LIMIT:\s*"50mb"/);
• assert.match(valuesYaml, /INGEST_JSON_LIMIT:\s*"50mb"/);
• assert.match(valuesYaml, /requestBodyLimit:\s*\n\s*enabled:\s*true/);
• assert.match(valuesYaml, /maxRequestBodyBytes:\s*52428800/);
• assert.match(valuesYaml, /secretName:\s*""/);
• assert.match(valuesYaml, /repository:\s*ghcr\.io\/smysnk\/test-station/);
• assert.match(valuesYaml, /pullPolicy:\s*Always/);
• assert.match(valuesYaml, /livenessProbe:\s*\n\s*path:\s*\/api\/healthz/);
• assert.match(valuesYaml, /readinessProbe:\s*\n\s*path:\s*\/api\/healthz/);
• assert.match(webIngressYaml, /test-station\.publicDomain/);
• assert.match(webIngressYaml, /router\.middlewares/);
• assert.match(webIngressYaml, /webIngressBufferingMiddlewareName/);
• assert.match(webIngressYaml, /test-station\.defaultTlsSecretName/);
• assert.match(webIngressYaml, /test-station\.serverName/);
• assert.match(webIngressYaml, /kindIs "map"/);
• assert.match(webConfigMapYaml, /NEXTAUTH_URL/);
• assert.match(serverConfigMapYaml, /WEB_URL/);
• assert.match(fleetReadme, /TLS secret/);
• assert.match(fleetReadme, /certificate \|\| true/);
• assert.match(fleetReadme, /apply-fleet-gitrepo-ssh-secret\.sh/);
• assert.match(fleetReadme, /apply-fleet-env-secret\.sh/);
• assert.match(fleetReadme, /deploy-fleet\.sh/);
• assert.match(fleetReadme, /FLEET_KUBECONFIG/);
• assert.match(envFleetExample, /DATABASE_URL=/);
• assert.match(envFleetExample, /NEXTAUTH_SECRET=/);
• assert.match(gitIgnore, /^\.env\.fleet$/m);
• assert.match(gitIgnore, /^\.env\.fleet\.config$/m);
• assert.match(workflowYaml, /vars\.CONTAINER_REGISTRY/);
• assert.match(workflowYaml, /vars\.CONTAINER_IMAGE_REPOSITORY/);
• assert.match(workflowYaml, /secrets\.CONTAINER_REGISTRY_PASSWORD/);
• assert.match(workflowYaml, /push:\s*\$\{\{ inputs\.push_image \}\}/);
• assert.match(dockerfile, /COPY scripts \.\/scripts/);

Source

test('fleet values and workflow use the unified image contract without stray reference names', () => {
  const fleetYaml = fs.readFileSync(path.join(repoRoot, 'fleet.yaml'), 'utf8');
  const scopedFleetYaml = fs.readFileSync(path.join(repoRoot, 'fleet/fleet.yaml'), 'utf8');
  const gitRepoYaml = fs.readFileSync(path.j…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/fleet-bundle.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(fs.existsSync(result.htmlPath), true);
• assert.equal(fs.existsSync(result.reportPath), true);
• assert.equal(fs.existsSync(path.join(outputDir, '.nojekyll')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'repo-repo-node.json')), true);
• assert.deepEqual(testsBadge, { schemaVersion: 1, label: 'tests', message: '11 passed / 1 failed', color: 'red', });
• assert.deepEqual(coverageBadge, { schemaVersion: 1, label: 'coverage', message: '80.0%', color: 'yellowgreen', });
• assert.deepEqual(healthBadge, { schemaVersion: 1, label: 'health', message: '80%', color: 'yellowgreen', });
• assert.equal(summary.artifacts.html, 'index.html');
• assert.equal(summary.artifacts.testsBadge, 'badges/tests.json');
• assert.equal(summary.artifacts.healthBadge, 'badges/health.json');
• assert.equal(summary.summary.totalTests, 12);

Source

test('buildSelfTestPagesSite copies the self-test report and writes Pages badge endpoints', () => {
  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-pages-'));
  const inputDir = path.join(tempRoot, 'input');
  const outputDir = path.join(tempRoot, 'output');
  const rawDir = path.join(inputDir,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/pages-site-builder.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(fs.existsSync(result.htmlPath), true);
• assert.equal(fs.existsSync(result.healthBadgePath), true);

Source

test('buildPagesSite writes HTML when the source report directory has no index.html', () => {
  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-pages-generic-'));
  const inputDir = path.join(tempRoot, 'input');
  const outputDir = path.join(tempRoot, 'output');
  const rawDir = path.join(inputDir…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/pages-site-builder.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(fs.existsSync(path.join(outputDir, 'badges', 'coverage.json')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'badges', 'health.json')), true);
• assert.equal(healthBadge.message, '87%');

Source

test('cli pages builds a Pages-ready site with health and coverage badges', () => {
  const repoRoot = path.resolve(import.meta.dirname, '..');
  const cliPath = path.join(repoRoot, 'packages', 'cli', 'src', 'cli.js');
  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-pages-cli-'));
  const inputD…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/pages-site-builder.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(parsed.command, 'run');
• assert.equal(parsed.config, './test-station.config.mjs');
• assert.equal(parsed.outputDir, './artifacts/custom-report');
• assert.equal(parsed.coverage, true);
• assert.deepEqual(parsed.workspaceFilters, ['web', 'transpiler']);

Source

test('parseCliArgs supports workspace filters, package alias, and output-dir', () => {
  const parsed = parseCliArgs([
    'run',
    '--config', './test-station.config.mjs',
    '--workspace', 'web',
    '--package', 'transpiler',
    '--output-dir', './artifacts/custom-report',
    '--coverage',
  ]);

  assert.equa…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(parsed.coverage, undefined);
• assert.deepEqual(parsed.workspaceFilters, ['app']);

Source

test('parseCliArgs leaves coverage undefined when the flag is omitted', () => {
  const parsed = parseCliArgs([
    'run',
    '--config', './test-station.config.mjs',
    '--workspace', 'app',
  ]);

  assert.equal(parsed.coverage, undefined);
  assert.deepEqual(parsed.workspaceFilters, ['app']);
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(parsed.coverage, false);

Source

test('parseCliArgs supports explicit no-coverage overrides', () => {
  const parsed = parseCliArgs([
    'run',
    '--config', './test-station.config.mjs',
    '--coverage',
    '--no-coverage',
  ]);

  assert.equal(parsed.coverage, false);
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.summary.totalPackages, 2);
• assert.equal(execution.report.summary.totalSuites, 1);
• assert.equal(execution.report.summary.totalTests, 2);
• assert.equal(execution.report.summary.failedTests, 0);
• assert.equal(execution.report.packages[0].name, 'app');
• assert.equal(execution.report.packages[1].name, 'lib');
• assert.equal(execution.report.packages[1].status, 'skipped');
• assert.equal(execution.context.project.outputDir, outputDir);
• assert.equal(execution.context.project.rawDir, path.join(outputDir, 'raw'));
• assert.equal(fs.existsSync(path.join(outputDir, 'report.json')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'app-app-unit.json')), true);
• assert.equal(storedReport.summary.totalPackages, 2);
• assert.equal(storedReport.packages[0].name, 'app');

Source

test('runReport filters suites by workspace and writes artifacts to the overridden output directory', async () => {
  const outputDir = path.join(fixtureDir, 'artifacts', 'filtered-app');
  fs.rmSync(outputDir, { recursive: true, force: true });

  const execution = await runReport({
    configPath: fixtureConfigPath,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• await assert.rejects( () => runReport({ configPath: fixtureConfigPath, workspaceFilters: ['missing-workspace'], writeArtifacts: false, }), /No suites matched workspaces: missing-workspace/ );

Source

test('runReport fails clearly when workspace filters match no suites', async () => {
  await assert.rejects(
    () => runReport({
      configPath: fixtureConfigPath,
      workspaceFilters: ['missing-workspace'],
      writeArtifacts: false,
    }),
    /No suites matched workspaces: missing-workspace/
  );
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.match(result.stdout, /Running Workspace Tests/);
• assert.match(result.stdout, /Workspace Test Report/);
• assert.match(result.stdout, /HTML report:/);
• assert.equal(fs.existsSync(path.join(outputDir, 'report.json')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'index.html')), true);
• assert.equal(report.summary.totalPackages, 2);
• assert.equal(report.packages[0].name, 'app');

Source

test('cli run supports package alias and output-dir without host wrapper logic', () => {
  const outputDir = path.join(fixtureDir, 'artifacts', 'cli-filtered-app');
  fs.rmSync(outputDir, { recursive: true, force: true });

  const result = spawnSync(process.execPath, [
    cliPath,
    'run',
    '--config', fixtureC…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase1-cli-overrides.test.js",
    "matched": true
  }
}

Assertions

• assert.ok(migrations.some((migration) => migration.id === initialMigration.id));
• assert.ok(migrations.some((migration) => migration.id === coverageTrendMigration.id));
• assert.ok(migrations.some((migration) => migration.id === accessControlMigration.id));
• assert.ok(migrations.some((migration) => migration.id === benchmarkIndexesMigration.id));
• assert.deepEqual( migrations.map((migration) => migration.id), [ initialMigration.id, coverageTrendMigration.id, accessControlMigration.id, benchmarkIndexesMigration.id, ], );

Source

test('loadMigrations includes the initial reporting schema migration', async () => {
  const migrations = await loadMigrations();
  assert.ok(migrations.some((migration) => migration.id === initialMigration.id));
  assert.ok(migrations.some((migration) => migration.id === coverageTrendMigration.id));
  assert.ok(migra…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase10-server-schema.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(state.createdTables.length, 22);
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'projects'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'runs'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'coverage_files'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'artifacts'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'coverage_trend_points'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'users'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'roles'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'groups'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'user_roles'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'user_groups'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'project_role_access'));
• assert.ok(state.createdTables.some((entry) => entry.tableName === 'project_group_access'));
• assert.ok(state.addedColumns.some((entry) => entry.tableName === 'projects' && entry.columnName === 'is_public'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'runs_project_id_external_key_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'coverage_snapshots_run_id_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'coverage_trend_points_run_scope_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'users_normalized_email_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'roles_key_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'groups_key_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'user_roles_user_id_role_id_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'user_groups_user_id_group_id_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'project_role_access_project_id_role_id_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'project_group_access_project_id_group_id_unique'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'performance_stats_stat_group_stat_name_idx'));
• assert.ok(state.indexes.some((entry) => entry.options?.name === 'runs_project_id_completed_at_idx'));
• assert.deepEqual(state.insertedMigrations, [ initialMigration.id, coverageTrendMigration.id, accessControlMigration.id, benchmarkIndexesMigration.id, ]);
• assert.equal(state.transactions.length, 4);
• assert.equal(state.transactions.every((entry) => entry.committed === true), true);
• assert.equal(state.transactions.every((entry) => entry.rolledBack === false), true);
• assert.equal(rerunState.createdTables.length, 0);
• assert.equal(rerunState.addedColumns.length, 0);
• assert.deepEqual(rerunState.insertedMigrations, []);

Source

test('runMigrations applies the initial reporting schema exactly once', async () => {
  const state = createFakeMigrationState();

  await runMigrations(state.sequelize, {
    migrations: [
      initialMigration,
      coverageTrendMigration,
      accessControlMigration,
      benchmarkIndexesMigration,
    ],
  });…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase10-server-schema.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(ProjectRoleAccess.getTableName(), 'project_role_access');
• assert.equal(ProjectGroupAccess.getTableName(), 'project_group_access');
• assert.equal(User.associations.userRoles.target, UserRole);
• assert.equal(User.associations.userGroups.target, UserGroup);
• assert.equal(User.associations.roles.target, Role);
• assert.equal(User.associations.groups.target, Group);
• assert.equal(Role.associations.userRoles.target, UserRole);
• assert.equal(Role.associations.users.target, User);
• assert.equal(Role.associations.projectRoleAccesses.target, ProjectRoleAccess);
• assert.equal(Role.associations.accessibleProjects.target, Project);
• assert.equal(Group.associations.userGroups.target, UserGroup);
• assert.equal(Group.associations.users.target, User);
• assert.equal(Group.associations.projectGroupAccesses.target, ProjectGroupAccess);
• assert.equal(Group.associations.accessibleProjects.target, Project);
• assert.equal(Project.associations.projectVersions.target, ProjectVersion);
• assert.equal(Project.associations.projectPackages.target, ProjectPackage);
• assert.equal(Project.associations.projectModules.target, ProjectModule);
• assert.equal(Project.associations.projectFiles.target, ProjectFile);
• assert.equal(Project.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(Project.associations.runs.target, Run);
• assert.equal(Project.associations.releaseNotes.target, ReleaseNote);
• assert.equal(Project.associations.projectRoleAccesses.target, ProjectRoleAccess);
• assert.equal(Project.associations.projectGroupAccesses.target, ProjectGroupAccess);
• assert.equal(Project.associations.accessRoles.target, Role);
• assert.equal(Project.associations.accessGroups.target, Group);
• assert.equal(ProjectVersion.associations.runs.target, Run);
• assert.equal(ProjectVersion.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(ProjectPackage.associations.projectModules.target, ProjectModule);
• assert.equal(ProjectPackage.associations.projectFiles.target, ProjectFile);
• assert.equal(ProjectPackage.associations.suiteRuns.target, SuiteRun);
• assert.equal(ProjectPackage.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(ProjectModule.associations.projectFiles.target, ProjectFile);
• assert.equal(ProjectModule.associations.testExecutions.target, TestExecution);
• assert.equal(ProjectModule.associations.coverageFiles.target, CoverageFile);
• assert.equal(ProjectModule.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(ProjectFile.associations.testExecutions.target, TestExecution);
• assert.equal(ProjectFile.associations.coverageFiles.target, CoverageFile);
• assert.equal(ProjectFile.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(Run.associations.suiteRuns.target, SuiteRun);
• assert.equal(Run.associations.coverageSnapshot.target, CoverageSnapshot);
• assert.equal(Run.associations.coverageTrendPoints.target, CoverageTrendPoint);
• assert.equal(Run.associations.errorOccurrences.target, ErrorOccurrence);
• assert.equal(Run.associations.performanceStats.target, PerformanceStat);
• assert.equal(Run.associations.artifacts.target, Artifact);
• assert.equal(SuiteRun.associations.testExecutions.target, TestExecution);
• assert.equal(SuiteRun.associations.errorOccurrences.target, ErrorOccurrence);
• assert.equal(SuiteRun.associations.performanceStats.target, PerformanceStat);
• assert.equal(SuiteRun.associations.artifacts.target, Artifact);
• assert.equal(TestExecution.associations.errorOccurrences.target, ErrorOccurrence);
• assert.equal(TestExecution.associations.performanceStats.target, PerformanceStat);
• assert.equal(TestExecution.associations.artifacts.target, Artifact);
• assert.equal(CoverageSnapshot.associations.coverageFiles.target, CoverageFile);

Source

test('server model registry wires the expected reporting associations', () => {
  assert.equal(ProjectRoleAccess.getTableName(), 'project_role_access');
  assert.equal(ProjectGroupAccess.getTableName(), 'project_group_access');

  assert.equal(User.associations.userRoles.target, UserRole);
  assert.equal(User.associat…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase10-server-schema.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(normalized.project.key, 'workspace');
• assert.equal(normalized.project.slug, 'workspace');
• assert.equal(normalized.projectVersion.versionKey, 'commit:abc123');
• assert.equal(normalized.run.externalKey, 'workspace:github-actions:1001');
• assert.equal(normalized.run.status, 'failed');
• assert.equal(normalized.packages.length, 1);
• assert.equal(normalized.modules.length, 1);
• assert.equal(normalized.files.length, 1);
• assert.equal(normalized.suites.length, 1);
• assert.equal(normalized.tests.length, 2);
• assert.equal(normalized.coverageFiles.length, 1);
• assert.equal(normalized.errors.length, 2);
• assert.equal(normalized.artifacts.length, 2);
• assert.equal(normalized.performanceStats.length, 5);
• assert.deepEqual( normalized.performanceStats.find((entry) => entry.statGroup === 'benchmark.node.engine.nibbles.intro'), { scope: 'suite', suiteIdentifier: 'repo-node', testIdentifier: null, statGroup: 'ben…

Source

test('normalizeIngestPayload validates the report contract and derives run identity', () => {
  const normalized = normalizeIngestPayload(createSamplePayload(), {
    now: '2026-03-09T15:00:00.000Z',
  });

  assert.equal(normalized.project.key, 'workspace');
  assert.equal(normalized.project.slug, 'workspace');
  ass…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.throws( () => normalizeIngestPayload(createSamplePayload({ report: { performanceStats: [ { scope: 'suite', suiteIdentifier: 'missing-suite', statGroup…

Source

test('normalizeIngestPayload rejects malformed custom performance stats clearly', () => {
  assert.throws(
    () =>
      normalizeIngestPayload(createSamplePayload({
        report: {
          performanceStats: [
            {
              scope: 'suite',
              suiteIdentifier: 'missing-suite',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(normalized.run.rawReport.meta.projectName, 'retrodisplay');
• assert.equal(normalized.run.rawReport.meta.nested.label, 'ansioutput');
• assert.equal(normalized.run.rawReport.summary.note, 'linebreak');
• assert.equal(normalized.run.metadata.source.repository, 'react-retro-displaytty');
• assert.equal(normalized.suites[0].warnings[0], 'fixture warning');
• assert.equal(normalized.suites[0].output.stdout, 'suite output');
• assert.equal(normalized.tests[0].assertions[0], 'assert.equal(1, 2)');
• assert.equal(normalized.tests[0].failureMessages[0], 'expected 2 but received 1');
• assert.equal(normalized.tests[0].rawDetails.snippet, 'badjson');
• assert.equal(normalized.tests[0].sourceSnippet, 'assert.equal(1, 2)');

Source

test('normalizeIngestPayload strips null characters from JSON-bound payload fields', () => {
  const normalized = normalizeIngestPayload(createSamplePayload({
    source: {
      repository: 'react-retro-display\u0000tty',
    },
    report: {
      meta: {
        projectName: 'retro\u0000display',
        nested: {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(first.created, true);
• assert.equal(first.counts.tests, 2);
• assert.equal(models.CoverageTrendPoint.rows.length, 4);
• assert.equal(second.created, false);
• assert.equal(models.Run.rows.length, 1);
• assert.equal(models.SuiteRun.rows.length, 1);
• assert.equal(models.TestExecution.rows.length, 1);
• assert.deepEqual(models.CoverageTrendPoint.rows.map((row) => row.scopeType).sort(), ['file', 'module', 'package', 'project']);
• assert.equal(models.ErrorOccurrence.rows.length, 0);
• assert.equal(models.Artifact.rows.length, 0);
• assert.equal(models.PerformanceStat.rows.length, 4);
• assert.equal(models.Run.rows[0].status, 'passed');
• assert.equal(models.Run.rows[0].summary.totalTests, 1);
• assert.equal(models.CoverageTrendPoint.rows.find((row) => row.scopeType === 'project')?.linesPct, 90);
• assert.equal(models.CoverageTrendPoint.rows.find((row) => row.scopeType === 'file')?.linesPct, 90);
• assert.equal( models.PerformanceStat.rows.some((row) => row.statGroup === 'benchmark.node.engine.nibbles.intro' && row.statName === 'elapsed_ms'), true, );

Source

test('ingestion persistence upserts duplicate runs and replaces prior facts', async () => {
  const persistenceContext = createFakePersistenceContext();
  const persistence = createSequelizeIngestionPersistence(persistenceContext);
  const service = createIngestionService({ persistence });

  const first = await servi…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(unauthorized.status, 401);
• assert.equal(unauthorizedPayload.error.code, 'INGEST_UNAUTHORIZED');
• assert.equal(invalid.status, 400);
• assert.equal(invalidPayload.error.code, 'INGEST_VALIDATION_ERROR');
• assert.match(invalidPayload.error.message, /projectKey/);
• assert.equal(success.status, 200);
• assert.equal(successPayload.status, 'ok');
• assert.equal(successPayload.externalKey, 'workspace:github-actions:1001');
• assert.equal(successPayload.counts.tests, 2);

Source

test('server ingest route enforces auth and returns actionable validation errors', async () => {
  const ingestionService = createIngestionService({
    persistence: {
      async persistRun(normalized) {
        return {
          runId: 'run-1',
          externalKey: normalized.run.externalKey,
          created: t…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(oversized.status, 413);
• assert.equal(oversizedPayload.error.code, 'INGEST_PAYLOAD_TOO_LARGE');
• assert.match(oversizedPayload.error.message, /1b/);

Source

test('server ingest route returns JSON when the payload exceeds the ingest body limit', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    ingestSharedKeys: ['top-secret'],
    ingestJsonLimit: '1b',
    ingestionService: createIngestionService({
      persist…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(invalid.status, 400);
• assert.equal(invalidPayload.error.code, 'INGEST_INVALID_JSON');
• assert.match(invalidPayload.error.message, /Unicode|JSON|escape/i);

Source

test('server ingest route returns JSON when the payload body is not valid JSON', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    ingestSharedKeys: ['top-secret'],
    ingestionService: createIngestionService({
      persistence: {
        async persistRun()…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase11-ingestion-api.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveRunBuildNumber({ metadata: { source: { buildNumber: 45, }, }, }), 45);
• assert.equal(resolveRunBuildNumber({ rawReport: { meta: { ci: { environment: { GITHUB_RUN_NUMBER: '12', }, }, }, }, }), 12);

Source

test('query service resolves build number from stored source fallbacks', () => {
  assert.equal(resolveRunBuildNumber({
    metadata: {
      source: {
        buildNumber: 45,
      },
    },
  }), 45);

  assert.equal(resolveRunBuildNumber({
    rawReport: {
      meta: {
        ci: {
          environment: {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.status, 200);
• assert.equal(response.payload.errors, undefined);
• assert.equal(response.payload.data.viewer, null);
• assert.deepEqual(response.payload.data.projects, [ { key: 'public-site', name: 'Public Site', }, ]);
• assert.deepEqual(response.payload.data.publicProject, { key: 'public-site', slug: 'public-site', });
• assert.equal(response.payload.data.privateProject, null);
• assert.equal(response.payload.data.runs.length, 1);
• assert.equal(response.payload.data.runs[0].externalKey, 'public-site:github-actions:2001');
• assert.equal(response.payload.data.runs[0].coverageSnapshot.linesPct, 91);
• assert.equal(response.payload.data.publicRun.externalKey, 'public-site:github-actions:2001');
• assert.equal(response.payload.data.publicRun.suites[0].tests[0].fullName, 'public site passes');
• assert.equal(response.payload.data.publicRun.artifacts[0].href, 'raw/public-site/public-site.log');
• assert.equal(response.payload.data.privateRun, null);
• assert.deepEqual(response.payload.data.runPackages, [ { name: 'public-site', status: 'passed', suiteCount: 1, }, ]);
• assert.deepEqual(response.payload.data.runModules, [ { module: 'marketing', owner: 'growth', packageCount: 1, }, ]);
• assert.deepEqual(response.payload.data.runFiles, [ { path: '/repo/apps/public-site/src/home.js', status: 'passed', testCount: 1, failedTestCount: 0, }, ]);
• assert.deepEqual(response.payload.data.tests, [ { fullName: 'public site passes', status: 'passed', packageName: 'public-site', }, ]);
• assert.deepEqual(response.payload.data.runPerformanceStats, [ { runId: 'run-public-1', statGroup: 'benchmark.browser.gameplay.nibbles.intro', statName: 'time_to_first_terminal_byte_ms', numericValue: 3200,…
• assert.deepEqual(response.payload.data.privateRunPerformanceStats, []);
• assert.deepEqual(response.payload.data.performanceTrend, [ { runId: 'run-public-1', statGroup: 'benchmark.browser.gameplay.nibbles.intro', statName: 'time_to_waiting_for_input_ms', numericValue: 11900, uni…
• assert.deepEqual(response.payload.data.privatePerformanceTrend, []);
• assert.deepEqual(response.payload.data.benchmarkCatalog, [ { projectKey: 'public-site', statGroup: 'benchmark.browser.gameplay.nibbles.intro', statNames: ['time_to_first_terminal_byte_ms', 'time_to_waiting_for_input_m…
• assert.deepEqual(response.payload.data.privateBenchmarkCatalog, []);
• assert.deepEqual(response.payload.data.coverageTrend, [ { runId: 'run-public-1', externalKey: 'public-site:github-actions:2001', scopeType: 'project', label: 'Public Site', linesPct: 91, versionKey:…
• assert.deepEqual(response.payload.data.runCoverageComparison, { runId: 'run-public-1', previousRunId: null, currentExternalKey: 'public-site:github-actions:2001', currentVersionKey: 'commit:public111', previousVersionKe…
• assert.deepEqual(response.payload.data.artifacts, [ { label: 'Public site log', href: 'raw/public-site/public-site.log', kind: 'file', }, ]);
• assert.deepEqual(response.payload.data.privateArtifacts, []);
• assert.deepEqual(response.payload.data.releaseNotes, [ { title: 'Public site launch', projectVersion: { versionKey: 'commit:public111', }, }, ]);

Source

test('GraphQL exposes guest-safe public reads and hides private resources', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createGraphqlModels(),
  });

  await listen(server);
  const response = await graphqlRequest(server, {
    query: `
      qu…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.status, 200);
• assert.equal(response.headers['x-request-id'], 'browser-request-123');
• assert.equal(response.headers['x-test-station-trace-id'], 'browser-request-123');
• assert.match(response.headers['server-timing'] || '', /graphql;dur=/);
• assert.equal(response.payload.extensions.testStationTrace.requestId, 'browser-request-123');
• assert.equal(response.payload.extensions.testStationTrace.traceId, 'browser-request-123');
• assert.equal(response.payload.extensions.testStationTrace.parentRequestId, null);
• assert.equal(response.payload.extensions.testStationTrace.operationName, 'TraceProbe');
• assert.equal(typeof response.payload.extensions.testStationTrace.durationMs, 'number');

Source

test('GraphQL returns trace headers and request profiling metadata', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createGraphqlModels(),
  });

  await listen(server);
  const response = await graphqlRequest(server, {
    query: `
      query Tra…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.status, 200);
• assert.equal(response.payload.errors, undefined);
• assert.deepEqual(response.payload.data.viewer, { id: 'user-1', userId: 'user-1', email: 'user-1@example.com', name: 'User One', role: 'member', isAdmin: false, isGuest: false, roleKeys: ['release-manager'],…
• assert.deepEqual(response.payload.data.projects, [ { key: 'group-only', name: 'Group Only', }, { key: 'hidden', name: 'Hidden', }, { key: 'public-site', name: 'Public Site', },…
• assert.deepEqual(response.payload.data.project, { key: 'workspace', slug: 'workspace', });
• assert.equal(response.payload.data.runs.length, 2);
• assert.equal(response.payload.data.runs[0].externalKey, 'workspace:github-actions:1001');
• assert.equal(response.payload.data.runs[0].coverageSnapshot.linesPct, 80);
• assert.equal(response.payload.data.runs[1].externalKey, 'workspace:github-actions:1000');
• assert.equal(response.payload.data.runs[1].coverageSnapshot.linesPct, 74);
• assert.equal(response.payload.data.run.suites.length, 1);
• assert.equal(response.payload.data.run.suites[0].tests.length, 2);
• assert.equal(response.payload.data.run.artifacts[0].href, 'raw/workspace/repo-node.log');
• assert.equal(response.payload.data.run.rawReport.summary.totalTests, 2);
• assert.deepEqual(response.payload.data.runPackages, [ { name: 'workspace', status: 'failed', suiteCount: 1, }, ]);
• assert.deepEqual(response.payload.data.runModules, [ { module: 'runtime', owner: 'platform', packageCount: 1, }, ]);
• assert.equal(response.payload.data.runFiles.length, 1);
• assert.equal(response.payload.data.runFiles[0].path, '/repo/packages/core/src/index.js');
• assert.equal(response.payload.data.runFiles[0].failedTestCount, 1);
• assert.equal(response.payload.data.tests.length, 1);
• assert.equal(response.payload.data.tests[0].fullName, 'workspace fails');
• assert.deepEqual(response.payload.data.runPerformanceStats, [ { runId: 'run-1', suiteRunId: null, testExecutionId: null, statGroup: 'benchmark.node.engine.nibbles.intro', statName: 'elapsed_ms', nume…
• assert.deepEqual(response.payload.data.performanceTrend, [ { runId: 'run-1', statGroup: 'benchmark.node.engine.nibbles.intro', statName: 'elapsed_ms', numericValue: 62.4, unit: 'ms', seriesId: 'inter…
• assert.deepEqual(response.payload.data.benchmarkCatalog, [ { projectKey: 'workspace', statGroup: 'benchmark.node.engine.nibbles.intro', statNames: ['elapsed_ms'], units: ['ms'], seriesIds: ['interpreter',…
• assert.equal(response.payload.data.coverageTrend.length, 2);
• assert.equal(response.payload.data.coverageTrend[0].scopeType, 'project');
• assert.equal(response.payload.data.coverageTrend[0].versionKey, 'commit:abc123');
• assert.equal(response.payload.data.runCoverageComparison.previousRunId, 'run-0');
• assert.equal(response.payload.data.runCoverageComparison.previousVersionKey, 'commit:zzz999');
• assert.equal(response.payload.data.runCoverageComparison.deltaLinesPct, 6);
• assert.equal(response.payload.data.runCoverageComparison.packageChanges[0].label, 'workspace');
• assert.equal(response.payload.data.runCoverageComparison.packageChanges[0].deltaLinesPct, 6);
• assert.equal(response.payload.data.runCoverageComparison.moduleChanges[0].label, 'runtime');
• assert.equal(response.payload.data.runCoverageComparison.fileChanges[0].filePath, '/repo/packages/core/src/index.js');
• assert.equal(response.payload.data.runCoverageComparison.fileChanges[0].deltaLinesPct, 6);
• assert.equal(response.payload.data.artifacts.length, 1);
• assert.equal(response.payload.data.releaseNotes[0].title, '0.1.0 release');

Source

test('GraphQL exposes project, run, file, test, artifact, trend, and release-note reads for signed-in actors', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createGraphqlModels(),
  });

  await listen(server);
  const response = await graphqlRequ…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.status, 403);
• assert.equal(response.payload.data, null);
• assert.equal(response.payload.errors[0].extensions.code, 'FORBIDDEN');

Source

test('GraphQL rejects admin queries for non-admin actors', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createAdminGraphqlModels(),
  });

  await listen(server);
  const response = await graphqlRequest(server, {
    query: `
      query AdminUse…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(initial.status, 200);
• assert.equal(initial.payload.errors, undefined);
• assert.deepEqual(initial.payload.data.adminUsers, [ { id: 'admin-1', email: 'admin@example.com', isAdmin: true, roleKeys: [], groupKeys: [], }, { id: 'user-1', email: 'user-1@example.co…
• assert.deepEqual(initial.payload.data.adminRoles, [ { id: 'role-1', key: 'release-manager', userCount: 1, projectCount: 1, }, ]);
• assert.deepEqual(initial.payload.data.adminGroups, [ { id: 'group-1', key: 'qa', userCount: 1, projectCount: 1, }, ]);
• assert.deepEqual(initial.payload.data.workspaceAccess, { isPublic: false, roleKeys: ['release-manager'], groupKeys: [], });
• assert.equal(createResponse.status, 200);
• assert.equal(createResponse.payload.errors, undefined);
• assert.equal(createResponse.payload.data.role.key, 'ops');
• assert.equal(createResponse.payload.data.group.key, 'partners');
• assert.equal(updateResponse.status, 200);
• assert.equal(updateResponse.payload.errors, undefined);
• assert.deepEqual(updateResponse.payload.data.updatedRole, { id: createdRoleId, key: 'ops', name: 'Operations Prime', description: 'Primary operations access', });
• assert.deepEqual(updateResponse.payload.data.updatedGroup, { id: createdGroupId, key: 'partners', name: 'Partners Prime', description: 'Primary partner access', });
• assert.equal(updateResponse.payload.data.promotedUser.isAdmin, true);
• assert.deepEqual(updateResponse.payload.data.userWithRole.roleKeys, ['ops', 'release-manager']);
• assert.deepEqual(updateResponse.payload.data.userWithGroup.groupKeys, ['partners', 'qa']);
• assert.deepEqual(updateResponse.payload.data.publicWorkspace, { project: { key: 'workspace', }, isPublic: true, roleKeys: ['release-manager'], groupKeys: [], });
• assert.deepEqual(updateResponse.payload.data.hiddenRoleAccess, { project: { key: 'hidden', }, isPublic: false, roleKeys: ['ops'], groupKeys: [], });
• assert.deepEqual(updateResponse.payload.data.hiddenGroupAccess, { project: { key: 'hidden', }, isPublic: false, roleKeys: ['ops'], groupKeys: ['partners'], });
• assert.equal(adminState.status, 200);
• assert.equal(adminState.payload.errors, undefined);
• assert.deepEqual(adminState.payload.data.user, { id: 'user-1', normalizedEmail: 'user-1@example.com', isAdmin: true, roleKeys: ['ops', 'release-manager'], groupKeys: ['partners', 'qa'], });
• assert.deepEqual(adminState.payload.data.hiddenAccess, { project: { key: 'hidden', }, isPublic: false, roleKeys: ['ops'], groupKeys: ['partners'], roles: [ { id: createdRoleId, key: 'ops'…
• assert.equal(cleanupResponse.status, 200);
• assert.equal(cleanupResponse.payload.errors, undefined);
• assert.deepEqual(cleanupResponse.payload.data.userWithoutRole, { id: 'user-1', roleKeys: ['release-manager'], groupKeys: ['partners', 'qa'], });
• assert.deepEqual(cleanupResponse.payload.data.userWithoutGroup, { id: 'user-1', roleKeys: ['release-manager'], groupKeys: ['qa'], });
• assert.deepEqual(cleanupResponse.payload.data.hiddenWithoutRole, { project: { key: 'hidden', }, roleKeys: [], groupKeys: ['partners'], });
• assert.deepEqual(cleanupResponse.payload.data.hiddenWithoutGroup, { project: { key: 'hidden', }, roleKeys: [], groupKeys: [], });
• assert.deepEqual(cleanupResponse.payload.data.deletedRole, { id: createdRoleId, key: 'ops', });
• assert.deepEqual(cleanupResponse.payload.data.deletedGroup, { id: createdGroupId, key: 'partners', });

Source

test('GraphQL admin queries and mutations manage roles, groups, users, and project access', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createAdminGraphqlModels(),
  });

  await listen(server);

  const initial = await graphqlRequest(server, {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(guestProjects.map((project) => project.key), ['public-site']);
• assert.deepEqual(memberProjects.map((project) => project.key), ['group-only', 'hidden', 'public-site', 'workspace']);
• assert.deepEqual(adminProjects.map((project) => project.key), ['group-only', 'hidden', 'public-site', 'workspace']);

Source

test('query service exposes public projects to guests and the full workspace to signed-in users', async () => {
  const queryService = createGraphqlQueryService({
    models: createGraphqlModels(),
  });

  const guestProjects = await queryService.listProjects({
    actor: {
      id: 'guest',
      userId: null,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.status, 200);
• assert.equal(response.payload.errors, undefined);
• assert.equal(response.payload.data.ingestRun.externalKey, 'workspace:github-actions:1002');
• assert.equal(response.payload.data.ingestRun.counts.tests, 2);
• assert.equal(ingestionCalls.length, 1);
• assert.equal(ingestionCalls[0].projectKey, 'workspace');
• assert.equal(ingestionCalls[0].source.runId, '1002');

Source

test('GraphQL ingest mutation accepts shared-key service auth', async () => {
  const ingestionCalls = [];
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    ingestSharedKeys: ['phase4-secret'],
    models: createGraphqlModels(),
    ingestionService: {
      async ingest(p…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(actor, { id: 'guest', userId: null, email: null, name: 'Guest', role: 'guest', isAdmin: false, isGuest: true, roleKeys: [], groupKeys: [], });

Source

test('resolveActorFromRequest returns a guest actor when no identity headers are present', async () => {
  const actor = await resolveActorFromRequest({
    headers: {},
  }, {
    models: createGraphqlModels(),
  });

  assert.deepEqual(actor, {
    id: 'guest',
    userId: null,
    email: null,
    name: 'Guest',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(actor.id, 'user-1');
• assert.equal(actor.userId, 'user-1');
• assert.equal(actor.email, 'Bootstrap.Admin@example.com');
• assert.equal(actor.name, 'Bootstrap Admin');
• assert.equal(actor.role, 'admin');
• assert.equal(actor.isAdmin, true);
• assert.equal(actor.isGuest, false);
• assert.deepEqual(actor.roleKeys, []);
• assert.deepEqual(actor.groupKeys, []);
• assert.deepEqual(models.User.rows, [{ id: 'user-1', email: 'Bootstrap.Admin@example.com', normalizedEmail: 'bootstrap.admin@example.com', name: 'Bootstrap Admin', avatarUrl: null, isAdmin: true, metadata: {},…

Source

test('resolveActorFromRequest upserts persisted users, applies bootstrap admin emails, and ignores legacy project key headers', async () => {
  const models = {
    User: createMutableModel([], 'user'),
    Role: createFindAllModel([]),
    Group: createFindAllModel([]),
    UserRole: createFindAllModel([]),
    UserG…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(runs.length, 2);
• assert.equal(runs[0].externalKey, 'workspace:github-actions:1002');
• assert.deepEqual(runFindAllOptions.where, { projectId: ['project-1'], });
• assert.equal(runFindAllOptions.limit, 5);
• assert.deepEqual(runFindAllOptions.order, [ ['completedAt', 'DESC'], ['startedAt', 'DESC'], ['createdAt', 'DESC'], ]);
• assert.deepEqual(runFindAllOptions.attributes, [ 'id', 'projectId', 'projectVersionId', 'externalKey', 'sourceProvider', 'sourceRunId', 'sourceUrl', 'triggeredBy', 'branch', 'commitSha', 'started…
• assert.deepEqual(versionFindAllOptions.where, { id: ['version-2', 'version-1'], });
• assert.deepEqual(snapshotFindAllOptions.where, { runId: ['run-2', 'run-1'], });
• assert.deepEqual(runs[0].summary, { totalTests: 3, passedTests: 3, failedTests: 0 });

Source

test('listRuns queries the lightweight feed fields with DB-side limit and related lookups', async () => {
  let runFindAllOptions = null;
  let versionFindAllOptions = null;
  let snapshotFindAllOptions = null;

  const queryService = createGraphqlQueryService({
    accessService: {
      async filterProjects({ projec…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(runs.length, 3);
• assert.equal(runs[0].externalKey, 'workspace:github-actions:1003');
• assert.equal(runFindAllOptions.limit, undefined);

Source

test('listRuns returns the full visible run set when no limit is provided', async () => {
  let runFindAllOptions = null;

  const queryService = createGraphqlQueryService({
    accessService: {
      async filterProjects({ projects }) {
        return projects;
      },
    },
    models: {
      Project: createFindA…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(memberPoints.map((point) => ({ runId: point.runId, statName: point.statName, numericValue: point.numericValue, seriesId: point.seriesId, buildNumber: point.buildNumber, projectKey: point.projectKey,…
• assert.deepEqual(guestPoints, []);

Source

test('listPerformanceTrend applies visibility, metadata filters, and post-filter limits', async () => {
  const queryService = createGraphqlQueryService({
    models: createGraphqlModels(),
  });

  const memberActor = {
    id: 'user-1',
    userId: 'user-1',
    email: 'user-1@example.com',
    name: 'User One',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase12-graphql-query-layer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(authOptions.pages.signIn, '/auth/signin');
• assert.equal(authOptions.pages.error, '/auth/signin');
• assert.equal(authOptions.providers.some((provider) => provider.type === 'credentials'), true);
• assert.equal(token.userId, 'user-1');
• assert.equal(token.role, 'admin');
• assert.equal(session.userId, 'user-1');
• assert.equal(session.role, 'admin');
• assert.equal(session.user.image, null);

Source

test('web auth options expose the sign-in page and session actor metadata', async () => {
  const originalGoogleClientId = process.env.GOOGLE_CLIENT_ID;
  const originalGoogleClientSecret = process.env.GOOGLE_CLIENT_SECRET;

  try {
    delete process.env.GOOGLE_CLIENT_ID;
    delete process.env.GOOGLE_CLIENT_SECRET;…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(token, { sub: 'google-user-1', userId: 'google-user-1', email: 'josh@psidox.com', name: 'Joshua Bellamy', role: 'member', picture: 'https://example.com/avatar.png', });
• assert.deepEqual(session, { expires: '2099-01-01T00:00:00.000Z', user: { name: 'Joshua Bellamy', email: 'josh@psidox.com', image: 'https://example.com/avatar.png', }, userId: 'google-user-1', role: 'me…

Source

test('web auth callbacks shape a successful Google OAuth user into a stable token and session', async () => {
  const authOptions = createAuthOptions({
    secret: 'test-secret',
    adminEmails: ['admin@example.com'],
    demoAuthEnabled: false,
  });

  const token = await authOptions.callbacks.jwt({
    token: {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(token, { sub: 'google-user-1', userId: 'google-user-1', email: 'admin@example.com', name: 'Admin Operator', role: 'admin', picture: 'https://example.com/avatar.png', });
• assert.deepEqual(session, { user: { name: 'Admin Operator', email: 'admin@example.com', image: 'https://example.com/avatar.png', }, userId: 'google-user-1', role: 'admin', });

Source

test('web auth callbacks keep a stable identity on follow-up requests after Google OAuth sign-in', async () => {
  const authOptions = createAuthOptions({
    secret: 'test-secret',
    adminEmails: ['admin@example.com'],
    demoAuthEnabled: false,
  });

  const token = await authOptions.callbacks.jwt({
    token: {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(chunks.length, 1);
• assert.match(logged, /\[next-auth:logger\]/);
• assert.doesNotMatch(logged, /secret-code/);
• assert.doesNotMatch(logged, /secret-state/);
• assert.doesNotMatch(logged, /access-token/);
• assert.doesNotMatch(logged, /id-token/);
• assert.doesNotMatch(logged, /refresh-token/);
• assert.match(logged, /<redacted>/);

Source

test('web auth logger redacts sensitive OAuth callback metadata', async () => {
  const authOptions = createAuthOptions({
    secret: 'test-secret',
    demoAuthEnabled: false,
  });
  const originalWrite = process.stderr.write;
  const chunks = [];

  process.stderr.write = function patchedWrite(chunk, encoding, call…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(authOptions.providers.some((provider) => provider.id === 'google'), true);

Source

test('web exposes Google as an OAuth provider when configured', () => {
  const originalGoogleClientId = process.env.GOOGLE_CLIENT_ID;
  const originalGoogleClientSecret = process.env.GOOGLE_CLIENT_SECRET;

  try {
    process.env.GOOGLE_CLIENT_ID = 'google-client-id';
    process.env.GOOGLE_CLIENT_SECRET = 'google-cl…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveDemoAuthEnabled(), false);
• assert.equal(authOptions.providers.some((provider) => provider.type === 'credentials'), false);

Source

test('web demo auth defaults off unless explicitly enabled', () => {
  const originalDemoAuthEnabled = process.env.WEB_DEMO_AUTH_ENABLED;

  try {
    delete process.env.WEB_DEMO_AUTH_ENABLED;

    assert.equal(resolveDemoAuthEnabled(), false);

    const authOptions = createAuthOptions();
    assert.equal(authOptions…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveDemoAuthEnabled(), true);
• assert.equal(authOptions.providers.some((provider) => provider.type === 'credentials'), true);

Source

test('web demo auth can be enabled from WEB_DEMO_AUTH_ENABLED', () => {
  const originalDemoAuthEnabled = process.env.WEB_DEMO_AUTH_ENABLED;
  const originalGoogleClientId = process.env.GOOGLE_CLIENT_ID;
  const originalGoogleClientSecret = process.env.GOOGLE_CLIENT_SECRET;

  try {
    process.env.WEB_DEMO_AUTH_ENABL…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(authOptions.providers.some((provider) => provider.id === 'google'), true);
• assert.equal(authOptions.providers.some((provider) => provider.type === 'credentials'), false);
• assert.equal(resolveAutoSignInProviderId(authOptions.providers), 'google');
• assert.equal(resolveAutoSignInProviderId(authOptions.providers, { signedOut: true }), null);
• assert.equal(resolveAutoSignInProviderId(authOptions.providers, { error: 'OAuthSignin' }), null);

Source

test('web hides demo auth and auto-selects Google when Google OAuth is configured', () => {
  const originalDemoAuthEnabled = process.env.WEB_DEMO_AUTH_ENABLED;
  const originalGoogleClientId = process.env.GOOGLE_CLIENT_ID;
  const originalGoogleClientSecret = process.env.GOOGLE_CLIENT_SECRET;

  try {
    process.env…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(buildSignedOutRedirectUrl(), '/');

Source

test('web sign-out redirects to a signed-out sign-in page without auto re-authenticating', () => {
  assert.equal(buildSignedOutRedirectUrl(), '/');
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveNextAuthUrl(), 'http://localhost:3017');
• assert.equal(process.env.NEXTAUTH_URL, 'http://localhost:3017');

Source

test('web defaults NEXTAUTH_URL to localhost using WEB_PORT when unset', () => {
  const originalNextAuthUrl = process.env.NEXTAUTH_URL;
  const originalWebPort = process.env.WEB_PORT;

  try {
    delete process.env.NEXTAUTH_URL;
    process.env.WEB_PORT = '3017';

    assert.equal(resolveNextAuthUrl(), 'http://local…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(ensureNextAuthUrl(), 'http://localhost:3018');
• assert.equal(process.env.NEXTAUTH_URL, 'http://localhost:3018');

Source

test('web normalizes blank NEXTAUTH_URL before next-auth reads it', () => {
  const originalNextAuthUrl = process.env.NEXTAUTH_URL;
  const originalWebPort = process.env.WEB_PORT;

  try {
    process.env.NEXTAUTH_URL = '   ';
    process.env.WEB_PORT = '3018';

    assert.equal(ensureNextAuthUrl(), 'http://localhost:…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(headers, { 'x-test-station-actor-id': 'user-1', 'x-test-station-actor-email': 'user@example.com', 'x-test-station-actor-name': 'Web User', 'x-test-station-actor-role': 'member', });
• assert.equal(isProtectedWebPath('/'), false);
• assert.equal(isProtectedWebPath('/projects/workspace'), false);
• assert.equal(isProtectedWebPath('/runs/run-1'), false);
• assert.equal(isProtectedWebPath('/admin'), true);
• assert.equal(isProtectedWebPath('/admin/access'), true);
• assert.equal(isProtectedWebPath('/auth/signin'), false);
• assert.equal(buildSignInRedirectUrl('/runs/run-1'), '/auth/signin?callbackUrl=%2Fruns%2Frun-1');
• assert.equal( buildSignInRedirectUrl('https://0.0.0.0:3001/?foo=bar#frag'), '/auth/signin?callbackUrl=%2F%3Ffoo%3Dbar%23frag', );

Source

test('web actor headers and route protection helpers produce the expected auth wiring', () => {
  const headers = buildWebActorHeaders({
    userId: 'user-1',
    user: {
      email: 'user@example.com',
      name: 'Web User',
    },
    role: 'member',
  });

  assert.deepEqual(headers, {
    'x-test-station-actor-i…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveWebServerUrl(), 'http://localhost:4411');

Source

test('web defaults SERVER_URL to localhost using SERVER_PORT when unset', () => {
  const originalServerUrl = process.env.SERVER_URL;
  const originalServerPort = process.env.SERVER_PORT;

  try {
    delete process.env.SERVER_URL;
    process.env.SERVER_PORT = '4411';

    assert.equal(resolveWebServerUrl(), 'http://…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(resolvePublicRuntimeConfig(), { graphqlPath: '/runtime-graphql', GA_MEASUREMENT_ID: 'G-TESTSTATION123', });

Source

test('web public runtime config exposes graphql path and analytics measurement id', () => {
  const originalGraphqlPath = process.env.WEB_GRAPHQL_PATH;
  const originalGaMeasurementId = process.env.GA_MEASUREMENT_ID;

  try {
    process.env.WEB_GRAPHQL_PATH = '/runtime-graphql';
    process.env.GA_MEASUREMENT_ID = 'G…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveWebServerUrl(), 'http://test-station-server:4400');

Source

test('web server URL ignores NEXT_PUBLIC_SERVER_URL and uses runtime SERVER_URL', () => {
  const originalServerUrl = process.env.SERVER_URL;
  const originalNextPublicServerUrl = process.env.NEXT_PUBLIC_SERVER_URL;

  try {
    process.env.SERVER_URL = 'http://test-station-server:4400';
    process.env.NEXT_PUBLIC_SE…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(typeof resolveNextAuthHandler(), 'function');

Source

test('web auth API resolves a callable NextAuth handler', () => {
  assert.equal(typeof resolveNextAuthHandler(), 'function');
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(response.statusCode, 302);
• assert.equal(headers.get('location'), '/auth/signin?callbackUrl=%2F&error=OAuthCallback');
• assert.equal(ended, true);
• assert.ok(Array.isArray(cookies));
• assert.ok(cookies.some((cookie) => cookie.startsWith('__Secure-next-auth.pkce.code_verifier=')));
• assert.ok(cookies.some((cookie) => cookie.startsWith('__Secure-next-auth.state=')));
• assert.ok(cookies.some((cookie) => cookie.startsWith('__Secure-next-auth.session-token=')));

Source

test('web auth API recovers OAuth callback invalid_grant errors by clearing auth cookies and redirecting to sign-in', async () => {
  const headers = new Map();
  let ended = false;
  const response = {
    statusCode: 200,
    setHeader(name, value) {
      headers.set(String(name).toLowerCase(), value);
    },
    e…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(handled, false);

Source

test('web auth API only recovers OAuth callback errors for the Google callback route', () => {
  const handled = handleRecoverableOAuthCallbackError(
    { url: '/api/auth/session' },
    {
      setHeader() {
        throw new Error('should not be called');
      },
      end() {
        throw new Error('should not b…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(headers.get('cache-control'), 'no-store');
• assert.equal(response.statusCode, 200);
• assert.deepEqual(response.payload, { status: 'ok', service: 'test-station-web', });

Source

test('web health endpoint returns a fast readiness payload', () => {
  const headers = new Map();
  const response = {
    statusCode: null,
    payload: null,
    setHeader(name, value) {
      headers.set(String(name).toLowerCase(), value);
    },
    status(code) {
      this.statusCode = code;
      return this;…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(request.query, /query WebBadgeSummary/);
• assert.deepEqual(request.variables, { projectKey: 'test-station', });
• assert.equal(responseState.statusCode, 200);
• assert.equal(responseState.headers['cache-control'], 'public, s-maxage=300, stale-while-revalidate=600');
• assert.deepEqual(JSON.parse(responseState.bodyText), { schemaVersion: 1, label: 'health', message: '91%', color: 'brightgreen', });

Source

test('web badge endpoint resolves latest run badges from the reporting backend', async () => {
  const responseState = createResponseRecorder();
  const handler = createBadgeHandler({
    fetchImpl: async (_url, options) => {
      const request = JSON.parse(options.body);
      assert.match(request.query, /query WebB…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(responseState.statusCode, 404);
• assert.equal(resolveRequestedBadgeType('HeAlTh'), 'health');

Source

test('web badge endpoint rejects unknown badge types', async () => {
  const responseState = createResponseRecorder();
  const handler = createBadgeHandler();

  await handler({
    method: 'GET',
    query: {
      badge: 'missing',
    },
    headers: {},
  }, responseState.res);

  assert.equal(responseState.status…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(capturedRequest.query, /badgeSummary/);
• assert.doesNotMatch(capturedRequest.query, /runs\(/);
• assert.deepEqual(summary, { totalTests: 7, passedTests: 5, failedTests: 2, skippedTests: 1, coverage: { lines: { pct: 91.2, }, }, });

Source

test('web badge summary query returns a minimal public projection', async () => {
  let capturedRequest = null;

  const summary = await loadProjectBadgeSummary({
    projectKey: 'private-project',
    fetchImpl: async (_url, options) => {
      capturedRequest = JSON.parse(options.body);

      return new Response(JS…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(responseState.statusCode, 200);
• assert.deepEqual(sanitizeBadgeSummary({ totalTests: 10, passedTests: 8, failedTests: 2, skippedTests: 0, coverage: { lines: { pct: 83.6 } }, branch: 'secret-branch', commitSha: 'abcdef123456', metadata: { in…
• assert.deepEqual(Object.keys(JSON.parse(responseState.bodyText)).sort(), ['color', 'label', 'message', 'schemaVersion']);

Source

test('web badge endpoint sanitizes summary payloads before returning badge JSON', async () => {
  const responseState = createResponseRecorder();
  const handler = createBadgeHandler({
    loadBadgeSummary: async () => ({
      totalTests: 10,
      passedTests: 8,
      failedTests: 2,
      skippedTests: 0,
      co…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(home.viewer.id, 'user-1');
• assert.equal(home.projects.length, 1);
• assert.deepEqual(home.runs[0].summary, { totalTests: 2, passedTests: 1, failedTests: 1 });
• assert.equal(requests[0].headers['x-request-id'], 'req-home');
• assert.equal(project.project.key, 'workspace');
• assert.equal(project.runs.length, 1);
• assert.equal(project.coverageTrend.length, 2);
• assert.equal(project.releaseNotes.length, 1);
• assert.equal(project.benchmarkCatalog.length, 1);
• assert.equal(project.benchmarkPanels.length, 1);
• assert.equal(project.benchmarkPanels[0].statGroup, 'benchmark.node.engine.nibbles.intro');
• assert.equal(project.benchmarkPanels[0].metrics[0].points.length, 3);
• assert.equal(project.trendPanels.overlays.length, 3);
• assert.equal(project.trendPanels.packageTrends.length, 1);
• assert.equal(project.trendPanels.packageTrends[0].label, 'workspace');
• assert.equal(project.trendPanels.moduleTrends[0].label, 'runtime');
• assert.equal(project.trendPanels.fileTrends[0].label, '/repo/packages/core/src/index.js');
• assert.equal(requests[1].body.variables.slug, 'workspace');
• assert.equal(requests[2].body.variables.projectKey, 'workspace');
• assert.equal(requests[3].body.variables.runId, 'run-1');
• assert.equal(requests[4].body.variables.packageName, 'workspace');
• assert.equal(requests[5].body.variables.moduleName, 'runtime');
• assert.equal(requests[6].body.variables.filePath, '/repo/packages/core/src/index.js');
• assert.equal(requests[7].body.variables.projectKey, 'workspace');
• assert.equal(requests[7].body.variables.statGroup, 'benchmark.node.engine.nibbles.intro');
• assert.equal(requests[7].body.variables.statName, 'elapsed_ms');

Source

test('web GraphQL helpers forward actor headers and combine project activity data', async () => {
  const session = {
    userId: 'user-1',
    user: {
      email: 'user@example.com',
      name: 'Web User',
    },
    role: 'member',
  };
  const requests = [];
  const fetchImpl = async (_url, options) => {
    cons…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(project.project.key, 'workspace');
• assert.equal(project.coverageTrend.length, 1);
• assert.equal(project.releaseNotes.length, 1);
• assert.equal(project.trendPanels.overall.length, 1);
• assert.equal(project.trendPanels.overlays.length, 2);
• assert.deepEqual(project.benchmarkPanels, []);
• assert.deepEqual(project.trendPanels.packageTrends, []);
• assert.deepEqual(project.trendPanels.moduleTrends, []);
• assert.deepEqual(project.trendPanels.fileTrends, []);

Source

test('web project loader falls back to the base trend view when scoped trend panels fail', async () => {
  const session = {
    userId: 'user-1',
    user: {
      email: 'user@example.com',
      name: 'Web User',
    },
    role: 'member',
  };

  const fetchImpl = async (_url, options) => {
    const request = JSO…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(home.viewer, null);
• assert.equal(home.projects[0].key, 'public-site');
• assert.equal(requests[0].headers['x-test-station-actor-id'], undefined);
• assert.equal(requests[0].headers['x-request-id'], 'req-guest');
• assert.equal(requests[0].headers['x-test-station-trace-id'], 'req-guest');
• assert.equal(responseState.statusCode, 200);
• assert.deepEqual(JSON.parse(responseState.bodyText), { data: { projects: [{ key: 'public-site' }], }, });
• assert.equal(responseState.headers['x-request-id'], 'proxy-guest');
• assert.equal(responseState.headers['x-test-station-trace-id'], 'proxy-guest');
• assert.equal(requests[1].headers['x-test-station-actor-id'], undefined);
• assert.match(requests[1].headers['x-request-id'], /^webproxy-/);
• assert.equal(requests[1].headers['x-test-station-trace-id'], 'proxy-guest');
• assert.equal(requests[1].headers['x-test-station-parent-request-id'], 'proxy-guest');

Source

test('web GraphQL helpers and proxy allow anonymous public reads without actor headers', async () => {
  const requests = [];
  const fetchImpl = async (_url, options) => {
    requests.push({
      headers: options.headers,
      body: JSON.parse(options.body),
    });

    return new Response(JSON.stringify({…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(overview.props.session, null);
• assert.equal(overview.props.data.projects[0].key, 'public-site');
• assert.equal(overview.props.pageProfile, pageProfile);
• assert.equal(projectPage.props.session, null);
• assert.equal(projectPage.props.data.project.slug, 'public-site');
• assert.equal(projectPage.props.pageProfile, pageProfile);
• assert.deepEqual(projectNotFound, { notFound: true });
• assert.equal(runPage.props.session, null);
• assert.equal(runPage.props.data.run.id, 'run-public-1');
• assert.equal(runPage.props.pageProfile, pageProfile);
• assert.deepEqual(runNotFound, { notFound: true });

Source

test('web SSR page result builders allow guest public pages and return notFound for private resources', async () => {
  const store = createStoreStub();
  const session = null;
  const pageProfile = {
    pageType: 'overview',
    route: '/',
    totalMs: 12.4,
    steps: [{ name: 'home-feed-query', durationMs: 8.7 }]…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(pageProfile.pageType, 'project');
• assert.equal(pageProfile.route, '/projects/public-site');
• assert.equal(pageProfile.projectSlug, 'public-site');
• assert.equal(pageProfile.runCount, 3);
• assert.equal(pageProfile.steps.length, 2);
• assert.match(serverTimingHeader, /project;dur=/);
• assert.match(serverTimingHeader, /project-base-query;dur=/);
• assert.equal(globalThis.window.__TEST_STATION_PERF__.serverPageProfile.pageType, 'project');
• assert.equal(globalThis.window.__TEST_STATION_PERF__.pageMarks[0].name, 'project-page-ready');
• assert.equal(completedRoute.to, '/runs/run-1');
• assert.equal(completedRoute.status, 'completed');
• assert.equal(completedRoute.marks[0].name, 'routeChangeStart');

Source

test('web page profiling helpers capture server timings and client route milestones', async () => {
  const pageProfiler = createPageLoadProfiler({
    pageType: 'project',
    route: '/projects/public-site',
  });

  await pageProfiler.measureStep('project-base-query', async () => {});
  await pageProfiler.measureSte…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(data, ADMIN_PAGE_UNAUTHORIZED);
• assert.equal(requests.length, 1);
• assert.match(requests[0].query, /WebViewerAccess/);

Source

test('web admin loaders short-circuit for authenticated non-admin viewers', async () => {
  const requests = [];
  const fetchImpl = async (_url, options) => {
    const body = JSON.parse(options.body);
    requests.push(body);

    return new Response(JSON.stringify({
      data: {
        viewer: {
          id: 'vi…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(overview.viewer.isAdmin, true);
• assert.equal(overview.users.length, 1);
• assert.equal(overview.projects[0].project.slug, 'workspace');
• assert.equal(projectAccess.projectAccess.project.slug, 'workspace');
• assert.equal(projectAccess.projectAccess.isPublic, false);
• assert.match(requests[0].query, /WebViewerAccess/);
• assert.match(requests[1].query, /AdminOverviewPage/);
• assert.match(requests[2].query, /WebViewerAccess/);
• assert.match(requests[3].query, /AdminProjectAccessPage/);
• assert.deepEqual(requests[3].variables, { slug: 'workspace' });

Source

test('web admin loaders normalize overview and project access data for admin pages', async () => {
  const requests = [];
  const session = {
    userId: 'admin-1',
    user: {
      email: 'admin@example.com',
      name: 'Admin User',
    },
    role: 'admin',
  };
  const fetchImpl = async (_url, options) => {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.props.session.userId, 'admin-1');
• assert.equal(result.props.data.viewer.isAdmin, true);
• assert.deepEqual(actions, [ { type: 'view', payload: 'admin' }, { type: 'runtime', payload: { graphqlPath: '/runtime-graphql', GA_MEASUREMENT_ID: 'G-TESTSTATION123' } }, { type: 'project', payload: 'workspace' }, {…
• assert.deepEqual(buildAdminPageResult({ store, session: null, data: null, }), { notFound: true });

Source

test('web admin page result builder dispatches admin state and selected project context', () => {
  const originalGraphqlPath = process.env.WEB_GRAPHQL_PATH;
  const originalGaMeasurementId = process.env.GA_MEASUREMENT_ID;
  const actions = [];
  const store = {
    dispatch(action) {
      actions.push(action);
    }…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(session, null);
• assert.equal(runId, 'run-public-1');
• assert.equal(requestId, 'runner-guest');
• assert.equal(responseState.statusCode, 200);
• assert.equal(responseState.headers['content-type'], 'text/html; charset=utf-8');
• assert.equal(responseState.headers['x-request-id'], 'runner-guest');
• assert.equal(responseState.headers['x-test-station-trace-id'], 'runner-guest');
• assert.match(responseState.bodyText, /public report/);

Source

test('web runner report handler allows anonymous public report rendering', async () => {
  const responseState = createResponseRecorder();
  const handler = createRunReportHandler({
    getSession: async () => null,
    loadReportHtml: async ({ session, runId, requestId }) => {
      assert.equal(session, null);…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(runnerView.run.id, 'run-1');
• assert.deepEqual(runnerView.failedTests, []);
• assert.deepEqual(runnerView.runModules, []);
• assert.equal(runnerView.coverageComparison, null);
• assert.equal(runnerView.coverageTrend.length, 1);
• assert.equal(runnerView.benchmarkPanels.length, 1);
• assert.equal(operationsView.run.id, 'run-1');
• assert.equal(operationsView.failedTests.length, 1);
• assert.equal(operationsView.runModules[0].module, 'runtime');
• assert.equal(operationsView.runPerformanceStats.length, 1);
• assert.equal(operationsView.runPerformanceStats[0].statGroup, 'benchmark.node.engine.nibbles.intro');
• assert.equal(operationsView.coverageComparison.deltaLinesPct, 6);
• assert.equal(operationsView.coverageComparison.fileChanges[0].filePath, '/repo/packages/core/src/index.js');
• assert.equal(operationsView.coverageTrend.length, 1);
• assert.equal(operationsView.coverageTrendOverlays.length, 2);
• assert.equal(operationsView.benchmarkPanels.length, 1);
• assert.deepEqual(direct, { projects: [], });
• assert.equal(formatDuration(1250), '1.3 s');
• assert.equal(formatCoveragePct(80), '80%');
• assert.equal(formatBuildNumber(88), 'build #88');
• assert.equal(formatCommitSha('abcdef1234567890'), 'abcdef1');
• assert.equal(formatRepositoryName('https://github.com/smysnk/test-station.git'), 'smysnk/test-station');
• assert.equal(resolveRunBuildNumber({ projectVersion: { buildNumber: 88 } }), 88);
• assert.equal(resolveRunBuildNumber({ buildNumber: 45 }), 45);
• assert.equal(resolveRunBuildNumber({ rawReport: { meta: { ci: { environment: { GITHUB_RUN_NUMBER: '12' } } } } }), 12);
• assert.equal(formatRunBuildLabel({ projectVersion: { buildNumber: 88 } }), 'build #88');
• assert.equal(formatRunBuildLabel({ rawReport: { meta: { ci: { environment: { GITHUB_RUN_NUMBER: '45' } } } } }), 'build #45');
• assert.equal(formatRunBuildLabel({ sourceRunId: '1001' }), 'run 1001');
• assert.equal(formatBenchmarkValue(57.54, 'ms'), '57.5 ms');
• assert.equal(formatBenchmarkValue(2048, 'bytes'), '2 KiB');
• assert.equal(formatBenchmarkMetricLabel('steps_per_second'), 'Steps Per Second');
• assert.equal(formatBenchmarkNamespace('benchmark.node.engine.nibbles.intro'), 'Node / Engine / Nibbles / Intro');
• assert.equal(graphqlQueries.some((query) => query.includes('query WebRunHeader')), true);
• assert.equal(graphqlQueries.some((query) => query.includes('query WebRunHeader') && query.includes('runPackages(runId: $runId)')), false);
• assert.equal(graphqlQueries.some((query) => query.includes('query WebRunDetail') && query.includes('runPackages(runId: $runId)')), true);
• assert.equal(graphqlQueries.some((query) => query.includes('query WebRunDetail') && query.includes('runPerformanceStats(runId: $runId)')), true);
• assert.equal(graphqlQueries.some((query) => query.includes('query WebRunProjectHistory') && query.includes('coverageTrend(projectKey: $projectKey')), true);
• assert.equal(graphqlQueries.some((query) => query.includes('query WebPerformanceTrend') && query.includes('performanceTrend(projectKey: $projectKey')), true);

Source

test('web run loader and raw GraphQL executor preserve response structure', async () => {
  const session = {
    userId: 'user-1',
    user: {
      email: 'user@example.com',
      name: 'Web User',
    },
    role: 'member',
  };
  const graphqlQueries = [];
  const fetchImpl = async (_url, options) => {
    const…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /build #88/);
• assert.match(html, /https:\/\/github\.com\/example\/test-station\/actions\/runs\/1001/);
• assert.match(WEB_HOME_QUERY, /viewer/);
• assert.match(WEB_HOME_QUERY, /runFeed\s*\{/);
• assert.doesNotMatch(WEB_HOME_QUERY, /runFeed\(limit:/);
• assert.match(WEB_HOME_QUERY, /sourceRunId/);
• assert.match(WEB_HOME_QUERY, /sourceUrl/);
• assert.match(WEB_HOME_QUERY, /buildNumber/);
• assert.match(PROJECT_ACTIVITY_QUERY, /runs\(projectKey: \$projectKey\)\s*\{/);
• assert.doesNotMatch(PROJECT_ACTIVITY_QUERY, /runs\(projectKey: \$projectKey,\s*limit:/);
• assert.match(PROJECT_ACTIVITY_QUERY, /sourceRunId/);
• assert.match(PROJECT_ACTIVITY_QUERY, /sourceUrl/);
• assert.match(PROJECT_ACTIVITY_QUERY, /buildNumber/);
• assert.match(PROJECT_ACTIVITY_QUERY, /benchmarkCatalog\(projectKey: \$projectKey\)/);
• assert.match(PERFORMANCE_TREND_QUERY, /performanceTrend\(projectKey: \$projectKey, statGroup: \$statGroup, statName: \$statName, limit: \$limit\)/);
• assert.match(RUN_HEADER_QUERY, /sourceRunId/);
• assert.match(RUN_HEADER_QUERY, /sourceUrl/);
• assert.match(RUN_HEADER_QUERY, /buildNumber/);
• assert.match(RUN_DETAIL_QUERY, /sourceRunId/);
• assert.match(RUN_DETAIL_QUERY, /sourceUrl/);
• assert.match(RUN_DETAIL_QUERY, /buildNumber/);
• assert.match(RUN_DETAIL_QUERY, /runPerformanceStats\(runId: \$runId\)/);
• assert.match(RUN_PROJECT_HISTORY_QUERY, /coverageTrend\(projectKey: \$projectKey, limit: 12\)/);
• assert.match(RUN_PROJECT_HISTORY_QUERY, /benchmarkCatalog\(projectKey: \$projectKey\)/);

Source

test('web run build chip and GraphQL queries include build metadata and source links', () => {
  const html = renderToStaticMarkup(React.createElement(RunBuildChip, {
    run: {
      sourceRunId: '1001',
      sourceUrl: 'https://github.com/example/test-station/actions/runs/1001',
      projectVersion: {
        buil…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /Open GitHub Actions run/);
• assert.match(html, /https:\/\/github\.com\/example\/test-station\/actions\/runs\/1001/);
• assert.match(html, /web-button/);

Source

test('run source link renders a direct action back to the GitHub Actions run', () => {
  const html = renderToStaticMarkup(React.createElement(RunSourceLink, {
    run: {
      sourceUrl: 'https://github.com/example/test-station/actions/runs/1001',
    },
  }));

  assert.match(html, /Open GitHub Actions run/);
  asse…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /Namespace/);
• assert.match(html, /Metric/);
• assert.match(html, /interpreter-redux/);
• assert.match(html, /Node \/ Engine \/ Nibbles \/ Intro/);
• assert.match(html, /Elapsed Ms/);
• assert.match(html, /svg/);

Source

test('benchmark explorer renders namespace controls, series toggles, and chart content', () => {
  const html = renderToStaticMarkup(React.createElement(BenchmarkExplorer, {
    benchmarkPanels: [{
      projectKey: 'workspace',
      statGroup: 'benchmark.node.engine.nibbles.intro',
      statNames: ['elapsed_ms'],…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /Node \/ Engine \/ Nibbles \/ Intro/);
• assert.match(html, /Shared \/ Tight Arithmetic Loop/);
• assert.match(html, /57.5 ms/);
• assert.match(html, /404.6 ops\/s/);
• assert.match(html, /suite scope/);

Source

test('run benchmark summary groups benchmark rows by namespace', () => {
  const html = renderToStaticMarkup(React.createElement(RunBenchmarkSummary, {
    stats: [
      {
        id: 'perf-run-1-redux',
        statGroup: 'benchmark.node.engine.nibbles.intro',
        statName: 'elapsed_ms',
        numericValue: 57…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(selected.selectedProject.slug, 'beta');
• assert.deepEqual(selected.visibleRuns.map((run) => run.id), ['run-beta-1']);
• assert.deepEqual(selected.projects.map((project) => project.slug), ['beta', 'alpha', 'charlie']);
• assert.equal(selected.projects[0].recentRunCount, 1);
• assert.equal(selected.projects[2].latestRun, null);
• assert.equal(selected.latestCoverage, 91.2);
• assert.equal(allRuns.selectedProject, null);
• assert.deepEqual(allRuns.visibleRuns.map((run) => run.id), ['run-beta-1', 'run-alpha-1']);

Source

test('web home explorer model sorts sidebar projects by activity and filters the selected project feed', () => {
  const projects = [
    {
      id: 'project-a',
      key: 'alpha',
      slug: 'alpha',
      name: 'Alpha',
      repositoryUrl: 'https://github.com/example/alpha.git',
    },
    {
      id: 'project-b…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /Group by Module/);
• assert.match(html, /Group by Package/);
• assert.match(html, /Workspace Report - workspace:github-actions:1001/);
• assert.match(html, /<base target="_blank" \/>/);
• assert.match(html, new RegExp(RUNNER_REPORT_HEIGHT_MESSAGE_TYPE));
• assert.match(html, /href="https:\/\/artifacts\.example\.com\/workspace\/unit\.log"/);

Source

test('web can render the runner report template from stored raw report data', async () => {
  const session = {
    userId: 'user-1',
    user: {
      email: 'user@example.com',
      name: 'Web User',
    },
    role: 'member',
  };

  const fetchImpl = async (_url, options) => {
    const request = JSON.parse(optio…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(html, /document\.querySelector\('main'\)/);
• assert.match(html, /content\?\.scrollHeight/);
• assert.doesNotMatch(html, /body\?\.scrollHeight/);

Source

test('web runner report embed script measures the report content instead of the full iframe viewport', () => {
  const html = decorateEmbeddedRunnerReportHtml('<!DOCTYPE html><html><head></head><body><main>report</main></body></html>');

  assert.match(html, /document\.querySelector\('main'\)/);
  assert.match(html, /…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.match(appStylesSource, /\.web-table-wrap\s*\{[\s\S]*overflow:\s*visible;/);
• assert.doesNotMatch(appStylesSource, /\.web-table-wrap\s*\{[\s\S]*overflow-x:\s*auto;/);
• assert.match(runPageSource, /scrolling:\s*'no'/);
• assert.doesNotMatch(runPageSource, /Exact runner HTML report/);
• assert.match(runPageSource, /function RunnerReportSection[\s\S]*return React\.createElement\(RunnerReportFrame/);

Source

test('web focused run view avoids nested scroll containers around the report', () => {
  const appStylesSource = fs.readFileSync(new URL('../packages/web/pages/_app.js', import.meta.url), 'utf8');
  const runPageSource = fs.readFileSync(new URL('../packages/web/pages/runs/[id].js', import.meta.url), 'utf8');

  assert…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveRunTemplateMode(undefined), 'runner');
• assert.equal(resolveRunTemplateMode('runner'), 'runner');
• assert.equal(resolveRunTemplateMode('web'), 'web');
• assert.equal(buildRunTemplateHref('run-1', 'runner'), '/runs/run-1');
• assert.equal(buildRunTemplateHref('run-1', 'web'), '/runs/run-1?template=web');

Source

test('web run template routing defaults to the runner report and keeps the operations view addressable', () => {
  assert.equal(resolveRunTemplateMode(undefined), 'runner');
  assert.equal(resolveRunTemplateMode('runner'), 'runner');
  assert.equal(resolveRunTemplateMode('web'), 'web');
  assert.equal(buildRunTemplate…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase13-web-phase5.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(payload.projectKey, 'test-station');
• assert.equal(payload.source.provider, 'github-actions');
• assert.equal(payload.source.runId, '100');
• assert.equal(payload.source.repository, 'smysnk/test-station');
• assert.equal(payload.source.repositoryUrl, 'https://github.com/smysnk/test-station');
• assert.equal(payload.source.branch, 'main');
• assert.equal(payload.source.commitSha, 'abc123');
• assert.equal(payload.source.buildNumber, 88);
• assert.equal(payload.source.ci.status, 'passed');
• assert.equal(payload.source.ci.buildDurationMs, 240000);
• assert.equal(payload.source.ci.artifactCount, 5);
• assert.equal(payload.source.ci.environment.CI, 'true');
• assert.equal(payload.source.ci.environment.GITHUB_SHA, 'abc123');
• assert.equal(payload.source.ci.environment.GITHUB_WORKFLOW, 'CI');
• assert.equal(payload.source.ci.environment.RUNNER_OS, 'Linux');
• assert.equal('GITHUB_TOKEN' in payload.source.ci.environment, false);
• assert.equal(payload.artifacts.some((artifact) => artifact.relativePath === 'report.json'), true);
• assert.equal(payload.artifacts.some((artifact) => artifact.relativePath === 'modules.json'), true);
• assert.equal(payload.artifacts.some((artifact) => artifact.relativePath === 'ownership.json'), true);
• assert.equal(payload.artifacts.some((artifact) => artifact.relativePath === 'index.html'), true);
• assert.equal(payload.artifacts.some((artifact) => artifact.relativePath === 'raw/workspace/unit.log'), true);
• assert.equal(reportArtifact.storageKey, 's3://artifact-bucket/ci/test-station/100/1/report.json');
• assert.equal(reportArtifact.sourceUrl, 'https://artifacts.example.com/test-station/ci/test-station/100/1/report.json');
• assert.equal(rawArtifact.storageKey, 's3://artifact-bucket/ci/test-station/100/1/raw/workspace/unit.log');
• assert.equal(rawArtifact.sourceUrl, 'https://artifacts.example.com/test-station/ci/test-station/100/1/raw/workspace/unit.log');

Source

test('createIngestPayload includes GitHub metadata and S3-backed artifact pointers', () => {
  const fixture = createIngestFixture();
  const payload = createIngestPayload({
    reportPath: fixture.reportPath,
    projectKey: 'test-station',
    buildStartedAt: '2026-03-12T12:00:00.000Z',
    buildCompletedAt: '2026-0…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase14-ci-ingest-publisher.test.js",
    "matched": true
  }
}

Assertions

• assert.match(stdout, /Published test-station:github-actions:100/);
• assert.equal(capturedRequest.authorization, 'Bearer phase14-secret');
• assert.equal(capturedRequest.body.projectKey, 'test-station');
• assert.equal(capturedRequest.body.source.ci.status, 'failed');
• assert.equal(capturedRequest.body.source.ci.environment.GITHUB_RUN_ID, '100');
• assert.equal(capturedRequest.body.artifacts.some((artifact) => artifact.relativePath === 'raw/workspace/unit.log'), true);

Source

test('publish-ingest-report CLI posts bearer-authenticated payloads', async () => {
  const fixture = createIngestFixture();
  let capturedRequest = null;
  const server = createServer(async (req, res) => {
    const chunks = [];
    for await (const chunk of req) {
      chunks.push(chunk);
    }
    capturedRequest…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase14-ci-ingest-publisher.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual( artifacts.map((artifact) => artifact.relativePath), ['index.html', 'modules.json', 'ownership.json', 'raw/workspace/unit.log', 'report.json'], );
• assert.equal(enrichedReport.packages[0].suites[0].rawArtifacts[0].sourceUrl, 'https://artifacts.example.com/test-station/ci/test-station/100/1/raw/workspace/unit.log');

Source

test('collectOutputArtifacts and attachArtifactLocations cover the complete report directory', () => {
  const fixture = createIngestFixture();
  const artifacts = collectOutputArtifacts(path.dirname(fixture.reportPath), {
    bucket: 'artifact-bucket',
    prefix: 'ci/test-station/100/1',
    baseUrl: 'https://artifa…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase14-ci-ingest-publisher.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(summary, { configured: 3, processed: 3, created: 1, updated: 1, skipped: 0, });
• assert.equal(userModel.rows.length, 3);
• assert.equal(userModel.rows.find((row) => row.normalizedEmail === 'member@example.com').isAdmin, true);
• assert.deepEqual(userModel.rows.find((row) => row.normalizedEmail === 'new-admin@example.com').toJSON(), { id: 'user-3', email: 'new-admin@example.com', normalizedEmail: 'new-admin@example.com', name: 'new-admin@example.com…

Source

test('bootstrap admin sync creates missing users and elevates existing ones', async () => {
  const userModel = createMutableUserModel([
    {
      id: 'user-1',
      email: 'member@example.com',
      normalizedEmail: 'member@example.com',
      name: 'Member User',
      avatarUrl: null,
      isAdmin: false,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase15-bootstrap-admins.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(summary, { configured: 1, processed: 0, created: 0, updated: 0, skipped: 1, });

Source

test('bootstrap admin sync skips cleanly when the users table is unavailable during startup fallback', async () => {
  const summary = await synchronizeBootstrapAdminUsers({
    adminEmails: ['admin@example.com'],
    allowMissingTable: true,
    userModel: {
      async findAll() {
        throw new Error('relation "…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase15-bootstrap-admins.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(resolveBootstrapAdminEmails(), ['admin@example.com', 'second@example.com']);

Source

test('bootstrap admin email resolution normalizes configured values', () => {
  const originalAdminEmails = process.env.WEB_ADMIN_EMAILS;

  try {
    process.env.WEB_ADMIN_EMAILS = ' Admin@Example.com, second@example.com ,,ADMIN@example.com ';
    assert.deepEqual(resolveBootstrapAdminEmails(), ['admin@example.com',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase15-bootstrap-admins.test.js",
    "matched": true
  }
}

Assertions

• assert.equal( formatBootstrapAdminSummary({ configured: 0, processed: 0, created: 0, updated: 0, skipped: 0, }), '[db] bootstrap admin sync skipped (no configured bootstrap admins)', );
• assert.equal( formatBootstrapAdminSummary({ configured: 2, processed: 2, created: 1, updated: 1, skipped: 0, }), '[db] bootstrap admin sync complete (1 created, 1 updated, 0 skipped)', );

Source

test('bootstrap admin summary formatter reports the startup outcome clearly', () => {
  assert.equal(
    formatBootstrapAdminSummary({
      configured: 0,
      processed: 0,
      created: 0,
      updated: 0,
      skipped: 0,
    }),
    '[db] bootstrap admin sync skipped (no configured bootstrap admins)',
  );…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase15-bootstrap-admins.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(parsed, { projectKey: 'workspace', runId: 'run-1', limit: 5, dryRun: true, });

Source

test('report regeneration args support project, run, limit, and dry-run filters', () => {
  const parsed = parseRegenerateStoredReportsArgs([
    '--project-key', 'workspace',
    '--run-id', 'run-1',
    '--limit', '5',
    '--dry-run',
  ]);

  assert.deepEqual(parsed, {
    projectKey: 'workspace',
    runId: 'run-…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase16-report-regeneration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(hasReplayableRawReport({ rawReport: { summary: { totalTests: 2 } } }), true);
• assert.equal(hasReplayableRawReport({ rawReport: {} }), false);
• assert.equal(hasReplayableRawReport({ rawReport: null }), false);

Source

test('report regeneration detects replayable raw reports', () => {
  assert.equal(hasReplayableRawReport({ rawReport: { summary: { totalTests: 2 } } }), true);
  assert.equal(hasReplayableRawReport({ rawReport: {} }), false);
  assert.equal(hasReplayableRawReport({ rawReport: null }), false);
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase16-report-regeneration.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(artifacts, [{ label: 'run-log', relativePath: 'raw/run.log', href: 'https://example.test/raw/run.log', kind: 'log', mediaType: 'text/plain', storageKey: 's3://bucket/raw/run.log', sourceUrl: 'ht…

Source

test('report regeneration only replays run-level artifact metadata', () => {
  const artifacts = buildRunArtifactReplayPayloads([
    {
      label: 'run-log',
      relativePath: 'raw/run.log',
      href: 'https://example.test/raw/run.log',
      kind: 'log',
      mediaType: 'text/plain',
      storageKey: 's3://bu…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase16-report-regeneration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(payload.projectKey, 'workspace');
• assert.equal(payload.report.summary.totalTests, 2);
• assert.equal(payload.source.provider, 'github-actions');
• assert.equal(payload.source.runId, '1001');
• assert.equal(payload.source.actor, 'octocat');
• assert.equal(payload.source.buildNumber, 88);
• assert.equal(payload.source.repositoryUrl, 'https://github.com/example/test-station');
• assert.equal(payload.source.defaultBranch, 'main');
• assert.equal(payload.artifacts.length, 1);
• assert.equal(payload.artifacts[0].label, 'run-log');

Source

test('report regeneration builds a replay payload from stored run metadata', () => {
  const payload = buildReplayPayload({
    project: {
      key: 'workspace',
      name: 'Workspace',
      repositoryUrl: 'https://github.com/example/test-station',
      defaultBranch: 'main',
    },
    run: {
      id: 'run-1',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase16-report-regeneration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(payload.source.buildNumber, 45);
• assert.equal(payload.source.actor, 'octocat');
• assert.equal(payload.source.repository, 'example/retro-display');
• assert.equal(payload.source.repositoryUrl, 'https://github.com/example/retro-display');
• assert.equal(payload.source.ci.environment.GITHUB_RUN_NUMBER, '45');

Source

test('report regeneration falls back to stored raw report GitHub environment for build number', () => {
  const payload = buildReplayPayload({
    project: {
      key: 'retro-display',
      name: 'Retro Display',
      repositoryUrl: 'https://github.com/example/retro-display',
      defaultBranch: 'main',
    },…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase16-report-regeneration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(summary.status, 'failed');
• assert.equal(summary.project.name, 'fixture-project');
• assert.equal(summary.git.sha, 'abc123456789');
• assert.equal(summary.git.ref, 'main');
• assert.equal(summary.totals.packages, 2);
• assert.equal(summary.totals.tests, 3);
• assert.deepEqual(summary.failures.packageNames, ['lib']);
• assert.equal(summary.packages.find((entry) => entry.name === 'lib')?.totals.failed, 1);

Source

test('createLegacySummary derives package totals, failures, and git metadata from report.json', async () => {
  const { report, reportPath } = await buildFixtureReport();
  const summary = createLegacySummary(report, {
    reportPath,
    git: { sha: 'abc123456789', ref: 'main' },
  });

  assert.equal(summary.status,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-publisher-migration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(fs.existsSync(outputPath), true);
• assert.equal(summary.schemaVersion, 'legacy-summary-v1');
• assert.equal(summary.git.sha, 'deadbeefcafebabe');
• assert.equal(summary.totals.tests, 3);
• assert.deepEqual(summary.failures.packageNames, ['lib']);

Source

test('report-json-to-summary script writes a compatibility summary file', async () => {
  const { reportPath } = await buildFixtureReport();
  const outputPath = path.join(createTempOutputDir('phase2-legacy-summary'), '.test-results', 'summary.json');
  const result = spawnSync(process.execPath, [
    summaryScriptPat…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-publisher-migration.test.js",
    "matched": true
  }
}

Assertions

• assert.match(payload.content, /fixture-project failed/);
• assert.match(payload.content, /packages 2 \| suites 2 \| tests 3/);
• assert.match(payload.content, /failed packages: lib/);

Source

test('createDiscordPayload formats a minimal direct-publisher payload from report.json', async () => {
  const { report, reportPath } = await buildFixtureReport();
  const payload = createDiscordPayload(report, {
    reportPath,
    git: { sha: 'deadbeefcafebabe', ref: 'main' },
  });

  assert.match(payload.content,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-publisher-migration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.match(payload.content, /fixture-project failed on main \(deadbeef\)/);
• assert.equal(payload.metadata.totals.tests, 3);

Source

test('report-json-to-discord-payload script prints a webhook-friendly payload', async () => {
  const { reportPath } = await buildFixtureReport();
  const result = spawnSync(process.execPath, [
    discordScriptPath,
    '--input',
    reportPath,
    '--sha',
    'deadbeefcafebabe',
    '--ref',
    'main',
  ], {…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-publisher-migration.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.schemaVersion, '1');
• assert.equal(execution.report.summary.totalPackages, 2);
• assert.equal(execution.report.summary.totalSuites, 2);
• assert.equal(execution.report.summary.totalTests, 3);
• assert.equal(execution.report.summary.failedTests, 1);
• assert.deepEqual(execution.report.summary.filterOptions.modules.sort(), ['editor', 'filesystem', 'runtime']);
• assert.equal(fs.existsSync(execution.artifactPaths.reportJsonPath), true);
• assert.equal(execution.artifactPaths.rawSuitePaths.length >= 4, true);
• assert.equal(execution.context.project.outputDir, outputDir);
• assert.equal(storedReport.summary.failedPackages, 1);
• assert.equal(Array.isArray(storedReport.performanceStats), true);
• assert.equal(storedReport.performanceStats.length, 1);
• assert.deepEqual(storedReport.performanceStats[0], { scope: 'suite', suiteIdentifier: 'app-unit', testIdentifier: null, statGroup: 'benchmark.node.engine.shared.tight_arithmetic_loop', statName: 'elapsed_ms', unit:…
• assert.equal(typeof rawSuitePath, 'string');
• assert.equal(Array.isArray(rawSuite.performanceStats), true);
• assert.deepEqual(rawSuite.performanceStats[0], { scope: 'suite', testIdentifier: null, statGroup: 'benchmark.node.engine.shared.tight_arithmetic_loop', statName: 'elapsed_ms', unit: 'ms', numericValue: 12.34, te…
• assert.match(consoleSummary, /Workspace Test Report/);
• assert.match(consoleSummary, /Packages: 2/);
• assert.match(consoleSummary, /Failed: 1/);
• assert.match(consoleSummary, /Report JSON:/);

Source

test('runReport executes configured suites and writes artifacts', async () => {
  const outputDir = createTempOutputDir('phase2-run-report');

  const execution = await runReport({
    configPath: fixtureConfigPath,
    outputDir,
    writeArtifacts: true,
  });

  assert.equal(execution.report.schemaVersion, '1');…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-run-report.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 1, result.stderr || result.stdout);
• assert.match(result.stdout, /Running Workspace Tests/);
• assert.match(result.stdout, /Workspace Test Report/);
• assert.match(result.stdout, /HTML report:/);
• assert.equal(fs.existsSync(path.join(outputDir, 'report.json')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'index.html')), true);

Source

test('cli run writes report json and html output', () => {
  const outputDir = createTempOutputDir('phase2-cli-run');

  const result = spawnSync(process.execPath, [cliPath, 'run', '--config', fixtureConfigPath, '--output-dir', outputDir], {
    encoding: 'utf8',
    cwd: repoRoot,
  });

  assert.equal(result.status,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-run-report.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(seeded.status, 1, seeded.stderr || seeded.stdout);
• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(fs.existsSync(path.join(resultDir, 'index.html')), true);

Source

test('cli render re-renders html from an existing report file', () => {
  const sourceDir = createTempOutputDir('phase2-render-source');
  const resultDir = createTempOutputDir('phase2-render-copy');
  const seeded = spawnSync(process.execPath, [cliPath, 'run', '--config', fixtureConfigPath, '--output-dir', sourceDir]…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-run-report.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.meta.ci.provider, 'github-actions');
• assert.equal(execution.report.meta.ci.environment.CI, 'true');
• assert.equal(execution.report.meta.ci.environment.GITHUB_SHA, 'abc123');
• assert.equal(execution.report.meta.ci.environment.GITHUB_WORKFLOW, 'CI');
• assert.equal(execution.report.meta.ci.environment.RUNNER_OS, 'Linux');
• assert.equal('GITHUB_TOKEN' in execution.report.meta.ci.environment, false);

Source

test('runReport captures GitHub Actions default environment in report metadata', async () => {
  const outputDir = createTempOutputDir('phase2-run-report-github-env');
  const originalEnv = process.env;
  process.env = {
    ...originalEnv,
    GITHUB_SHA: 'abc123',
    GITHUB_REF_NAME: 'main',
    GITHUB_WORKFLOW: 'C…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-run-report.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(report.summary.failedPackages, 1);
• assert.equal(report.summary.skippedPackages, 0);
• assert.equal(report.packages[0].status, 'failed');
• assert.equal(report.packages[0].summary.total, 0);
• assert.equal(report.packages[0].suites[0].status, 'failed');

Source

test('buildReportFromSuiteResults keeps zero-test failed suites failed at the package level', () => {
  const report = buildReportFromSuiteResults({
    config: {},
    project: {
      name: 'fixture-project',
      rootDir: repoRoot,
      outputDir: path.join(repoRoot, 'artifacts'),
    },
    packageCatalog: […

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase2-run-report.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 3, passed: 1, failed: 1, skipped: 1 });
• assert.equal(result.tests.length, 3);
• assert.equal(result.coverage?.lines?.total > 0, true);
• assert.match(result.rawArtifacts[0].relativePath, /node\.ndjson$/);

Source

test('node:test adapter executes and normalizes suite output', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'node-test');
  const adapter = createNodeTestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'node-fixture',
      label: 'Node Fixtu…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });
• assert.equal(result.coverage?.lines?.total > 0, true);
• assert.deepEqual(result.warnings, []);
• assert.equal(result.rawArtifacts.some((artifact) => /node-coverage\.ndjson$/.test(artifact.relativePath)), true);

Source

test('node:test adapter collects coverage for supported package-script wrappers', async () => {
  const project = createProject();
  const cwd = createWrappedNodeTestFixture();
  const adapter = createNodeTestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'node-package-script',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 3, passed: 1, failed: 1, skipped: 1 });
• assert.equal(result.tests.length, 3);
• assert.equal(result.coverage?.lines?.total > 0, true);
• assert.equal(result.rawArtifacts.some((artifact) => /vitest-coverage-summary\.json$/.test(artifact.relativePath)), true);

Source

test('vitest adapter executes and parses json report plus coverage', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'vitest');
  const adapter = createVitestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'vitest-fixture',
      label: 'Vitest…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 3, passed: 1, failed: 1, skipped: 1 });
• assert.equal(result.tests.length, 3);
• assert.match(result.rawArtifacts[0].relativePath, /playwright\.json$/);

Source

test('playwright adapter executes and parses json report', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'playwright');
  const adapter = createPlaywrightAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'playwright-fixture',
      label: 'Playw…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });
• assert.equal(result.coverage?.lines?.total, 1);
• assert.equal(result.coverage?.files.length, 1);
• assert.match(result.coverage?.files[0].path || '', /coverage-target\.js$/);
• assert.equal(result.warnings.length, 0);
• assert.equal(result.rawArtifacts.some((artifact) => /playwright-coverage$/.test(artifact.relativePath)), true);
• assert.equal( result.rawArtifacts.some((artifact) => /playwright-coverage\/coverage-summary\.json$/.test(artifact.relativePath)), true, );

Source

test('playwright adapter collects suite-scoped browser Istanbul coverage when requested', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'playwright');
  const adapter = createPlaywrightAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'playwrigh…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 0, passed: 0, failed: 0, skipped: 0 });
• assert.equal(result.tests.length, 0);
• assert.deepEqual(result.warnings, ['Error: Failed to launch: Error: spawn /bin/sh ENOENT']);

Source

test('playwright adapter surfaces top-level launcher errors when no tests are emitted', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'playwright');
  const adapter = createPlaywrightAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'playwright-…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 3, passed: 2, failed: 1, skipped: 0 });
• assert.equal(result.tests.length, 1);
• assert.match(result.tests[0].failureMessages[0], /simulated shell failure/);

Source

test('shell adapter executes command and synthesizes suite result', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'shell');
  const adapter = createShellAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'shell-fixture',
      label: 'Shell Fixtu…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });
• assert.equal(result.tests.length, 1);
• assert.equal(result.tests[0].name, 'OpenJSCAD mapping parity');
• assert.equal(result.tests[0].module, 'transpiler');
• assert.equal(result.tests[0].theme, 'analysis');
• assert.equal(result.tests[0].classificationSource, 'config');
• assert.deepEqual(result.tests[0].rawDetails, { referenceCount: 28, localCount: 27, missingFromLocal: ['surface'], localOnly: [], });
• assert.deepEqual(result.warnings, ['1 mappings missing locally']);
• assert.match(result.rawArtifacts[0].relativePath, /shell\.json$/);

Source

test('shell adapter supports single-check-json-v1 result parsing', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'shell-json');
  const adapter = createShellAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'shell-json-fixture',
      label: 'Ma…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.equal(result.durationMs, 321);
• assert.deepEqual(result.summary, { total: 2, passed: 2, failed: 0, skipped: 0 });
• assert.equal(result.tests.length, 2);
• assert.deepEqual(result.warnings, ['benchmark sample count is below the long-run target']);
• assert.equal(result.performanceStats.length, 2);
• assert.deepEqual(result.performanceStats[0], { statGroup: 'benchmark.node.engine.shared.tight_arithmetic_loop', statName: 'elapsed_ms', unit: 'ms', numericValue: 12.34, metadata: { seriesId: 'interpreter', e…
• assert.equal( result.rawArtifacts.some((artifact) => artifact.relativePath === 'benchmarks/engine-battery.json'), true, );
• assert.match(result.rawArtifacts[result.rawArtifacts.length - 1].relativePath, /shell\.json$/);

Source

test('shell adapter supports suite-json-v1 structured suite parsing', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'shell-suite-json');
  const adapter = createShellAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'shell-suite-json-fixture',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'failed');
• assert.deepEqual(result.summary, { total: 3, passed: 1, failed: 1, skipped: 1 });
• assert.equal(result.tests.length, 3);
• assert.equal(result.coverage?.lines?.total > 0, true);
• assert.equal(result.rawArtifacts.some((artifact) => /jest-coverage-summary\.json$/.test(artifact.relativePath)), true);

Source

test('jest adapter executes and parses json report plus coverage', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'jest');
  const adapter = createJestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'jest-fixture',
      label: 'Jest Fixture',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });

Source

test('node:test adapter merges suite.env into execution environment', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'node-test');
  const adapter = createNodeTestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'node-env',
      label: 'Node En…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });

Source

test('vitest adapter merges suite.env into execution environment', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'vitest');
  const adapter = createVitestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'vitest-env',
      label: 'Vitest Env Fi…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });

Source

test('playwright adapter merges suite.env into execution environment', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'playwright');
  const adapter = createPlaywrightAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'playwright-env',
      label…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });

Source

test('shell adapter merges suite.env into execution environment', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'shell');
  const adapter = createShellAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'shell-env',
      label: 'Shell Env Fixture…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 'passed');
• assert.deepEqual(result.summary, { total: 1, passed: 1, failed: 0, skipped: 0 });

Source

test('jest adapter merges suite.env into execution environment', async () => {
  const project = createProject();
  const cwd = path.join(fixtureRoot, 'jest');
  const adapter = createJestAdapter();
  const result = await adapter.run({
    project,
    suite: {
      id: 'jest-env',
      label: 'Jest Env Fixture',…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-adapters.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(Array.isArray(suite.rawArtifacts), true);
• assert.equal(suite.rawArtifacts.length, 3);
• assert.deepEqual( suite.rawArtifacts.map((artifact) => artifact.href), [ 'raw/fixture-inline/log.txt', 'raw/fixture-file/trace.zip', 'raw/fixture-dir/test-results', ], );
• assert.equal(suite.rawArtifacts[1].mediaType, 'application/zip');
• assert.equal(suite.rawArtifacts[2].kind, 'directory');
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'fixture-inline', 'log.txt')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'fixture-file', 'trace.zip')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'fixture-dir', 'test-results', 'result.txt')), true);
• assert.equal(report.packages[0].suites[0].rawArtifacts[0].label, 'Inline log');
• assert.equal(report.packages[0].suites[0].rawArtifacts[2].href, 'raw/fixture-dir/test-results');
• assert.equal(rawSuitePayload.rawArtifacts.length, 3);
• assert.equal(rawSuitePayload.rawArtifacts[1].href, 'raw/fixture-file/trace.zip');

Source

test('runReport writes raw artifact manifests and copies file and directory sources into raw/', async () => {
  const outputDir = createTempOutputDir('phase3-raw-artifacts');
  const execution = await runReport({
    configPath: fixtureConfigPath,
    outputDir,
    writeArtifacts: true,
  });

  const suite = executi…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase3-raw-artifacts.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.summary.totalPackages, 2);
• assert.equal(execution.report.summary.totalModules, 2);
• assert.deepEqual(execution.report.summary.filterOptions.modules.sort(), ['repository', 'runtime']);
• assert.deepEqual(execution.report.summary.coverageAttribution, { totalFiles: 2, attributedFiles: 2, sharedFiles: 0, moduleOnlyFiles: 0, packageOnlySharedFiles: 0, unattributedFiles: 0, manifestFiles: 1, heur…
• assert.ok(runtimeModule);
• assert.equal(runtimeModule.owner, 'runtime-team');
• assert.equal(runtimeModule.themes[0].owner, 'runtime-core-team');
• assert.equal(runtimeModule.coverage.lines.pct, 80);
• assert.equal(runtimeTest.module, 'runtime');
• assert.equal(runtimeTest.theme, 'core');
• assert.equal(runtimeTest.classificationSource, 'manifest');
• assert.match(runtimeTest.sourceSnippet, /test\('loads runtime state'/);
• assert.ok(runtimeTest.assertions.includes("assert.equal(loadRuntimeState(), 'ok');"));
• assert.ok(runtimeTest.setup.some((entry) => entry.startsWith('beforeEach:')));
• assert.ok(runtimeTest.mocks.includes('mock module ../src/runtime.js'));
• assert.equal(runtimeTest.rawDetails.sourceAnalysis.matched, true);
• assert.ok(repositoryModule);
• assert.equal(repositoryModule.owner, 'repository-team');
• assert.equal(repositoryModule.themes[0].owner, 'repository-team');
• assert.equal(repositoryModule.coverage.lines.pct, 50);
• assert.equal(repositoryModule.coverage.files[0].attributionSource, 'plugin');
• assert.equal(repositoryModule.coverage.files[0].attributionReason, 'fixture plugin coverage mapping');
• assert.equal(repositoryTest.module, 'repository');
• assert.equal(repositoryTest.theme, 'sync');
• assert.equal(repositoryTest.classificationSource, 'plugin');
• assert.ok(repositoryTest.assertions.includes('expect(syncRepository()).toBeTruthy();'));
• assert.ok(repositoryTest.setup.some((entry) => entry.startsWith('beforeAll:')));
• assert.ok(repositoryTest.mocks.includes('mock module ../src/custom.js'));
• assert.equal(storedReport.summary.coverageAttribution.pluginFiles, 1);

Source

test('runReport applies manifest and plugin policy plus source analysis enrichment', async () => {
  const artifactsDir = path.join(fixtureDir, 'artifacts');
  fs.rmSync(artifactsDir, { recursive: true, force: true });

  const execution = await runReport({
    configPath: fixtureConfigPath,
    writeArtifacts: true,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase5-policy.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.equal(fs.existsSync(reportPath), true);
• assert.equal(fs.existsSync(htmlPath), true);
• assert.equal(report.meta.projectName, 'generic-node-library');
• assert.equal(report.summary.totalPackages, 1);
• assert.equal(report.summary.totalSuites, 1);
• assert.equal(report.summary.totalTests, 1);
• assert.deepEqual(report.summary.filterOptions.modules, ['library']);
• assert.ok(moduleEntry);
• assert.equal(moduleEntry.owner, 'library-team');
• assert.equal(moduleEntry.themes[0].owner, 'library-api-team');
• assert.equal(moduleEntry.coverage.lines.pct, 100);
• assert.equal(testEntry.classificationSource, 'manifest');
• assert.ok(testEntry.assertions.includes('assert.equal(add(2, 3), 5);'));
• assert.ok(testEntry.setup.some((entry) => entry.startsWith('beforeEach:')));
• assert.match(testEntry.sourceSnippet, /adds positive integers/);

Source

test('generic external consumer project can run through the standalone CLI without varcad-specific code', () => {
  const artifactsDir = path.join(exampleDir, 'artifacts');
  fs.rmSync(artifactsDir, { recursive: true, force: true });

  const result = spawnSync(process.execPath, [cliPath, 'run', '--config', exampleCon…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase7-external-consumer.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.summary.failedPackages, 0);
• assert.equal(execution.report.summary.failedSuites, 0);
• assert.deepEqual(execution.report.summary.policy, { failedThresholds: 1, warningThresholds: 1, diagnosticsSuites: 0, failedDiagnostics: 0, });
• assert.equal(execution.report.policy.thresholds.totalRules, 2);
• assert.equal(execution.report.policy.thresholds.failedRules, 1);
• assert.equal(execution.report.policy.thresholds.warningRules, 1);
• assert.equal(execution.report.policy.thresholds.violations.length, 2);
• assert.ok(runtimeModule);
• assert.equal(runtimeModule.owner, 'platform-team');
• assert.equal(runtimeModule.threshold.status, 'failed');
• assert.equal(runtimeModule.threshold.metrics[0].metric, 'lines');
• assert.equal(runtimeModule.threshold.metrics[0].actualPct, 40);
• assert.equal(runtimeModule.threshold.metrics[0].minPct, 45);
• assert.ok(runtimeTheme);
• assert.equal(runtimeTheme.owner, 'runtime-core-team');
• assert.equal(runtimeTheme.threshold.status, 'warn');
• assert.match(html, /Threshold Failures/);
• assert.match(html, /Threshold Warnings/);
• assert.match(html, /Coverage Policy/);
• assert.match(consoleSummary, /Policy: threshold failures 1 \| threshold warnings 1/);

Source

test('runReport evaluates module and theme coverage thresholds', async () => {
  const execution = await runReport({
    configPath: thresholdConfigPath,
    writeArtifacts: false,
  });

  assert.equal(execution.report.summary.failedPackages, 0);
  assert.equal(execution.report.summary.failedSuites, 0);
  assert.deep…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase7-policy-diagnostics.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 1, result.stderr || result.stdout);
• assert.match(result.stdout, /Policy: threshold failures 1 \| threshold warnings 1/);

Source

test('cli run exits non-zero when error thresholds fail', () => {
  const outputDir = createTempOutputDir('phase7-threshold-cli');
  const result = spawnSync(process.execPath, [cliPath, 'run', '--config', thresholdConfigPath, '--output-dir', outputDir], {
    encoding: 'utf8',
    cwd: repoRoot,
  });

  assert.equal(…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase7-policy-diagnostics.test.js",
    "matched": true
  }
}

Assertions

• assert.deepEqual(execution.report.summary.policy, { failedThresholds: 0, warningThresholds: 0, diagnosticsSuites: 0, failedDiagnostics: 0, });
• assert.equal(execution.report.policy.thresholds.totalRules, 2);
• assert.equal(execution.report.policy.thresholds.evaluatedRules, 0);
• assert.equal(execution.report.policy.thresholds.failedRules, 0);
• assert.equal(execution.report.policy.thresholds.warningRules, 0);
• assert.ok(runtimeModule);
• assert.equal(runtimeModule.threshold.status, 'skipped');
• assert.equal(runtimeModule.themes[0].threshold.status, 'skipped');

Source

test('runReport skips threshold evaluation when coverage is disabled', async () => {
  const execution = await runReport({
    configPath: thresholdConfigPath,
    coverage: false,
    writeArtifacts: false,
  });

  assert.deepEqual(execution.report.summary.policy, {
    failedThresholds: 0,
    warningThresholds: 0,…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase7-policy-diagnostics.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(events.includes('suite-diagnostics-start'), true);
• assert.equal(events.includes('suite-diagnostics-complete'), true);
• assert.deepEqual(execution.report.summary.policy, { failedThresholds: 0, warningThresholds: 0, diagnosticsSuites: 1, failedDiagnostics: 1, });
• assert.equal(suite.status, 'failed');
• assert.equal(suite.diagnostics.label, 'Verbose rerun');
• assert.equal(suite.diagnostics.status, 'failed');
• assert.match(suite.diagnostics.output.stdout, /rerun stdout/);
• assert.match(suite.diagnostics.output.stderr, /rerun stderr/);
• assert.equal(suite.rawArtifacts.some((artifact) => artifact.relativePath === 'diagnostics/app-app-unit-rerun.log'), true);
• assert.equal(suite.rawArtifacts.some((artifact) => artifact.relativePath === 'diagnostics/app-app-unit-rerun.json'), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'diagnostics', 'app-app-unit-rerun.log')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'raw', 'diagnostics', 'app-app-unit-rerun.json')), true);
• assert.match(html, /Verbose rerun/);
• assert.match(html, /diagnostics\/app-app-unit-rerun\.log/);
• assert.match(consoleSummary, /Policy: diagnostic reruns 1 \| failed diagnostics 1/);

Source

test('runReport reruns failing suites for diagnostics and preserves raw artifacts', async () => {
  const outputDir = createTempOutputDir('phase7-diagnostics');
  const events = [];
  const execution = await runReport({
    configPath: diagnosticsConfigPath,
    outputDir,
    writeArtifacts: true,
    onEvent(event)…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase7-policy-diagnostics.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.summary.totalPackages, 2);
• assert.deepEqual(execution.report.packages.map((entry) => entry.name), ['app', 'empty']);
• assert.deepEqual(eventTypes, [ 'run-start::', 'package-start:app:', 'suite-start:app:App Unit', 'suite-complete:app:App Unit', 'package-complete:app:', 'package-start:empty:', 'package-complete:empty:', ]);
• assert.equal(skippedPackageEvent.status, 'skipped');
• assert.deepEqual(skippedPackageEvent.summary, { total: 0, passed: 0, failed: 0, skipped: 0 });

Source

test('runReport emits package and suite progress events including skipped packages from workspace discovery', async () => {
  const events = [];
  const execution = await runReport({
    configPath: fixtureConfigPath,
    writeArtifacts: false,
    onEvent(event) {
      events.push(event);
    },
  });

  assert.equa…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase8-console-progress.test.js",
    "matched": true
  }
}

Assertions

• assert.match(output, /Running Workspace Tests/);
• assert.match(output, /01\/02 PACKAGE app \(packages\/app\)/);
• assert.match(output, /- Unit Tests: running node-test/);
• assert.match(output, /PASS 00:42 tests 3 \| pass 3 \| fail 0 \| skip 0/);
• assert.match(summary, /Workspace Test Report/);
• assert.match(summary, /Packages: 2/);
• assert.match(summary, /Coverage: lines 80.00% \| branches 50.00% \| functions 75.00% \| statements 80.00%/);
• assert.match(summary, /HTML report: \/tmp\/report\/index.html/);
• assert.match(summary, /PASS\s+app\s+00:42\s+tests 3 \| pass 3 \| fail 0 \| skip 0\s+L 80.00%/);
• assert.match(summary, /SKIP\s+empty\s+00:00\s+tests 0 \| pass 0 \| fail 0 \| skip 0/);
• assert.match(summary, /Modules/);
• assert.match(summary, /PASS\s+runtime\s+00:42\s+tests 3 \| pass 3 \| fail 0 \| skip 0\s+L 80.00% \| owner platform-team \| threshold passed/);

Source

test('createConsoleProgressReporter and formatConsoleSummary render the legacy-style console layout', () => {
  let output = '';
  const reporter = createConsoleProgressReporter({
    stream: {
      write(chunk) {
        output += chunk;
      },
    },
  });

  reporter.onEvent({ type: 'run-start', totalPackages: 2…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase8-console-progress.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(execution.report.meta.phase, 8);
• assert.equal(fs.existsSync(path.join(outputDir, 'modules.json')), true);
• assert.equal(fs.existsSync(path.join(outputDir, 'ownership.json')), true);
• assert.equal(modulesArtifact.modules[0].module, 'runtime');
• assert.equal(modulesArtifact.modules[0].themes[0].theme, 'core');
• assert.equal(ownershipArtifact.modules[0].owner, 'platform-team');
• assert.equal(ownershipArtifact.themes[0].owner, 'runtime-core-team');

Source

test('runReport writes module and ownership rollup artifacts', async () => {
  const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-phase8-rollups-'));
  const execution = await runReport({
    configPath: thresholdFixtureConfigPath,
    outputDir,
  });

  assert.equal(execution.report.meta.phase, 8)…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase8-console-progress.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(targetEnv.BASE_ONLY, 'from-env');
• assert.equal(targetEnv.LOCAL_ONLY, 'from-env-local');
• assert.equal(targetEnv.SHARED, 'value-from-env-local');

Source

test('loadRepoEnv loads .env and lets .env.local override values', () => {
  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-env-'));
  fs.writeFileSync(path.join(tempRoot, '.env'), 'BASE_ONLY=from-env\nSHARED=value-from-env\n');
  fs.writeFileSync(path.join(tempRoot, '.env.local'), 'LOCAL_ONLY=fr…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase9-app-scaffold.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(typeof address?.port, 'number');
• assert.equal(healthResponse.status, 200);
• assert.equal(healthPayload.status, 'ok');
• assert.equal(healthPayload.service, 'test-station-server');
• assert.equal(graphqlResponse.status, 200);
• assert.deepEqual(graphqlPayload.data, { schemaVersion: '1', serviceStatus: 'phase-8-access-control', });

Source

test('server scaffold exposes health and GraphQL endpoints', async () => {
  const server = await createServer({ port: 0, corsOrigin: 'http://localhost:3001' });

  try {
    await new Promise((resolve) => {
      server.httpServer.listen(0, resolve);
    });

    const address = server.httpServer.address();
    asser…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase9-app-scaffold.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveCorsOrigin(), 'http://localhost:3015');

Source

test('server defaults WEB_URL to localhost using WEB_PORT when unset', () => {
  const originalWebUrl = process.env.WEB_URL;
  const originalWebPort = process.env.WEB_PORT;

  try {
    delete process.env.WEB_URL;
    process.env.WEB_PORT = '3015';

    assert.equal(resolveCorsOrigin(), 'http://localhost:3015');
  } f…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase9-app-scaffold.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(resolveServerJsonLimit(), '50mb');
• assert.equal(resolveIngestJsonLimit(), '50mb');
• assert.equal(resolveServerJsonLimit(), '32mb');
• assert.equal(resolveIngestJsonLimit(), '32mb');
• assert.equal(resolveIngestJsonLimit(), '64mb');

Source

test('server defaults JSON body limits to 50mb and lets ingest inherit the server limit', () => {
  const originalServerJsonLimit = process.env.SERVER_JSON_LIMIT;
  const originalIngestJsonLimit = process.env.INGEST_JSON_LIMIT;

  try {
    delete process.env.SERVER_JSON_LIMIT;
    delete process.env.INGEST_JSON_LIMIT…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/phase9-app-scaffold.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(result.status, 0, result.stderr || result.stdout);
• assert.match(result.stdout, /target=0\.2\.412/);
• assert.equal(manifest.version, '0.2.412');
• assert.deepEqual(cliManifest.dependencies, { '@test-station/core': '0.2.412', '@test-station/render-html': '0.2.412', });
• assert.deepEqual(coreManifest.dependencies, { '@test-station/adapter-jest': '0.2.412', '@test-station/adapter-node-test': '0.2.412', '@test-station/adapter-playwright': '0.2.412', '@test-station/adapter-shell': '0.2.412',…

Source

test('set-version-from-build rewrites publishable package versions and internal dependencies', () => {
  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'test-station-release-version-'));
  fs.mkdirSync(path.join(tempRoot, 'packages'), { recursive: true });
  fs.writeFileSync(path.join(tempRoot, 'package.json')…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/release-versioning.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(fs.existsSync(packageJsonPath), true, `missing ${packageJsonPath}`);

Source

test('workspace contains expected reporter packages', () => {
  for (const pkg of expectedPackages) {
    const packageJsonPath = path.join(repoRoot, 'packages', pkg, 'package.json');
    assert.equal(fs.existsSync(packageJsonPath), true, `missing ${packageJsonPath}`);
  }
});

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/workspace-layout.test.js",
    "matched": true
  }
}

Assertions

• assert.equal(fs.existsSync(packageJsonPath), true, `missing ${packageJsonPath}`);
• assert.equal(packageJson.private, true, `${pkg} should remain private`);

Source

test('workspace contains expected private application packages', () => {
  for (const pkg of expectedAppPackages) {
    const packageJsonPath = path.join(repoRoot, 'packages', pkg, 'package.json');
    assert.equal(fs.existsSync(packageJsonPath), true, `missing ${packageJsonPath}`);
    const packageJson = JSON.parse(…

Detail

{
  "sourceAnalysis": {
    "file": "/home/runner/work/test-station/test-station/tests/workspace-layout.test.js",
    "matched": true
  }
}