test: add unit tests for EditorPageComponent (#55)

* test: add unit tests for EditorPageComponent

Add 55 unit tests covering all EditorPageComponent behavior:
- editor-page.spec.ts: init, tab switching, validation, frontmatter/section
  changes, navigation, filename editing (26 tests)
- editor-page-signals.spec.ts: computed properties — canCreatePR,
  editableSections, activeEditableSection, knownModules, body, frontmatter,
  rebuildBody (17 tests)
- editor-page-computed.spec.ts: ngOnInit edge case, onExport, onCreatePR
  including error handling and PR description content (12 tests)
- editor-page-test-utils.ts: shared TestHarness, makeSpec factory,
  setupTestBed with mocked services

Fixes document.createElement spy leak that caused happy-dom
"rootElement.setAttribute is not a function" in subsequent tests.

Closes #49

Co-Authored-By: Claude Opus 4.6 <[email protected]>

* fix: exclude test utility files from production build

Add `src/**/*-test-utils.ts` to tsconfig.app.json exclude list so test
helper files that reference vitest globals don't break the production
build or e2e tests.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

---------

Co-authored-by: Claude Opus 4.6 <[email protected]>

Author: corvid-agent

src/app/pages/editor/editor-page-computed.spec.ts

@@ -0,0 +1,199 @@
+/**
+ * Unit tests for EditorPageComponent — export, PR creation, and ngOnInit edge cases.
+ *
+ * Split from editor-page.spec.ts to stay under happy-dom's per-file
+ * DOM element limit (~27 TestBed.createComponent calls).
+ */
+import { type SpecFrontmatter, type SpecSection } from '../../models/spec.model';
+import { makeSpec, type TestHarness, setupTestBed } from './editor-page-test-utils';
+
+// ══════════════════════════════════════════════════════════════════════════
+// ngOnInit edge case (requires separate TestBed with different routeId)
+// ══════════════════════════════════════════════════════════════════════════
+
+describe('EditorPageComponent — ngOnInit edge case', () => {
+  it('should not call selectSpec for id=0', async () => {
+    const h = await setupTestBed({ routeId: '0' });
+    h.page.ngOnInit();
+
+    await vi.waitFor(() => {
+      expect(h.storeSpy.selectSpec).not.toHaveBeenCalled();
+    });
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════
+// Export
+// ══════════════════════════════════════════════════════════════════════════
+
+describe('EditorPageComponent — onExport', () => {
+  let h: TestHarness;
+
+  beforeEach(async () => {
+    h = await setupTestBed();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should call store.exportSpec with spec id', async () => {
+    h.activeSpecSignal.set(makeSpec({ id: 42 }));
+
+    const clickSpy = vi.fn();
+    const origCreateElement = document.createElement.bind(document);
+    vi.spyOn(document, 'createElement').mockImplementation((tag: string) => {
+      if (tag === 'a') {
+        return { set href(_: string) {}, set download(_: string) {}, click: clickSpy } as unknown as HTMLAnchorElement;
+      }
+      return origCreateElement(tag);
+    });
+    vi.spyOn(URL, 'createObjectURL').mockReturnValue('blob:test');
+    vi.spyOn(URL, 'revokeObjectURL').mockImplementation(() => {});
+
+    await h.page.onExport();
+
+    expect(h.storeSpy.exportSpec).toHaveBeenCalledWith(42);
+    expect(clickSpy).toHaveBeenCalled();
+  });
+
+  it('should return early when spec has no id', async () => {
+    h.activeSpecSignal.set(makeSpec({ id: undefined }));
+
+    await h.page.onExport();
+
+    expect(h.storeSpy.exportSpec).not.toHaveBeenCalled();
+  });
+
+  it('should return early when exportSpec returns no content', async () => {
+    h.activeSpecSignal.set(makeSpec({ id: 1 }));
+    h.storeSpy.exportSpec.mockResolvedValue(null);
+
+    const clickSpy = vi.fn();
+    const origCreateElement = document.createElement.bind(document);
+    vi.spyOn(document, 'createElement').mockImplementation((tag: string) => {
+      if (tag === 'a') {
+        return { click: clickSpy } as unknown as HTMLAnchorElement;
+      }
+      return origCreateElement(tag);
+    });
+
+    await h.page.onExport();
+
+    expect(clickSpy).not.toHaveBeenCalled();
+  });
+});
+
+// ══════════════════════════════════════════════════════════════════════════
+// PR creation
+// ══════════════════════════════════════════════════════════════════════════
+
+describe('EditorPageComponent — onCreatePR', () => {
+  let h: TestHarness;
+
+  beforeEach(async () => {
+    h = await setupTestBed();
+  });
+
+  it('should create PR and set prUrl on success', async () => {
+    h.activeSpecSignal.set(makeSpec({
+      id: 1,
+      filepath: 'specs/auth.spec.md',
+      githubSha: 'abc123',
+    }));
+
+    await h.page.onCreatePR();
+
+    expect(h.githubSpy.createSpecPR).toHaveBeenCalledWith(
+      'specs/auth.spec.md',
+      expect.any(String),
+      'abc123',
+      expect.stringContaining('update auth.spec.md'),
+      expect.any(String),
+    );
+    expect(h.page.prUrl()).toBe('https://github.com/owner/repo/pull/42');
+  });
+
+  it('should set prLoading during PR creation', async () => {
+    let loadingDuringCall = false;
+    h.githubSpy.createSpecPR.mockImplementation(async () => {
+      loadingDuringCall = h.page.prLoading() as boolean;
+      return { html_url: 'https://github.com/owner/repo/pull/1' };
+    });
+
+    h.activeSpecSignal.set(makeSpec({ id: 1, filepath: 'specs/test.spec.md' }));
+
+    await h.page.onCreatePR();
+
+    expect(loadingDuringCall).toBe(true);
+    expect(h.page.prLoading()).toBe(false);
+  });
+
+  it('should set github error on failure', async () => {
+    h.githubSpy.createSpecPR.mockRejectedValue(new Error('API rate limit exceeded'));
+
+    h.activeSpecSignal.set(makeSpec({ id: 1, filepath: 'specs/test.spec.md' }));
+
+    await h.page.onCreatePR();
+
+    expect(h.githubSpy._error()).toBe('API rate limit exceeded');
+    expect(h.page.prLoading()).toBe(false);
+  });
+
+  it('should handle non-Error exceptions', async () => {
+    h.githubSpy.createSpecPR.mockRejectedValue('string error');
+
+    h.activeSpecSignal.set(makeSpec({ id: 1, filepath: 'specs/test.spec.md' }));
+
+    await h.page.onCreatePR();
+
+    expect(h.githubSpy._error()).toBe('PR creation failed');
+  });
+
+  it('should return early when spec has no id', async () => {
+    h.activeSpecSignal.set(makeSpec({ id: undefined }));
+
+    await h.page.onCreatePR();
+
+    expect(h.githubSpy.createSpecPR).not.toHaveBeenCalled();
+  });
+
+  it('should return early when spec has no filepath', async () => {
+    h.activeSpecSignal.set(makeSpec({ id: 1, filepath: undefined }));
+
+    await h.page.onCreatePR();
+
+    expect(h.githubSpy.createSpecPR).not.toHaveBeenCalled();
+  });
+
+  it('should clear prUrl before new PR creation', async () => {
+    h.page.prUrl.set('https://old-url');
+
+    h.activeSpecSignal.set(makeSpec({ id: 1, filepath: 'specs/test.spec.md' }));
+
+    await h.page.onCreatePR();
+
+    expect(h.page.prUrl()).toBe('https://github.com/owner/repo/pull/42');
+  });
+
+  it('should include module name and version in PR description', async () => {
+    h.activeSpecSignal.set(makeSpec({
+      id: 1,
+      filepath: 'specs/auth.spec.md',
+      frontmatter: {
+        module: 'auth-service',
+        version: 3,
+        status: 'active',
+        files: [],
+        db_tables: [],
+        depends_on: [],
+      },
+    }));
+
+    await h.page.onCreatePR();
+
+    const description = h.githubSpy.createSpecPR.mock.calls[0][4] as string;
+    expect(description).toContain('auth-service');
+    expect(description).toContain('v3');
+  });
+});

src/app/pages/editor/editor-page-signals.spec.ts

@@ -0,0 +1,184 @@
+/**
+ * Unit tests for EditorPageComponent — computed properties & rebuildBody.
+ *
+ * Split from editor-page.spec.ts to stay under happy-dom's per-file
+ * DOM element limit (~27 TestBed.createComponent calls).
+ *
+ * Tests cover:
+ * - Computed: canCreatePR, editableSections, activeEditableSection
+ * - Computed: knownModules, body, frontmatter
+ * - rebuildBody (tested through section changes)
+ */
+import { type SpecFrontmatter, type SpecSection } from '../../models/spec.model';
+import { makeSpec, type TestHarness, setupTestBed } from './editor-page-test-utils';
+
+describe('EditorPageComponent — computed properties', () => {
+  let h: TestHarness;
+
+  beforeEach(async () => {
+    h = await setupTestBed();
+  });
+
+  describe('canCreatePR', () => {
+    it('should return true when github is connected and spec has filepath', () => {
+      h.githubSpy.connected.set(true);
+      h.activeSpecSignal.set(makeSpec({ filepath: 'specs/test.spec.md' }));
+
+      expect(h.page.canCreatePR()).toBe(true);
+    });
+
+    it('should return false when github is not connected', () => {
+      h.githubSpy.connected.set(false);
+      h.activeSpecSignal.set(makeSpec({ filepath: 'specs/test.spec.md' }));
+
+      expect(h.page.canCreatePR()).toBe(false);
+    });
+
+    it('should return false when spec has no filepath', () => {
+      h.githubSpy.connected.set(true);
+      h.activeSpecSignal.set(makeSpec({ filepath: undefined }));
+
+      expect(h.page.canCreatePR()).toBe(false);
+    });
+
+    it('should return false when no spec is loaded', () => {
+      h.githubSpy.connected.set(true);
+      h.activeSpecSignal.set(null);
+
+      expect(h.page.canCreatePR()).toBe(false);
+    });
+  });
+
+  describe('editableSections', () => {
+    it('should filter out level-1 sections', () => {
+      h.activeSpecSignal.set(makeSpec({
+        sections: [
+          { heading: 'Title', level: 1, content: '' },
+          { heading: 'Purpose', level: 2, content: 'text' },
+          { heading: 'Sub', level: 3, content: 'nested' },
+        ],
+      }));
+
+      const editables = h.page.editableSections();
+      expect(editables).toHaveLength(2);
+      expect(editables[0].heading).toBe('Purpose');
+      expect(editables[1].heading).toBe('Sub');
+    });
+
+    it('should return empty array when no spec', () => {
+      h.activeSpecSignal.set(null);
+
+      expect(h.page.editableSections()).toEqual([]);
+    });
+  });
+
+  describe('activeEditableSection', () => {
+    it('should return null when activeSectionIndex is -1', () => {
+      h.activeSpecSignal.set(makeSpec());
+      h.page.activeSectionIndex.set(-1);
+
+      expect(h.page.activeEditableSection()).toBeNull();
+    });
+
+    it('should return the correct section for valid index', () => {
+      h.activeSpecSignal.set(makeSpec());
+      h.page.activeSectionIndex.set(0);
+
+      const section = h.page.activeEditableSection();
+      expect(section).not.toBeNull();
+      expect(section!.heading).toBe('Purpose');
+    });
+
+    it('should return null for out-of-range index', () => {
+      h.activeSpecSignal.set(makeSpec());
+      h.page.activeSectionIndex.set(99);
+
+      expect(h.page.activeEditableSection()).toBeNull();
+    });
+  });
+
+  describe('knownModules', () => {
+    it('should extract and sort module names from all specs', () => {
+      h.allSpecsSignal.set([
+        makeSpec({ frontmatter: { ...makeSpec().frontmatter, module: 'zebra' } }),
+        makeSpec({ frontmatter: { ...makeSpec().frontmatter, module: 'alpha' } }),
+        makeSpec({ frontmatter: { ...makeSpec().frontmatter, module: 'middle' } }),
+      ]);
+
+      expect(h.page.knownModules()).toEqual(['alpha', 'middle', 'zebra']);
+    });
+
+    it('should filter out empty module names', () => {
+      h.allSpecsSignal.set([
+        makeSpec({ frontmatter: { ...makeSpec().frontmatter, module: 'valid' } }),
+        makeSpec({ frontmatter: { ...makeSpec().frontmatter, module: '' } }),
+      ]);
+
+      expect(h.page.knownModules()).toEqual(['valid']);
+    });
+  });
+
+  describe('body', () => {
+    it('should return spec body', () => {
+      h.activeSpecSignal.set(makeSpec({ body: '# Test\n\nContent' }));
+
+      expect(h.page.body()).toBe('# Test\n\nContent');
+    });
+
+    it('should return empty string when no spec', () => {
+      h.activeSpecSignal.set(null);
+
+      expect(h.page.body()).toBe('');
+    });
+  });
+
+  describe('frontmatter', () => {
+    it('should return spec frontmatter', () => {
+      const fm: SpecFrontmatter = { module: 'test', version: 2, status: 'active', files: ['a.ts'], db_tables: [], depends_on: [] };
+      h.activeSpecSignal.set(makeSpec({ frontmatter: fm }));
+
+      expect(h.page.frontmatter()).toEqual(fm);
+    });
+
+    it('should return default frontmatter when no spec', () => {
+      h.activeSpecSignal.set(null);
+
+      const fm = h.page.frontmatter();
+      expect(fm.module).toBe('');
+      expect(fm.version).toBe(1);
+      expect(fm.status).toBe('draft');
+    });
+  });
+
+  // ── rebuildBody (private, tested through section changes) ─────────────
+
+  describe('rebuildBody (via section changes)', () => {
+    it('should call parser.sectionsToBody with title and non-title sections', () => {
+      h.activeSpecSignal.set(makeSpec());
+      h.page.activeSectionIndex.set(0);
+
+      h.page.onSectionContentChange('New content');
+
+      expect(h.parserSpy.sectionsToBody).toHaveBeenCalled();
+      const [title, sections] = h.parserSpy.sectionsToBody.mock.calls[0] as [string, SpecSection[]];
+      expect(title).toBe('auth-service');
+      expect(sections.every((s: SpecSection) => s.level >= 2)).toBe(true);
+    });
+
+    it('should update store with rebuilt body and sections', () => {
+      h.parserSpy.sectionsToBody.mockReturnValue('## Purpose\n\nUpdated content');
+
+      h.activeSpecSignal.set(makeSpec());
+      h.page.activeSectionIndex.set(0);
+
+      h.page.onSectionContentChange('Updated content');
+
+      expect(h.storeSpy.updateActiveSpec).toHaveBeenCalledWith(
+        expect.objectContaining({
+          body: expect.any(String),
+          sections: expect.any(Array),
+        }),
+      );
+    });
+  });
+});