@redocly/openapi-docs 3.24.1 → 3.25.0-next.1

package/lib/utils/__tests__/configure-helpers.test.js

@@ -1,356 +0,0 @@
-import { updateObjectProperties, createSecurityUpdates, updateServerVariablesWithUserValues, } from '../index.js';
-import { isDirectConfigureRequestValues } from '@redocly/theme/ext/configure';
-describe('Utils', () => {
-    describe('configure-helpers updateObjectProperties', () => {
-        it('Should update object with new values for existing properties', () => {
-            const originalObject = {
-                name: 'Museum Hours',
-                items: [
-                    {
-                        date: '2023-10-29',
-                        timeOpen: '09:00',
-                        timeClose: '18:00',
-                    },
-                ],
-            };
-            const newValues = {
-                location: 'Grand Exhibition Hall',
-                name: 'John Doe Prod',
-                items: [
-                    {
-                        date: '2024-01-13',
-                        timeOpen: '08:00',
-                        timeClose: '15:00',
-                    },
-                ],
-                artifacts: [
-                    {
-                        artifactId: 'prod-artifact-777',
-                        artifactNumber: 777,
-                    },
-                ],
-                visitors: [
-                    {
-                        visitorId: 'prod-visitor-345-678',
-                        visitorNumber: 678,
-                    },
-                ],
-            };
-            const expectedObject = {
-                name: 'John Doe Prod',
-                items: [
-                    {
-                        date: '2024-01-13',
-                        timeOpen: '08:00',
-                        timeClose: '15:00',
-                    },
-                ],
-            };
-            expect(updateObjectProperties(originalObject, newValues)).toStrictEqual(expectedObject);
-        });
-    });
-    describe('configure-helpers createSecurityUpdates', () => {
-        it('Should create security updates', () => {
-            const scheme = {
-                type: 'http',
-                scheme: 'basic',
-                id: 'MuseumPlaceholderAuth',
-                sectionId: 'MuseumPlaceholderAuth',
-                scopes: [],
-                serverValues: {
-                    'https://api.fake-museum-example.com/{version}': {
-                        scopes: [],
-                        'x-defaultUsername': 'prod_api_user',
-                        'x-defaultPassword': 'Pr0d@P!S3cur3',
-                    },
-                    'https://dev.api.fake-museum-example.com/v1.1': {
-                        scopes: [],
-                        'x-defaultUsername': 'dev_api_user',
-                        'x-defaultPassword': 'Dev@P!T3st',
-                    },
-                    'https://stage.api.fake-museum-example.com/v1.1': {
-                        scopes: [],
-                        'x-defaultUsername': 'api_user',
-                        'x-defaultPassword': 'secureP@ssword123',
-                    },
-                },
-            };
-            const securityValues = {
-                MuseumPlaceholderAuth: {
-                    username: 'prod_api_user',
-                    password: 'Pr0d@P!S3cur3',
-                    token: {
-                        access_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-                    },
-                },
-            };
-            const expectedObject = {
-                scopes: [],
-                'x-defaultClientId': undefined,
-                'x-defaultClientSecret': undefined,
-                'x-defaultUsername': 'prod_api_user',
-                'x-defaultPassword': 'Pr0d@P!S3cur3',
-            };
-            expect(createSecurityUpdates(scheme, securityValues)).toStrictEqual(expectedObject);
-        });
-    });
-    describe('configure-helpers isDirectConfigureRequestValues', () => {
-        it('Should return true if the value is a direct request values', () => {
-            const directRequestValues = {
-                body: {
-                    location: 'Grand Exhibition Hall',
-                    name: 'John Doe Prod',
-                },
-                security: {
-                    default: {
-                        username: 'prod_api_user',
-                        password: 'Pr0d@P!S3cur3',
-                        token: {
-                            access_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-                        },
-                    },
-                },
-            };
-            expect(isDirectConfigureRequestValues(directRequestValues)).toBe(true);
-        });
-        it('Should return false if the value is not a direct request values', () => {
-            const serverRequestValues = {
-                'https://api.fake-museum-example.com/{version}': {
-                    body: {
-                        location: 'Grand Exhibition Hall',
-                        name: 'John Doe Prod',
-                    },
-                    security: {
-                        default: {
-                            username: 'prod_api_user',
-                            password: 'Pr0d@P!S3cur3',
-                            token: {
-                                access_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-                            },
-                        },
-                    },
-                },
-                'https://dev.api.fake-museum-example.com/v1.1': {
-                    body: {
-                        location: 'Development Testing Hall',
-                        eventDescription: 'Testing event configurations in development',
-                        name: 'John Doe Dev',
-                    },
-                    security: {
-                        default: {
-                            username: 'dev_api_user',
-                            password: 'Dev@P!T3st',
-                            token: {
-                                access_token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-                            },
-                        },
-                    },
-                },
-            };
-            expect(isDirectConfigureRequestValues(serverRequestValues)).toBe(false);
-        });
-        it('Should return true if the value contains serverVariables', () => {
-            const directRequestValuesWithServerVariables = {
-                serverVariables: {
-                    version: 'v2',
-                    environment: 'staging',
-                },
-            };
-            expect(isDirectConfigureRequestValues(directRequestValuesWithServerVariables)).toBe(true);
-        });
-        it('Should return true if the value contains inputHints only', () => {
-            const directRequestValuesWithInputHints = {
-                inputHints: {
-                    bearerAuth_token: {
-                        title: 'Sign in to auto-fill',
-                        text: 'Sign in first.',
-                    },
-                },
-            };
-            expect(isDirectConfigureRequestValues(directRequestValuesWithInputHints)).toBe(true);
-        });
-        it('Should return false when server-keyed values include a top-level inputHints sibling', () => {
-            const serverRequestValuesWithTopLevelInputHints = {
-                'https://{host}/v1.1': {
-                    security: {
-                        default: {
-                            username: 'user',
-                            password: 'password',
-                        },
-                    },
-                },
-                inputHints: {
-                    bearerAuth_token: {
-                        title: 'Sign in to auto-fill',
-                        text: 'Sign in first.',
-                    },
-                },
-            };
-            expect(isDirectConfigureRequestValues(serverRequestValuesWithTopLevelInputHints)).toBe(false);
-        });
-    });
-    describe('configure-helpers updateServerVariablesWithUserValues', () => {
-        let mockOperation;
-        beforeEach(() => {
-            mockOperation = {
-                servers: [
-                    {
-                        url: 'https://api.example.com/{version}/{environment}',
-                        variables: {
-                            version: { default: 'v1' },
-                            environment: { default: 'prod' },
-                        },
-                    },
-                    {
-                        url: 'https://dev.api.example.com/{version}',
-                        variables: {
-                            version: { default: 'v1' },
-                        },
-                    },
-                ],
-            };
-        });
-        it('should update server variables for all servers when no serverUrl is provided', () => {
-            const serverVariables = {
-                version: 'v2',
-                environment: 'staging',
-            };
-            updateServerVariablesWithUserValues(mockOperation, serverVariables);
-            expect(mockOperation.servers[0].variables.version.default).toBe('v2');
-            expect(mockOperation.servers[0].variables.environment.default).toBe('staging');
-            expect(mockOperation.servers[1].variables.version.default).toBe('v2');
-            expect(mockOperation.servers[1].variables.environment).toBeUndefined();
-        });
-        it('should update server variables for specific server when serverUrl is provided', () => {
-            const serverVariables = {
-                version: 'v3',
-                environment: 'development',
-            };
-            const targetServerUrl = 'https://api.example.com/{version}/{environment}';
-            updateServerVariablesWithUserValues(mockOperation, serverVariables, targetServerUrl);
-            expect(mockOperation.servers[0].variables.version.default).toBe('v3');
-            expect(mockOperation.servers[0].variables.environment.default).toBe('development');
-            expect(mockOperation.servers[1].variables.version.default).toBe('v1');
-        });
-        it('should not update non-existent server variables', () => {
-            const serverVariables = {
-                nonExistentVar: 'should-not-be-added',
-                version: 'v2',
-            };
-            updateServerVariablesWithUserValues(mockOperation, serverVariables);
-            expect(mockOperation.servers[0].variables.version.default).toBe('v2');
-            expect(mockOperation.servers[0].variables.nonExistentVar).toBeUndefined();
-        });
-        it('should handle empty serverVariables object', () => {
-            const originalVersion = mockOperation.servers[0].variables.version.default;
-            const originalEnvironment = mockOperation.servers[0].variables.environment.default;
-            updateServerVariablesWithUserValues(mockOperation, {});
-            expect(mockOperation.servers[0].variables.version.default).toBe(originalVersion);
-            expect(mockOperation.servers[0].variables.environment.default).toBe(originalEnvironment);
-        });
-        it('should handle undefined serverVariables', () => {
-            const originalVersion = mockOperation.servers[0].variables.version.default;
-            const originalEnvironment = mockOperation.servers[0].variables.environment.default;
-            updateServerVariablesWithUserValues(mockOperation, undefined);
-            expect(mockOperation.servers[0].variables.version.default).toBe(originalVersion);
-            expect(mockOperation.servers[0].variables.environment.default).toBe(originalEnvironment);
-        });
-        it('should preserve other variable properties when updating default values', () => {
-            const operationWithExtendedVariables = {
-                servers: [
-                    {
-                        url: 'https://api.example.com/{version}',
-                        variables: {
-                            version: {
-                                default: 'v1',
-                                enum: ['v1', 'v2', 'v3'],
-                                description: 'API version',
-                            },
-                        },
-                    },
-                ],
-            };
-            const serverVariables = {
-                version: 'v2',
-            };
-            updateServerVariablesWithUserValues(operationWithExtendedVariables, serverVariables);
-            expect(operationWithExtendedVariables.servers?.[0].variables?.version.default).toBe('v2');
-            expect(operationWithExtendedVariables.servers?.[0].variables?.version.enum).toEqual([
-                'v1',
-                'v2',
-                'v3',
-            ]);
-            expect(operationWithExtendedVariables.servers?.[0].variables?.version.description).toBe('API version');
-        });
-        it('should handle partial serverVariables updates', () => {
-            const serverVariables = {
-                version: 'v2',
-            };
-            updateServerVariablesWithUserValues(mockOperation, serverVariables);
-            expect(mockOperation.servers[0].variables.version.default).toBe('v2');
-            expect(mockOperation.servers[0].variables.environment.default).toBe('prod');
-        });
-    });
-    describe('createSecurityUpdates - security resolution logic', () => {
-        it('should use scheme-specific values when scheme.id matches a key in securityValues', () => {
-            const scheme = {
-                id: 'MyApiKey',
-                type: 'apiKey',
-                in: 'header',
-                name: 'X-API-Key',
-            };
-            const securityValues = {
-                MyApiKey: {
-                    token: {
-                        access_token: 'scheme-specific-token',
-                    },
-                },
-                default: {
-                    token: {
-                        access_token: 'default-token',
-                    },
-                },
-            };
-            const result = createSecurityUpdates(scheme, securityValues);
-            expect(result['x-defaultAccessToken']).toBe('scheme-specific-token');
-        });
-        it('should fallback to default values when scheme.id does not match any key', () => {
-            const scheme = {
-                id: 'UnknownScheme',
-                type: 'http',
-                scheme: 'bearer',
-            };
-            const securityValues = {
-                SomeOtherScheme: {
-                    token: {
-                        access_token: 'other-token',
-                    },
-                },
-                default: {
-                    token: {
-                        access_token: 'fallback-token',
-                    },
-                },
-            };
-            const result = createSecurityUpdates(scheme, securityValues);
-            expect(result['x-defaultAccessToken']).toBe('fallback-token');
-        });
-        it('should return empty object values when neither scheme.id nor default key exist', () => {
-            const scheme = {
-                id: 'MissingScheme',
-                type: 'http',
-                scheme: 'bearer',
-            };
-            const securityValues = {
-                CompletelyDifferentScheme: {
-                    token: {
-                        access_token: 'unrelated-token',
-                    },
-                },
-            };
-            const result = createSecurityUpdates(scheme, securityValues);
-            expect(result['x-defaultAccessToken']).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=configure-helpers.test.js.map

package/lib/utils/__tests__/convertSwagger2OpenAPI.test.d.ts

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