@nathapp/nax 0.27.1 → 0.29.0

package/test/unit/config/quality-commands-schema.test.ts

@@ -1,72 +0,0 @@
-// RE-ARCH: keep
-/**
- * quality.commands schema — testScoped and other optional command fields
- *
- * Regression test for BUG-043: testScoped was present in types.ts but missing
- * from schemas.ts, causing Zod to silently strip it during config parsing.
- * Result: testScopedTemplate was always undefined at runtime, so the {{files}}
- * template was never applied and scoped tests fell back to buildSmartTestCommand.
- */
-
-import { describe, test, expect } from "bun:test";
-import { NaxConfigSchema } from "../../../src/config/schemas";
-import { DEFAULT_CONFIG } from "../../../src/config/defaults";
-
-function buildConfigWithCommands(commands: Record<string, unknown>) {
-  return {
-    ...DEFAULT_CONFIG,
-    quality: {
-      ...DEFAULT_CONFIG.quality,
-      commands: {
-        ...DEFAULT_CONFIG.quality.commands,
-        ...commands,
-      },
-    },
-  };
-}
-
-describe("quality.commands schema", () => {
-  test("testScoped is preserved after schema parse (BUG-043 regression)", () => {
-    const input = buildConfigWithCommands({
-      testScoped: "bun test --timeout=60000 {{files}}",
-    });
-    const result = NaxConfigSchema.parse(input);
-    expect(result.quality.commands.testScoped).toBe("bun test --timeout=60000 {{files}}");
-  });
-
-  test("testScoped is optional — absent when not provided", () => {
-    const input = buildConfigWithCommands({});
-    const result = NaxConfigSchema.parse(input);
-    expect(result.quality.commands.testScoped).toBeUndefined();
-  });
-
-  test("lintFix is preserved after schema parse", () => {
-    const input = buildConfigWithCommands({ lintFix: "bun run lint --fix" });
-    const result = NaxConfigSchema.parse(input);
-    expect(result.quality.commands.lintFix).toBe("bun run lint --fix");
-  });
-
-  test("formatFix is preserved after schema parse", () => {
-    const input = buildConfigWithCommands({ formatFix: "bun run format --write" });
-    const result = NaxConfigSchema.parse(input);
-    expect(result.quality.commands.formatFix).toBe("bun run format --write");
-  });
-
-  test("all command fields coexist correctly", () => {
-    const input = buildConfigWithCommands({
-      test: "bun run test",
-      testScoped: "bun test --timeout=60000 {{files}}",
-      typecheck: "bun run typecheck",
-      lint: "bun run lint",
-      lintFix: "bun run lint --fix",
-      formatFix: "bun run format --write",
-    });
-    const result = NaxConfigSchema.parse(input);
-    expect(result.quality.commands.test).toBe("bun run test");
-    expect(result.quality.commands.testScoped).toBe("bun test --timeout=60000 {{files}}");
-    expect(result.quality.commands.typecheck).toBe("bun run typecheck");
-    expect(result.quality.commands.lint).toBe("bun run lint");
-    expect(result.quality.commands.lintFix).toBe("bun run lint --fix");
-    expect(result.quality.commands.formatFix).toBe("bun run format --write");
-  });
-});

package/test/unit/config/regression-gate-schema.test.ts

@@ -1,160 +0,0 @@
-// RE-ARCH: keep
-/**
- * RegressionGateConfigSchema — mode and maxRectificationAttempts fields
- *
- * Tests that the Zod schema accepts the new 'mode' enum and
- * 'maxRectificationAttempts' integer fields added in US-003.
- *
- * These tests FAIL until RegressionGateConfigSchema is updated in
- * src/config/schemas.ts to add:
- *   mode: z.enum(["deferred", "per-story", "disabled"]).default("deferred")
- *   maxRectificationAttempts: z.number().int().min(1).default(2)
- */
-
-import { describe, test, expect } from "bun:test";
-import { NaxConfigSchema } from "../../../src/config/schemas";
-import { DEFAULT_CONFIG } from "../../../src/config/defaults";
-
-// ---------------------------------------------------------------------------
-// Helper: build a full NaxConfig-shaped object with a custom regressionGate
-// ---------------------------------------------------------------------------
-
-function buildConfigWith(regressionGate: Record<string, unknown>) {
-  return {
-    ...DEFAULT_CONFIG,
-    execution: {
-      ...DEFAULT_CONFIG.execution,
-      regressionGate,
-    },
-  };
-}
-
-const BASE_REGRESSION_GATE = {
-  enabled: true,
-  timeoutSeconds: 120,
-  acceptOnTimeout: true,
-};
-
-// ---------------------------------------------------------------------------
-// mode field
-// ---------------------------------------------------------------------------
-
-describe("RegressionGateConfigSchema - mode field", () => {
-  test("accepts mode: 'deferred'", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: "deferred" });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // Cast needed until schema is updated (mode not yet in inferred type)
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).mode).toBe("deferred");
-    }
-  });
-
-  test("accepts mode: 'per-story'", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: "per-story" });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).mode).toBe("per-story");
-    }
-  });
-
-  test("accepts mode: 'disabled'", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: "disabled" });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).mode).toBe("disabled");
-    }
-  });
-
-  test("defaults mode to 'deferred' when field is omitted", () => {
-    const raw = buildConfigWith(BASE_REGRESSION_GATE);
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).mode).toBe("deferred");
-    }
-  });
-
-  test("rejects invalid mode value", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: "always" });
-    const result = NaxConfigSchema.safeParse(raw);
-    // Schema must reject unknown enum values (currently strips them → FAILS)
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects numeric mode value", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: 1 });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// maxRectificationAttempts field
-// ---------------------------------------------------------------------------
-
-describe("RegressionGateConfigSchema - maxRectificationAttempts field", () => {
-  test("accepts maxRectificationAttempts: 2", () => {
-    const raw = buildConfigWith({
-      ...BASE_REGRESSION_GATE,
-      mode: "deferred",
-      maxRectificationAttempts: 2,
-    });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).maxRectificationAttempts).toBe(2);
-    }
-  });
-
-  test("accepts maxRectificationAttempts: 1", () => {
-    const raw = buildConfigWith({
-      ...BASE_REGRESSION_GATE,
-      mode: "deferred",
-      maxRectificationAttempts: 1,
-    });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).maxRectificationAttempts).toBe(1);
-    }
-  });
-
-  test("defaults maxRectificationAttempts to 2 when omitted", () => {
-    const raw = buildConfigWith({ ...BASE_REGRESSION_GATE, mode: "deferred" });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      expect((result.data.execution.regressionGate as any).maxRectificationAttempts).toBe(2);
-    }
-  });
-
-  test("rejects non-integer maxRectificationAttempts", () => {
-    const raw = buildConfigWith({
-      ...BASE_REGRESSION_GATE,
-      mode: "deferred",
-      maxRectificationAttempts: 1.5,
-    });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(false);
-  });
-
-  test("rejects string maxRectificationAttempts", () => {
-    const raw = buildConfigWith({
-      ...BASE_REGRESSION_GATE,
-      mode: "deferred",
-      maxRectificationAttempts: "two",
-    });
-    const result = NaxConfigSchema.safeParse(raw);
-    expect(result.success).toBe(false);
-  });
-});

package/test/unit/config/smart-runner-flag.test.ts

@@ -1,250 +0,0 @@
-// RE-ARCH: keep
-/**
- * Smart Test Runner Config Flag Tests (STR-004)
- *
- * Verifies that execution.smartTestRunner is present in the ExecutionConfig
- * interface, defaults to true in the Zod schema, and loads correctly.
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { globalConfigPath, loadConfig } from "../../../src/config/loader";
-import { DEFAULT_CONFIG } from "../../../src/config/defaults";
-import { NaxConfigSchema } from "../../../src/config/schemas";
-
-describe("execution.smartTestRunner config flag", () => {
-  let tempDir: string;
-  let globalBackup: string | null = null;
-
-  beforeEach(() => {
-    tempDir = join(tmpdir(), `nax-str-004-${Date.now()}`);
-    mkdirSync(join(tempDir, "nax"), { recursive: true });
-
-    const globalPath = globalConfigPath();
-    if (existsSync(globalPath)) {
-      globalBackup = `${globalPath}.test-backup-${Date.now()}`;
-      renameSync(globalPath, globalBackup);
-    }
-  });
-
-  afterEach(() => {
-    if (tempDir) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    if (globalBackup && existsSync(globalBackup)) {
-      const globalPath = globalConfigPath();
-      if (existsSync(globalPath)) rmSync(globalPath);
-      renameSync(globalBackup, globalPath);
-      globalBackup = null;
-    }
-  });
-
-  test("DEFAULT_CONFIG has smartTestRunner: true", () => {
-    expect(DEFAULT_CONFIG.execution.smartTestRunner).toBe(true);
-  });
-
-  test("Zod schema defaults smartTestRunner to enabled object when field is absent", () => {
-    const minimal = {
-      version: 1,
-      models: {
-        fast: { provider: "anthropic", model: "haiku" },
-        balanced: { provider: "anthropic", model: "sonnet" },
-        powerful: { provider: "anthropic", model: "opus" },
-      },
-      autoMode: {
-        enabled: true,
-        defaultAgent: "claude",
-        fallbackOrder: [],
-        complexityRouting: { simple: "fast", medium: "balanced", complex: "powerful", expert: "powerful" },
-        escalation: { enabled: true, tierOrder: [{ tier: "fast", attempts: 1 }] },
-      },
-      routing: { strategy: "keyword" },
-      execution: {
-        maxIterations: 10,
-        iterationDelayMs: 0,
-        costLimit: 1,
-        sessionTimeoutSeconds: 60,
-        maxStoriesPerFeature: 10,
-        rectification: {
-          enabled: true,
-          maxRetries: 1,
-          fullSuiteTimeoutSeconds: 30,
-          maxFailureSummaryChars: 500,
-          abortOnIncreasingFailures: true,
-        },
-        regressionGate: { enabled: true, timeoutSeconds: 30 },
-        contextProviderTokenBudget: 100,
-        // smartTestRunner intentionally omitted
-      },
-      quality: {
-        requireTypecheck: true,
-        requireLint: true,
-        requireTests: true,
-        commands: {},
-        forceExit: false,
-        detectOpenHandles: true,
-        detectOpenHandlesRetries: 1,
-        gracePeriodMs: 500,
-        drainTimeoutMs: 0,
-        shell: "/bin/sh",
-        stripEnvVars: [],
-        environmentalEscalationDivisor: 2,
-      },
-      tdd: { maxRetries: 0, autoVerifyIsolation: false, autoApproveVerifier: false },
-      constitution: { enabled: false, path: "constitution.md", maxTokens: 100 },
-      analyze: { llmEnhanced: false, model: "balanced", fallbackToKeywords: true, maxCodebaseSummaryTokens: 100 },
-      review: { enabled: false, checks: [], commands: {} },
-      plan: { model: "balanced", outputPath: "spec.md" },
-      acceptance: { enabled: false, maxRetries: 0, generateTests: false, testPath: "acceptance.test.ts" },
-      context: {
-        testCoverage: { enabled: false, detail: "names-only", maxTokens: 50, testPattern: "**/*.test.ts", scopeToStory: false },
-        autoDetect: { enabled: false, maxFiles: 1, traceImports: false },
-      },
-    };
-
-    const result = NaxConfigSchema.safeParse(minimal);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.execution.smartTestRunner).toEqual({
-        enabled: true,
-        testFilePatterns: ["test/**/*.test.ts"],
-        fallback: "import-grep",
-      });
-    }
-  });
-
-  test("Zod schema coerces smartTestRunner: false to disabled config object", () => {
-    const result = NaxConfigSchema.safeParse({
-      ...buildMinimalConfig(),
-      execution: { ...buildMinimalConfig().execution, smartTestRunner: false },
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.execution.smartTestRunner).toEqual({
-        enabled: false,
-        testFilePatterns: ["test/**/*.test.ts"],
-        fallback: "import-grep",
-      });
-    }
-  });
-
-  test("Zod schema coerces smartTestRunner: true to enabled config object", () => {
-    const result = NaxConfigSchema.safeParse({
-      ...buildMinimalConfig(),
-      execution: { ...buildMinimalConfig().execution, smartTestRunner: true },
-    });
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.execution.smartTestRunner).toEqual({
-        enabled: true,
-        testFilePatterns: ["test/**/*.test.ts"],
-        fallback: "import-grep",
-      });
-    }
-  });
-
-  test("loadConfig defaults smartTestRunner to enabled object when not in project config", async () => {
-    const configPath = join(tempDir, "nax", "config.json");
-    writeFileSync(configPath, JSON.stringify({ routing: { strategy: "keyword" } }, null, 2));
-
-    const config = await loadConfig(join(tempDir, "nax"));
-    expect(config.execution.smartTestRunner).toEqual({
-      enabled: true,
-      testFilePatterns: ["test/**/*.test.ts"],
-      fallback: "import-grep",
-    });
-  });
-
-  test("loadConfig coerces smartTestRunner: false to disabled config object", async () => {
-    const configPath = join(tempDir, "nax", "config.json");
-    writeFileSync(
-      configPath,
-      JSON.stringify({ execution: { smartTestRunner: false } }, null, 2),
-    );
-
-    const config = await loadConfig(join(tempDir, "nax"));
-    expect(config.execution.smartTestRunner).toEqual({
-      enabled: false,
-      testFilePatterns: ["test/**/*.test.ts"],
-      fallback: "import-grep",
-    });
-  });
-
-  test("loadConfig normalizes to enabled object when field is absent (backward compat)", async () => {
-    const configPath = join(tempDir, "nax", "config.json");
-    // Config without smartTestRunner field at all
-    writeFileSync(configPath, JSON.stringify({}, null, 2));
-
-    const config = await loadConfig(join(tempDir, "nax"));
-    expect(config.execution.smartTestRunner).toEqual({
-      enabled: true,
-      testFilePatterns: ["test/**/*.test.ts"],
-      fallback: "import-grep",
-    });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Minimal valid config helper
-// ---------------------------------------------------------------------------
-
-function buildMinimalConfig() {
-  return {
-    version: 1,
-    models: {
-      fast: { provider: "anthropic", model: "haiku" },
-      balanced: { provider: "anthropic", model: "sonnet" },
-      powerful: { provider: "anthropic", model: "opus" },
-    },
-    autoMode: {
-      enabled: true,
-      defaultAgent: "claude",
-      fallbackOrder: [],
-      complexityRouting: { simple: "fast", medium: "balanced", complex: "powerful", expert: "powerful" },
-      escalation: { enabled: true, tierOrder: [{ tier: "fast", attempts: 1 }] },
-    },
-    routing: { strategy: "keyword" as const },
-    execution: {
-      maxIterations: 10,
-      iterationDelayMs: 0,
-      costLimit: 1,
-      sessionTimeoutSeconds: 60,
-      maxStoriesPerFeature: 10,
-      rectification: {
-        enabled: true,
-        maxRetries: 1,
-        fullSuiteTimeoutSeconds: 30,
-        maxFailureSummaryChars: 500,
-        abortOnIncreasingFailures: true,
-      },
-      regressionGate: { enabled: true, timeoutSeconds: 30 },
-      contextProviderTokenBudget: 100,
-    },
-    quality: {
-      requireTypecheck: true,
-      requireLint: true,
-      requireTests: true,
-      commands: {},
-      forceExit: false,
-      detectOpenHandles: true,
-      detectOpenHandlesRetries: 1,
-      gracePeriodMs: 500,
-      drainTimeoutMs: 0,
-      shell: "/bin/sh",
-      stripEnvVars: [],
-      environmentalEscalationDivisor: 2,
-    },
-    tdd: { maxRetries: 0, autoVerifyIsolation: false, autoApproveVerifier: false },
-    constitution: { enabled: false, path: "constitution.md", maxTokens: 100 },
-    analyze: { llmEnhanced: false, model: "balanced", fallbackToKeywords: true, maxCodebaseSummaryTokens: 100 },
-    review: { enabled: false, checks: [] as Array<"typecheck" | "lint" | "test">, commands: {} },
-    plan: { model: "balanced", outputPath: "spec.md" },
-    acceptance: { enabled: false, maxRetries: 0, generateTests: false, testPath: "acceptance.test.ts" },
-    context: {
-      testCoverage: { enabled: false, detail: "names-only" as const, maxTokens: 50, testPattern: "**/*.test.ts", scopeToStory: false },
-      autoDetect: { enabled: false, maxFiles: 1, traceImports: false },
-    },
-  };
-}

package/test/unit/constitution-generators.test.ts

@@ -1,161 +0,0 @@
-// RE-ARCH: keep
-/**
- * Constitution Generators Tests
- *
- * Tests for generating agent-specific config files from constitution.
- */
-
-import { describe, expect, test } from "bun:test";
-import { aiderGenerator } from "../../src/constitution/generators/aider";
-import { claudeGenerator } from "../../src/constitution/generators/claude";
-import { cursorGenerator } from "../../src/constitution/generators/cursor";
-import { opencodeGenerator } from "../../src/constitution/generators/opencode";
-import type { ConstitutionContent } from "../../src/constitution/generators/types";
-import { windsurfGenerator } from "../../src/constitution/generators/windsurf";
-
-const sampleConstitution: ConstitutionContent = {
-	markdown: `# Project Constitution
-
-## Coding Standards
-- Follow TypeScript best practices
-- Use strict typing
-
-## Testing Requirements
-- 80% minimum coverage
-- Write tests first (TDD)
-
-## Architecture Rules
-- Single responsibility principle
-- Dependency injection
-`,
-	sections: {},
-};
-
-describe("Constitution Generators", () => {
-	describe("Claude Generator", () => {
-		test("should generate CLAUDE.md with correct format", () => {
-			const result = claudeGenerator.generate(sampleConstitution);
-
-			expect(result).toContain("# Project Constitution");
-			expect(result).toContain("auto-generated from `nax/constitution.md`");
-			expect(result).toContain("DO NOT EDIT MANUALLY");
-			expect(result).toContain("## Coding Standards");
-			expect(result).toContain("Follow TypeScript best practices");
-		});
-
-		test("should have correct output filename", () => {
-			expect(claudeGenerator.outputFile).toBe("CLAUDE.md");
-		});
-
-		test("should have correct generator name", () => {
-			expect(claudeGenerator.name).toBe("claude");
-		});
-	});
-
-	describe("OpenCode Generator", () => {
-		test("should generate AGENTS.md with correct format", () => {
-			const result = opencodeGenerator.generate(sampleConstitution);
-
-			expect(result).toContain("# Agent Instructions");
-			expect(result).toContain("auto-generated from `nax/constitution.md`");
-			expect(result).toContain("DO NOT EDIT MANUALLY");
-			expect(result).toContain("## Coding Standards");
-		});
-
-		test("should have correct output filename", () => {
-			expect(opencodeGenerator.outputFile).toBe("AGENTS.md");
-		});
-
-		test("should have correct generator name", () => {
-			expect(opencodeGenerator.name).toBe("opencode");
-		});
-	});
-
-	describe("Cursor Generator", () => {
-		test("should generate .cursorrules with correct format", () => {
-			const result = cursorGenerator.generate(sampleConstitution);
-
-			expect(result).toContain("# Project Rules");
-			expect(result).toContain("Auto-generated from nax/constitution.md");
-			expect(result).toContain("DO NOT EDIT MANUALLY");
-			expect(result).toContain("## Coding Standards");
-		});
-
-		test("should have correct output filename", () => {
-			expect(cursorGenerator.outputFile).toBe(".cursorrules");
-		});
-
-		test("should have correct generator name", () => {
-			expect(cursorGenerator.name).toBe("cursor");
-		});
-	});
-
-	describe("Windsurf Generator", () => {
-		test("should generate .windsurfrules with correct format", () => {
-			const result = windsurfGenerator.generate(sampleConstitution);
-
-			expect(result).toContain("# Windsurf Project Rules");
-			expect(result).toContain("Auto-generated from nax/constitution.md");
-			expect(result).toContain("DO NOT EDIT MANUALLY");
-			expect(result).toContain("## Coding Standards");
-		});
-
-		test("should have correct output filename", () => {
-			expect(windsurfGenerator.outputFile).toBe(".windsurfrules");
-		});
-
-		test("should have correct generator name", () => {
-			expect(windsurfGenerator.name).toBe("windsurf");
-		});
-	});
-
-	describe("Aider Generator", () => {
-		test("should generate .aider.conf.yml with correct YAML format", () => {
-			const result = aiderGenerator.generate(sampleConstitution);
-
-			expect(result).toContain("# Aider Configuration");
-			expect(result).toContain("# Auto-generated from nax/constitution.md");
-			expect(result).toContain("# DO NOT EDIT MANUALLY");
-			expect(result).toContain("instructions: |");
-			// Check YAML indentation
-			expect(result).toContain("  # Project Constitution");
-			expect(result).toContain("  ## Coding Standards");
-		});
-
-		test("should have correct output filename", () => {
-			expect(aiderGenerator.outputFile).toBe(".aider.conf.yml");
-		});
-
-		test("should have correct generator name", () => {
-			expect(aiderGenerator.name).toBe("aider");
-		});
-	});
-
-	describe("All Generators", () => {
-		test("should preserve original constitution content", () => {
-			const generators = [claudeGenerator, opencodeGenerator, cursorGenerator, windsurfGenerator, aiderGenerator];
-
-			for (const generator of generators) {
-				const result = generator.generate(sampleConstitution);
-				expect(result).toContain("Follow TypeScript best practices");
-				expect(result).toContain("80% minimum coverage");
-				expect(result).toContain("Single responsibility principle");
-			}
-		});
-
-		test("should handle empty constitution", () => {
-			const emptyConstitution: ConstitutionContent = {
-				markdown: "",
-				sections: {},
-			};
-
-			const generators = [claudeGenerator, opencodeGenerator, cursorGenerator, windsurfGenerator, aiderGenerator];
-
-			for (const generator of generators) {
-				const result = generator.generate(emptyConstitution);
-				// Should still have header
-				expect(result.length).toBeGreaterThan(0);
-			}
-		});
-	});
-});