@unispechq/unispec-core 0.3.0 → 0.3.2

package/dist/tests/loader/loader.test.js

@@ -0,0 +1,336 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import { describe, it } from "node:test";
+import { getExamplePath } from "../../tests/utils.js";
+import { getYamlModule, loadUniSpec, validateDocumentSecurity, validateYamlModule, } from "../../src/loader/index.js";
+describe("loader", () => {
+    describe("loadUniSpec", () => {
+        it("should load valid JSON UniSpec document", async () => {
+            const validSpecPath = getExamplePath("valid", "spec", "rest-simple.json");
+            const jsonContent = fs.readFileSync(validSpecPath, "utf-8");
+            const result = await loadUniSpec(jsonContent);
+            assert.strictEqual(result.unispecVersion, "1.0.0");
+            assert.strictEqual(result.service.name, "user-service");
+            assert.strictEqual(result.service.protocols?.rest?.routes?.length, 2);
+        });
+        it("should load valid UniSpec document as object", async () => {
+            const validSpec = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service",
+                    description: "Test service",
+                    protocols: {
+                        rest: {
+                            routes: [
+                                {
+                                    name: "testRoute",
+                                    path: "/test",
+                                    method: "GET",
+                                    responses: {
+                                        "200": { description: "OK" },
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            };
+            const result = await loadUniSpec(validSpec);
+            assert.strictEqual(result.service.name, "test-service");
+            assert.strictEqual(result.unispecVersion, "1.0.0");
+        });
+        it("should load valid YAML UniSpec document", async () => {
+            const yamlContent = `
+unispecVersion: "1.0.0"
+service:
+  name: "yaml-service"
+  description: "YAML based service"
+  protocols:
+    rest:
+      routes:
+        - name: "getUsers"
+          path: "/users"
+          method: "GET"
+          responses:
+            "200":
+              description: "Success"
+`;
+            const result = await loadUniSpec(yamlContent);
+            assert.strictEqual(result.service.name, "yaml-service");
+            assert.strictEqual(result.unispecVersion, "1.0.0");
+        });
+        it("should reject empty string input", async () => {
+            try {
+                await loadUniSpec("   ");
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("empty"));
+            }
+        });
+        it("should reject invalid JSON and YAML", async () => {
+            const invalidContent = "{ invalid json syntax: [unclosed array";
+            try {
+                await loadUniSpec(invalidContent);
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("Failed to parse"));
+            }
+        });
+        it("should enforce document size limit", async () => {
+            const largeContent = "x".repeat(11 * 1024 * 1024); // 11MB
+            try {
+                await loadUniSpec(largeContent, { maxDocumentSize: 10 * 1024 * 1024 });
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("Document size"));
+            }
+        });
+        it("should load valid examples from schema package", async () => {
+            const validExamples = [
+                "valid/spec/rest-simple.json",
+                "valid/spec/graphql-simple.json",
+                "valid/spec/websocket-simple.json",
+                "valid/spec/mixed-complete.json",
+            ];
+            for (const example of validExamples) {
+                const examplePath = getExamplePath(...example.split("/"));
+                const content = fs.readFileSync(examplePath, "utf-8");
+                const result = await loadUniSpec(content);
+                assert.ok(result.unispecVersion);
+                assert.ok(result.service.name);
+                assert.ok(result.service.protocols);
+            }
+        });
+        it("should handle invalid examples appropriately", async () => {
+            const invalidExamples = [
+                "invalid/spec/missing-service-name.json",
+                "invalid/spec/missing-unispec-version.json",
+                "invalid/spec/invalid-identifier.json",
+            ];
+            for (const example of invalidExamples) {
+                const examplePath = getExamplePath(...example.split("/"));
+                const content = fs.readFileSync(examplePath, "utf-8");
+                // Note: loader only handles parsing, not validation
+                // Invalid schema examples should still parse as JSON/YAML
+                const result = await loadUniSpec(content);
+                // Should parse successfully but validation errors would be caught elsewhere
+                assert.ok(typeof result === "object");
+            }
+        });
+    });
+    describe("validateDocumentSecurity", () => {
+        const defaultOptions = {
+            maxDepth: 100,
+            maxKeys: 10000,
+            allowedTags: ["str", "int", "float", "bool", "null", "seq", "map"],
+            maxDocumentSize: 10 * 1024 * 1024,
+            strictYamlTags: false,
+        };
+        it("should pass validation for normal documents", () => {
+            const doc = {
+                level1: {
+                    level2: {
+                        level3: "value",
+                    },
+                },
+            };
+            validateDocumentSecurity(doc, defaultOptions);
+            // Should not throw
+        });
+        it("should reject documents exceeding max depth", () => {
+            const doc = {};
+            let current = doc;
+            // Create nested structure exceeding max depth
+            for (let i = 0; i < 105; i++) {
+                current.next = {};
+                current = current.next;
+            }
+            try {
+                validateDocumentSecurity(doc, { ...defaultOptions, maxDepth: 100 });
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("depth"));
+            }
+        });
+        it("should reject documents exceeding max keys", () => {
+            const doc = {};
+            // Create object with many keys
+            for (let i = 0; i < 105; i++) {
+                doc[`key${i}`] = `value${i}`;
+            }
+            try {
+                validateDocumentSecurity(doc, { ...defaultOptions, maxKeys: 100 });
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("key count"));
+            }
+        });
+        it("should handle arrays correctly", () => {
+            const doc = {
+                array: [{ item: 1 }, { item: 2 }, { nested: { deep: "value" } }],
+            };
+            validateDocumentSecurity(doc, defaultOptions);
+            // Should not throw
+        });
+        it("should handle mixed structures", () => {
+            const doc = {
+                strings: ["a", "b", "c"],
+                objects: {
+                    nested: {
+                        array: [1, 2, 3],
+                    },
+                },
+                number: 42,
+                boolean: true,
+                null: null,
+            };
+            validateDocumentSecurity(doc, defaultOptions);
+            // Should not throw
+        });
+    });
+    describe("getYamlModule", () => {
+        it("should load and validate YAML module", async () => {
+            const yamlModule = await getYamlModule();
+            assert.ok(yamlModule);
+            assert.strictEqual(typeof yamlModule.load, "function");
+            assert.ok(yamlModule.FAILSAFE_SCHEMA);
+        });
+        it("should cache YAML module", async () => {
+            const module1 = await getYamlModule();
+            const module2 = await getYamlModule();
+            assert.strictEqual(module1, module2);
+        });
+    });
+    describe("validateYamlModule", () => {
+        it("should validate correct YAML module", () => {
+            const mockYamlModule = {
+                load: () => { },
+                FAILSAFE_SCHEMA: {},
+                other: "property",
+            };
+            // Should not throw
+            validateYamlModule(mockYamlModule);
+        });
+        it("should reject non-object modules", () => {
+            try {
+                validateYamlModule("not an object");
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("must be an object"));
+            }
+        });
+        it("should reject modules without load function", () => {
+            const invalidModule = {
+                FAILSAFE_SCHEMA: {},
+            };
+            try {
+                validateYamlModule(invalidModule);
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("missing load function"));
+            }
+        });
+        it("should reject modules without FAILSAFE_SCHEMA", () => {
+            const invalidModule = {
+                load: () => { },
+            };
+            try {
+                validateYamlModule(invalidModule);
+                assert.fail("Should have thrown an error");
+            }
+            catch (error) {
+                assert.ok(error instanceof Error);
+                assert.ok(error.message.includes("FAILSAFE_SCHEMA"));
+            }
+        });
+    });
+    describe("security constraints", () => {
+        it("should respect custom security options", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test",
+                    protocols: {},
+                },
+            };
+            // Should work with relaxed constraints
+            await loadUniSpec(doc, {
+                maxDepth: 1000,
+                maxKeys: 100000,
+                maxDocumentSize: 100 * 1024 * 1024,
+            });
+        });
+        it("should handle circular references gracefully", async () => {
+            const doc = { name: "test" };
+            doc.self = doc;
+            try {
+                await loadUniSpec(doc);
+                // Circular references in JavaScript objects are handled by the security validation
+                // which uses iteration instead of recursion
+            }
+            catch (error) {
+                // Should not cause stack overflow
+                assert.ok(error instanceof Error);
+                assert.ok(!error.message.includes("stack"));
+            }
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle null and undefined values", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test",
+                    description: null,
+                    tags: undefined,
+                    protocols: {},
+                },
+            };
+            const result = await loadUniSpec(doc);
+            assert.strictEqual(result.service.name, "test");
+            assert.strictEqual(result.service.description, null);
+        });
+        it("should handle empty objects and arrays", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test",
+                    protocols: {
+                        rest: {
+                            routes: [],
+                            schemas: {},
+                        },
+                    },
+                },
+            };
+            const result = await loadUniSpec(doc);
+            assert.strictEqual(result.service.protocols?.rest?.routes?.length, 0);
+        });
+        it("should handle special characters in strings", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test-service-特殊字符-🚀",
+                    description: 'Description with "quotes" and \n newlines',
+                    protocols: {},
+                },
+            };
+            const result = await loadUniSpec(doc);
+            assert.strictEqual(result.service.name, "test-service-特殊字符-🚀");
+        });
+    });
+});

package/dist/tests/normalizer/normalizer-comprehensive.test.d.ts

@@ -0,0 +1 @@
+export {};