@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

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

@@ -0,0 +1,356 @@
+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

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