ts-openapi-codegen 2.0.0 → 2.1.0-beta.10

package/dist/core/utils/__tests__/applyDiffReportToClient.test.js

@@ -0,0 +1,290 @@
+"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_test_1 = require("node:test");
+const applyDiffReportToClient_1 = require("../applyDiffReportToClient");
+const getOpenApiVersion_1 = require("../getOpenApiVersion");
+const createPropertyModel = (name, type) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'generic',
+    type,
+    base: type,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+const createObjectModel = (name, properties) => ({
+    name,
+    alias: '',
+    path: 'models',
+    export: 'interface',
+    type: name,
+    base: name,
+    template: null,
+    link: null,
+    description: null,
+    isDefinition: true,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [],
+    enum: [],
+    enums: [],
+    properties,
+});
+(0, node_test_1.describe)('@unit: applyDiffReportToClient (TYPE_COERCION miracles)', () => {
+    (0, node_test_1.test)('marks needsCoercion from TYPE_COERCION miracle', () => {
+        const userModel = createObjectModel('IUser', [createPropertyModel('age', 'number')]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [userModel],
+            services: [],
+        };
+        const openApi = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            age: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        };
+        const report = {
+            diff: {
+                all: [
+                    {
+                        action: 'changed',
+                        path: '$.components.schemas.User.properties.age.type',
+                        severity: 'warning',
+                        from: 'string',
+                        to: 'number',
+                    },
+                ],
+            },
+            miracles: [
+                {
+                    oldPath: '$.components.schemas.User.properties.age',
+                    newPath: '$.components.schemas.User.properties.age',
+                    type: 'TYPE_COERCION',
+                    confidence: 1,
+                    status: 'auto-generated',
+                },
+            ],
+        };
+        const result = (0, applyDiffReportToClient_1.applyDiffReportToClient)({
+            client,
+            openApi,
+            openApiVersion: getOpenApiVersion_1.OpenApiVersion.V3,
+            diffReport: report,
+            prefix: { interface: 'I', enum: 'E', type: 'T' },
+        });
+        const updatedModel = result.models[0];
+        const property = updatedModel.properties.find(prop => prop.name === 'age');
+        node_assert_1.default.ok(property?.needsCoercion, 'Expected needsCoercion to be true');
+        node_assert_1.default.strictEqual(property?.coercionFrom, 'string');
+        node_assert_1.default.strictEqual(property?.coercionTo, 'number');
+        node_assert_1.default.ok(updatedModel.hasCoercion, 'Expected model.hasCoercion to be true');
+    });
+    (0, node_test_1.test)('marks needsCoercion for $ref alias schema via Context resolver', () => {
+        const userBodyDef = {
+            type: 'object',
+            properties: {
+                age: { type: 'number' },
+            },
+        };
+        const mockContext = {
+            get: (ref) => {
+                if (ref === '#/components/schemas/User') {
+                    return userBodyDef;
+                }
+                return undefined;
+            },
+        };
+        const userModel = createObjectModel('IUser', [createPropertyModel('age', 'number')]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [userModel],
+            services: [],
+        };
+        const openApi = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: '#/components/schemas/UserBody' },
+                    UserBody: userBodyDef,
+                },
+            },
+        };
+        const report = {
+            diff: {
+                all: [
+                    {
+                        action: 'changed',
+                        path: '$.components.schemas.User.properties.age.type',
+                        severity: 'warning',
+                        from: 'string',
+                        to: 'number',
+                    },
+                ],
+            },
+            miracles: [
+                {
+                    oldPath: '$.components.schemas.User.properties.age',
+                    newPath: '$.components.schemas.User.properties.age',
+                    type: 'TYPE_COERCION',
+                    confidence: 1,
+                    status: 'auto-generated',
+                },
+            ],
+        };
+        const result = (0, applyDiffReportToClient_1.applyDiffReportToClient)({
+            client,
+            openApi,
+            openApiVersion: getOpenApiVersion_1.OpenApiVersion.V3,
+            diffReport: report,
+            prefix: { interface: 'I', enum: 'E', type: 'T' },
+            context: mockContext,
+        });
+        const updatedModel = result.models[0];
+        const property = updatedModel.properties.find(prop => prop.name === 'age');
+        node_assert_1.default.ok(property?.needsCoercion, 'Expected needsCoercion to be true for $ref schema');
+        node_assert_1.default.strictEqual(property?.coercionFrom, 'string');
+        node_assert_1.default.strictEqual(property?.coercionTo, 'number');
+        node_assert_1.default.ok(updatedModel.hasCoercion, 'Expected model.hasCoercion to be true');
+    });
+    (0, node_test_1.test)('marks needsCoercion on property via applyModelDiffs with $ref schema', () => {
+        const userBodyDef = {
+            type: 'object',
+            properties: {
+                age: { type: 'number' },
+            },
+        };
+        const mockContext = {
+            get: (ref) => {
+                if (ref === '#/components/schemas/User') {
+                    return userBodyDef;
+                }
+                return undefined;
+            },
+        };
+        const userModel = createObjectModel('IUser', [createPropertyModel('age', 'number')]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [userModel],
+            services: [],
+        };
+        const openApi = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: '#/components/schemas/UserBody' },
+                    UserBody: userBodyDef,
+                },
+            },
+        };
+        const report = {
+            diff: {
+                all: [
+                    {
+                        action: 'changed',
+                        path: '$.components.schemas.User.properties.age.type',
+                        severity: 'warning',
+                        from: 'string',
+                        to: 'number',
+                    },
+                ],
+            },
+        };
+        const result = (0, applyDiffReportToClient_1.applyDiffReportToClient)({
+            client,
+            openApi,
+            openApiVersion: getOpenApiVersion_1.OpenApiVersion.V3,
+            diffReport: report,
+            prefix: { interface: 'I', enum: 'E', type: 'T' },
+            context: mockContext,
+        });
+        const updatedModel = result.models[0];
+        const property = updatedModel.properties.find(prop => prop.name === 'age');
+        node_assert_1.default.ok(property?.needsCoercion, 'Expected needsCoercion from applyModelDiffs');
+        node_assert_1.default.strictEqual(property?.coercionFrom, 'string');
+        node_assert_1.default.strictEqual(property?.coercionTo, 'number');
+        node_assert_1.default.ok(updatedModel.hasCoercion, 'Expected model.hasCoercion to be true');
+    });
+    (0, node_test_1.test)('applies model diffs to all models with the same schema name', () => {
+        const sequence1 = createObjectModel('ISequence', [createPropertyModel('pathway_id', 'string')]);
+        const sequence2 = createObjectModel('ISequence', [createPropertyModel('pathwayId', 'string')]);
+        sequence2.alias = 'ISequence$2';
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [sequence1, sequence2],
+            services: [],
+        };
+        const openApi = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    Sequence: {
+                        type: 'object',
+                        properties: {
+                            pathway_id: { type: 'string' },
+                            pathwayId: { type: 'string' },
+                        },
+                    },
+                },
+            },
+        };
+        const report = {
+            diff: {
+                all: [
+                    {
+                        action: 'removed',
+                        path: '$.components.schemas.Sequence.properties.legacyField',
+                        severity: 'warning',
+                    },
+                ],
+            },
+        };
+        const result = (0, applyDiffReportToClient_1.applyDiffReportToClient)({
+            client,
+            openApi,
+            openApiVersion: getOpenApiVersion_1.OpenApiVersion.V3,
+            diffReport: report,
+            prefix: { interface: 'I', enum: 'E', type: 'T' },
+        });
+        const updated1 = result.models.find(model => model.name === 'ISequence' && !model.alias);
+        const updated2 = result.models.find(model => model.alias === 'ISequence$2');
+        node_assert_1.default.strictEqual(updated1?.ghostProperties?.length, 1);
+        node_assert_1.default.strictEqual(updated1?.ghostProperties?.[0].name, 'legacyField');
+        node_assert_1.default.strictEqual(updated2?.ghostProperties?.length, 1);
+        node_assert_1.default.strictEqual(updated2?.ghostProperties?.[0].name, 'legacyField');
+    });
+});

package/dist/core/utils/__tests__/buildMiraclesFromSemanticChanges.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=buildMiraclesFromSemanticChanges.test.d.ts.map

package/dist/core/utils/__tests__/buildMiraclesFromSemanticChanges.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildMiraclesFromSemanticChanges.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/buildMiraclesFromSemanticChanges.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/buildMiraclesFromSemanticChanges.test.js

@@ -0,0 +1,77 @@
+"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_test_1 = require("node:test");
+const buildMiraclesFromSemanticChanges_1 = require("../buildMiraclesFromSemanticChanges");
+(0, node_test_1.describe)('@unit: buildMiraclesFromSemanticChanges', () => {
+    (0, node_test_1.test)('parses schema property pointer', () => {
+        const parsed = (0, buildMiraclesFromSemanticChanges_1.parseSchemaPropertyPointer)('#/components/schemas/User/properties/first_name');
+        node_assert_1.default.ok(parsed);
+        node_assert_1.default.strictEqual(parsed.schemaName, 'User');
+        node_assert_1.default.strictEqual(parsed.propertyName, 'first_name');
+        node_assert_1.default.strictEqual(parsed.jsonPath, '$.components.schemas.User.properties.first_name');
+    });
+    (0, node_test_1.test)('creates RENAME miracle between removed and added property', () => {
+        const changes = [
+            {
+                type: 'model.property.removed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/first_name',
+                message: 'removed',
+                from: { type: 'string' },
+            },
+            {
+                type: 'model.property.added',
+                severity: 'non-breaking',
+                path: '#/components/schemas/User/properties/firstName',
+                message: 'added',
+                to: { type: 'string' },
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.strictEqual(miracles.length, 1);
+        node_assert_1.default.strictEqual(miracles[0].type, 'RENAME');
+        node_assert_1.default.strictEqual(miracles[0].oldPath, '$.components.schemas.User.properties.first_name');
+        node_assert_1.default.strictEqual(miracles[0].newPath, '$.components.schemas.User.properties.firstName');
+        node_assert_1.default.ok(miracles[0].confidence >= 0.8);
+    });
+    (0, node_test_1.test)('creates TYPE_COERCION miracle for scalar type changes', () => {
+        const changes = [
+            {
+                type: 'model.property.type.changed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/age',
+                message: 'type changed',
+                from: 'string',
+                to: 'integer',
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.strictEqual(miracles.length, 1);
+        node_assert_1.default.strictEqual(miracles[0].type, 'TYPE_COERCION');
+        node_assert_1.default.strictEqual(miracles[0].oldPath, '$.components.schemas.User.properties.age');
+    });
+    (0, node_test_1.test)('returns empty list when rename candidates do not match', () => {
+        const changes = [
+            {
+                type: 'model.property.removed',
+                severity: 'breaking',
+                path: '#/components/schemas/User/properties/id',
+                message: 'removed',
+                from: { type: 'string' },
+            },
+            {
+                type: 'model.property.added',
+                severity: 'non-breaking',
+                path: '#/components/schemas/Account/properties/accountId',
+                message: 'added',
+                to: { type: 'string' },
+            },
+        ];
+        const miracles = (0, buildMiraclesFromSemanticChanges_1.buildMiraclesFromSemanticChanges)(changes);
+        node_assert_1.default.deepStrictEqual(miracles, []);
+    });
+});

package/dist/core/utils/__tests__/expandOpenApiRefsForSemanticDiff.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=expandOpenApiRefsForSemanticDiff.test.d.ts.map

package/dist/core/utils/__tests__/expandOpenApiRefsForSemanticDiff.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expandOpenApiRefsForSemanticDiff.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/expandOpenApiRefsForSemanticDiff.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/expandOpenApiRefsForSemanticDiff.test.js

@@ -0,0 +1,159 @@
+"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_test_1 = require("node:test");
+const expandOpenApiRefsForSemanticDiff_1 = require("../expandOpenApiRefsForSemanticDiff");
+const sourceFile = '/tmp/openapi/api.yaml';
+function createResolver(entries) {
+    return {
+        exists: ref => Object.prototype.hasOwnProperty.call(entries, ref),
+        get: ref => entries[ref],
+    };
+}
+(0, node_test_1.describe)('@unit: expandOpenApiRefsForSemanticDiff', () => {
+    (0, node_test_1.test)('expands local refs without mutating the original document', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: {
+                        type: 'object',
+                        properties: {
+                            id: { $ref: '#/components/schemas/UserId' },
+                        },
+                    },
+                    UserId: { type: 'string', format: 'uuid' },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User.properties.id, { type: 'string', format: 'uuid' });
+        node_assert_1.default.deepStrictEqual(spec.components.schemas.User.properties.id, { $ref: '#/components/schemas/UserId' });
+    });
+    (0, node_test_1.test)('expands external file refs through the resolver', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: './schemas/User.yaml' },
+                },
+            },
+        };
+        const resolver = createResolver({
+            '/tmp/openapi/schemas/User.yaml': {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                },
+            },
+        });
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { refs: resolver, sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User, {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+            },
+        });
+    });
+    (0, node_test_1.test)('expands external file fragment refs through the resolver', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    User: { $ref: './schemas/common.yaml#/components/schemas/User' },
+                },
+            },
+        };
+        const resolver = createResolver({
+            '/tmp/openapi/schemas/common.yaml#/components/schemas/User': {
+                type: 'object',
+                required: ['id'],
+                properties: {
+                    id: { type: 'string' },
+                },
+            },
+        });
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { refs: resolver, sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.User, {
+            type: 'object',
+            required: ['id'],
+            properties: {
+                id: { type: 'string' },
+            },
+        });
+    });
+    (0, node_test_1.test)('expands path item refs', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {
+                '/users': { $ref: '#/components/pathItems/Users' },
+            },
+            components: {
+                pathItems: {
+                    Users: {
+                        get: {
+                            operationId: 'listUsers',
+                            responses: {
+                                '200': { description: 'ok' },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.paths['/users'], {
+            get: {
+                operationId: 'listUsers',
+                responses: {
+                    '200': { description: 'ok' },
+                },
+            },
+        });
+    });
+    (0, node_test_1.test)('keeps unresolved refs stable', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    Missing: { $ref: './missing.yaml#/Missing' },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        node_assert_1.default.deepStrictEqual(expanded.components.schemas.Missing, { $ref: './missing.yaml#/Missing' });
+    });
+    (0, node_test_1.test)('keeps circular refs stringify-safe', () => {
+        const spec = {
+            openapi: '3.0.0',
+            info: { title: 'Test', version: '1.0.0' },
+            paths: {},
+            components: {
+                schemas: {
+                    Node: {
+                        type: 'object',
+                        properties: {
+                            child: { $ref: '#/components/schemas/Node' },
+                        },
+                    },
+                },
+            },
+        };
+        const expanded = (0, expandOpenApiRefsForSemanticDiff_1.expandOpenApiRefsForSemanticDiff)(spec, { sourceFile });
+        const child = expanded.components.schemas.Node.properties.child;
+        node_assert_1.default.deepStrictEqual(child.properties.child, { $ref: '#/components/schemas/Node' });
+        node_assert_1.default.doesNotThrow(() => JSON.stringify(expanded));
+    });
+});

package/dist/core/utils/__tests__/getMappedType.test.js

@@ -10,6 +10,8 @@ const getMappedType_1 = require("../getMappedType");
     (0, node_test_1.test)('should map types to the basics', () => {
         node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('File'), 'File');
         node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('file'), 'File');
+        node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('Blob'), 'Blob');
+        node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('binary'), 'Blob');
         node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('string'), 'string');
         node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('date'), 'string');
         node_assert_1.default.strictEqual((0, getMappedType_1.getMappedType)('date-time'), 'string');

package/dist/core/utils/__tests__/getOperationResponseCode.test.js

@@ -9,11 +9,16 @@ const getOperationResponseCode_1 = require("../getOperationResponseCode");
 (0, node_test_1.describe)('@unit: getOperationResponseCode', () => {
     (0, node_test_1.test)('should produce correct result', () => {
         node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)(''), null);
-        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('default'), 200);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('default'), null);
         node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('200'), 200);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('201'), 201);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('2XX'), 200);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('2xx'), 200);
         node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('300'), 300);
         node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('400'), 400);
         node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('abc'), null);
-        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('-100'), 100);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('-100'), null);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('20'), null);
+        node_assert_1.default.strictEqual((0, getOperationResponseCode_1.getOperationResponseCode)('200 OK'), null);
     });
 });

package/dist/core/utils/__tests__/getOperationResults.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getOperationResults.test.d.ts.map

package/dist/core/utils/__tests__/getOperationResults.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getOperationResults.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/getOperationResults.test.ts"],"names":[],"mappings":""}

package/dist/core/utils/__tests__/getOperationResults.test.js

@@ -0,0 +1,43 @@
+"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_test_1 = require("node:test");
+const getOperationResults_1 = require("../getOperationResults");
+function createResponse(code, type) {
+    return {
+        in: 'response',
+        name: '',
+        alias: '',
+        path: '',
+        code,
+        description: '',
+        export: 'generic',
+        type,
+        base: type,
+        template: null,
+        link: null,
+        isDefinition: false,
+        isReadOnly: false,
+        isRequired: false,
+        isNullable: false,
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+    };
+}
+(0, node_test_1.describe)('@unit: getOperationResults', () => {
+    (0, node_test_1.test)('returns only success responses excluding 204', () => {
+        const result = (0, getOperationResults_1.getOperationResults)([createResponse(200, 'string'), createResponse(201, 'number'), createResponse(204, 'void'), createResponse(400, 'Error')]);
+        node_assert_1.default.deepStrictEqual(result.map(item => item.code), [200, 201]);
+    });
+    (0, node_test_1.test)('returns void 200 response when success responses are missing', () => {
+        const result = (0, getOperationResults_1.getOperationResults)([createResponse(400, 'Error')]);
+        node_assert_1.default.strictEqual(result.length, 1);
+        node_assert_1.default.strictEqual(result[0].code, 200);
+        node_assert_1.default.strictEqual(result[0].type, 'void');
+    });
+});

package/dist/core/utils/__tests__/loadDiffReport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=loadDiffReport.test.d.ts.map

package/dist/core/utils/__tests__/loadDiffReport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadDiffReport.test.d.ts","sourceRoot":"","sources":["../../../../src/core/utils/__tests__/loadDiffReport.test.ts"],"names":[],"mappings":""}