@unispechq/unispec-core 0.3.2 → 0.3.4

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

@@ -1,336 +0,0 @@
-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

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