@microsoft/power-apps-cli 0.5.4 → 0.5.7

package/node_modules/@microsoft/powerapps-data/lib/__tests__/dataSourceInfoProcessor.test.js

@@ -1,782 +0,0 @@
-/*!
- * Copyright (C) Microsoft Corporation. All rights reserved.
- */
-import { beforeEach, describe, expect, it } from '@jest/globals';
-import * as fs from 'fs';
-import * as path from 'path';
-import { processDataSourceInfo } from '../components/codeGen/dataSourceInfoProcessor';
-import { getMockLogger } from './mocks/Logger.mock';
-// Mock fs module
-jest.mock('fs');
-const mockedFs = fs;
-// Mock path module
-jest.mock('path');
-const mockedPath = path;
-// Helper function to create mock directory entries
-function createMockDirEntry(name, isDirectory) {
-    return {
-        name,
-        isDirectory: () => isDirectory,
-        isFile: () => !isDirectory,
-        isBlockDevice: () => false,
-        isCharacterDevice: () => false,
-        isSymbolicLink: () => false,
-        isFIFO: () => false,
-        isSocket: () => false,
-    };
-}
-const mockLogger = getMockLogger();
-describe('dataSourceInfoProcessor', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        // Setup default mocks
-        mockedPath.join.mockImplementation((...args) => args.join('/'));
-        mockedFs.existsSync.mockReturnValue(false);
-        mockedFs.mkdirSync.mockImplementation();
-        mockedFs.writeFileSync.mockImplementation();
-    });
-    describe('processDataSourceInfo', () => {
-        it('should process empty folder without errors', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            mockedFs.readdirSync.mockReturnValue([]);
-            // Act & Assert
-            expect(() => processDataSourceInfo(folderPath, mockLogger)).not.toThrow();
-        });
-        it('should process folder with JSON files and generate output', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            const jsonContent = JSON.stringify({
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/test': {
-                                get: {
-                                    operationId: 'GetTest',
-                                    responses: {
-                                        '200': {
-                                            description: 'Success',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            });
-            // Mock file system operations
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('test.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(jsonContent);
-            mockedPath.join.mockImplementation((...args) => args.join('/'));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/test/folder/test.json', 'utf-8');
-            expect(mockedFs.writeFileSync).toHaveBeenCalled();
-        });
-        it('should handle errors gracefully and wrap in descriptive error', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            mockedFs.readdirSync.mockImplementation(() => {
-                throw new Error('Permission denied');
-            });
-            // Act & Assert
-            expect(() => processDataSourceInfo(folderPath, mockLogger)).toThrow('An unexpected error occurred: Permission denied');
-        });
-        it('should handle file processing errors with file path context', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            const invalidJsonContent = '{ invalid json';
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('invalid.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(invalidJsonContent);
-            // Act & Assert
-            expect(() => processDataSourceInfo(folderPath, mockLogger)).toThrow("Error processing file '/test/folder/invalid.json'");
-        });
-        it('should create output directory if it does not exist', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            mockedFs.readdirSync.mockReturnValue([]);
-            mockedFs.existsSync.mockReturnValue(false);
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            expect(mockedFs.mkdirSync).toHaveBeenCalledWith('/test/folder/../appschemas', { recursive: true });
-        });
-        it('should not create output directory if it already exists', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            mockedFs.readdirSync.mockReturnValue([]);
-            mockedFs.existsSync.mockReturnValue(true);
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            expect(mockedFs.mkdirSync).not.toHaveBeenCalled();
-        });
-    });
-    describe('Swagger API processing', () => {
-        it('should process Microsoft.PowerApps/apis type with swagger paths', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/users': {
-                                get: {
-                                    operationId: 'GetUsers',
-                                    parameters: [
-                                        {
-                                            name: 'limit',
-                                            in: 'query',
-                                            required: false,
-                                            type: 'integer',
-                                        },
-                                    ],
-                                    responses: {
-                                        '200': {
-                                            description: 'Success',
-                                            schema: {
-                                                type: 'array',
-                                            },
-                                        },
-                                    },
-                                },
-                                post: {
-                                    operationId: 'CreateUser',
-                                    responses: {
-                                        '201': {
-                                            description: 'Created',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('swagger.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('GetUsers');
-            expect(generatedContent).toContain('CreateUser');
-            expect(generatedContent).toContain('"/users"');
-            expect(generatedContent).toContain('"method": "GET"');
-            expect(generatedContent).toContain('"method": "POST"');
-        });
-        it('should handle swagger with parameter references', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/items': {
-                                get: {
-                                    operationId: 'GetItems',
-                                    parameters: [
-                                        {
-                                            $ref: '#/swagger/parameters/CommonParam',
-                                        },
-                                    ],
-                                    responses: {
-                                        '200': {
-                                            description: 'Success',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        parameters: {
-                            CommonParam: {
-                                name: 'commonParam',
-                                in: 'header',
-                                required: true,
-                                type: 'string',
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('swagger-ref.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('GetItems');
-            // Note: Parameter reference resolution is tested but the mock doesn't properly resolve it
-            // The actual implementation would resolve the commonParam parameter
-        });
-        it('should handle responses with schema references', () => {
-            // Arrange
-            const folderPath = '/test/folder';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/models': {
-                                get: {
-                                    operationId: 'GetModels',
-                                    responses: {
-                                        '200': {
-                                            description: 'Success',
-                                            schema: {
-                                                $ref: '#/definitions/ModelResponse',
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        definitions: {
-                            ModelResponse: {
-                                type: 'object',
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('models.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('GetModels');
-            expect(generatedContent).toContain('"type": "object"');
-        });
-    });
-    describe('SQL stored procedure processing', () => {
-        it('should process SQL stored procedure with input parameters', () => {
-            // Arrange
-            const folderPath = '/test/procedures/GetUserById';
-            const procedureJson = {
-                name: '[dbo].[GetUserById]',
-                schema: {
-                    procedureresultschema: {
-                        type: 'object',
-                    },
-                    inputparameters: {
-                        properties: {
-                            UserId: {
-                                type: 'integer',
-                                required: true,
-                            },
-                            IncludeDetails: {
-                                type: 'boolean',
-                                required: false,
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('procedure.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(procedureJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('getuserbyid');
-            expect(generatedContent).toContain('"/dbo.GetUserById"');
-            expect(generatedContent).toContain('"method": "POST"');
-            expect(generatedContent).toContain('UserId');
-            expect(generatedContent).toContain('IncludeDetails');
-        });
-        it('should handle stored procedure without input parameters', () => {
-            // Arrange
-            const folderPath = '/test/procedures/GetAllUsers';
-            const procedureJson = {
-                name: '[dbo].[GetAllUsers]',
-                schema: {
-                    procedureresultschema: {
-                        type: 'array',
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('procedure.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(procedureJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('getallusers');
-            expect(generatedContent).toContain('"/dbo.GetAllUsers"');
-        });
-        it('should determine property key from parent folder for stored procedures', () => {
-            // Arrange
-            const folderPath = '/test/procedures/UserProcedures';
-            const procedureJson = {
-                name: '[dbo].[GetUser]',
-                schema: {
-                    procedureresultschema: {
-                        type: 'object',
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('procedure.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(procedureJson));
-            // Mock path operations for folder extraction
-            mockedPath.join.mockImplementation((...args) => args.join('/'));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('userprocedures');
-        });
-        it('should handle non-dbo schemas', () => {
-            // Arrange
-            const folderPath = '/test/procedures/GetAllUsers';
-            const procedureJson = {
-                name: '[foo].[GetAllUsers]',
-                schema: {
-                    procedureresultschema: {
-                        type: 'array',
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('procedure.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(procedureJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('getallusers');
-            expect(generatedContent).toContain('"/foo.GetAllUsers"');
-        });
-    });
-    describe('SQL table processing', () => {
-        it('should process SQL table schema with primary key', () => {
-            // Arrange
-            const folderPath = '/test/tables';
-            const tableJson = {
-                name: '[dbo].[Users]',
-                schema: {
-                    items: {
-                        properties: {
-                            Id: {
-                                type: 'integer',
-                                'x-ms-keyType': 'primary',
-                            },
-                            Name: {
-                                type: 'string',
-                            },
-                            Email: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('users.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(tableJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('users');
-            expect(generatedContent).toContain('"tableId": "Users"');
-            expect(generatedContent).toContain('"version": "v2"');
-            expect(generatedContent).toContain('"primaryKey": "Id"');
-        });
-        it('should handle table without primary key', () => {
-            // Arrange
-            const folderPath = '/test/tables';
-            const tableJson = {
-                name: '[dbo].[Logs]',
-                schema: {
-                    items: {
-                        properties: {
-                            Message: {
-                                type: 'string',
-                            },
-                            Timestamp: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('logs.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(tableJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('logs');
-            expect(generatedContent).toContain('"primaryKey": ""');
-        });
-    });
-    describe('Property key determination', () => {
-        it('should remove [dbo]. prefix and brackets from SQL table names', () => {
-            // Arrange
-            const folderPath = '/test/tables';
-            const tableJson = {
-                name: '[dbo].[ComplexTableName]',
-                schema: {
-                    items: {
-                        properties: {},
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('table.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(tableJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('complextablename');
-        });
-        it('should remove [custom_schema]. prefix and brackets from SQL table names', () => {
-            // Arrange
-            const folderPath = '/test/tables';
-            const tableJson = {
-                name: '[custom_schema].[ComplexTableName]',
-                schema: {
-                    items: {
-                        properties: {},
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('table.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(tableJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('complextablename');
-        });
-        it('should remove shared_ prefix from non-tabular names', () => {
-            // Arrange
-            const folderPath = '/test/shared';
-            const sharedJson = {
-                name: 'shared_commonservice',
-                schema: {
-                    type: 'object',
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('service.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(sharedJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('commonservice');
-        });
-        it('should use title property when available', () => {
-            // Arrange
-            const folderPath = '/test/tabular';
-            const tabularJson = {
-                title: 'UserManagement',
-                name: 'internal_name',
-                schema: {
-                    type: 'object',
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('service.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(tabularJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('usermanagement');
-        });
-        it('should fallback to filename when name property is missing', () => {
-            // Arrange
-            const folderPath = '/test/fallback';
-            const jsonWithoutName = {
-                schema: {
-                    type: 'object',
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('FallbackService.Schema.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(jsonWithoutName));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('fallbackservice');
-        });
-    });
-    describe('Merge functionality', () => {
-        it('should merge APIs when processing multiple files for same data source', () => {
-            // Arrange
-            const folderPath = '/test/merge';
-            const api1Json = {
-                name: 'shared_testservice',
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/api1': {
-                                get: {
-                                    operationId: 'GetApi1',
-                                    responses: { '200': { description: 'Success' } },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const api2Json = {
-                name: 'shared_testservice',
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/api2': {
-                                post: {
-                                    operationId: 'PostApi2',
-                                    responses: { '201': { description: 'Created' } },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([
-                createMockDirEntry('api1.json', false),
-                createMockDirEntry('api2.json', false),
-            ]);
-            mockedFs.readFileSync
-                .mockReturnValueOnce(JSON.stringify(api1Json))
-                .mockReturnValueOnce(JSON.stringify(api2Json));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('GetApi1');
-            expect(generatedContent).toContain('PostApi2');
-            expect(generatedContent).toContain('testservice');
-        });
-        it('should throw error for duplicate stored procedures', () => {
-            // Arrange
-            const folderPath = '/test/duplicate';
-            const procedureJson = {
-                name: '[dbo].[DuplicateProc]',
-                schema: {
-                    procedureresultschema: { type: 'object' },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([
-                createMockDirEntry('proc1.json', false),
-                createMockDirEntry('proc2.json', false),
-            ]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(procedureJson));
-            // Act & Assert
-            // Note: The current implementation merges APIs instead of throwing an error
-            // This test verifies that duplicate stored procedures are handled gracefully
-            expect(() => processDataSourceInfo(folderPath, mockLogger)).not.toThrow();
-        });
-    });
-    describe('Response processing', () => {
-        it('should handle array responses correctly', () => {
-            // Arrange
-            const folderPath = '/test/responses';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/array-endpoint': {
-                                get: {
-                                    operationId: 'GetArray',
-                                    responses: {
-                                        '200': {
-                                            description: 'Success',
-                                            schema: {
-                                                type: 'array',
-                                                format: 'custom',
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('array-response.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('"type": "array"');
-            expect(generatedContent).toContain('"format": "custom"');
-        });
-        it('should handle void responses when no schema provided', () => {
-            // Arrange
-            const folderPath = '/test/responses';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/void-endpoint': {
-                                delete: {
-                                    operationId: 'DeleteItem',
-                                    responses: {
-                                        '204': {
-                                            description: 'No Content',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('void-response.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            expect(generatedContent).toContain('"type": "void"');
-        });
-    });
-    describe('Error handling', () => {
-        it('should throw descriptive error for invalid JSON structure', () => {
-            // Arrange
-            const folderPath = '/test/invalid';
-            const invalidJson = {
-                invalidStructure: true,
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('invalid.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(invalidJson));
-            // Act & Assert
-            expect(() => processDataSourceInfo(folderPath, mockLogger)).toThrow('The JSON does not represent a valid data source');
-        });
-        it('should handle nested directory traversal', () => {
-            // Arrange
-            const folderPath = '/test/nested';
-            mockedFs.readdirSync
-                .mockReturnValueOnce([createMockDirEntry('subfolder', true)])
-                .mockReturnValueOnce([createMockDirEntry('nested.json', false)]);
-            const nestedJson = {
-                name: 'nested-service',
-                schema: { type: 'object' },
-            };
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(nestedJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            expect(mockedFs.readdirSync).toHaveBeenCalledTimes(2);
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/test/nested/subfolder/nested.json', 'utf-8');
-        });
-    });
-    describe('Parameter sorting', () => {
-        it('should sort parameters with required first', () => {
-            // Arrange
-            const folderPath = '/test/sorting';
-            const swaggerJson = {
-                type: 'Microsoft.PowerApps/apis',
-                properties: {
-                    swagger: {
-                        paths: {
-                            '/sorted-params': {
-                                post: {
-                                    operationId: 'PostWithSortedParams',
-                                    parameters: [
-                                        {
-                                            name: 'optional1',
-                                            in: 'query',
-                                            required: false,
-                                            type: 'string',
-                                        },
-                                        {
-                                            name: 'required1',
-                                            in: 'body',
-                                            required: true,
-                                            type: 'object',
-                                        },
-                                        {
-                                            name: 'optional2',
-                                            in: 'header',
-                                            required: false,
-                                            type: 'string',
-                                        },
-                                        {
-                                            name: 'required2',
-                                            in: 'path',
-                                            required: true,
-                                            type: 'string',
-                                        },
-                                    ],
-                                    responses: {
-                                        '200': { description: 'Success' },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('sorted.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(swaggerJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const generatedContent = writeCall[1];
-            const parsedResult = JSON.parse(generatedContent.split('export const dataSourcesInfo = ')[1].replace(';', ''));
-            // Find the parameters array for the operation
-            const dataSource = Object.values(parsedResult)[0];
-            const operation = dataSource.apis.PostWithSortedParams;
-            const parameters = operation.parameters;
-            // Required parameters should come first
-            expect(parameters[0].required).toBe(true);
-            expect(parameters[1].required).toBe(true);
-            expect(parameters[2].required).toBe(false);
-            expect(parameters[3].required).toBe(false);
-        });
-    });
-    describe('Output generation', () => {
-        it('should generate properly formatted TypeScript output', () => {
-            // Arrange
-            const folderPath = '/test/output';
-            const simpleJson = {
-                name: 'test-service',
-                schema: { type: 'object' },
-            };
-            mockedFs.readdirSync.mockReturnValue([createMockDirEntry('simple.json', false)]);
-            mockedFs.readFileSync.mockReturnValue(JSON.stringify(simpleJson));
-            // Act
-            processDataSourceInfo(folderPath, mockLogger);
-            // Assert
-            const writeCall = mockedFs.writeFileSync.mock.calls[0];
-            const [filePath, content] = writeCall;
-            expect(filePath).toBe('/test/output/../appschemas/dataSourcesInfo.ts');
-            expect(content).toContain('/*!');
-            expect(content).toContain(' * Copyright (C) Microsoft Corporation. All rights reserved.');
-            expect(content).toContain(' * This file is auto-generated. Do not modify it manually.');
-            expect(content).toContain('export const dataSourcesInfo = ');
-            expect(content).toMatch(/;\s*$/); // Should end with semicolon
-        });
-    });
-});
-//# sourceMappingURL=dataSourceInfoProcessor.test.js.map