test(schemas): expand valibot integrity coverage

Author: tuanductran

packages/nextdns-scripts/src/__tests__/audit.test.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { describe, expect, it } from 'vitest';
 
 import { formatAuditText, runAudit } from '../commands/audit.js';
+import { parseAuditReport } from '../core/schemas.js';
 import { getPackageVersion } from '../core/version.js';
 
 function createFixture(rule: string, skill = '[Example](rules/example.md)') {
@@ -52,6 +53,13 @@ describe('runAudit', () => {
     expect(report.statistics.totalRules).toBe(report.ruleCount);
   });
 
+  it('round-trips the repository report through the Valibot schema', () => {
+    const report = runAudit();
+    const parsed = parseAuditReport(JSON.parse(JSON.stringify(report)));
+
+    expect(parsed).toEqual(report);
+  });
+
   it('formats a concise human-readable summary', () => {
     const report = runAudit();
     const output = formatAuditText(report);

packages/nextdns-scripts/src/__tests__/public-api.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  AuditCheckSchema,
+  AuditReportSchema,
+  parseAuditReport,
+  parseStatsReport,
+  SkillStatsSchema,
+  StatsReportSchema,
+} from '../index.js';
+
+describe('maintenance package public schema API', () => {
+  it('exports all Valibot schema objects from the package root', () => {
+    expect(AuditCheckSchema).toBeDefined();
+    expect(AuditReportSchema).toBeDefined();
+    expect(SkillStatsSchema).toBeDefined();
+    expect(StatsReportSchema).toBeDefined();
+  });
+
+  it('exports callable report parsers from the package root', () => {
+    expect(typeof parseAuditReport).toBe('function');
+    expect(typeof parseStatsReport).toBe('function');
+  });
+});

packages/nextdns-scripts/src/__tests__/schemas.test.ts

@@ -29,55 +29,82 @@ const validChecks = [
   { name: 'duplicate-tags', passed: true, errors: 0, warnings: 0 },
 ];
 
+function validAuditReport(overrides: Record<string, unknown> = {}) {
+  return {
+    generatedAt: '2026-08-18T00:00:00.000Z',
+    passed: true,
+    ruleCount: 1,
+    checks: validChecks,
+    statistics: validStatistics,
+    ...overrides,
+  };
+}
+
 describe('schema parsing', () => {
   it('accepts a complete audit report', () => {
-    const report = parseAuditReport({
-      generatedAt: '2026-08-18T00:00:00.000Z',
-      passed: true,
-      ruleCount: 1,
-      checks: validChecks,
-      statistics: validStatistics,
-    });
+    const report = parseAuditReport(validAuditReport());
 
     expect(report.statistics.totalRules).toBe(1);
     expect(report.checks).toHaveLength(5);
   });
 
+  it.each([validChecks.slice(0, 4), [...validChecks, ...validChecks.slice(0, 1)]])(
+    'rejects an audit report with %s checks',
+    (checks) => {
+      expect(() => parseAuditReport(validAuditReport({ checks }))).toThrow();
+    }
+  );
+
   it('rejects an unknown audit check name', () => {
     expect(() =>
-      parseAuditReport({
-        generatedAt: '2026-08-18T00:00:00.000Z',
-        passed: false,
-        ruleCount: 1,
-        checks: [
-          ...validChecks.slice(0, 4),
-          { name: 'unknown-check', passed: false, errors: 1, warnings: 0 },
-        ],
-        statistics: validStatistics,
-      })
+      parseAuditReport(
+        validAuditReport({
+          passed: false,
+          checks: [
+            ...validChecks.slice(0, 4),
+            { name: 'unknown-check', passed: false, errors: 1, warnings: 0 },
+          ],
+        })
+      )
     ).toThrow();
   });
 
   it('rejects missing nested statistics', () => {
+    const { statistics, ...reportWithoutStatistics } = validAuditReport();
+
+    expect(statistics).toBeDefined();
+    expect(() => parseAuditReport(reportWithoutStatistics)).toThrow();
+  });
+
+  it('rejects wrong primitive types', () => {
+    expect(() => parseAuditReport(validAuditReport({ passed: 'true' }))).toThrow();
+    expect(() => parseAuditReport(validAuditReport({ ruleCount: '1' }))).toThrow();
+  });
+
+  it('rejects non-integer or negative counters', () => {
+    expect(() => parseStatsReport({ ...validStatistics, totalRules: 1.5 })).toThrow();
     expect(() =>
-      parseAuditReport({
-        generatedAt: '2026-08-18T00:00:00.000Z',
-        passed: true,
-        ruleCount: 1,
-        checks: validChecks,
+      parseStatsReport({
+        ...validStatistics,
+        impactDistribution: { HIGH: -1, MEDIUM: 0, LOW: 0 },
       })
     ).toThrow();
   });
 
-  it('rejects negative counters', () => {
+  it('rejects incomplete nested skill statistics', () => {
     expect(() =>
       parseStatsReport({
         ...validStatistics,
-        totalRules: -1,
+        skills: [{ name: 'nextdns-api', total: 1 }],
       })
     ).toThrow();
   });
 
+  it('rejects unknown input', () => {
+    expect(() => parseAuditReport(null)).toThrow();
+    expect(() => parseStatsReport('not-a-report')).toThrow();
+  });
+
   it('returns type-safe stats data for a valid report', () => {
     const report = parseStatsReport(validStatistics);