@setzkasten-cms/astro-admin 0.6.0

package/src/api-routes/__tests__/catalog-api.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Tests for catalog API helper logic (pure functions — no GitHub API).
+ *
+ * The catalog API routes themselves need an Astro + GitHub environment,
+ * so we test the pure helper functions that are extracted from the route logic.
+ *
+ * Covered:
+ *   1. buildCatalogResponse  — shapes registry list for the API response
+ *   2. validateCatalogAddBody — validates POST /api/setzkasten/catalog/add request body
+ *   3. buildCatalogAddCommit  — builds file paths for a catalog add commit
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  buildCatalogResponse,
+  validateCatalogAddBody,
+  buildCatalogAddCommit,
+} from '../catalog-helpers'
+
+// ---------------------------------------------------------------------------
+// buildCatalogResponse
+// ---------------------------------------------------------------------------
+
+describe('buildCatalogResponse', () => {
+  it('returns name, label, description, icon for each template', () => {
+    const result = buildCatalogResponse()
+    expect(result.length).toBeGreaterThanOrEqual(3)
+    for (const item of result) {
+      expect(item.name).toBeTruthy()
+    }
+  })
+
+  it('includes hero, features, cta', () => {
+    const names = buildCatalogResponse().map(t => t.name)
+    expect(names).toContain('hero')
+    expect(names).toContain('features')
+    expect(names).toContain('cta')
+  })
+
+  it('includes schema in each entry', () => {
+    const result = buildCatalogResponse()
+    for (const item of result) {
+      expect(item.schema?.fields).toBeDefined()
+    }
+  })
+
+  it('includes defaultContent in each entry', () => {
+    const result = buildCatalogResponse()
+    for (const item of result) {
+      expect(item.defaultContent).toBeDefined()
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// validateCatalogAddBody
+// ---------------------------------------------------------------------------
+
+describe('validateCatalogAddBody', () => {
+  it('accepts valid body with templateName and pageKey', () => {
+    expect(() => validateCatalogAddBody({ templateName: 'hero', pageKey: 'index' })).not.toThrow()
+  })
+
+  it('accepts body with sectionKey override', () => {
+    expect(() => validateCatalogAddBody({ templateName: 'hero', pageKey: 'index', sectionKey: 'hero--top' })).not.toThrow()
+  })
+
+  it('throws when templateName is missing', () => {
+    expect(() => validateCatalogAddBody({ pageKey: 'index' })).toThrow(/templateName/)
+  })
+
+  it('throws when pageKey is missing', () => {
+    expect(() => validateCatalogAddBody({ templateName: 'hero' })).toThrow(/pageKey/)
+  })
+
+  it('throws when templateName is not in registry', () => {
+    expect(() => validateCatalogAddBody({ templateName: 'nonexistent-xyz', pageKey: 'index' })).toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildCatalogAddCommit
+// ---------------------------------------------------------------------------
+
+describe('buildCatalogAddCommit', () => {
+  const opts = {
+    contentPath: 'content',
+    projectPrefix: '',
+    pageKey: 'index',
+    sectionKey: 'hero',
+    templateName: 'hero',
+    pageConfigPath: 'content/pages/_index.json',
+  }
+
+  it('includes content JSON path', () => {
+    const result = buildCatalogAddCommit(opts)
+    expect(result.sectionJsonPath).toBe('content/_sections/hero.json')
+  })
+
+  it('applies projectPrefix to paths', () => {
+    const result = buildCatalogAddCommit({ ...opts, projectPrefix: 'apps/website' })
+    expect(result.sectionJsonPath.startsWith('apps/website/')).toBe(true)
+    expect(result.pageConfigPath.startsWith('apps/website/')).toBe(true)
+  })
+
+  it('uses sectionKey for the content JSON filename', () => {
+    const result = buildCatalogAddCommit({ ...opts, sectionKey: 'hero--2' })
+    expect(result.sectionJsonPath).toContain('hero--2.json')
+  })
+
+  it('pageConfigPath matches the pageKey', () => {
+    const result = buildCatalogAddCommit({ ...opts, pageKey: 'about', pageConfigPath: 'content/pages/_about.json' })
+    expect(result.pageConfigPath).toBe('content/pages/_about.json')
+  })
+})

package/src/api-routes/__tests__/deferred-operations.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for the deferred-commit model: prepare-copy, pendingDeletes, and the
+ * extended commit-pending (empty sections array for delete-only commits).
+ *
+ * These tests catch the bugs that were found in v0.6.x:
+ * - Duplicated sections appearing empty in the editor
+ * - No content in preview after duplicate
+ * - Commits triggered on every duplicate/delete instead of batched
+ */
+
+import { describe, it, expect } from 'vitest'
+import { generateDuplicateKey, duplicateInPageConfig } from '../section-management'
+
+// ---------------------------------------------------------------------------
+// 1. Duplicate key generation (reused by prepare-copy)
+// ---------------------------------------------------------------------------
+
+describe('generateDuplicateKey (used by prepare-copy)', () => {
+  it('appends --copy to simple key', () => {
+    expect(generateDuplicateKey(['hero', 'features'], 'hero')).toBe('hero--copy')
+  })
+
+  it('appends --copy2 when --copy already exists', () => {
+    expect(generateDuplicateKey(['hero', 'hero--copy'], 'hero')).toBe('hero--copy2')
+  })
+
+  it('increments suffix until unique', () => {
+    expect(generateDuplicateKey(['hero', 'hero--copy', 'hero--copy2', 'hero--copy3'], 'hero'))
+      .toBe('hero--copy4')
+  })
+
+  it('generates copy of a copy', () => {
+    expect(generateDuplicateKey(['hero', 'hero--copy'], 'hero--copy')).toBe('hero--copy--copy')
+  })
+
+  it('handles multi-instance keys (hero--about → hero--about--copy)', () => {
+    expect(generateDuplicateKey(['hero--about'], 'hero--about')).toBe('hero--about--copy')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. duplicateInPageConfig — used by prepare-copy to build updatedPageConfig
+// ---------------------------------------------------------------------------
+
+describe('duplicateInPageConfig (used by prepare-copy)', () => {
+  const baseConfig = {
+    sections: [
+      { key: 'hero', enabled: true, order: 0 },
+      { key: 'features', enabled: true, order: 1 },
+      { key: 'cta', enabled: true, order: 2 },
+    ],
+  }
+
+  it('inserts copy immediately after original', () => {
+    const result = duplicateInPageConfig(baseConfig, 'features', 'features--copy')
+    const keys = result.sections.map((s: any) => s.key)
+    expect(keys).toEqual(['hero', 'features', 'features--copy', 'cta'])
+  })
+
+  it('copy is enabled by default', () => {
+    const result = duplicateInPageConfig(baseConfig, 'hero', 'hero--copy')
+    const copy = result.sections.find((s: any) => s.key === 'hero--copy')
+    expect(copy?.enabled).toBe(true)
+  })
+
+  it('reassigns consecutive order values after insertion', () => {
+    const result = duplicateInPageConfig(baseConfig, 'features', 'features--copy')
+    const orders = result.sections.map((s: any) => s.order)
+    expect(orders).toEqual([0, 1, 2, 3])
+  })
+
+  it('does not mutate the original config', () => {
+    duplicateInPageConfig(baseConfig, 'hero', 'hero--copy')
+    expect(baseConfig.sections).toHaveLength(3)
+  })
+
+  it('returns config unchanged when original key not found', () => {
+    const result = duplicateInPageConfig(baseConfig, 'nonexistent', 'nonexistent--copy')
+    expect(result.sections).toHaveLength(3)
+    expect(result.sections.map((s: any) => s.key)).toEqual(['hero', 'features', 'cta'])
+  })
+
+  it('preserves type field from original entry when present', () => {
+    const configWithType = {
+      sections: [
+        { key: 'hero--about', type: 'hero', enabled: true, order: 0 },
+      ],
+    }
+    const result = duplicateInPageConfig(configWithType, 'hero--about', 'hero--about--copy')
+    const copy = result.sections.find((s: any) => s.key === 'hero--about--copy')
+    expect(copy?.type).toBe('hero')
+  })
+
+  it('sets type to original key when original has no explicit type (regression: copy shows no schema and not in preview)', () => {
+    // Sections without explicit "type" use key as type (backward-compat).
+    // Example: { key: 'testPricing' } — type resolves to 'testPricing'.
+    // The copy gets key 'testPricing--copy'. WITHOUT an explicit type,
+    // getSectionDef looks up 'testPricing--copy' in the catalog → not found → empty editor.
+    // resolveSectionType returns 'testPricing--copy' → no component → not in preview.
+    const configNoType = {
+      sections: [
+        { key: 'testPricing', enabled: true, order: 0 },
+      ],
+    }
+    const result = duplicateInPageConfig(configNoType, 'testPricing', 'testPricing--copy')
+    const copy = result.sections.find((s: any) => s.key === 'testPricing--copy')
+    // Must have explicit type = original key so catalog lookup works
+    expect(copy?.type).toBe('testPricing')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. commit-pending: empty sections array (delete-only commit)
+// ---------------------------------------------------------------------------
+
+describe('commit-pending: empty sections (delete-only)', () => {
+  /**
+   * Simulates the validation logic in section-commit-pending.ts.
+   * Before the fix: sections.length === 0 caused a 400.
+   * After the fix: empty sections is valid as long as pageKey + pageConfig are present.
+   */
+  function validateCommitBody(body: {
+    pageKey?: string
+    pageConfig?: object
+    sections?: unknown
+  }): { valid: boolean; error?: string } {
+    const { pageKey, pageConfig, sections } = body
+    if (!pageKey || !pageConfig || !Array.isArray(sections)) {
+      return { valid: false, error: 'pageKey, pageConfig, and sections are required' }
+    }
+    return { valid: true }
+  }
+
+  it('rejects missing pageKey', () => {
+    const r = validateCommitBody({ pageConfig: {}, sections: [] })
+    expect(r.valid).toBe(false)
+  })
+
+  it('rejects missing pageConfig', () => {
+    const r = validateCommitBody({ pageKey: 'index', sections: [] })
+    expect(r.valid).toBe(false)
+  })
+
+  it('rejects non-array sections', () => {
+    const r = validateCommitBody({ pageKey: 'index', pageConfig: {}, sections: 'nope' })
+    expect(r.valid).toBe(false)
+  })
+
+  it('accepts empty sections array (delete-only commit)', () => {
+    const r = validateCommitBody({ pageKey: 'index', pageConfig: { sections: [] }, sections: [] })
+    expect(r.valid).toBe(true)
+  })
+
+  it('accepts non-empty sections array (add commit)', () => {
+    const r = validateCommitBody({
+      pageKey: 'index',
+      pageConfig: { sections: [{ key: 'hero', enabled: true }] },
+      sections: [{ key: 'hero', content: { heading: 'Hello' } }],
+    })
+    expect(r.valid).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. commit-pending: commit message generation
+// ---------------------------------------------------------------------------
+
+describe('commit-pending: commit message', () => {
+  function buildCommitMessage(pageKey: string, sections: Array<{ key: string }>): string {
+    const parts: string[] = []
+    if (sections.length > 0) {
+      const keys = sections.map(s => s.key).join(', ')
+      parts.push(`add ${sections.length} section${sections.length > 1 ? 's' : ''} (${keys})`)
+    }
+    return `content: ${parts.length > 0 ? parts.join(', ') : 'update page config'} on ${pageKey}`
+  }
+
+  it('describes added sections', () => {
+    const msg = buildCommitMessage('index', [{ key: 'hero' }, { key: 'cta' }])
+    expect(msg).toBe('content: add 2 sections (hero, cta) on index')
+  })
+
+  it('uses singular for one section', () => {
+    const msg = buildCommitMessage('index', [{ key: 'hero' }])
+    expect(msg).toBe('content: add 1 section (hero) on index')
+  })
+
+  it('falls back to "update page config" for delete-only (empty sections)', () => {
+    const msg = buildCommitMessage('index', [])
+    expect(msg).toBe('content: update page config on index')
+  })
+
+  it('includes page key in message', () => {
+    const msg = buildCommitMessage('docs/architecture', [])
+    expect(msg).toContain('on docs/architecture')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. prepare-copy: type resolution (inline simulation)
+// ---------------------------------------------------------------------------
+
+describe('prepare-copy: type resolution', () => {
+  /**
+   * Simulates the logic in section-prepare-copy.ts that resolves the section
+   * type from the page config entry. For multi-instance sections (hero--about),
+   * the type field is 'hero', not 'hero--about'.
+   */
+  function resolveType(
+    sections: Array<{ key: string; type?: string }>,
+    sectionKey: string,
+  ): string {
+    const entry = sections.find(s => s.key === sectionKey)
+    return entry?.type ?? sectionKey
+  }
+
+  it('returns key as type for regular sections', () => {
+    expect(resolveType([{ key: 'hero' }], 'hero')).toBe('hero')
+  })
+
+  it('returns type field for multi-instance sections', () => {
+    expect(resolveType([{ key: 'hero--about', type: 'hero' }], 'hero--about')).toBe('hero')
+  })
+
+  it('falls back to key when type field absent on multi-instance', () => {
+    expect(resolveType([{ key: 'hero--about' }], 'hero--about')).toBe('hero--about')
+  })
+
+  it('returns key when section not found in config', () => {
+    expect(resolveType([], 'hero')).toBe('hero')
+  })
+})

package/src/api-routes/__tests__/deploy-hook.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Tests for deploy-hook.ts API route.
+ *
+ * Covers:
+ *   1. No session cookie → 401
+ *   2. No deployHook configured → { skipped: true }
+ *   3. Successful deploy hook call → { ok: true }
+ *   4. Hook responds with 4xx → { ok: false, status }
+ *   5. Hook throws network error → { ok: false, error }
+ *   6. Secret header is sent when configured
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// We import the POST handler directly; Astro's APIRoute type is just a function.
+// We construct a minimal mock context manually.
+
+// Inline type to avoid Astro peer dep resolution in test env
+type MockContext = {
+  cookies: { get: (name: string) => { value: string } | undefined }
+}
+
+describe('deploy-hook POST handler', () => {
+  let POST: (ctx: MockContext) => Promise<Response>
+
+  beforeEach(async () => {
+    // Reset modules so globalThis state doesn't leak between tests
+    vi.resetModules()
+    const mod = await import('../deploy-hook.js')
+    POST = mod.POST as unknown as typeof POST
+  })
+
+  afterEach(() => {
+    // Clean up global state
+    delete (globalThis as any).__SETZKASTEN_CONFIG__
+    vi.restoreAllMocks()
+  })
+
+  function makeCtx(sessionValue?: string): MockContext {
+    return {
+      cookies: {
+        get: (name: string) =>
+          name === 'setzkasten_session' && sessionValue
+            ? { value: sessionValue }
+            : undefined,
+      },
+    }
+  }
+
+  it('no session → 401', async () => {
+    const res = await POST(makeCtx())
+    expect(res.status).toBe(401)
+  })
+
+  it('no deployHook configured → skipped', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {}
+    const res = await POST(makeCtx('tok'))
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.skipped).toBe(true)
+  })
+
+  it('successful hook call → { ok: true }', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {
+      deployHook: { url: 'https://example.com/hook' },
+    }
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({ ok: true, status: 200 } as Response),
+    )
+
+    const res = await POST(makeCtx('tok'))
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(true)
+  })
+
+  it('hook responds with 4xx → { ok: false, status }', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {
+      deployHook: { url: 'https://example.com/hook' },
+    }
+    vi.stubGlobal(
+      'fetch',
+      vi.fn().mockResolvedValue({ ok: false, status: 403, statusText: 'Forbidden' } as Response),
+    )
+
+    const res = await POST(makeCtx('tok'))
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(false)
+    expect(body.status).toBe(403)
+  })
+
+  it('network error → { ok: false, error }', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {
+      deployHook: { url: 'https://example.com/hook' },
+    }
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('ECONNREFUSED')))
+
+    const res = await POST(makeCtx('tok'))
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(body.ok).toBe(false)
+    expect(body.error).toContain('ECONNREFUSED')
+  })
+
+  it('secret is sent as X-Setzkasten-Secret header', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {
+      deployHook: { url: 'https://example.com/hook', secret: 'mysecret' },
+    }
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 } as Response)
+    vi.stubGlobal('fetch', fetchMock)
+
+    await POST(makeCtx('tok'))
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Setzkasten-Secret']).toBe('mysecret')
+  })
+
+  it('no secret configured → no X-Setzkasten-Secret header', async () => {
+    ;(globalThis as any).__SETZKASTEN_CONFIG__ = {
+      deployHook: { url: 'https://example.com/hook' },
+    }
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 } as Response)
+    vi.stubGlobal('fetch', fetchMock)
+
+    await POST(makeCtx('tok'))
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    const headers = init.headers as Record<string, string>
+    expect(headers['X-Setzkasten-Secret']).toBeUndefined()
+  })
+})

package/src/api-routes/__tests__/patch-page-file.test.ts

@@ -0,0 +1,193 @@
+/**
+ * Tests for patchPageFile() in init-add-section.ts
+ *
+ * patchPageFile() is called on every section adoption. It:
+ *   1. Inserts an import statement for the new component
+ *   2. Adds the section key to the SECTION_COMPONENTS registry
+ *   3. Removes any hardcoded <ComponentName /> from the template
+ *
+ * Bugs here mean sections either don't appear in the page or appear twice.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { patchPageFile, calculateRelativePath } from '../init-add-section'
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const PAGE_WITH_SECTIONS = `---
+import BaseLayout from '../../layouts/BaseLayout.astro'
+import HeroSection from '../../components/sections/HeroSection.astro'
+import { getSection } from 'setzkasten:content'
+
+const normalize = (k) => k.replace(/[-_]/g, '').toLowerCase()
+const SECTION_COMPONENTS = {
+  [normalize('hero')]: HeroSection,
+}
+
+const page = getPage('index')
+---
+
+<BaseLayout>
+  {page?.sections.map(({ key, data }) => {
+    const Component = SECTION_COMPONENTS[normalize(key)]
+    if (!Component) return null
+    return <Component data={data} />
+  })}
+</BaseLayout>
+`
+
+// Page where the import exists but the registry is empty (new adoption: registry add + tag removal)
+const PAGE_WITH_HARDCODED_COMPONENT = `---
+import BaseLayout from '../../layouts/BaseLayout.astro'
+import HeroSection from '../../components/sections/HeroSection.astro'
+import { getSection } from 'setzkasten:content'
+
+const normalize = (k) => k.replace(/[-_]/g, '').toLowerCase()
+const SECTION_COMPONENTS = {
+  [normalize('features')]: FeaturesSection,
+}
+---
+
+<BaseLayout>
+  <HeroSection />
+</BaseLayout>
+`
+
+// ---------------------------------------------------------------------------
+// 1. Basic import injection and registry entry
+// ---------------------------------------------------------------------------
+
+describe('patchPageFile — new section injection', () => {
+  const pagePath = 'src/pages/index.astro'
+  const componentPath = 'src/components/sections/FeaturesSection.astro'
+
+  it('should return a non-null result', () => {
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'features', 'FeaturesSection', componentPath, pagePath)
+    expect(result).not.toBeNull()
+  })
+
+  it('should add the import statement', () => {
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'features', 'FeaturesSection', componentPath, pagePath)!
+    expect(result).toContain("import FeaturesSection from")
+  })
+
+  it('should include the correct relative path', () => {
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'features', 'FeaturesSection', componentPath, pagePath)!
+    // From src/pages to src/components/sections → one level up → ../components/sections/...
+    expect(result).toContain('../components/sections/FeaturesSection.astro')
+  })
+
+  it('should add the section key to SECTION_COMPONENTS', () => {
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'features', 'FeaturesSection', componentPath, pagePath)!
+    expect(result).toContain('features')
+    expect(result).toContain('FeaturesSection')
+  })
+
+  it('should preserve existing sections in the registry', () => {
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'features', 'FeaturesSection', componentPath, pagePath)!
+    expect(result).toContain('HeroSection')
+    expect(result).toContain("normalize('hero')")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. Idempotency — same section adopted twice
+// ---------------------------------------------------------------------------
+
+describe('patchPageFile — duplicate prevention', () => {
+  const pagePath = 'src/pages/index.astro'
+  const componentPath = 'src/components/sections/HeroSection.astro'
+
+  it('should return null if section is already registered', () => {
+    // HeroSection with key 'hero' is already in PAGE_WITH_SECTIONS
+    const result = patchPageFile(PAGE_WITH_SECTIONS, 'hero', 'HeroSection', componentPath, pagePath)
+    // Either null (no change) or source with only one hero entry
+    if (result !== null) {
+      const heroCount = (result.match(/normalize\('hero'\)/g) ?? []).length
+      expect(heroCount).toBe(1)
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. Hardcoded component removal
+// ---------------------------------------------------------------------------
+
+describe('patchPageFile — hardcoded tag removal', () => {
+  const pagePath = 'src/pages/index.astro'
+  const componentPath = 'src/components/sections/HeroSection.astro'
+
+  it('should remove the hardcoded <HeroSection /> when adding to registry', () => {
+    // PAGE_WITH_HARDCODED_COMPONENT has HeroSection imported but NOT in registry
+    // → patchPageFile adds it to registry AND removes the hardcoded tag
+    const result = patchPageFile(PAGE_WITH_HARDCODED_COMPONENT, 'hero', 'HeroSection', componentPath, pagePath)
+    expect(result).not.toBeNull()
+    expect(result).not.toMatch(/<HeroSection\s*\/>/)
+  })
+
+  it('should add the section to SECTION_COMPONENTS when removing hardcoded tag', () => {
+    const result = patchPageFile(PAGE_WITH_HARDCODED_COMPONENT, 'hero', 'HeroSection', componentPath, pagePath)!
+    expect(result).toContain('hero')
+    expect(result).toContain('HeroSection')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. Page at a nested path — import depth
+// ---------------------------------------------------------------------------
+
+describe('patchPageFile — nested page paths', () => {
+  const PAGE_NESTED = `---
+import BaseLayout from '../../../layouts/BaseLayout.astro'
+import HeroSection from '../../../components/sections/HeroSection.astro'
+import { getSection } from 'setzkasten:content'
+
+const normalize = (k) => k.replace(/[-_]/g, '').toLowerCase()
+const SECTION_COMPONENTS = {
+  [normalize('hero')]: HeroSection,
+}
+---
+
+<BaseLayout />
+`
+
+  it('should calculate correct import depth for nested page', () => {
+    const pagePath = 'src/pages/docs/architecture.astro'
+    const componentPath = 'src/components/sections/FeaturesSection.astro'
+
+    const result = patchPageFile(PAGE_NESTED, 'features', 'FeaturesSection', componentPath, pagePath)
+    if (result) {
+      // From src/pages/docs to src/components/sections = ../../components/sections
+      expect(result).toContain('../../components/sections/FeaturesSection.astro')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. calculateRelativePath (exported for direct testing)
+// ---------------------------------------------------------------------------
+
+describe('calculateRelativePath', () => {
+  it('same directory → ./file', () => {
+    expect(calculateRelativePath('src/pages', 'src/pages/Hero.astro')).toBe('./Hero.astro')
+  })
+
+  it('one level up', () => {
+    expect(calculateRelativePath('src/pages', 'src/components/Hero.astro'))
+      .toBe('../components/Hero.astro')
+  })
+
+  it('two levels up', () => {
+    expect(calculateRelativePath('src/pages/docs', 'src/components/sections/Hero.astro'))
+      .toBe('../../components/sections/Hero.astro')
+  })
+
+  it('deeper nesting in monorepo', () => {
+    expect(calculateRelativePath(
+      'apps/website/src/pages',
+      'apps/website/src/components/sections/FooterSection.astro',
+    )).toBe('../components/sections/FooterSection.astro')
+  })
+})