@unispechq/unispec-core 0.3.2 → 0.3.4

package/dist/cjs/tests/normalizer/normalizer-comprehensive.test.js

@@ -1,648 +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_path_1 = __importDefault(require("node:path"));
-const node_test_1 = require("node:test");
-const normalizer_1 = require("../../src/normalizer/index.js");
-const utils_1 = require("./utils.js");
-(0, node_test_1.describe)("normalizer module - comprehensive protocol tests", () => {
-    (0, node_test_1.describe)("REST protocol normalization", () => {
-        (0, node_test_1.it)("should sort REST routes by name when available", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "zebraRoute",
-                                    method: "GET",
-                                    path: "/zebra",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                                {
-                                    name: "alphaRoute",
-                                    method: "POST",
-                                    path: "/alpha",
-                                    responses: { "201": { description: "Created" } },
-                                },
-                                {
-                                    name: "betaRoute",
-                                    method: "PUT",
-                                    path: "/beta",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Routes should be sorted by name
-            const routes = normalized.service?.protocols?.rest?.routes || [];
-            const routeNames = routes.map((r) => r.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(routeNames, [
-                "alphaRoute",
-                "betaRoute",
-                "zebraRoute",
-            ]);
-        });
-        (0, node_test_1.it)("should sort REST routes by path+method when name is missing", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "",
-                                    method: "GET",
-                                    path: "/users",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                                {
-                                    name: "",
-                                    method: "POST",
-                                    path: "/users",
-                                    responses: { "201": { description: "Created" } },
-                                },
-                                {
-                                    name: "",
-                                    method: "DELETE",
-                                    path: "/users/{id}",
-                                    responses: { "204": { description: "No Content" } },
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Routes should be sorted by path+method
-            const routes = normalized.service?.protocols?.rest?.routes || [];
-            const routeKeys = routes.map((r) => r.name ? `${r.path} ${r.method}` : `${r.path} ${r.method}`);
-            node_assert_1.default.deepStrictEqual(routeKeys, [
-                "/users GET",
-                "/users POST",
-                "/users/{id} DELETE",
-            ]);
-        });
-        (0, node_test_1.it)("should handle mixed named and unnamed routes", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "getUser",
-                                    method: "GET",
-                                    path: "/users/{id}",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                                {
-                                    name: "",
-                                    method: "POST",
-                                    path: "/users",
-                                    responses: { "201": { description: "Created" } },
-                                },
-                                {
-                                    name: "deleteUser",
-                                    method: "DELETE",
-                                    path: "/users/{id}",
-                                    responses: { "204": { description: "No Content" } },
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Routes should be sorted by name or path+method
-            const routes = normalized.service?.protocols?.rest?.routes || [];
-            const routeKeys = routes.map((r) => r.name || `${r.path} ${r.method}`);
-            node_assert_1.default.deepStrictEqual(routeKeys, [
-                "/users POST",
-                "deleteUser",
-                "getUser",
-            ]);
-        });
-    });
-    (0, node_test_1.describe)("GraphQL protocol normalization", () => {
-        (0, node_test_1.it)("should sort GraphQL queries by name", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        graphql: {
-                            queries: [
-                                {
-                                    name: "zebraQuery",
-                                    description: "Get zebra",
-                                    args: [],
-                                    returnType: "Zebra",
-                                },
-                                {
-                                    name: "alphaQuery",
-                                    description: "Get alpha",
-                                    args: [],
-                                    returnType: "Alpha",
-                                },
-                                {
-                                    name: "betaQuery",
-                                    description: "Get beta",
-                                    args: [],
-                                    returnType: "Beta",
-                                },
-                            ],
-                            mutations: [],
-                            subscriptions: [],
-                            schema: "type Query { alphaQuery: Alpha betaQuery: Beta zebraQuery: Zebra }",
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Queries should be sorted by name
-            const queries = normalized.service?.protocols?.graphql?.queries || [];
-            const queryNames = queries.map((q) => q.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(queryNames, [
-                "alphaQuery",
-                "betaQuery",
-                "zebraQuery",
-            ]);
-        });
-        (0, node_test_1.it)("should sort GraphQL mutations by name", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        graphql: {
-                            queries: [],
-                            mutations: [
-                                {
-                                    name: "zebraMutation",
-                                    description: "Create zebra",
-                                    args: [],
-                                    returnType: "Zebra",
-                                },
-                                {
-                                    name: "alphaMutation",
-                                    description: "Create alpha",
-                                    args: [],
-                                    returnType: "Alpha",
-                                },
-                            ],
-                            subscriptions: [],
-                            schema: "type Mutation { alphaMutation: Alpha zebraMutation: Zebra }",
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Mutations should be sorted by name
-            const mutations = normalized.service?.protocols?.graphql?.mutations || [];
-            const mutationNames = mutations.map((m) => m.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(mutationNames, ["alphaMutation", "zebraMutation"]);
-        });
-        (0, node_test_1.it)("should sort GraphQL subscriptions by name", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        graphql: {
-                            queries: [],
-                            mutations: [],
-                            subscriptions: [
-                                {
-                                    name: "zebraSubscription",
-                                    description: "Subscribe to zebra",
-                                    args: [],
-                                    returnType: "Zebra",
-                                },
-                                {
-                                    name: "alphaSubscription",
-                                    description: "Subscribe to alpha",
-                                    args: [],
-                                    returnType: "Alpha",
-                                },
-                            ],
-                            schema: "type Subscription { alphaSubscription: Alpha zebraSubscription: Zebra }",
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Subscriptions should be sorted by name
-            const subscriptions = normalized.service?.protocols?.graphql?.subscriptions || [];
-            const subscriptionNames = subscriptions
-                .map((s) => s.name)
-                .filter(Boolean);
-            node_assert_1.default.deepStrictEqual(subscriptionNames, [
-                "alphaSubscription",
-                "zebraSubscription",
-            ]);
-        });
-        (0, node_test_1.it)("should handle operations with missing names", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        graphql: {
-                            queries: [
-                                {
-                                    name: "",
-                                    description: "Query without name",
-                                    args: [],
-                                    returnType: "String",
-                                },
-                                {
-                                    name: "namedQuery",
-                                    description: "Named query",
-                                    args: [],
-                                    returnType: "String",
-                                },
-                            ],
-                            mutations: [],
-                            subscriptions: [],
-                            schema: "type Query { namedQuery: String }",
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle missing names gracefully
-            const queries = normalized.service?.protocols?.graphql?.queries || [];
-            node_assert_1.default.strictEqual(queries.length, 2);
-            // Named query should come after unnamed (empty string sorts first)
-            const queryNames = queries.map((q) => q.name || "");
-            node_assert_1.default.deepStrictEqual(queryNames, ["", "namedQuery"]);
-        });
-    });
-    (0, node_test_1.describe)("WebSocket protocol normalization", () => {
-        (0, node_test_1.it)("should sort WebSocket channels by name", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "zebraChannel",
-                                    description: "Zebra channel",
-                                    messages: [],
-                                },
-                                {
-                                    name: "alphaChannel",
-                                    description: "Alpha channel",
-                                    messages: [],
-                                },
-                                {
-                                    name: "betaChannel",
-                                    description: "Beta channel",
-                                    messages: [],
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Channels should be sorted by name
-            const channels = normalized.service?.protocols?.websocket?.channels || [];
-            const channelNames = channels.map((c) => c.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(channelNames, [
-                "alphaChannel",
-                "betaChannel",
-                "zebraChannel",
-            ]);
-        });
-        (0, node_test_1.it)("should sort messages within each channel by name", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "notifications",
-                                    description: "Notification channel",
-                                    messages: [
-                                        {
-                                            name: "zebraMessage",
-                                            description: "Zebra notification",
-                                            direction: "subscribe",
-                                        },
-                                        {
-                                            name: "alphaMessage",
-                                            description: "Alpha notification",
-                                            direction: "publish",
-                                        },
-                                        {
-                                            name: "betaMessage",
-                                            description: "Beta notification",
-                                            direction: "both",
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Messages should be sorted by name within the channel
-            const channel = normalized.service?.protocols?.websocket?.channels?.find((c) => c.name === "notifications");
-            node_assert_1.default.ok(channel);
-            const messages = channel?.messages || [];
-            const messageNames = messages.map((m) => m.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(messageNames, [
-                "alphaMessage",
-                "betaMessage",
-                "zebraMessage",
-            ]);
-        });
-        (0, node_test_1.it)("should handle channels with missing names", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "",
-                                    description: "Channel without name",
-                                    messages: [],
-                                },
-                                {
-                                    name: "namedChannel",
-                                    description: "Named channel",
-                                    messages: [],
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle missing names gracefully
-            const channels = normalized.service?.protocols?.websocket?.channels || [];
-            node_assert_1.default.strictEqual(channels.length, 2);
-            // Named channel should come after unnamed
-            const channelNames = channels.map((c) => c.name || "");
-            node_assert_1.default.deepStrictEqual(channelNames, ["", "namedChannel"]);
-        });
-        (0, node_test_1.it)("should handle messages with missing names", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "testChannel",
-                                    description: "Test channel",
-                                    messages: [
-                                        {
-                                            name: "",
-                                            description: "Message without name",
-                                            direction: "subscribe",
-                                        },
-                                        {
-                                            name: "namedMessage",
-                                            description: "Named message",
-                                            direction: "publish",
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Should handle missing names gracefully
-            const channel = normalized.service?.protocols?.websocket?.channels?.find((c) => c.name === "testChannel");
-            node_assert_1.default.ok(channel);
-            const messages = channel?.messages || [];
-            node_assert_1.default.strictEqual(messages.length, 2);
-            // Named message should come after unnamed
-            const messageNames = messages.map((m) => m.name || "");
-            node_assert_1.default.deepStrictEqual(messageNames, ["", "namedMessage"]);
-        });
-    });
-    (0, node_test_1.describe)("Mixed protocol normalization", () => {
-        (0, node_test_1.it)("should normalize all protocols simultaneously", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "zebraRoute",
-                                    method: "GET",
-                                    path: "/zebra",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                                {
-                                    name: "alphaRoute",
-                                    method: "POST",
-                                    path: "/alpha",
-                                    responses: { "201": { description: "Created" } },
-                                },
-                            ],
-                        },
-                        graphql: {
-                            queries: [
-                                {
-                                    name: "zebraQuery",
-                                    description: "Get zebra",
-                                    args: [],
-                                    returnType: "Zebra",
-                                },
-                                {
-                                    name: "alphaQuery",
-                                    description: "Get alpha",
-                                    args: [],
-                                    returnType: "Alpha",
-                                },
-                            ],
-                            mutations: [],
-                            subscriptions: [],
-                            schema: "type Query { alphaQuery: Alpha zebraQuery: Zebra }",
-                        },
-                        websocket: {
-                            channels: [
-                                {
-                                    name: "zebraChannel",
-                                    description: "Zebra channel",
-                                    messages: [],
-                                },
-                                {
-                                    name: "alphaChannel",
-                                    description: "Alpha channel",
-                                    messages: [],
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // All protocols should be normalized
-            const protocols = normalized.service?.protocols;
-            // Check REST routes
-            const restRoutes = protocols?.rest?.routes || [];
-            const restRouteNames = restRoutes.map((r) => r.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(restRouteNames, ["alphaRoute", "zebraRoute"]);
-            // Check GraphQL queries
-            const graphqlQueries = protocols?.graphql?.queries || [];
-            const graphqlQueryNames = graphqlQueries
-                .map((q) => q.name)
-                .filter(Boolean);
-            node_assert_1.default.deepStrictEqual(graphqlQueryNames, ["alphaQuery", "zebraQuery"]);
-            // Check WebSocket channels
-            const wsChannels = protocols?.websocket?.channels || [];
-            const wsChannelNames = wsChannels.map((c) => c.name).filter(Boolean);
-            node_assert_1.default.deepStrictEqual(wsChannelNames, ["alphaChannel", "zebraChannel"]);
-        });
-    });
-    (0, node_test_1.describe)("Structural normalization", () => {
-        (0, node_test_1.it)("should sort all object keys lexicographically", () => {
-            const doc = {
-                unispecVersion: "1.0.0",
-                service: {
-                    name: "test-service",
-                    description: "Test service for sorting",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "zRoute",
-                                    method: "GET",
-                                    path: "/z",
-                                    responses: { "200": { description: "OK" } },
-                                },
-                                {
-                                    name: "aRoute",
-                                    method: "POST",
-                                    path: "/a",
-                                    responses: { "201": { description: "Created" } },
-                                },
-                            ],
-                        },
-                    },
-                },
-            };
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Top-level keys should be sorted
-            const docKeys = Object.keys(normalized);
-            node_assert_1.default.deepStrictEqual(docKeys, ["service", "unispecVersion"]);
-            // Service keys should be sorted lexicographically
-            const serviceKeys = Object.keys(normalized.service || {});
-            const expectedServiceKeys = ["description", "name", "protocols"];
-            node_assert_1.default.deepStrictEqual(serviceKeys, expectedServiceKeys);
-            // Protocol keys should be sorted
-            const protocolKeys = Object.keys(normalized.service?.protocols || {});
-            node_assert_1.default.deepStrictEqual(protocolKeys, ["rest"]);
-        });
-        (0, node_test_1.it)("should handle nested objects recursively", () => {
-            const doc = (0, utils_1.createTestDocument)({
-                service: {
-                    name: "test-service",
-                    protocols: {
-                        rest: {
-                            routes: [
-                                {
-                                    name: "testRoute",
-                                    method: "POST",
-                                    path: "/test",
-                                    requestBody: {
-                                        description: "Request body",
-                                        content: {
-                                            "application/json": {
-                                                schemaRef: "ZSchema",
-                                            },
-                                            "text/plain": {
-                                                schemaRef: "ASchema",
-                                            },
-                                        },
-                                    },
-                                    responses: {
-                                        "201": {
-                                            description: "Created",
-                                        },
-                                        "200": {
-                                            description: "OK",
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-            });
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            // Nested object keys should be sorted
-            const route = normalized.service?.protocols?.rest?.routes?.[0];
-            node_assert_1.default.ok(route);
-            // requestBody keys should be sorted lexicographically
-            const requestBodyKeys = Object.keys(route.requestBody || {});
-            node_assert_1.default.deepStrictEqual(requestBodyKeys, ["content", "description"]);
-            // response keys should be sorted
-            const responseKeys = Object.keys(route.responses || {});
-            node_assert_1.default.deepStrictEqual(responseKeys, ["200", "201"]);
-        });
-    });
-    (0, node_test_1.describe)("Real-world examples", () => {
-        (0, node_test_1.it)("should handle complex real-world example from mixed-complete.json", () => {
-            const doc = (0, utils_1.loadExample)(node_path_1.default.join(utils_1.examplesDir, "valid", "spec", "mixed-complete.json"));
-            // Should not crash
-            const normalized = (0, normalizer_1.normalizeUniSpec)(doc);
-            node_assert_1.default.ok(normalized);
-            // Should have sorted structure
-            const docKeys = Object.keys(normalized);
-            node_assert_1.default.deepStrictEqual(docKeys, ["service", "unispecVersion"]);
-            // Should normalize all protocols present
-            const protocols = normalized.service?.protocols;
-            if (protocols?.rest?.routes) {
-                const routeKeys = protocols.rest.routes.map((r) => r.name || `${r.path} ${r.method}`);
-                const sortedRouteKeys = [...routeKeys].sort();
-                node_assert_1.default.deepStrictEqual(routeKeys, sortedRouteKeys);
-            }
-            if (protocols?.graphql) {
-                ["queries", "mutations", "subscriptions"].forEach((operationType) => {
-                    const operations = protocols[operationType];
-                    if (Array.isArray(operations)) {
-                        const names = operations
-                            .map((op) => op.name || "")
-                            .filter(Boolean);
-                        const sortedNames = [...names].sort();
-                        node_assert_1.default.deepStrictEqual(names, sortedNames);
-                    }
-                });
-            }
-            if (protocols?.websocket?.channels) {
-                const channelNames = protocols.websocket.channels
-                    .map((c) => c.name || "")
-                    .filter(Boolean);
-                const sortedChannelNames = [...channelNames].sort();
-                node_assert_1.default.deepStrictEqual(channelNames, sortedChannelNames);
-                // Check message sorting within channels
-                protocols.websocket.channels.forEach((channel) => {
-                    if (channel.messages) {
-                        const messageNames = channel.messages
-                            .map((m) => m.name || "")
-                            .filter(Boolean);
-                        const sortedMessageNames = [...messageNames].sort();
-                        node_assert_1.default.deepStrictEqual(messageNames, sortedMessageNames);
-                    }
-                });
-            }
-        });
-    });
-});