@unispechq/unispec-core 0.3.0 → 0.3.2

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

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_test_1 = require("node:test");
+const utils_1 = require("../../tests/utils.js");
+const loader_1 = require("../../src/loader/index.js");
+(0, node_test_1.describe)("loader", () => {
+    (0, node_test_1.describe)("loadUniSpec", () => {
+        (0, node_test_1.it)("should load valid JSON UniSpec document", async () => {
+            const validSpecPath = (0, utils_1.getExamplePath)("valid", "spec", "rest-simple.json");
+            const jsonContent = node_fs_1.default.readFileSync(validSpecPath, "utf-8");
+            const result = await (0, loader_1.loadUniSpec)(jsonContent);
+            node_assert_1.default.strictEqual(result.unispecVersion, "1.0.0");
+            node_assert_1.default.strictEqual(result.service.name, "user-service");
+            node_assert_1.default.strictEqual(result.service.protocols?.rest?.routes?.length, 2);
+        });
+        (0, node_test_1.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 (0, loader_1.loadUniSpec)(validSpec);
+            node_assert_1.default.strictEqual(result.service.name, "test-service");
+            node_assert_1.default.strictEqual(result.unispecVersion, "1.0.0");
+        });
+        (0, node_test_1.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 (0, loader_1.loadUniSpec)(yamlContent);
+            node_assert_1.default.strictEqual(result.service.name, "yaml-service");
+            node_assert_1.default.strictEqual(result.unispecVersion, "1.0.0");
+        });
+        (0, node_test_1.it)("should reject empty string input", async () => {
+            try {
+                await (0, loader_1.loadUniSpec)("   ");
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("empty"));
+            }
+        });
+        (0, node_test_1.it)("should reject invalid JSON and YAML", async () => {
+            const invalidContent = "{ invalid json syntax: [unclosed array";
+            try {
+                await (0, loader_1.loadUniSpec)(invalidContent);
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("Failed to parse"));
+            }
+        });
+        (0, node_test_1.it)("should enforce document size limit", async () => {
+            const largeContent = "x".repeat(11 * 1024 * 1024); // 11MB
+            try {
+                await (0, loader_1.loadUniSpec)(largeContent, { maxDocumentSize: 10 * 1024 * 1024 });
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("Document size"));
+            }
+        });
+        (0, node_test_1.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 = (0, utils_1.getExamplePath)(...example.split("/"));
+                const content = node_fs_1.default.readFileSync(examplePath, "utf-8");
+                const result = await (0, loader_1.loadUniSpec)(content);
+                node_assert_1.default.ok(result.unispecVersion);
+                node_assert_1.default.ok(result.service.name);
+                node_assert_1.default.ok(result.service.protocols);
+            }
+        });
+        (0, node_test_1.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 = (0, utils_1.getExamplePath)(...example.split("/"));
+                const content = node_fs_1.default.readFileSync(examplePath, "utf-8");
+                // Note: loader only handles parsing, not validation
+                // Invalid schema examples should still parse as JSON/YAML
+                const result = await (0, loader_1.loadUniSpec)(content);
+                // Should parse successfully but validation errors would be caught elsewhere
+                node_assert_1.default.ok(typeof result === "object");
+            }
+        });
+    });
+    (0, node_test_1.describe)("validateDocumentSecurity", () => {
+        const defaultOptions = {
+            maxDepth: 100,
+            maxKeys: 10000,
+            allowedTags: ["str", "int", "float", "bool", "null", "seq", "map"],
+            maxDocumentSize: 10 * 1024 * 1024,
+            strictYamlTags: false,
+        };
+        (0, node_test_1.it)("should pass validation for normal documents", () => {
+            const doc = {
+                level1: {
+                    level2: {
+                        level3: "value",
+                    },
+                },
+            };
+            (0, loader_1.validateDocumentSecurity)(doc, defaultOptions);
+            // Should not throw
+        });
+        (0, node_test_1.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 {
+                (0, loader_1.validateDocumentSecurity)(doc, { ...defaultOptions, maxDepth: 100 });
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("depth"));
+            }
+        });
+        (0, node_test_1.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 {
+                (0, loader_1.validateDocumentSecurity)(doc, { ...defaultOptions, maxKeys: 100 });
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("key count"));
+            }
+        });
+        (0, node_test_1.it)("should handle arrays correctly", () => {
+            const doc = {
+                array: [{ item: 1 }, { item: 2 }, { nested: { deep: "value" } }],
+            };
+            (0, loader_1.validateDocumentSecurity)(doc, defaultOptions);
+            // Should not throw
+        });
+        (0, node_test_1.it)("should handle mixed structures", () => {
+            const doc = {
+                strings: ["a", "b", "c"],
+                objects: {
+                    nested: {
+                        array: [1, 2, 3],
+                    },
+                },
+                number: 42,
+                boolean: true,
+                null: null,
+            };
+            (0, loader_1.validateDocumentSecurity)(doc, defaultOptions);
+            // Should not throw
+        });
+    });
+    (0, node_test_1.describe)("getYamlModule", () => {
+        (0, node_test_1.it)("should load and validate YAML module", async () => {
+            const yamlModule = await (0, loader_1.getYamlModule)();
+            node_assert_1.default.ok(yamlModule);
+            node_assert_1.default.strictEqual(typeof yamlModule.load, "function");
+            node_assert_1.default.ok(yamlModule.FAILSAFE_SCHEMA);
+        });
+        (0, node_test_1.it)("should cache YAML module", async () => {
+            const module1 = await (0, loader_1.getYamlModule)();
+            const module2 = await (0, loader_1.getYamlModule)();
+            node_assert_1.default.strictEqual(module1, module2);
+        });
+    });
+    (0, node_test_1.describe)("validateYamlModule", () => {
+        (0, node_test_1.it)("should validate correct YAML module", () => {
+            const mockYamlModule = {
+                load: () => { },
+                FAILSAFE_SCHEMA: {},
+                other: "property",
+            };
+            // Should not throw
+            (0, loader_1.validateYamlModule)(mockYamlModule);
+        });
+        (0, node_test_1.it)("should reject non-object modules", () => {
+            try {
+                (0, loader_1.validateYamlModule)("not an object");
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("must be an object"));
+            }
+        });
+        (0, node_test_1.it)("should reject modules without load function", () => {
+            const invalidModule = {
+                FAILSAFE_SCHEMA: {},
+            };
+            try {
+                (0, loader_1.validateYamlModule)(invalidModule);
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("missing load function"));
+            }
+        });
+        (0, node_test_1.it)("should reject modules without FAILSAFE_SCHEMA", () => {
+            const invalidModule = {
+                load: () => { },
+            };
+            try {
+                (0, loader_1.validateYamlModule)(invalidModule);
+                node_assert_1.default.fail("Should have thrown an error");
+            }
+            catch (error) {
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(error.message.includes("FAILSAFE_SCHEMA"));
+            }
+        });
+    });
+    (0, node_test_1.describe)("security constraints", () => {
+        (0, node_test_1.it)("should respect custom security options", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test",
+                    protocols: {},
+                },
+            };
+            // Should work with relaxed constraints
+            await (0, loader_1.loadUniSpec)(doc, {
+                maxDepth: 1000,
+                maxKeys: 100000,
+                maxDocumentSize: 100 * 1024 * 1024,
+            });
+        });
+        (0, node_test_1.it)("should handle circular references gracefully", async () => {
+            const doc = { name: "test" };
+            doc.self = doc;
+            try {
+                await (0, loader_1.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
+                node_assert_1.default.ok(error instanceof Error);
+                node_assert_1.default.ok(!error.message.includes("stack"));
+            }
+        });
+    });
+    (0, node_test_1.describe)("edge cases", () => {
+        (0, node_test_1.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 (0, loader_1.loadUniSpec)(doc);
+            node_assert_1.default.strictEqual(result.service.name, "test");
+            node_assert_1.default.strictEqual(result.service.description, null);
+        });
+        (0, node_test_1.it)("should handle empty objects and arrays", async () => {
+            const doc = {
+                unispecVersion: "1.0.0",
+                service: {
+                    name: "test",
+                    protocols: {
+                        rest: {
+                            routes: [],
+                            schemas: {},
+                        },
+                    },
+                },
+            };
+            const result = await (0, loader_1.loadUniSpec)(doc);
+            node_assert_1.default.strictEqual(result.service.protocols?.rest?.routes?.length, 0);
+        });
+        (0, node_test_1.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 (0, loader_1.loadUniSpec)(doc);
+            node_assert_1.default.strictEqual(result.service.name, "test-service-特殊字符-🚀");
+        });
+    });
+});