popeye-cli 1.5.0 → 1.6.0

package/tests/generators/website-landing.test.ts

@@ -0,0 +1,188 @@
+/**
+ * Tests for website-landing module
+ * Verifies 10-section landing page generation with strategy data flow
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateWebsiteLandingPageWithInfo } from '../../src/generators/templates/website-landing.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+import type { WebsiteStrategyDocument } from '../../src/types/website-strategy.js';
+
+function makeStrategy(overrides?: Partial<WebsiteStrategyDocument>): WebsiteStrategyDocument {
+  return {
+    icp: {
+      primaryPersona: 'Engineering teams',
+      painPoints: ['Data leaks', 'No access control', 'Compliance gaps'],
+      goals: ['Secure AI access'],
+      objections: ['Is it secure?', 'Does it scale?'],
+    },
+    positioning: {
+      category: 'AI Security',
+      differentiators: ['Zero-trust by default', 'Vector DB agnostic'],
+      valueProposition: 'Secure AI data access without complexity',
+      proofPoints: ['SOC2 compliant', '10K+ queries/sec'],
+    },
+    messaging: {
+      headline: 'Secure AI Retrieval',
+      subheadline: 'Permission-aware access for AI agents',
+      elevatorPitch: 'Stop worrying about data leaks',
+      longDescription: 'A permission-aware retrieval layer for AI systems.',
+    },
+    seoStrategy: {
+      primaryKeywords: ['AI security'],
+      secondaryKeywords: [],
+      longTailKeywords: [],
+      titleTemplates: { home: 'Gateco - AI Security' },
+      metaDescriptions: { home: 'Secure AI retrieval' },
+    },
+    siteArchitecture: {
+      pages: [],
+      navigation: [{ label: 'Features', href: '/#features' }],
+      footerSections: [],
+    },
+    conversionStrategy: {
+      primaryCta: { text: 'Try Free', href: '/signup' },
+      secondaryCta: { text: 'View Docs', href: '/docs' },
+      trustSignals: ['Enterprise ready', 'SOC2 compliant'],
+      socialProof: ['Great product!'],
+      leadCapture: 'none',
+    },
+    competitiveContext: { category: 'Security', competitors: [], differentiators: [] },
+    ...overrides,
+  };
+}
+
+function makeContext(overrides?: Partial<WebsiteContentContext>): WebsiteContentContext {
+  return {
+    productName: 'Gateco',
+    features: [
+      { title: 'Access Control', description: 'Fine-grained permissions' },
+      { title: 'Vector Search', description: 'Fast semantic search' },
+      { title: 'Audit Trail', description: 'Full audit logging' },
+    ],
+    rawDocs: 'docs content here',
+    description: 'A permission-aware retrieval layer for AI systems.',
+    pricing: [
+      { name: 'Free', price: 'Free', description: 'Dev & POC', features: ['Basic'], cta: 'Start', featured: false },
+      { name: 'Pro', price: '$99', period: '/month', description: 'Production', features: ['All'], cta: 'Subscribe', featured: true },
+    ],
+    strategy: makeStrategy(),
+    ...overrides,
+  };
+}
+
+describe('generateWebsiteLandingPageWithInfo', () => {
+  it('generates page with all 10 sections when full context provided', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+
+    // Hero
+    expect(result.code).toContain('Secure AI Retrieval');
+    expect(result.code).toContain('AI Security'); // eyebrow category
+
+    // Sections rendered info should have all sections
+    const sectionNames = result.sections.map(s => s.name);
+    expect(sectionNames).toContain('Hero');
+    expect(sectionNames).toContain('PainPoints');
+    expect(sectionNames).toContain('Differentiators');
+    expect(sectionNames).toContain('Features');
+    expect(sectionNames).toContain('HowItWorks');
+    expect(sectionNames).toContain('Stats');
+    expect(sectionNames).toContain('SocialProof');
+    expect(sectionNames).toContain('PricingTeaser');
+    expect(sectionNames).toContain('FAQ');
+    expect(sectionNames).toContain('FinalCTA');
+  });
+
+  it('includes strategy headline in hero', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Secure AI Retrieval');
+  });
+
+  it('includes pain points from strategy', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Data leaks');
+    expect(result.code).toContain('No access control');
+  });
+
+  it('includes differentiators from strategy', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Zero-trust by default');
+    expect(result.code).toContain('Vector DB agnostic');
+  });
+
+  it('renders features with lucide icons', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Access Control');
+    expect(result.code).toContain('lucide-react');
+    expect(result.code).toContain('ICON_MAP');
+  });
+
+  it('renders FAQ from strategy objections', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Is it secure?');
+    expect(result.code).toContain('Does it scale?');
+    expect(result.code).toContain('FaqItem');
+  });
+
+  it('renders pricing teaser from context pricing', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('View full pricing');
+    expect(result.code).toContain('$99');
+  });
+
+  it('skips sections when data is missing', () => {
+    const ctx = makeContext({
+      strategy: makeStrategy({
+        icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] },
+        positioning: { category: 'SaaS', differentiators: [], valueProposition: '', proofPoints: [] },
+        conversionStrategy: {
+          primaryCta: { text: 'Go', href: '/' },
+          secondaryCta: { text: 'More', href: '/' },
+          trustSignals: [],
+          socialProof: [],
+          leadCapture: 'none',
+        },
+      }),
+      pricing: undefined,
+    });
+    const result = generateWebsiteLandingPageWithInfo('gateco', ctx);
+
+    const skipped = result.sections.filter(s => s.dataSource === 'skipped');
+    expect(skipped.map(s => s.name)).toContain('PainPoints');
+    expect(skipped.map(s => s.name)).toContain('SocialProof');
+    expect(skipped.map(s => s.name)).toContain('FAQ');
+    expect(skipped.map(s => s.name)).toContain('PricingTeaser');
+  });
+
+  it('uses product name as headline when no strategy', () => {
+    const ctx = makeContext({ strategy: undefined });
+    const result = generateWebsiteLandingPageWithInfo('gateco', ctx);
+    expect(result.code).toContain('Gateco');
+  });
+
+  it('renders only a single H1', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    const h1Count = (result.code.match(/<h1/g) || []).length;
+    expect(h1Count).toBe(1);
+  });
+
+  it('includes trust signals in hero', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Enterprise ready');
+    expect(result.code).toContain('SOC2 compliant');
+  });
+
+  it('includes dual CTAs from strategy', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Try Free');
+    expect(result.code).toContain('View Docs');
+  });
+
+  it('includes JSON-LD schemas', () => {
+    const result = generateWebsiteLandingPageWithInfo('gateco', makeContext());
+    expect(result.code).toContain('Organization');
+    expect(result.code).toContain('SoftwareApplication');
+    // FAQ schema when objections exist
+    expect(result.code).toContain('FAQPage');
+  });
+});

package/tests/generators/website-pricing.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for website-pricing module
+ * Verifies pricing page generation with tiers, comparison table, and FAQ
+ */
+
+import { describe, it, expect } from 'vitest';
+import { generateWebsitePricingPage } from '../../src/generators/templates/website-pricing.js';
+import type { WebsiteContentContext } from '../../src/generators/website-context.js';
+
+function makeContext(): WebsiteContentContext {
+  return {
+    productName: 'Gateco',
+    features: [],
+    rawDocs: 'docs',
+    pricing: [
+      {
+        name: 'Free',
+        price: 'Free',
+        period: '',
+        description: 'Dev & POC',
+        features: ['Basic access', 'Community support'],
+        cta: 'Get started',
+        featured: false,
+      },
+      {
+        name: 'Pro',
+        price: '$99',
+        period: '/month',
+        description: 'Production workloads',
+        features: ['Basic access', 'Priority support', 'Advanced analytics'],
+        cta: 'Start free trial',
+        featured: true,
+      },
+      {
+        name: 'Enterprise',
+        price: 'Custom',
+        period: '',
+        description: 'Regulated environments',
+        features: ['Basic access', 'Priority support', 'Advanced analytics', 'SLA guarantee'],
+        cta: 'Contact sales',
+        featured: false,
+      },
+    ],
+  };
+}
+
+describe('generateWebsitePricingPage', () => {
+  it('generates page with tier cards', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Free');
+    expect(code).toContain('$99');
+    expect(code).toContain('Custom');
+  });
+
+  it('includes monthly/annual toggle', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Annual');
+    expect(code).toContain('Save 20%');
+    expect(code).toContain('useState(false)');
+  });
+
+  it('marks featured tier as Most Popular', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Most Popular');
+  });
+
+  it('includes feature comparison table when tiers have features', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Compare plans');
+    expect(code).toContain('Basic access');
+  });
+
+  it('includes pricing FAQ', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('Pricing FAQ');
+    expect(code).toContain('switch plans');
+    expect(code).toContain('free trial');
+  });
+
+  it('includes enterprise CTA section', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    expect(code).toContain('custom plan');
+    expect(code).toContain('/contact');
+  });
+
+  it('renders single H1', () => {
+    const code = generateWebsitePricingPage('gateco', makeContext());
+    const h1Count = (code.match(/<h1/g) || []).length;
+    expect(h1Count).toBe(1);
+  });
+
+  it('generates defaults when no pricing provided', () => {
+    const code = generateWebsitePricingPage('gateco');
+    expect(code).toContain('Starter');
+    expect(code).toContain('Pro');
+    expect(code).toContain('Enterprise');
+  });
+});

package/tests/generators/website-sections.test.ts

@@ -0,0 +1,245 @@
+/**
+ * Tests for website-sections module
+ * Verifies FAQ, Stats (no fake numbers), HowItWorks, PainPoints
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  mapFeatureIcon,
+  isNumericMetric,
+  generatePainPointsSection,
+  generateDifferentiatorsSection,
+  generateHowItWorksSection,
+  generateStatsSection,
+  generateSocialProofSection,
+  generateFaqSection,
+  buildFaqItemsDeclaration,
+  generateFaqItemComponent,
+  generatePricingTeaserSection,
+} from '../../src/generators/templates/website-sections.js';
+import type { WebsiteStrategyDocument } from '../../src/types/website-strategy.js';
+
+function makeStrategy(overrides?: Partial<WebsiteStrategyDocument>): WebsiteStrategyDocument {
+  return {
+    icp: { primaryPersona: 'devs', painPoints: ['No ACL', 'Slow queries'], goals: [], objections: ['Is it secure?'] },
+    positioning: {
+      category: 'Security',
+      differentiators: ['Zero-trust', 'DB agnostic'],
+      valueProposition: 'Secure AI access',
+      proofPoints: ['SOC2 compliant', '10K+ queries/sec', '99.9% uptime'],
+    },
+    messaging: { headline: 'h', subheadline: 's', elevatorPitch: 'e', longDescription: 'l' },
+    seoStrategy: { primaryKeywords: [], secondaryKeywords: [], longTailKeywords: [], titleTemplates: {}, metaDescriptions: {} },
+    siteArchitecture: { pages: [{ path: '/', title: 'Home', purpose: '', pageType: 'landing', sections: ['Sign Up', 'Configure', 'Deploy'], seoKeywords: [], conversionGoal: '' }], navigation: [], footerSections: [] },
+    conversionStrategy: { primaryCta: { text: 'Go', href: '/' }, secondaryCta: { text: 'More', href: '/' }, trustSignals: [], socialProof: ['Great tool!'], leadCapture: 'none' },
+    competitiveContext: { category: 'sec', competitors: [], differentiators: [] },
+    ...overrides,
+  };
+}
+
+describe('mapFeatureIcon', () => {
+  it('maps security-related features to Shield icon', () => {
+    expect(mapFeatureIcon('Access Control')).toBe('Shield');
+    expect(mapFeatureIcon('Authentication')).toBe('Shield');
+  });
+
+  it('maps search features to Search icon', () => {
+    expect(mapFeatureIcon('Vector Search')).toBe('Search');
+  });
+
+  it('returns Star for unknown features', () => {
+    expect(mapFeatureIcon('Something Unique')).toBe('Star');
+  });
+});
+
+describe('isNumericMetric', () => {
+  it('detects numeric metrics', () => {
+    expect(isNumericMetric('10K+ queries/sec')).toBe(true);
+    expect(isNumericMetric('99.9% uptime')).toBe(true);
+    expect(isNumericMetric('500+ customers')).toBe(true);
+  });
+
+  it('rejects qualitative metrics', () => {
+    expect(isNumericMetric('SOC2 compliant')).toBe(false);
+    expect(isNumericMetric('Enterprise ready')).toBe(false);
+    expect(isNumericMetric('Audit-ready')).toBe(false);
+  });
+});
+
+describe('generatePainPointsSection', () => {
+  it('renders pain points from strategy', () => {
+    const { jsx, info } = generatePainPointsSection(makeStrategy());
+    expect(jsx).toContain('No ACL');
+    expect(jsx).toContain('Slow queries');
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(2);
+  });
+
+  it('skips when no pain points', () => {
+    const strategy = makeStrategy({ icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] } });
+    const { jsx, info } = generatePainPointsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateDifferentiatorsSection', () => {
+  it('renders differentiators with value proposition heading', () => {
+    const { jsx, info } = generateDifferentiatorsSection(makeStrategy());
+    expect(jsx).toContain('Secure AI access');
+    expect(jsx).toContain('Zero-trust');
+    expect(info.dataSource).toBe('strategy');
+  });
+
+  it('skips when no differentiators', () => {
+    const strategy = makeStrategy({
+      positioning: { category: 'x', differentiators: [], valueProposition: '', proofPoints: [] },
+    });
+    const { jsx, info } = generateDifferentiatorsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateHowItWorksSection', () => {
+  it('renders with strategy sections', () => {
+    const { jsx, info } = generateHowItWorksSection(makeStrategy());
+    expect(jsx).toContain('How it works');
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(3);
+  });
+
+  it('uses defaults when no strategy', () => {
+    const { jsx, info } = generateHowItWorksSection(undefined);
+    expect(jsx).toContain('Sign Up');
+    expect(jsx).toContain('Configure');
+    expect(jsx).toContain('Deploy');
+    expect(info.dataSource).toBe('defaults');
+  });
+});
+
+describe('generateStatsSection', () => {
+  it('renders numeric metrics as stats and qualitative as badges', () => {
+    const { jsx, info } = generateStatsSection(makeStrategy());
+
+    // Numeric: rendered as big stat
+    expect(jsx).toContain('10K+ queries/sec');
+    expect(jsx).toContain('99.9% uptime');
+
+    // Qualitative: rendered as badge
+    expect(jsx).toContain('SOC2 compliant');
+
+    expect(info.dataSource).toBe('strategy');
+    expect(info.itemCount).toBe(3);
+  });
+
+  it('does NOT fabricate numeric stats from qualitative data', () => {
+    const strategy = makeStrategy({
+      positioning: {
+        category: 'x',
+        differentiators: [],
+        valueProposition: '',
+        proofPoints: ['Audit-ready', 'HIPAA compliant'],
+      },
+    });
+    const { jsx } = generateStatsSection(strategy);
+
+    // Should NOT contain fabricated numbers
+    expect(jsx).not.toContain('10K+');
+    expect(jsx).not.toContain('99.9%');
+    // Should contain qualitative badges
+    expect(jsx).toContain('Audit-ready');
+    expect(jsx).toContain('HIPAA compliant');
+  });
+
+  it('skips when no proof points', () => {
+    const strategy = makeStrategy({
+      positioning: { category: 'x', differentiators: [], valueProposition: '', proofPoints: [] },
+    });
+    const { jsx, info } = generateStatsSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateSocialProofSection', () => {
+  it('renders social proof quotes', () => {
+    const { jsx, info } = generateSocialProofSection(makeStrategy());
+    expect(jsx).toContain('Great tool!');
+    expect(info.dataSource).toBe('strategy');
+  });
+
+  it('skips when empty', () => {
+    const strategy = makeStrategy({
+      conversionStrategy: {
+        primaryCta: { text: 'Go', href: '/' },
+        secondaryCta: { text: 'More', href: '/' },
+        trustSignals: [],
+        socialProof: [],
+        leadCapture: 'none',
+      },
+    });
+    const { jsx, info } = generateSocialProofSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generateFaqSection', () => {
+  it('renders FAQ from objections', () => {
+    const { jsx, info, needsClientDirective } = generateFaqSection(makeStrategy());
+    // FAQ section JSX references faqItems via runtime mapping
+    expect(jsx).toContain('FaqItem');
+    expect(jsx).toContain('faqItems.map');
+    expect(info.dataSource).toBe('strategy');
+    expect(needsClientDirective).toBe(true);
+  });
+
+  it('builds FAQ items declaration with objection content', () => {
+    const decl = buildFaqItemsDeclaration(makeStrategy());
+    expect(decl).toContain('Is it secure?');
+    expect(decl).toContain('faqItems');
+  });
+
+  it('includes keyboard-accessible accordion in FaqItem component', () => {
+    const component = generateFaqItemComponent();
+    expect(component).toContain('aria-expanded');
+    expect(component).toContain('onClick');
+  });
+
+  it('skips when no objections', () => {
+    const strategy = makeStrategy({
+      icp: { primaryPersona: 'devs', painPoints: [], goals: [], objections: [] },
+    });
+    const { jsx, info } = generateFaqSection(strategy);
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});
+
+describe('generatePricingTeaserSection', () => {
+  it('renders teaser when pricing exists', () => {
+    const { jsx, info } = generatePricingTeaserSection({
+      productName: 'Test',
+      features: [],
+      rawDocs: '',
+      pricing: [
+        { name: 'Free', price: 'Free', description: 'Basic', features: [], cta: 'Start' },
+        { name: 'Pro', price: '$99', period: '/mo', description: 'Full', features: [], cta: 'Buy', featured: true },
+      ],
+    });
+    expect(jsx).toContain('$99');
+    expect(jsx).toContain('View full pricing');
+    expect(info.dataSource).toBe('docs');
+  });
+
+  it('skips when no pricing', () => {
+    const { jsx, info } = generatePricingTeaserSection({
+      productName: 'Test',
+      features: [],
+      rawDocs: '',
+    });
+    expect(jsx).toBe('');
+    expect(info.dataSource).toBe('skipped');
+  });
+});

package/tests/generators/workspace-root.test.ts

@@ -0,0 +1,105 @@
+/**
+ * Tests for workspace root detection
+ * Verifies .popeye/ detection, workspaces in package.json, and fallback behavior
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { resolveWorkspaceRoot, getScanDirectories } from '../../src/generators/workspace-root.js';
+
+describe('resolveWorkspaceRoot', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-ws-root-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('detects .popeye/ directory as workspace root', async () => {
+    // Create nested structure: tmpDir/project/.popeye/ with cwd = tmpDir/project/sub
+    const projectDir = path.join(tmpDir, 'project');
+    const subDir = path.join(projectDir, 'sub');
+    await fs.mkdir(path.join(projectDir, '.popeye'), { recursive: true });
+    await fs.mkdir(subDir, { recursive: true });
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+
+  it('detects package.json with workspaces field', async () => {
+    const projectDir = path.join(tmpDir, 'monorepo');
+    const subDir = path.join(projectDir, 'apps', 'website');
+    await fs.mkdir(subDir, { recursive: true });
+    await fs.writeFile(
+      path.join(projectDir, 'package.json'),
+      JSON.stringify({ name: 'root', workspaces: ['apps/*', 'packages/*'] })
+    );
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+
+  it('falls back to cwd when no workspace indicators found', async () => {
+    const cwd = path.join(tmpDir, 'standalone');
+    await fs.mkdir(cwd, { recursive: true });
+
+    const root = await resolveWorkspaceRoot(cwd);
+
+    expect(root).toBe(cwd);
+  });
+
+  it('detects turbo.json or pnpm-workspace.yaml', async () => {
+    const projectDir = path.join(tmpDir, 'turborepo');
+    const subDir = path.join(projectDir, 'apps', 'web');
+    await fs.mkdir(subDir, { recursive: true });
+    await fs.writeFile(path.join(projectDir, 'turbo.json'), '{}');
+
+    const root = await resolveWorkspaceRoot(subDir);
+
+    expect(root).toBe(projectDir);
+  });
+});
+
+describe('getScanDirectories', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'popeye-scan-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('includes workspace root, parent, and subdirectories', async () => {
+    const projectDir = path.join(tmpDir, 'project');
+    await fs.mkdir(path.join(projectDir, '.popeye'), { recursive: true });
+    await fs.mkdir(path.join(projectDir, 'docs'), { recursive: true });
+    await fs.mkdir(path.join(projectDir, 'brand'), { recursive: true });
+
+    const dirs = await getScanDirectories(projectDir);
+
+    expect(dirs).toContain(projectDir);
+    expect(dirs).toContain(tmpDir); // parent
+    expect(dirs).toContain(path.join(projectDir, 'docs'));
+    expect(dirs).toContain(path.join(projectDir, 'brand'));
+  });
+
+  it('deduplicates directories', async () => {
+    const projectDir = path.join(tmpDir, 'project');
+    await fs.mkdir(projectDir, { recursive: true });
+
+    const dirs = await getScanDirectories(projectDir);
+
+    // No duplicates
+    const unique = new Set(dirs);
+    expect(unique.size).toBe(dirs.length);
+  });
+});