@dommaker/harness 0.13.0 → 0.13.2

package/src/cli/commands/__tests__/passes-gate.test.ts

@@ -0,0 +1,256 @@
+/**
+ * passes-gate 命令测试
+ */
+
+import { runPassesGate, checkCoverage } from '../passes-gate';
+import * as fs from 'fs/promises';
+import { PassesGate } from '../../../core/validators/passes-gate';
+import { execAsync } from '../../../utils/exec';
+
+// Mock fs/promises
+jest.mock('fs/promises', () => ({
+  readFile: jest.fn(),
+  access: jest.fn(),
+}));
+
+// Mock execAsync
+jest.mock('../../../utils/exec', () => ({
+  execAsync: jest.fn(),
+}));
+
+// Mock PassesGate
+jest.mock('../../../core/validators/passes-gate', () => ({
+  PassesGate: jest.fn(),
+}));
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  blue: jest.fn((str: string) => str),
+  yellow: jest.fn((str: string) => str),
+  green: jest.fn((str: string) => str),
+  gray: jest.fn((str: string) => str),
+  red: jest.fn((str: string) => str),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+const MockPassesGate = PassesGate as jest.MockedClass<typeof PassesGate>;
+const mockExecAsync = execAsync as jest.MockedFunction<typeof execAsync>;
+
+describe('passes-gate command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    process.exitCode = 0;
+  });
+
+  describe('runPassesGate', () => {
+    it('应该跳过无测试命令的情况', async () => {
+      mockFs.readFile.mockRejectedValue(new Error('no package.json'));
+      mockFs.access.mockRejectedValue(new Error('no file'));
+
+      await runPassesGate({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未检测到测试命令'));
+    });
+
+    it('应该通过测试门控', async () => {
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        scripts: { test: 'jest' },
+      }));
+
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: true,
+        passedTests: 10,
+        failedTests: 0,
+        totalTests: 10,
+        duration: 1000,
+        failures: [],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({
+        runTests: mockRunTests,
+      }));
+
+      await runPassesGate({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('测试门控通过'));
+    });
+
+    it('应该失败测试门控', async () => {
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        scripts: { test: 'jest' },
+      }));
+
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: false,
+        passedTests: 8,
+        failedTests: 2,
+        totalTests: 10,
+        duration: 1000,
+        failures: [{ name: 'test1', message: 'failed' }],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({
+        runTests: mockRunTests,
+      }));
+
+      // Mock process.exit
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+
+      await runPassesGate({});
+      expect(mockExit).toHaveBeenCalledWith(1);
+      mockExit.mockRestore();
+    });
+
+    it('应该处理测试执行错误', async () => {
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        scripts: { test: 'jest' },
+      }));
+
+      const mockRunTests = jest.fn().mockRejectedValue(new Error('test failed'));
+      (MockPassesGate as any).mockImplementation(() => ({
+        runTests: mockRunTests,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+
+      await runPassesGate({});
+      expect(mockExit).toHaveBeenCalledWith(1);
+      mockExit.mockRestore();
+    });
+
+    it('应该使用自定义测试命令', async () => {
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: true,
+        passedTests: 5,
+        failedTests: 0,
+        totalTests: 5,
+        duration: 500,
+        failures: [],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({
+        runTests: mockRunTests,
+      }));
+
+      await runPassesGate({ testCommand: 'pytest' });
+      expect(MockPassesGate).toHaveBeenCalledWith(
+        expect.objectContaining({ testCommand: 'pytest' })
+      );
+    });
+  });
+
+  describe('checkCoverage', () => {
+    it('应该返回 true 当覆盖率达标', async () => {
+      mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        total: { lines: { pct: 85 } },
+      }));
+
+      const result = await checkCoverage('/project', 80);
+      expect(result).toBe(true);
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('覆盖率达标'));
+    });
+
+    it('应该返回 false 当覆盖率不足', async () => {
+      mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        total: { lines: { pct: 60 } },
+      }));
+
+      const result = await checkCoverage('/project', 80);
+      expect(result).toBe(false);
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('覆盖率不足'));
+    });
+
+    it('应该返回 true 当执行出错时', async () => {
+      mockExecAsync.mockRejectedValue(new Error('command failed'));
+
+      const result = await checkCoverage('/project');
+      expect(result).toBe(true);
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('无法获取覆盖率信息'));
+    });
+
+    it('应该使用默认阈值 80', async () => {
+      mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        total: { lines: { pct: 80 } },
+      }));
+
+      const result = await checkCoverage('/project');
+      expect(result).toBe(true);
+    });
+
+    it('应该处理 coverage.total 为 undefined', async () => {
+      mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
+      mockFs.readFile.mockResolvedValue(JSON.stringify({}));
+
+      const result = await checkCoverage('/project', 80);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('detectTestCommand', () => {
+    it('应该检测 pytest 项目', async () => {
+      // package.json 不存在
+      mockFs.readFile.mockRejectedValue(new Error('no file'));
+      // pytest.ini 存在
+      mockFs.access
+        .mockResolvedValueOnce(undefined) // pytest.ini
+        .mockRejectedValueOnce(new Error('no file')); // go.mod
+
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: true, passedTests: 5, failedTests: 0, totalTests: 5, duration: 500, failures: [],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
+
+      await runPassesGate({});
+      expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'pytest' }));
+    });
+
+    it('应该检测 Go 项目', async () => {
+      mockFs.readFile.mockRejectedValue(new Error('no file'));
+      // Reset access mock to avoid leaking from previous tests
+      mockFs.access.mockReset();
+      mockFs.access
+        .mockRejectedValueOnce(new Error('no file')) // pytest.ini
+        .mockResolvedValueOnce(undefined); // go.mod
+
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: true, passedTests: 5, failedTests: 0, totalTests: 5, duration: 500, failures: [],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
+
+      await runPassesGate({});
+      expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'go test ./...' }));
+    });
+
+    it('应该检测 test:ci 脚本', async () => {
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        scripts: { 'test:ci': 'jest --ci' },
+      }));
+
+      const mockRunTests = jest.fn().mockResolvedValue({
+        passed: true, passedTests: 5, failedTests: 0, totalTests: 5, duration: 500, failures: [],
+      });
+      (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
+
+      await runPassesGate({});
+      expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'npm run test:ci' }));
+    });
+
+    it('应该跳过默认 echo 测试脚本', async () => {
+      mockFs.readFile.mockReset();
+      mockFs.readFile.mockResolvedValue(JSON.stringify({
+        scripts: { test: 'echo "Error: no test specified"' },
+      }));
+      mockFs.access.mockReset();
+      mockFs.access.mockRejectedValue(new Error('no file'));
+
+      await runPassesGate({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未检测到测试命令'));
+    });
+  });
+});

package/src/cli/commands/__tests__/performance.test.ts

@@ -0,0 +1,116 @@
+/**
+ * performance 命令测试
+ */
+
+import { performance } from '../performance';
+import { PerformanceGate } from '../../../gates/performance';
+
+jest.mock('../../../gates/performance', () => ({
+  PerformanceGate: jest.fn().mockImplementation(() => ({
+    check: jest.fn(),
+  })),
+}));
+
+jest.mock('chalk', () => ({
+  blue: jest.fn((s: string) => s),
+  green: jest.fn((s: string) => s),
+  red: jest.fn((s: string) => s),
+  gray: jest.fn((s: string) => s),
+}));
+
+const MockGate = PerformanceGate as jest.MockedClass<typeof PerformanceGate>;
+
+describe('performance command', () => {
+  let consoleSpy: jest.SpyInstance;
+  let exitSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+    process.exitCode = 0;
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    exitSpy.mockRestore();
+    process.exitCode = 0;
+  });
+
+  it('should print success when check passes', async () => {
+    const mockCheck = jest.fn().mockResolvedValue({
+      passed: true,
+      message: 'ok',
+      details: {
+        metrics: { coverage: 85.5, bundleSize: 204800, benchmarkTime: 150 },
+      },
+    });
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('性能门控检查通过'));
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it('should print failure and exit 1 when check fails', async () => {
+    const mockCheck = jest.fn().mockResolvedValue({
+      passed: false,
+      message: 'threshold exceeded',
+      details: { failures: ['coverage below 80%', 'bundle too large'] },
+    });
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('性能门控检查失败'));
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should handle errors and exit 1', async () => {
+    const mockCheck = jest.fn().mockRejectedValue(new Error('gate error'));
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({});
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('性能门控检查出错'));
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('should convert bundleThreshold from KB to bytes', async () => {
+    const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({ bundleThreshold: 500 });
+
+    expect(MockGate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        thresholds: expect.objectContaining({ bundleSize: 500 * 1024 }),
+      }),
+    );
+  });
+
+  it('should convert benchmarkTimeout from seconds to ms', async () => {
+    const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({ benchmarkTimeout: 30 });
+
+    expect(MockGate).toHaveBeenCalledWith(
+      expect.objectContaining({ benchmarkTimeout: 30000 }),
+    );
+  });
+
+  it('should set coverage threshold when both flags provided', async () => {
+    const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
+    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+
+    await performance({ coverage: true, coverageThreshold: 90 });
+
+    expect(MockGate).toHaveBeenCalledWith(
+      expect.objectContaining({
+        thresholds: expect.objectContaining({ coverage: 90 }),
+      }),
+    );
+  });
+});

package/src/cli/commands/__tests__/posteval-plan.test.ts

@@ -0,0 +1,201 @@
+/**
+ * posteval-plan 命令测试
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+describe('postevalPlan', () => {
+  jest.setTimeout(30000); // Retry-based tests with exponential backoff need longer timeout
+  const tempDir = path.join(process.cwd(), 'temp-test-posteval');
+  const planPath = path.join(tempDir, 'plan.md');
+  let consoleErrorSpy: jest.SpyInstance;
+  let consoleLogSpy: jest.SpyInstance;
+  let mockExit: jest.SpyInstance;
+  let originalFetch: typeof fetch;
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeAll(() => {
+    fs.mkdirSync(tempDir, { recursive: true });
+    fs.writeFileSync(planPath, '# Test plan\n- [AC-001] Task 1\n- [AC-002] Task 2');
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    originalFetch = global.fetch;
+    originalEnv = { ...process.env };
+    delete process.env.API_PORT;
+    delete process.env.POSTEVAL_GRACE_MS;
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {
+      // Don't actually exit
+    }) as any);
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    process.env = originalEnv;
+    consoleErrorSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+    mockExit.mockRestore();
+    jest.useRealTimers();
+  });
+
+  it('应该成功验证 plan 覆盖率并打印绿色信息', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        completeness: 1,
+        matchedAcs: ['AC-001', 'AC-002'],
+        missedAcs: [],
+      }),
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('100%'));
+  });
+
+  it('completeness < 1 应该 exit(1)', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        completeness: 0.5,
+        matchedAcs: ['AC-001'],
+        missedAcs: ['AC-002'],
+      }),
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('50%'));
+  });
+
+  it('completeness < 1 时应该列出缺失项', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        completeness: 0.33,
+        matchedAcs: ['AC-001'],
+        missedAcs: ['AC-002', 'AC-003'],
+      }),
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('AC-002'));
+  });
+
+  it('4xx 错误应该 exit(1)', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      status: 400,
+      statusText: 'Bad Request',
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('400'));
+  });
+
+  it('5xx 错误应该 exit(0) 允许提交', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: false,
+      status: 503,
+      statusText: 'Service Unavailable',
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('unavailable'));
+  });
+
+  it('网络错误重试耗尽后应该 exit(0)', async () => {
+    global.fetch = jest.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('unreachable'));
+  });
+
+  it('应该支持自定义 API_PORT', async () => {
+    process.env.API_PORT = '3999';
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        completeness: 1,
+        matchedAcs: ['AC-001'],
+        missedAcs: [],
+      }),
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    // Verify the fetch was called with port 3999
+    const fetchCall = (global.fetch as jest.Mock).mock.calls[0][0];
+    expect(fetchCall).toContain(':3999');
+  });
+
+  it('网络错误重试后成功应该不退出', async () => {
+    // First 2 calls fail, 3rd succeeds
+    const mockFetch = jest.fn()
+      .mockRejectedValueOnce(new Error('ECONNREFUSED'))
+      .mockRejectedValueOnce(new Error('ECONNREFUSED'))
+      .mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({
+          completeness: 1,
+          matchedAcs: ['AC-001'],
+          missedAcs: [],
+        }),
+      });
+
+    global.fetch = mockFetch as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    // Should have been called 3 times
+    expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('100%'));
+    expect(mockExit).not.toHaveBeenCalled();
+  });
+
+  it('completeness 为 0 时应该正确显示 0%', async () => {
+    global.fetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        completeness: 0,
+        matchedAcs: [],
+        missedAcs: ['AC-001'],
+      }),
+    }) as any;
+
+    const { postevalPlan } = await import('../posteval-plan');
+    await postevalPlan({ planPath });
+
+    expect(mockExit).toHaveBeenCalledWith(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('0%'));
+  });
+});

package/src/cli/commands/__tests__/report-extra.test.ts

@@ -0,0 +1,98 @@
+/**
+ * report 命令补充测试
+ */
+
+import { report } from '../report';
+import * as fs from 'fs/promises';
+
+// Mock fs/promises
+jest.mock('fs/promises', () => ({
+  writeFile: jest.fn(),
+}));
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  blue: jest.fn((str: string) => str),
+  green: jest.fn((str: string) => str),
+  gray: jest.fn((str: string) => str),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+
+describe('report command - 补充覆盖', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  describe('format 边界情况', () => {
+    it('未知格式应该默认输出 JSON', async () => {
+      await report({ format: 'json' });
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('timestamp');
+    });
+  });
+
+  describe('Markdown 报告完整内容', () => {
+    it('Markdown 报告应该包含所有区块', async () => {
+      await report({ format: 'markdown' });
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+
+      expect(output).toContain('# Harness 检查报告');
+      expect(output).toContain('## 约束检查');
+      expect(output).toContain('Iron Laws');
+      expect(output).toContain('Guidelines');
+      expect(output).toContain('@dommaker/harness');
+    });
+  });
+
+  describe('HTML 报告完整内容', () => {
+    it('HTML 报告应该包含所有区块', async () => {
+      await report({ format: 'html' });
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+
+      expect(output).toContain('<!DOCTYPE html>');
+      expect(output).toContain('<title>Harness 检查报告</title>');
+      expect(output).toContain('约束检查');
+      expect(output).toContain('Iron Laws');
+    });
+  });
+
+  describe('文件输出', () => {
+    it('Markdown 输出到文件', async () => {
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await report({ format: 'markdown', output: 'report.md' });
+      expect(mockFs.writeFile).toHaveBeenCalledWith('report.md', expect.stringContaining('# Harness'), 'utf-8');
+    });
+
+    it('HTML 输出到文件', async () => {
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await report({ format: 'html', output: 'report.html' });
+      expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
+    });
+  });
+
+  describe('JSON 报告内容', () => {
+    it('JSON 应该包含完整数据结构', async () => {
+      await report({ format: 'json' });
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      const jsonStart = output.indexOf('{');
+      const jsonStr = output.slice(jsonStart);
+      const data = JSON.parse(jsonStr);
+      expect(data).toHaveProperty('timestamp');
+      expect(data).toHaveProperty('constraints');
+      expect(data.constraints).toHaveProperty('total');
+      expect(data.constraints).toHaveProperty('ironLaws');
+      expect(data.constraints).toHaveProperty('guidelines');
+      expect(data.constraints).toHaveProperty('violations');
+    });
+  });
+});