Initial commit

test/basic.test.ts

@@ -0,0 +1,145 @@
+import { describe, test, expect } from "bun:test";
+import {
+  validate,
+  parse,
+  generateValidationReport,
+  getSupportedVersions,
+  createVarsity,
+  type ValidationResult,
+} from "../src/varsity.js";
+import { resolve } from "path";
+
+describe("Varsity Library", () => {
+  const sampleSpecPath = resolve(__dirname, "sample-openapi.json");
+
+  test("should parse a valid OpenAPI specification", async () => {
+    const parsed = await parse(sampleSpecPath);
+
+    expect(parsed).toBeDefined();
+    expect(parsed.version).toBe("3.0.3");
+    expect(parsed.spec.info.title).toBe("Sample API");
+  });
+
+  test("should validate a valid OpenAPI specification", async () => {
+    const result = (await validate(sampleSpecPath)) as ValidationResult;
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+    expect(result.version).toBe("3.0.3");
+  });
+
+  test("should generate a JSON report", async () => {
+    const report = await generateValidationReport(sampleSpecPath, {
+      format: "json",
+      includeWarnings: true,
+      includeMetadata: true,
+    });
+
+    const parsedReport = JSON.parse(report);
+    expect(parsedReport.summary.valid).toBe(true);
+    expect(parsedReport.summary.version).toBe("3.0.3");
+  });
+
+  test("should generate a markdown report", async () => {
+    const report = await generateValidationReport(sampleSpecPath, {
+      format: "markdown",
+      includeWarnings: true,
+      includeMetadata: true,
+    });
+
+    expect(report).toContain("# OpenAPI Validation Report");
+    expect(report).toContain("✅ Valid");
+    expect(report).toContain("Sample API");
+  });
+
+  test("should get supported versions", () => {
+    const versions = getSupportedVersions();
+
+    expect(versions).toContain("2.0");
+    expect(versions).toContain("3.0.3");
+    expect(versions).toContain("3.1.0");
+  });
+
+  test("should handle invalid specification", async () => {
+    const invalidSpec = {
+      openapi: "3.0.3",
+      // Missing required 'info' and 'paths' fields
+    };
+
+    // Create a temporary file with invalid spec
+    const fs = await import("fs");
+    const tempPath = resolve(__dirname, "invalid-spec.json");
+    fs.writeFileSync(tempPath, JSON.stringify(invalidSpec));
+
+    try {
+      const result = (await validate(tempPath)) as ValidationResult;
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+    } finally {
+      // Clean up
+      fs.unlinkSync(tempPath);
+    }
+  });
+
+  test("should work with createVarsity factory", async () => {
+    const varsity = createVarsity();
+
+    const result = (await varsity.validate(sampleSpecPath)) as ValidationResult;
+    expect(result.valid).toBe(true);
+
+    const versions = varsity.getSupportedVersions();
+    expect(versions).toContain("3.0.3");
+  });
+
+  test("should work with createVarsity factory for multiple specs", async () => {
+    const varsity = createVarsity();
+
+    const results = (await varsity.validate([
+      sampleSpecPath,
+      sampleSpecPath,
+    ])) as ValidationResult[];
+    expect(Array.isArray(results)).toBe(true);
+    expect(results).toHaveLength(2);
+    expect(results[0]?.valid).toBe(true);
+    expect(results[1]?.valid).toBe(true);
+  });
+
+  test("should validate multiple specifications", async () => {
+    const results = (await validate([
+      sampleSpecPath,
+      sampleSpecPath,
+    ])) as ValidationResult[];
+
+    expect(Array.isArray(results)).toBe(true);
+    expect(results).toHaveLength(2);
+    expect(results[0]?.valid).toBe(true);
+    expect(results[1]?.valid).toBe(true);
+  });
+
+  test("should handle mixed valid and invalid specifications", async () => {
+    const invalidSpec = {
+      openapi: "3.0.3",
+      // Missing required 'info' and 'paths' fields
+    };
+
+    // Create a temporary file with invalid spec
+    const fs = await import("fs");
+    const tempPath = resolve(__dirname, "invalid-spec-mixed.json");
+    fs.writeFileSync(tempPath, JSON.stringify(invalidSpec));
+
+    try {
+      const results = (await validate([
+        sampleSpecPath,
+        tempPath,
+      ])) as ValidationResult[];
+
+      expect(Array.isArray(results)).toBe(true);
+      expect(results).toHaveLength(2);
+      expect(results[0]?.valid).toBe(true); // Valid spec
+      expect(results[1]?.valid).toBe(false); // Invalid spec
+    } finally {
+      // Clean up
+      fs.unlinkSync(tempPath);
+    }
+  });
+});