@testspectra/cli 1.1.7 → 1.1.8-rc.2

package/dist/linter/__tests__/shared-lib-boundary.test.js

@@ -0,0 +1,270 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SpecLinter } from '../spec-linter.js';
+import { isInsideSharedLibrary, findSharedLibraryRoots } from '../discovery.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('Shared Library Boundary (testspectra/no-specs-in-shared-lib)', () => {
+    const tempDir = path.join(__dirname, '__temp_shared_boundary__');
+    beforeEach(() => {
+        fs.mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('findSharedLibraryRoots()', () => {
+        it('discovers parent folders of project.json files containing both scope:shared and type:shared', () => {
+            const sharedDir1 = path.join(tempDir, 'shared', 'testing');
+            const sharedDir2 = path.join(tempDir, 'libs', 'common-helpers');
+            const nonSharedDir = path.join(tempDir, 'packages', 'playground', 'e2e');
+            fs.mkdirSync(sharedDir1, { recursive: true });
+            fs.mkdirSync(sharedDir2, { recursive: true });
+            fs.mkdirSync(nonSharedDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedDir1, 'project.json'), JSON.stringify({ name: 'shared-testing', tags: ['scope:shared', 'type:shared'] }));
+            fs.writeFileSync(path.join(sharedDir2, 'project.json'), JSON.stringify({ name: 'common-helpers', tags: ['scope:shared', 'type:shared'] }));
+            fs.writeFileSync(path.join(nonSharedDir, 'project.json'), JSON.stringify({ name: 'playground-e2e', tags: ['scope:playground', 'type:e2e'] }));
+            const roots = findSharedLibraryRoots(tempDir);
+            expect(roots).toHaveLength(2);
+            expect(roots).toContain(sharedDir1);
+            expect(roots).toContain(sharedDir2);
+            expect(roots).not.toContain(nonSharedDir);
+        });
+    });
+    describe('isInsideSharedLibrary()', () => {
+        it('returns true for files inside a project tagged with scope:shared or type:shared in project.json', () => {
+            const sharedDir = path.join(tempDir, 'shared', 'testing');
+            fs.mkdirSync(sharedDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedDir, 'project.json'), JSON.stringify({
+                name: 'shared-testing',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const stepFile = path.join(sharedDir, 'support', 'steps', 'web.step.ts');
+            const specFile = path.join(sharedDir, 'specs', 'TC-001', 'spec.md');
+            const actionFile = path.join(sharedDir, 'support', 'actions', 'web.action.ts');
+            expect(isInsideSharedLibrary(stepFile)).toBe(true);
+            expect(isInsideSharedLibrary(specFile)).toBe(true);
+            expect(isInsideSharedLibrary(actionFile)).toBe(true);
+            expect(isInsideSharedLibrary(sharedDir)).toBe(true);
+        });
+        it('returns true for shared library regardless of folder name if tagged in project.json', () => {
+            const customLibDir = path.join(tempDir, 'custom-helpers', 'common');
+            fs.mkdirSync(customLibDir, { recursive: true });
+            fs.writeFileSync(path.join(customLibDir, 'project.json'), JSON.stringify({
+                name: 'custom-common-lib',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const actionFile = path.join(customLibDir, 'support', 'actions', 'click.action.ts');
+            expect(isInsideSharedLibrary(actionFile)).toBe(true);
+        });
+        it('returns false when folder is named "shared" but project.json is not tagged as shared', () => {
+            const sharedAppDir = path.join(tempDir, 'shared-app');
+            fs.mkdirSync(sharedAppDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedAppDir, 'project.json'), JSON.stringify({
+                name: 'shared-app',
+                tags: ['scope:shared-app', 'type:e2e'],
+            }));
+            const specFile = path.join(sharedAppDir, 'specs', 'TC-001', 'spec.md');
+            expect(isInsideSharedLibrary(specFile)).toBe(false);
+        });
+        it('returns false for feature package project.json without shared tags', () => {
+            const featureDir = path.join(tempDir, 'packages', 'playground', 'e2e');
+            fs.mkdirSync(featureDir, { recursive: true });
+            fs.writeFileSync(path.join(featureDir, 'project.json'), JSON.stringify({
+                name: 'playground-e2e',
+                tags: ['scope:playground', 'type:e2e'],
+            }));
+            const specFile = path.join(featureDir, 'specs', 'TC-001', 'spec.md');
+            expect(isInsideSharedLibrary(specFile)).toBe(false);
+        });
+        it('returns false when no project.json exists in directory tree', () => {
+            const nonProjectSpec = path.join(tempDir, 'standalone', 'specs', 'TC-001', 'spec.md');
+            expect(isInsideSharedLibrary(nonProjectSpec)).toBe(false);
+        });
+    });
+    describe('testspectra/no-specs-in-shared-lib validation', () => {
+        it('emits testspectra/no-specs-in-shared-lib when spec.md is found inside shared/testing/', () => {
+            const sharedLibDir = path.join(tempDir, 'shared', 'testing');
+            fs.mkdirSync(sharedLibDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedLibDir, 'project.json'), JSON.stringify({
+                name: 'shared-testing',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const sharedSpecDir = path.join(sharedLibDir, 'specs', 'TC-error');
+            fs.mkdirSync(sharedSpecDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedSpecDir, 'spec.md'), `---
+id: TC-ERROR-001
+title: Spec inside shared lib
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Spec inside shared lib
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(1);
+            expect(errors[0].severity).toBe('error');
+            expect(errors[0].message).toContain('shared testing library');
+        });
+        it('emits testspectra/no-specs-in-shared-lib when suite.md is found inside shared/testing/', () => {
+            const sharedLibDir = path.join(tempDir, 'shared', 'testing');
+            fs.mkdirSync(sharedLibDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedLibDir, 'project.json'), JSON.stringify({
+                name: 'shared-testing',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const sharedSuiteDir = path.join(sharedLibDir, 'support');
+            fs.mkdirSync(sharedSuiteDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedSuiteDir, 'suite.md'), `---
+id: suite-error
+name: Suite inside shared lib
+status: active
+---
+
+# Suite: Inside Shared Lib
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toContain('shared testing library');
+        });
+        it('emits testspectra/no-specs-in-shared-lib when spec.md is inside a shared library with non-"shared" folder name', () => {
+            const customLibDir = path.join(tempDir, 'libs', 'my-testing-utils');
+            fs.mkdirSync(customLibDir, { recursive: true });
+            fs.writeFileSync(path.join(customLibDir, 'project.json'), JSON.stringify({
+                name: 'my-testing-utils',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const specDir = path.join(customLibDir, 'specs', 'TC-custom');
+            fs.mkdirSync(specDir, { recursive: true });
+            fs.writeFileSync(path.join(specDir, 'spec.md'), `---
+id: TC-CUSTOM-001
+title: Spec inside custom shared lib
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Spec inside custom shared lib
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(1);
+            expect(errors[0].severity).toBe('error');
+            expect(errors[0].message).toContain('shared testing library');
+        });
+        it('does NOT emit testspectra/no-specs-in-shared-lib for specs in feature package directories', () => {
+            const featureDir = path.join(tempDir, 'packages', 'playground', 'e2e');
+            fs.mkdirSync(featureDir, { recursive: true });
+            fs.writeFileSync(path.join(featureDir, 'project.json'), JSON.stringify({
+                name: 'playground-e2e',
+                tags: ['scope:playground', 'type:e2e'],
+            }));
+            const featureSpecDir = path.join(featureDir, 'specs', 'TC-001');
+            fs.mkdirSync(featureSpecDir, { recursive: true });
+            fs.writeFileSync(path.join(featureSpecDir, 'spec.md'), `---
+id: TC-001
+title: Feature spec
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Feature spec
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(0);
+        });
+        it('does NOT emit testspectra/no-specs-in-shared-lib when folder is named "shared" but project.json has e2e tags', () => {
+            const sharedE2eDir = path.join(tempDir, 'shared-feature', 'e2e');
+            fs.mkdirSync(sharedE2eDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedE2eDir, 'project.json'), JSON.stringify({
+                name: 'shared-feature-e2e',
+                tags: ['scope:shared-feature', 'type:e2e'],
+            }));
+            const specDir = path.join(sharedE2eDir, 'specs', 'TC-001');
+            fs.mkdirSync(specDir, { recursive: true });
+            fs.writeFileSync(path.join(specDir, 'spec.md'), `---
+id: TC-001
+title: Shared named feature spec
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Shared named feature spec
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(0);
+        });
+        it('does NOT emit testspectra/no-specs-in-shared-lib for specs in root specs/ directory', () => {
+            const rootSpecDir = path.join(tempDir, 'specs', 'TC-001');
+            fs.mkdirSync(rootSpecDir, { recursive: true });
+            fs.writeFileSync(path.join(rootSpecDir, 'spec.md'), `---
+id: TC-001
+title: Root spec
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Root spec
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(0);
+        });
+        it('emits multiple testspectra/no-specs-in-shared-lib when multiple specs found in shared library', () => {
+            const sharedLibDir = path.join(tempDir, 'shared', 'testing');
+            fs.mkdirSync(sharedLibDir, { recursive: true });
+            fs.writeFileSync(path.join(sharedLibDir, 'project.json'), JSON.stringify({
+                name: 'shared-testing',
+                tags: ['scope:shared', 'type:shared'],
+            }));
+            const sharedDir1 = path.join(sharedLibDir, 'specs', 'TC-001');
+            const sharedDir2 = path.join(sharedLibDir, 'specs', 'TC-002');
+            fs.mkdirSync(sharedDir1, { recursive: true });
+            fs.mkdirSync(sharedDir2, { recursive: true });
+            const specContent = `---
+id: TC-TEST
+title: Test
+priority: High
+caseType: Positive
+status: draft
+---
+
+# Test
+
+## Test Steps
+1. Step
+`;
+            fs.writeFileSync(path.join(sharedDir1, 'spec.md'), specContent);
+            fs.writeFileSync(path.join(sharedDir2, 'spec.md'), specContent);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            const errors = result.diagnostics.filter((d) => d.code === 'testspectra/no-specs-in-shared-lib');
+            expect(errors).toHaveLength(2);
+        });
+    });
+});

package/dist/linter/__tests__/spec-schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/linter/__tests__/spec-schema.test.js

@@ -0,0 +1,369 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SpecLinter } from '../spec-linter.js';
+import { parseMarkdownFrontmatter } from '../parser.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+describe('Spec Schema Linter (Stage 1 & Stage 2)', () => {
+    const tempDir = path.join(__dirname, '__temp_specs__');
+    beforeEach(() => {
+        fs.mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(tempDir)) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+    describe('Spec File Validation (spec.md)', () => {
+        it('passes validation for a well-formed spec.md with frontmatter, H1 title, and Test Steps', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0001-valid
+title: Verify user authentication
+priority: High
+caseType: Positive
+status: ready-for-automation
+coverage:
+  web: automated
+  mobile: automated
+tags:
+  - auth
+---
+
+# Verify user authentication
+
+## Test Steps
+1. Open login page and submit credentials
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            expect(result.diagnostics).toHaveLength(0);
+            expect(result.id).toBe('TC-0001-valid');
+        });
+        it('reports testspectra/missing-frontmatter when required frontmatter attributes are missing', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0002-missing-attrs
+title: Missing priority and caseType
+status: draft
+---
+
+# Missing priority and caseType
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            const codes = result.diagnostics.map((d) => d.code);
+            expect(codes).toContain('testspectra/missing-frontmatter');
+            const missingPriority = result.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' &&
+                d.message.includes("Missing required frontmatter attribute 'priority'"));
+            expect(missingPriority).toBeDefined();
+            expect(missingPriority?.severity).toBe('error');
+            const missingCaseType = result.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' &&
+                d.message.includes("Missing required frontmatter attribute 'caseType'"));
+            expect(missingCaseType).toBeDefined();
+            expect(missingCaseType?.severity).toBe('error');
+        });
+        it('differentiates missing status (testspectra/missing-frontmatter) from invalid status value (testspectra/invalid-frontmatter-enum)', () => {
+            // 1. Missing status -> testspectra/missing-frontmatter
+            const missingSpecPath = path.join(tempDir, 'missing-status.spec.md');
+            fs.writeFileSync(missingSpecPath, `---
+id: TC-0002-missing-status
+title: Missing Status Spec
+priority: High
+caseType: Positive
+---
+
+# Missing Status Spec
+
+## Test Steps
+1. Step one
+`);
+            const missingResult = SpecLinter.validateSpecFile(missingSpecPath);
+            const missingStatusDiag = missingResult.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' &&
+                d.message === "Missing required frontmatter attribute 'status'");
+            expect(missingStatusDiag).toBeDefined();
+            expect(missingStatusDiag?.severity).toBe('error');
+            expect(missingResult.diagnostics.some((d) => d.code === 'testspectra/invalid-frontmatter-enum')).toBe(false);
+            // 2. Invalid status -> testspectra/invalid-frontmatter-enum
+            const invalidSpecPath = path.join(tempDir, 'invalid-status.spec.md');
+            fs.writeFileSync(invalidSpecPath, `---
+id: TC-0002-invalid-status
+title: Invalid Status Spec
+priority: High
+caseType: Positive
+status: not-a-valid-status
+---
+
+# Invalid Status Spec
+
+## Test Steps
+1. Step one
+`);
+            const invalidResult = SpecLinter.validateSpecFile(invalidSpecPath);
+            const invalidStatusDiag = invalidResult.diagnostics.find((d) => d.code === 'testspectra/invalid-frontmatter-enum' &&
+                d.message === 'Invalid status value. Expected one of: draft, ready-for-automation, automated, deprecated');
+            expect(invalidStatusDiag).toBeDefined();
+            expect(invalidStatusDiag?.severity).toBe('error');
+            expect(invalidResult.diagnostics.some((d) => d.message.includes("Missing required frontmatter attribute 'status'"))).toBe(false);
+        });
+        it('reports testspectra/invalid-frontmatter-enum when enum attributes have invalid values', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0003-invalid-enum
+title: Invalid priority value
+priority: SuperHigh
+caseType: MaybePositive
+status: unknown-status
+---
+
+# Invalid priority value
+
+## Test Steps
+1. Step one
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            const enumErrors = result.diagnostics.filter((d) => d.code === 'testspectra/invalid-frontmatter-enum');
+            expect(enumErrors.length).toBeGreaterThanOrEqual(1);
+            const priorityErr = enumErrors.find((d) => d.message.toLowerCase().includes('priority'));
+            expect(priorityErr).toBeDefined();
+            expect(priorityErr?.line).toBe(4); // Priority is on line 4
+        });
+        it('reports testspectra/missing-frontmatter when required H1 title section is missing in spec.md body', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0004-no-h1
+title: No Heading Section
+priority: High
+caseType: Positive
+status: draft
+---
+
+## Test Steps
+1. Step without H1
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            const missingHeading = result.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' && d.message.includes('expected top-level test title'));
+            expect(missingHeading).toBeDefined();
+            expect(missingHeading?.severity).toBe('error');
+        });
+        it('reports testspectra/missing-frontmatter when required ## Test Steps section is missing in spec.md body', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0005-no-steps
+title: No Steps Heading
+priority: High
+caseType: Positive
+status: draft
+---
+
+# No Steps Heading
+
+Some narrative without Test Steps section.
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            const missingSteps = result.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' && d.message.includes('expected "## Test Steps"'));
+            expect(missingSteps).toBeDefined();
+            expect(missingSteps?.severity).toBe('error');
+        });
+        it('warns when multiple H1 headings are declared in spec.md body', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: TC-0006-multiple-h1
+title: Multiple Headings
+priority: High
+caseType: Positive
+status: draft
+---
+
+# First Title
+
+# Second Title
+
+## Test Steps
+1. Step
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            const multipleH1 = result.diagnostics.find((d) => d.severity === 'warning' && d.message.includes('Multiple top-level H1 headings'));
+            expect(multipleH1).toBeDefined();
+        });
+        it('reports testspectra/parse-error on malformed YAML syntax', () => {
+            const specPath = path.join(tempDir, 'spec.md');
+            fs.writeFileSync(specPath, `---
+id: [broken yaml
+title: Test
+---
+`);
+            const result = SpecLinter.validateSpecFile(specPath);
+            expect(result.diagnostics.some((d) => d.code === 'testspectra/parse-error')).toBe(true);
+        });
+    });
+    describe('Suite File Validation (suite.md)', () => {
+        it('passes validation for a well-formed suite.md with H1 suite heading', () => {
+            const suitePath = path.join(tempDir, 'suite.md');
+            fs.writeFileSync(suitePath, `---
+id: suite-auth
+name: Authentication
+description: User authentication flows
+executionOrder: 1.0
+parallel: true
+status: active
+---
+
+# Suite: Authentication
+`);
+            const result = SpecLinter.validateSuiteFile(suitePath);
+            expect(result.diagnostics).toHaveLength(0);
+            expect(result.id).toBe('suite-auth');
+        });
+        it('reports testspectra/missing-frontmatter when suite id or title/name is missing', () => {
+            const suitePath = path.join(tempDir, 'suite.md');
+            fs.writeFileSync(suitePath, `---
+description: No id and no name
+---
+
+# Suite: Incomplete
+`);
+            const result = SpecLinter.validateSuiteFile(suitePath);
+            expect(result.diagnostics.some((d) => d.code === 'testspectra/missing-frontmatter')).toBe(true);
+        });
+        it('reports testspectra/invalid-frontmatter-enum when suite status has invalid enum value', () => {
+            const suitePath = path.join(tempDir, 'suite.md');
+            fs.writeFileSync(suitePath, `---
+id: suite-invalid-status
+name: Invalid Status Suite
+status: unknown-status
+---
+
+# Suite: Invalid Status Suite
+`);
+            const result = SpecLinter.validateSuiteFile(suitePath);
+            const enumErr = result.diagnostics.find((d) => d.code === 'testspectra/invalid-frontmatter-enum');
+            expect(enumErr).toBeDefined();
+            expect(enumErr?.severity).toBe('error');
+        });
+        it('supports in-memory content override for suite.md without writing to disk', () => {
+            const suitePath = path.join(tempDir, 'non-existent-suite.md');
+            const inMemoryContent = `---
+id: suite-in-memory
+title: In Memory Suite
+status: active
+---
+
+# Suite: In Memory Suite
+`;
+            const result = SpecLinter.validateSuiteFile(suitePath, inMemoryContent);
+            expect(result.diagnostics).toHaveLength(0);
+            expect(result.id).toBe('suite-in-memory');
+        });
+        it('reports testspectra/missing-frontmatter when suite H1 title heading is missing', () => {
+            const suitePath = path.join(tempDir, 'suite.md');
+            fs.writeFileSync(suitePath, `---
+id: suite-no-heading
+name: No Heading
+---
+
+Body without H1 suite heading.
+`);
+            const result = SpecLinter.validateSuiteFile(suitePath);
+            const headingErr = result.diagnostics.find((d) => d.code === 'testspectra/missing-frontmatter' && d.message.includes('expected top-level suite title'));
+            expect(headingErr).toBeDefined();
+        });
+    });
+    describe('Workspace Validation & Duplicate ID Detection (testspectra/duplicate-spec-id)', () => {
+        it('detects duplicate IDs across different spec files', () => {
+            const tc1Dir = path.join(tempDir, 'TC-1');
+            const tc2Dir = path.join(tempDir, 'TC-2');
+            fs.mkdirSync(tc1Dir, { recursive: true });
+            fs.mkdirSync(tc2Dir, { recursive: true });
+            const specContent = `---
+id: TC-DUPLICATE-001
+title: Duplicate test case
+priority: High
+caseType: Positive
+status: automated
+---
+
+# Duplicate test case
+
+## Test Steps
+1. Duplicate step
+`;
+            fs.writeFileSync(path.join(tc1Dir, 'spec.md'), specContent);
+            fs.writeFileSync(path.join(tc2Dir, 'spec.md'), specContent);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            expect(result.valid).toBe(false);
+            const dupErrors = result.diagnostics.filter((d) => d.code === 'testspectra/duplicate-spec-id');
+            expect(dupErrors).toHaveLength(1);
+            expect(dupErrors[0].message).toContain('TC-DUPLICATE-001');
+        });
+        it('successfully validates workspace with valid specs', () => {
+            const validSuiteDir = path.join(tempDir, 'ValidSuite');
+            const validTcDir = path.join(validSuiteDir, 'TC-001');
+            fs.mkdirSync(validTcDir, { recursive: true });
+            fs.writeFileSync(path.join(validSuiteDir, 'suite.md'), `---
+id: suite-valid
+name: Valid Suite
+status: active
+---
+
+# Suite: Valid Suite
+`);
+            fs.writeFileSync(path.join(validTcDir, 'spec.md'), `---
+id: TC-VALID-001
+title: Valid Test Case
+priority: High
+caseType: Positive
+status: automated
+---
+
+# Valid Test Case
+
+## Test Steps
+1. Open page
+`);
+            fs.writeFileSync(path.join(validTcDir, 'web.test.ts'), `it('Valid Test Case', async () => {});\n`);
+            const result = SpecLinter.validateWorkspace(tempDir);
+            expect(result.valid).toBe(true);
+            expect(result.stats.errorCount).toBe(0);
+            expect(result.stats.totalSpecs).toBe(1);
+            expect(result.stats.totalSuites).toBe(1);
+        });
+    });
+    describe('parseMarkdownFrontmatter Delimiter Detection Cases', () => {
+        it('Case 1: detects missing opening delimiter when closing delimiter exists', () => {
+            const content = `id: suite-api-interception\nname: ApiInterception\n---\n\n# Suite: ApiInterception\n`;
+            const result = parseMarkdownFrontmatter(content, 'specs/api/suite.md');
+            expect(result.hasFrontmatter).toBe(false);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0].code).toBe('testspectra/missing-frontmatter');
+            expect(result.diagnostics[0].message).toBe('Missing opening YAML frontmatter delimiter (---) at line 1');
+        });
+        it('Case 2: detects missing closing delimiter when opening delimiter exists', () => {
+            const content = `---\nid: suite-api-interception\nname: ApiInterception\n\n# Suite: ApiInterception\n`;
+            const result = parseMarkdownFrontmatter(content, 'specs/api/suite.md');
+            expect(result.hasFrontmatter).toBe(false);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0].code).toBe('testspectra/missing-frontmatter');
+            expect(result.diagnostics[0].message).toBe('Missing closing YAML frontmatter delimiter (---). Expected closing "---"');
+        });
+        it('Case 3: detects missing delimiters when frontmatter properties exist', () => {
+            const content = `id: suite-api-interception\nname: ApiInterception\nexecutionOrder: 1.4\nparallel: true\n\n# Suite: ApiInterception\n`;
+            const result = parseMarkdownFrontmatter(content, 'specs/api/suite.md');
+            expect(result.hasFrontmatter).toBe(false);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0].code).toBe('testspectra/missing-frontmatter');
+            expect(result.diagnostics[0].message).toBe('Missing YAML frontmatter delimiters (---) at line 1');
+        });
+        it('Case 4: detects missing delimiter when file is empty or only has markdown heading', () => {
+            const content = `# Suite: ApiInterception\n`;
+            const result = parseMarkdownFrontmatter(content, 'specs/api/suite.md');
+            expect(result.hasFrontmatter).toBe(false);
+            expect(result.diagnostics).toHaveLength(1);
+            expect(result.diagnostics[0].code).toBe('testspectra/missing-frontmatter');
+            expect(result.diagnostics[0].message).toBe('Missing YAML frontmatter delimiter (---) at line 1');
+        });
+    });
+});

package/dist/linter/__tests__/step-parity.test.d.ts

@@ -0,0 +1 @@
+export {};