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, /branches:\s*\n\s*-\s*main/);
• assert.match(workflow, /yarn install --immutable/);
• assert.match(workflow, /yarn test:node/);
• assert.match(workflow, /yarn test:coverage/);
• 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 main and pull requests', () => {
  const workflow = fs.readFileSync(path.join(repoRoot, '.github', 'workflows', 'ci.yml'), 'utf8');

  assert.match(workflow, /branches:\s*\n\s*-\s*main/);
  assert.match(workflow, /yarn install --immutable/);
  assert.match(workflow, /yar…

Detail

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

Assertions

• assert.match(workflow, /branches:\s*\n\s*-\s*staging/);
• 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*staging/);
• assert.match(workflow, /NPM_PUBLISH:\s*\$\{\{ \(\(github\.event_name == 'push' && github\.ref_name == 'staging'\) \|\| inputs\.publish_npm\) && '1' \|\| '0' \}\}/);
• assert.match(workflow, /TEST_STATION_INGEST_SHARED_KEY/);
• assert.match(workflow, /S3_BUCKET/);
• assert.match(workflow, /azure\/setup-kubectl@v4/);
• assert.match(workflow, /FLEET_KUBECONFIG/);
• assert.match(workflow, /deploy-fleet\.sh --kubeconfig "\$KUBECONFIG_PATH" --restart/);

Source

test('staging 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, /branches:\s*\n\s*-\s*staging/);
  assert.match(workflow, /needs:\s*validate/…

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%/);

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, /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.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 = path.join(repoRoot, 'artifacts', 'phase1-render-test');
  const inputPath = path.join(outputDir, 'report.json');
  fs.rmSync(outputDir, { recursive: true, force: true });
  fs.mkdirSync(outputDir, { recursive: true });
  fs.writeFileSync(inputP…

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/README.md',
    'fleet/gitrepo.yml',
    'fleet/test-station/Chart.yaml',
    'fleet/test-station/values.yaml',
    '.env.fleet.example',
    '.env.fleet.config.example',
    'scripts/a…

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, /image:\s*\n\s*tag:\s*staging/);
• 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*\./);
• 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, /secretName:\s*""/);
• assert.match(valuesYaml, /repository:\s*ghcr\.io\/smysnk\/test-station/);
• assert.match(valuesYaml, /pullPolicy:\s*Always/);
• assert.match(webIngressYaml, /test-station\.publicDomain/);
• 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 gitRepoYaml = fs.readFileSync(path.join(repoRoot, 'fleet/gitrepo.yml'), 'utf8');
  const valuesYaml = fs.readFileSync(path.join(…

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.00% lines', color: 'yellowgreen', });
• assert.equal(summary.artifacts.html, 'index.html');
• assert.equal(summary.artifacts.testsBadge, 'badges/tests.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(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.deepEqual( migrations.map((migration) => migration.id), [initialMigration.id, coverageTrendMigration.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.deepEqua…

Detail

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

Assertions

• assert.equal(state.createdTables.length, 15);
• 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.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.deepEqual(state.insertedMigrations, [initialMigration.id, coverageTrendMigration.id]);
• assert.equal(state.transactions.length, 2);
• 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.deepEqual(rerunState.insertedMigrations, []);

Source

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

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

  assert.equal(state.createdTables.length, 15);
  assert.ok(state.createdTables.…

Detail

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

Assertions

• 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(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(Project.associations.projectVersions.target, ProjectVersion);
  assert.equal(Project.associations.projectPackages.target, ProjectPackage);
  assert.equal(Project.associations.projectModules.target, ProjectModule);
  assert.e…

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);

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.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, 3);
• 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);

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(response.status, 401);
• assert.equal(response.payload.data, null);
• assert.equal(response.payload.errors[0].extensions.code, 'UNAUTHORIZED');

Source

test('GraphQL rejects protected queries without an actor', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createGraphqlModels(),
  });

  await listen(server);
  const response = await graphqlRequest(server, {
    query: '{ projects { key } }',
  }…

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.me, { id: 'user-1', role: 'member', projectKeys: ['workspace'], });
• assert.deepEqual(response.payload.data.projects, [ { key: 'workspace', name: 'Workspace', }, ]);
• 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.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 authorized actors', async () => {
  const server = await createServer({
    port: 0,
    corsOrigin: 'http://localhost:3001',
    models: createGraphqlModels(),
  });

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

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.equal(authOptions.pages.signIn, '/auth/signin');
• assert.equal(authOptions.providers.some((provider) => provider.type === 'credentials'), true);
• assert.equal(token.userId, 'user-1');
• assert.equal(token.role, 'admin');
• assert.deepEqual(token.projectKeys, ['workspace']);
• assert.equal(session.userId, 'user-1');
• assert.equal(session.role, 'admin');
• assert.deepEqual(session.projectKeys, ['workspace']);
• assert.equal(session.user.image, null);

Source

test('web auth options expose the sign-in page and session actor metadata', async () => {
  const authOptions = createAuthOptions({
    secret: 'test-secret',
    adminEmails: ['admin@example.com'],
    defaultProjectKeys: ['workspace'],
    demoAuthEnabled: true,
  });

  assert.equal(authOptions.pages.signIn, '/auth…

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(), '/auth/signin?signedOut=1');

Source

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

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', 'x-test-station-actor-pr…
• assert.equal(isProtectedWebPath('/'), true);
• assert.equal(isProtectedWebPath('/projects/workspace'), true);
• assert.equal(isProtectedWebPath('/runs/run-1'), 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',
    projectKeys: ['workspace', 'api'],
  });

  assert.deepEqual…

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.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(home.projects.length, 1);
• assert.equal(requests[0].headers['x-test-station-actor-project-keys'], 'workspace');
• 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.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');

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',
    projectKeys: ['workspace'],
  };
  const requests = [];
  const fetchImpl = asy…

Detail

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

Assertions

• assert.equal(run.run.id, 'run-1');
• assert.equal(run.failedTests.length, 1);
• assert.equal(run.runModules[0].module, 'runtime');
• assert.equal(run.coverageComparison.deltaLinesPct, 6);
• assert.equal(run.coverageComparison.fileChanges[0].filePath, '/repo/packages/core/src/index.js');
• 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(formatRunBuildLabel({ projectVersion: { buildNumber: 88 } }), 'build #88');
• assert.equal(formatRunBuildLabel({ sourceRunId: '1001' }), 'run 1001');

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',
    projectKeys: ['workspace'],
  };
  const responses = [
    {
      data: {
        run:…

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, /sourceRunId/);
• assert.match(WEB_HOME_QUERY, /sourceUrl/);
• assert.match(WEB_HOME_QUERY, /buildNumber/);
• assert.match(PROJECT_ACTIVITY_QUERY, /sourceRunId/);
• assert.match(PROJECT_ACTIVITY_QUERY, /sourceUrl/);
• assert.match(PROJECT_ACTIVITY_QUERY, /buildNumber/);
• assert.match(RUN_DETAIL_QUERY, /sourceRunId/);
• assert.match(RUN_DETAIL_QUERY, /sourceUrl/);
• assert.match(RUN_DETAIL_QUERY, /buildNumber/);

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, /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',
    projectKeys: ['workspace'],
  };

  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.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.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.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.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(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: 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, '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-4-query-layer', });

Source

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

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

  const address = server.httpServer.address();
  assert.equal(typeof add…

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(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
  }
}