@unispechq/unispec-core 0.3.2 → 0.3.4

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

@@ -1,341 +0,0 @@
-"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-特殊字符-🚀");
-        });
-    });
-});