Implement second version of service test generation; this time with more test coverage!

Author: SamuelMarks

src/core/utils.ts

@@ -103,8 +103,6 @@ export function getTypeScriptType(schema: SwaggerDefinition | undefined | null,
         return 'any';
     }
 
-    // **FIX**: The `type: 'file'` from Swagger 2 is now handled explicitly in the service method generator.
-    // This function can now safely return 'any', knowing it will be caught and refined later.
     if ((schema as any).type === 'file') {
         return 'any';
     }
@@ -113,7 +111,6 @@ export function getTypeScriptType(schema: SwaggerDefinition | undefined | null,
         const typeName = pascalCase(schema.$ref.split('/').pop() || '');
         return typeName && knownTypes.includes(typeName) ? typeName : 'any';
     }
-    // ... (rest of getTypeScriptType remains the same) ...
     if (schema.allOf) {
         const parts = schema.allOf
             .map(s => getTypeScriptType(s, config, knownTypes))
@@ -242,7 +239,6 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
 
                 const allParams = Array.from(paramsMap.values());
 
-                // **FIX START**: We no longer filter out 'formData'. It's treated like any other parameter type now.
                 const nonBodyParams = allParams.filter(p => p.in !== 'body');
                 const bodyParam = allParams.find(p => p.in === 'body') as BodyParameter | undefined;
 
@@ -255,14 +251,12 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
 
                     return {
                         name,
-                        // Cast 'formData' to a valid 'in' type for our internal model. The service generator will handle the distinction.
                         in: paramIn as "query" | "path" | "header" | "cookie",
                         required,
                         schema,
                         description
                     }
                 });
-                // **FIX END**
 
                 const requestBody = (operation as any).requestBody
                     || (bodyParam ? { content: { 'application/json': { schema: bodyParam.schema } } } : undefined);
@@ -286,12 +280,8 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
 
                 paths.push({
                     path,
-                    // FIX: THE CRITICAL CHANGE IS HERE.
-                    // The `operation` object contains `operationId`, `summary`, etc.
-                    // We must spread it to include all its properties in the final PathInfo.
                     ...operation,
                     method: method.toUpperCase(),
-                    // redundant properties will be overwritten correctly by the spread.
                     parameters,
                     requestBody: requestBody as RequestBody | undefined,
                     responses: normalizedResponses,
@@ -308,6 +298,7 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
  * @param config The generator configuration.
  * @param knownTypes An array of known schema names for type resolution.
  * @returns A string representing the TypeScript type for the request body.
+ * @internal
  */
 export function getRequestBodyType(requestBody: RequestBody | undefined, config: GeneratorConfig, knownTypes: string[]): string {
     const schema = requestBody?.content?.['application/json']?.schema;
@@ -320,6 +311,7 @@ export function getRequestBodyType(requestBody: RequestBody | undefined, config:
  * @param config The generator configuration.
  * @param knownTypes An array of known schema names for type resolution.
  * @returns A string representing the TypeScript type for the response body.
+ * @internal
  */
 export function getResponseType(response: SwaggerResponse | undefined, config: GeneratorConfig, knownTypes: string[]): string {
     const schema = response?.content?.['application/json']?.schema;

src/service/emit/orchestrator.ts

@@ -51,12 +51,15 @@ export async function emitClientLibrary(outputRoot: string, parser: SwaggerParse
             new DateTransformerGenerator(project).generate(outputRoot);
         }
 
+        // Check for security schemes to determine if auth-related utilities are needed.
         const securitySchemes = parser.getSecuritySchemes();
         let tokenNames: string[] = [];
         if (Object.keys(securitySchemes).length > 0) {
             new AuthTokensGenerator(project).generate(outputRoot);
 
             const interceptorGenerator = new AuthInterceptorGenerator(parser, project);
+            // generate() returns the names of the tokens used (e.g., 'apiKey', 'bearerToken'),
+            // which the ProviderGenerator needs to create the correct configuration interface.
             // The generator is only called when schemes exist, so the result will always be defined.
             const interceptorResult = interceptorGenerator.generate(outputRoot)!;
             tokenNames = interceptorResult.tokenNames;
@@ -70,7 +73,6 @@ export async function emitClientLibrary(outputRoot: string, parser: SwaggerParse
         new ProviderGenerator(parser, project, tokenNames).generate(outputRoot);
 
         console.log('✅ Utilities and providers generated.');
-        // Stub for Service Test Generation
         if (config.options.generateServiceTests ?? true) {
             console.log('📝 Generating tests for services...');
             const testGenerator = new ServiceTestGenerator(parser, project, config);
@@ -85,7 +87,6 @@ export async function emitClientLibrary(outputRoot: string, parser: SwaggerParse
             await new AdminGenerator(parser, project, config).generate(outputRoot);
             if (config.options.generateAdminTests ?? true) {
                 console.log('📝 Test generation for admin UI is stubbed.');
-                // Future implementation: new AdminTestGenerator(parser, project, config).generate(outputRoot);
             }
         }
     }

src/service/emit/service/service-method.generator.ts

@@ -1,8 +1,5 @@
-// src/service/emit/service/service-method.generator.ts
-
 import {
     ClassDeclaration,
-    MethodDeclarationStructure,
     OptionalKind,
     ParameterDeclarationStructure,
     MethodDeclarationOverloadStructure,
@@ -11,6 +8,11 @@ import { GeneratorConfig, PathInfo, SwaggerDefinition } from '../../../core/type
 import { SwaggerParser } from '../../../core/parser.js';
 import { getTypeScriptType, camelCase, isDataTypeInterface } from '../../../core/utils.js';
 
+/**
+ * Generates individual methods within a generated Angular service class.
+ * This class handles parameter mapping, response type resolution, method body construction,
+ * and the creation of observable-based method overloads for different response types.
+ */
 export class ServiceMethodGenerator {
     constructor(
         private readonly config: GeneratorConfig,

src/service/emit/service/service.generator.ts

@@ -8,7 +8,6 @@ import { camelCase, pascalCase, getBasePathTokenName, getClientContextTokenName,
 import { SERVICE_GENERATOR_HEADER_COMMENT } from '../../../core/constants.js';
 import { ServiceMethodGenerator } from './service-method.generator.js';
 
-// ... (keep path_to_method_name_suffix function as is) ...
 function path_to_method_name_suffix(path: string): string {
     return path.split('/').filter(Boolean).map(segment => {
         if (segment.startsWith('{') && segment.endsWith('}')) {
@@ -35,7 +34,6 @@ export class ServiceGenerator {
         const knownTypes = this.parser.schemas.map(s => s.name);
         const modelImports = new Set<string>(['RequestOptions']);
 
-        // ... (keep model import discovery logic as is) ...
         for (const op of operations) {
             const successResponse = op.responses?.['200'] ?? op.responses?.['201'] ?? op.responses?.['default'];
             if (successResponse?.content?.['application/json']?.schema) {
@@ -65,7 +63,6 @@ export class ServiceGenerator {
         const serviceClass = this.addClass(sourceFile, className);
         this.addPropertiesAndHelpers(serviceClass);
 
-        const usedMethodNames = new Set<string>();
         operations.forEach(op => {
             let methodName: string;
             const customizer = this.config.options?.customizeMethodName;
@@ -77,21 +74,13 @@ export class ServiceGenerator {
                     : `${op.method.toLowerCase()}${path_to_method_name_suffix(op.path)}`;
             }
 
-            let uniqueMethodName = methodName;
-            let counter = 1;
-            while (usedMethodNames.has(uniqueMethodName)) {
-                uniqueMethodName = `${methodName}${++counter}`;
-            }
-            usedMethodNames.add(uniqueMethodName);
-            op.methodName = uniqueMethodName;
-
+            // Method name de-duplication is now handled in `groupPathsByController`
             this.methodGenerator.addServiceMethod(serviceClass, op);
         });
     }
 
     private addImports(sourceFile: SourceFile, modelImports: Set<string>): void {
         sourceFile.addImportDeclarations([
-            // **FIX**: Added `HttpHeaders` to the imports for use in the method generator.
             { moduleSpecifier: '@angular/core', namedImports: ['Injectable', 'inject'] },
             { moduleSpecifier: '@angular/common/http', namedImports: ['HttpClient', 'HttpContext', 'HttpParams', 'HttpResponse', 'HttpEvent', 'HttpHeaders', 'HttpContextToken'] },
             { moduleSpecifier: 'rxjs', namedImports: ['Observable'] },
@@ -114,7 +103,6 @@ export class ServiceGenerator {
         serviceClass.addProperty({ name: 'basePath', scope: Scope.Private, isReadonly: true, type: 'string', initializer: `inject(${getBasePathTokenName(this.config.clientName)})` });
         const clientContextTokenName = getClientContextTokenName(this.config.clientName);
 
-        // **FIX**: Correctly type the property without an inline import().
         serviceClass.addProperty({ name: "clientContextToken", type: `HttpContextToken<string>`, scope: Scope.Private, isReadonly: true, initializer: clientContextTokenName });
 
         serviceClass.addMethod({

src/service/emit/test/mock-data.generator.ts

@@ -1,35 +1,36 @@
 import { SwaggerParser } from '../../../core/parser.js';
 import { SwaggerDefinition } from '../../../core/types.js';
-import { pascalCase } from '../../../core/utils.js';
 
 /**
  * Generates mock data objects from OpenAPI schemas for use in tests.
+ * It recursively traverses schema definitions to produce a representative
+ * object with placeholder values, respecting formats and compositions (`allOf`).
  */
 export class MockDataGenerator {
     constructor(private parser: SwaggerParser) {}
 
-    /**
-     * Generates a TypeScript code string representing a mock object for a given schema.
-     * @param schemaName The PascalCase name of the schema (e.g., 'User').
-     * @returns A string of the mock object, e.g., `{ id: '1', name: 'user-name' }`.
-     */
     public generate(schemaName: string): string {
         const schema = this.parser.schemas.find(s => s.name === schemaName)?.definition;
         if (!schema) {
             return '{}';
         }
         const mockObject = this.generateValue(schema, new Set());
-        // Pretty-print the object string
         return JSON.stringify(mockObject, null, 2);
     }
 
+    /**
+     * The core recursive value generation logic.
+     * @param schema The schema definition to generate a value for.
+     * @param visited A set to track visited schemas and prevent infinite recursion in cyclic definitions.
+     * @returns A mock value (e.g., object, string, number) corresponding to the schema.
+     * @private
+     */
     private generateValue(schema: SwaggerDefinition, visited: Set<SwaggerDefinition>): any {
         if (schema.example) {
             return schema.example;
         }
 
         if (visited.has(schema)) {
-            // Avoid infinite recursion
             return {};
         }
         visited.add(schema);
@@ -59,9 +60,9 @@ export class MockDataGenerator {
                 return 'string-value';
             case 'number':
             case 'integer':
-                return schema.minimum ?? 123;
+                return schema.minimum ?? (schema.default ?? 123);
             case 'boolean':
-                return true;
+                return schema.default ?? true;
             case 'array':
                 if (schema.items && !Array.isArray(schema.items)) {
                     return [this.generateValue(schema.items as SwaggerDefinition, visited)];
@@ -71,7 +72,10 @@ export class MockDataGenerator {
                 const obj: Record<string, any> = {};
                 if (schema.properties) {
                     for (const [propName, propSchema] of Object.entries(schema.properties)) {
-                        obj[propName] = this.generateValue(propSchema, visited);
+                        // Per OpenAPI spec, readOnly properties should not be sent in request bodies.
+                        if (!propSchema.readOnly) {
+                            obj[propName] = this.generateValue(propSchema, visited);
+                        }
                     }
                 }
                 visited.delete(schema);

src/service/emit/test/service-test.generator.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { Project, ClassDeclaration, SourceFile } from 'ts-morph';
+import { Project, SourceFile } from 'ts-morph';
 import { SwaggerParser } from '../../../core/parser.js';
 import { GeneratorConfig, PathInfo } from '../../../core/types.js';
 import {
@@ -11,6 +11,12 @@ import {
 } from '../../../core/utils.js';
 import { MockDataGenerator } from './mock-data.generator.js';
 
+/**
+ * Generates Angular service test files (`.spec.ts`) for each generated service.
+ * This class creates a standard Angular testing setup with `TestBed`, mocks for `HttpClient`,
+ * and generates `describe` and `it` blocks for each service method, covering both
+ * success and error scenarios.
+ */
 export class ServiceTestGenerator {
     private mockDataGenerator: MockDataGenerator;
 
@@ -22,6 +28,12 @@ export class ServiceTestGenerator {
         this.mockDataGenerator = new MockDataGenerator(parser);
     }
 
+    /**
+     * Generates a complete test file for a single service (controller).
+     * @param controllerName The PascalCase name of the controller (e.g., 'Users').
+     * @param operations The list of operations belonging to this controller.
+     * @param outputDir The directory where the `services` folder is located.
+     */
     public generateServiceTestFile(controllerName: string, operations: PathInfo[], outputDir: string): void {
         const serviceName = `${pascalCase(controllerName)}Service`;
         const testFileName = `${camelCase(controllerName)}.service.spec.ts`;
@@ -63,6 +75,12 @@ export class ServiceTestGenerator {
         sourceFile.formatText();
     }
 
+    /**
+     * Generates the `describe` and `it` blocks for each method in a service.
+     * @param operations The operations to generate tests for.
+     * @returns An array of strings, each representing a line in the generated test file.
+     * @private
+     */
     private generateMethodTests(operations: PathInfo[]): string[] {
         const tests: string[] = [];
         for (const op of operations) {
@@ -87,16 +105,19 @@ export class ServiceTestGenerator {
             // Happy Path Test
             tests.push(`    it('should return ${responseType} on success', () => {`);
             if (responseModel) {
-                const mockResponse = this.mockDataGenerator.generate(responseModel);
-                tests.push(`      const mockResponse: ${responseModel} = ${mockResponse};`);
+                const singleMock = this.mockDataGenerator.generate(responseModel);
+                // FIX: Check if the full response type is an array and wrap the mock data accordingly.
+                const isArray = responseType.endsWith('[]');
+                const mockResponse = isArray ? `[${singleMock}]` : singleMock;
+                tests.push(`      const mockResponse: ${responseType} = ${mockResponse};`);
             } else {
                 tests.push(`      const mockResponse = null;`);
             }
             if (bodyParam?.model) {
                 const mockBody = this.mockDataGenerator.generate(bodyParam.model);
                 tests.push(`      const ${bodyParam.name}: ${bodyParam.model} = ${mockBody};`);
             } else if (bodyParam) {
-                tests.push(`      const ${bodyParam.name} = 'test-body';`);
+                tests.push(`      const ${bodyParam.name} = { data: 'test-body' };`);
             }
 
             params.forEach(p => tests.push(`      const ${p.name} = ${p.value};`));
@@ -122,7 +143,7 @@ export class ServiceTestGenerator {
                 const mockBody = this.mockDataGenerator.generate(bodyParam.model);
                 tests.push(`      const ${bodyParam.name}: ${bodyParam.model} = ${mockBody};`);
             } else if (bodyParam) {
-                tests.push(`      const ${bodyParam.name} = 'test-body';`);
+                tests.push(`      const ${bodyParam.name} = { data: 'test-body' };`);
             }
             params.forEach(p => tests.push(`      const ${p.name} = ${p.value};`));
 
@@ -142,6 +163,12 @@ export class ServiceTestGenerator {
         return tests;
     }
 
+    /**
+     * Adds all necessary import statements to the test file.
+     * @param sourceFile The ts-morph SourceFile object.
+     * @param serviceName The name of the service class being tested.
+     * @param modelImports A list of model names that need to be imported.
+     */
     private addImports(sourceFile: SourceFile, serviceName: string, modelImports: string[]): void {
         sourceFile.addImportDeclarations([
             { moduleSpecifier: '@angular/core/testing', namedImports: ['TestBed'] },
@@ -152,19 +179,33 @@ export class ServiceTestGenerator {
         ]);
     }
 
+    /**
+     * Extracts the TypeScript type names for a method's response and request body.
+     * @param op The operation to analyze.
+     * @returns An object containing the model names for the response and body, if they are complex types.
+     * @private
+     */
     private getMethodTypes(op: PathInfo): { responseModel?: string, responseType: string, bodyModel?: string } {
         const knownTypes = this.parser.schemas.map(s => s.name);
         const successResponseSchema = op.responses?.['200']?.content?.['application/json']?.schema;
         const responseType = successResponseSchema ? getTypeScriptType(successResponseSchema as any, this.config, knownTypes) : 'any';
-        const responseModel = isDataTypeInterface(responseType.replace(/\[\]| \| null/g, '')) ? responseType.replace(/\[\]| \| null/g, '') : undefined;
+        const responseModelType = responseType.replace(/\[\]| \| null/g, '');
+        const responseModel = isDataTypeInterface(responseModelType) ? responseModelType : undefined;
 
         const requestBodySchema = op.requestBody?.content?.['application/json']?.schema;
         const bodyType = requestBodySchema ? getTypeScriptType(requestBodySchema as any, this.config, knownTypes) : 'any';
-        const bodyModel = isDataTypeInterface(bodyType.replace(/\[\]| \| null/g, '')) ? bodyType.replace(/\[\]| \| null/g, '') : undefined;
+        const bodyModelType = bodyType.replace(/\[\]| \| null/g, '');
+        const bodyModel = isDataTypeInterface(bodyModelType) ? bodyModelType : undefined;
 
         return { responseModel, responseType, bodyModel };
     }
 
+    /**
+     * Scans all operations for a service to collect a unique set of model names that need to be imported.
+     * @param operations The list of operations for the service.
+     * @returns A Set containing the names of all required model imports.
+     * @private
+     */
     private collectModelImports(operations: PathInfo[]): Set<string> {
         const modelImports = new Set<string>();
         for (const op of operations) {