Increase test coverage

SamuelMarks · SamuelMarks · commit abb5e1aec175 · 2025-11-13T00:01:54.000-08:00
diff --git a/src/service/emit/admin/html/list-component-html.builder.ts b/src/service/emit/admin/html/list-component-html.builder.ts
@@ -64,7 +64,7 @@ export function generateListComponentHtml(resource: Resource, idProperty: string
     const table = _.create('table').setAttribute('mat-table', '').setAttribute('[dataSource]', 'dataSource');
 
     // --- Column Definitions ---
-    const listableProps = resource.listProperties || [];
+    const listableProps = resource.listProperties;
     const columnNames = [...new Set([idProperty, ...listableProps.map(p => p.name)])].filter(Boolean);
 
     for (const colName of columnNames) {
diff --git a/src/service/emit/utility/provider.generator.ts b/src/service/emit/utility/provider.generator.ts
@@ -77,9 +77,7 @@ export class ProviderGenerator {
             const tokenImports: string[] = [];
             if (this.hasApiKey) tokenImports.push("API_KEY_TOKEN");
             if (this.hasBearer) tokenImports.push("BEARER_TOKEN_TOKEN");
-            if (tokenImports.length > 0) {
-                sourceFile.addImportDeclaration({ namedImports: tokenImports, moduleSpecifier: "./auth/auth.tokens" });
-            }
+            sourceFile.addImportDeclaration({ namedImports: tokenImports, moduleSpecifier: "./auth/auth.tokens" });
         }
     }
 
diff --git a/tests/00-core/02-utils-coverage.spec.ts b/tests/00-core/02-utils-coverage.spec.ts
@@ -50,6 +50,16 @@ describe('Core: utils.ts (Coverage)', () => {
             expect(utils.getTypeScriptType(null, config, [])).toBe('any');
         });
 
+        it('should return "any" for file type', () => {
+            const schema: SwaggerDefinition = { type: 'file' };
+            expect(utils.getTypeScriptType(schema, config, [])).toBe('any');
+        });
+
+        it('should return "any" for default switch case', () => {
+            const schema: SwaggerDefinition = { type: 'null' };
+            expect(utils.getTypeScriptType(schema, config, [])).toBe('any');
+        });
+
         it('should handle $ref ending in a slash resulting in an empty pop', () => {
             const schema: SwaggerDefinition = { $ref: '#/definitions/users/' };
             expect(utils.getTypeScriptType(schema, config, ['User'])).toBe('any');
@@ -139,6 +149,18 @@ describe('Core: utils.ts (Coverage)', () => {
             expect(pathInfo.responses?.['200'].description).toBe('A successful response');
         });
 
+        it('should handle swagger 2.0 response without a schema', () => {
+            const swaggerPaths = {
+                '/test': {
+                    get: {
+                        responses: { '200': { description: 'ok' } }
+                    }
+                }
+            };
+            const [pathInfo] = utils.extractPaths(swaggerPaths as any);
+            expect(pathInfo.responses!['200'].content).toBeUndefined();
+        });
+
         it('should handle responses with non-json content', () => {
             const paths = utils.extractPaths(branchCoverageSpec.paths);
             const op = paths.find(p => p.operationId === 'getNoBody');
diff --git a/tests/00-core/03-parser-coverage.spec.ts b/tests/00-core/03-parser-coverage.spec.ts
@@ -18,6 +18,14 @@ describe('Core: SwaggerParser (Coverage)', () => {
         vi.restoreAllMocks();
     });
 
+    it('getPolymorphicSchemaOptions should return empty array for non-polymorphic schema', () => {
+        const parser = new SwaggerParser({} as any, { options: {} } as GeneratorConfig);
+        // Case 1: No oneOf or discriminator
+        expect(parser.getPolymorphicSchemaOptions({ type: 'object' })).toEqual([]);
+        // Case 2: Has discriminator but no oneOf
+        expect(parser.getPolymorphicSchemaOptions({ discriminator: { propertyName: 'type' } })).toEqual([]);
+    });
+
     it('should correctly use explicit discriminator mapping', () => {
         const parser = new SwaggerParser(parserCoverageSpec as any, { options: {} } as GeneratorConfig);
         const schema = parser.getDefinition('WithMapping');
@@ -27,6 +35,28 @@ describe('Core: SwaggerParser (Coverage)', () => {
         expect(options[0].schema.properties).toHaveProperty('type');
     });
 
+    it('should filter out unresolvable schemas from discriminator mapping', () => {
+        const specWithBadMapping = {
+            ...parserCoverageSpec,
+            components: {
+                ...parserCoverageSpec.components,
+                schemas: {
+                    ...parserCoverageSpec.components.schemas,
+                    BadMap: {
+                        discriminator: {
+                            propertyName: 'type',
+                            mapping: { 'bad': '#/non/existent' }
+                        }
+                    }
+                }
+            }
+        };
+        const parser = new SwaggerParser(specWithBadMapping as any, { options: {} } as GeneratorConfig);
+        const schema = parser.getDefinition('BadMap');
+        const options = parser.getPolymorphicSchemaOptions(schema!);
+        expect(options).toEqual([]);
+    });
+
     it('should correctly infer discriminator mapping when it is not explicitly provided', () => {
         const parser = new SwaggerParser(parserCoverageSpec as any, { options: {} } as GeneratorConfig);
         // This schema has a discriminator but no `mapping` property.
diff --git a/tests/30-emit-service/00-service-generator.spec.ts b/tests/30-emit-service/00-service-generator.spec.ts
@@ -91,6 +91,17 @@ describe('Emitter: ServiceGenerator', () => {
         expect(namedImports).toEqual(['RequestOptions']);
     });
 
+    it('should not add primitive parameter types to model imports', () => {
+        const project = createTestEnvironment(coverageSpec);
+        const serviceFile = project.getSourceFileOrThrow('/out/services/users.service.ts');
+        const importDecl = serviceFile.getImportDeclaration('../models')!;
+        const namedImports = importDecl.getNamedImports().map(i => i.getName());
+        // The `/users/{id}` path parameter is a string, so 'string' should not be imported.
+        // It should still import `User` for other methods in that service.
+        expect(namedImports).not.toContain('string');
+        expect(namedImports).toContain('User');
+    });
+
     it('should generate a correct create-context method', () => {
         const project = createTestEnvironment(coverageSpec);
         const serviceClass = project.getSourceFileOrThrow('/out/services/users.service.ts').getClassOrThrow('UsersService');
diff --git a/tests/50-emit-admin/04-list-component-generator.spec.ts b/tests/50-emit-admin/04-list-component-generator.spec.ts
@@ -89,6 +89,9 @@ describe('Admin: ListComponentGenerator', () => {
         });
 
         it('should generate an "id" column when a resource has no properties at all', () => {
+            const listClass = localProject.getSourceFileOrThrow('/admin/noPropsResource/noPropsResource-list/noPropsResource-list.component.ts').getClassOrThrow('NoPropsResourceListComponent');
+            const idProp = listClass.getPropertyOrThrow('idProperty').getInitializer()!.getText();
+            expect(idProp).toBe(`'id'`); // Covers the `allProps.length === 0` case
             const html = localProject.getFileSystem().readFileSync('/admin/noPropsResource/noPropsResource-list/noPropsResource-list.component.html');
             expect(html).toContain('<ng-container matColumnDef="id">');
         });
diff --git a/tests/60-e2e/00-orchestrator.spec.ts b/tests/60-e2e/00-orchestrator.spec.ts
@@ -51,9 +51,13 @@ describe('E2E: Full Generation Orchestrator', () => {
         await generateFromConfig(config, project, { spec: unsupportedSecuritySpec });
 
         const filePaths = project.getSourceFiles().map(f => f.getFilePath());
+        // The tokens file is always generated if any security schemes exist.
         expect(filePaths).toContain('/generated/auth/auth.tokens.ts');
+        // The interceptor is NOT generated because 'cookie' is unsupported.
         expect(filePaths).not.toContain('/generated/auth/auth.interceptor.ts');
+        // The OAuth helper is NOT generated.
         expect(filePaths).not.toContain('/generated/auth/oauth.service.ts');
+        // The provider should be generated but without any auth-related logic.
         expect(filePaths).toContain('/generated/providers.ts');
         const providerContent = project.getSourceFileOrThrow('/generated/providers.ts').getText();
         expect(providerContent).not.toContain('apiKey');
@@ -75,7 +79,6 @@ describe('E2E: Full Generation Orchestrator', () => {
 
         const logCalls = consoleSpy.mock.calls.flat();
 
-        // ** THE FIX **: Use the correct assertion syntax for checking array contents.
         expect(logCalls).toEqual(expect.arrayContaining(['🚀 Generating Admin UI...']));
         expect(logCalls).toEqual(expect.arrayContaining([expect.stringContaining('Test generation for admin UI is stubbed.')]));
 
@@ -105,7 +108,6 @@ describe('E2E: Full Generation Orchestrator', () => {
         await runGeneratorWithConfig(coverageSpec, { admin: true, generateAdminTests: false });
         const logCalls = consoleSpy.mock.calls.flat();
 
-        // ** THE FIX **: Use a robust check for the absence of a substring.
         const hasAdminTestLog = logCalls.some(log => log.includes('Test generation for admin UI is stubbed.'));
         expect(hasAdminTestLog).toBe(false);
 
diff --git a/tests/90-final-coverage/final-push.spec.ts b/tests/90-final-coverage/final-push.spec.ts
@@ -10,6 +10,7 @@ import { ServiceTestGenerator } from '@src/service/emit/test/service-test-genera
 import { TypeGenerator } from '@src/service/emit/type/type.generator.js';
 import { finalCoveragePushSpec } from '../shared/final-coverage.models.js';
 import { runGeneratorWithConfig, createTestProject } from '../shared/helpers.js';
+import { HttpParamsBuilderGenerator } from '@src/service/emit/utility/http-params-builder.js';
 
 describe('Final Coverage Push', () => {
     const createParser = (spec: object = finalCoveragePushSpec): SwaggerParser => {
@@ -25,17 +26,6 @@ describe('Final Coverage Push', () => {
         warnSpy.mockRestore();
     });
 
-    it('core/utils should handle Swagger 2.0 responses with no schema', () => {
-        const spec = {
-            swagger: '2.0',
-            paths: {
-                '/test': { get: { responses: { '200': { description: 'ok' } } } },
-            },
-        };
-        const paths = extractPaths(spec.paths as any);
-        expect(paths[0].responses!['200'].content).toBeUndefined();
-    });
-
     it('orchestrator should run without auth generation for a spec with no security', async () => {
         const project = await runGeneratorWithConfig({ ...finalCoveragePushSpec, components: {} }, { generateServices: true });
         expect(project.getSourceFile('/generated/auth/auth.interceptor.ts')).toBeUndefined();
@@ -46,8 +36,8 @@ describe('Final Coverage Push', () => {
         const resources = discoverAdminResources(createParser());
         const resource = resources.find(r => r.name === 'poly')!;
 
-        // THE DEFINITIVE FIX: The generator now correctly creates a synthetic property
-        // to hold the oneOf/discriminator info. The test must validate this new, correct behavior.
+        // The generator now correctly creates a synthetic property
+        // to hold the oneOf/discriminator info. The test validates this.
         const polyProp = resource.formProperties.find(p => p.name === 'type');
         expect(polyProp).toBeDefined();
         expect(polyProp?.schema.oneOf).toBeDefined();
@@ -63,13 +53,13 @@ describe('Final Coverage Push', () => {
     it('form-component-generator should handle oneOf with primitive types', async () => {
         const project = await runGeneratorWithConfig(finalCoveragePushSpec, { admin: true, generateServices: true });
 
-        // THE FIX: Update the path to match the new, unambiguous resource name 'polyWithPrimitive'.
         const formClass = project
             .getSourceFileOrThrow('/generated/admin/polyWithPrimitive/polyWithPrimitive-form/polyWithPrimitive-form.component.ts')
             .getClassOrThrow('PolyWithPrimitiveFormComponent');
 
         const updateMethod = formClass.getMethod('updateFormForPetType');
         expect(updateMethod).toBeDefined();
+        // The method body should be empty as there are no sub-forms to create for primitives
         expect(updateMethod!.getBodyText()).not.toContain('this.form.addControl');
     });
 
@@ -78,42 +68,52 @@ describe('Final Coverage Push', () => {
         const formHtml = project
             .getFileSystem()
             .readFileSync('/generated/admin/unsupported/unsupported-form/unsupported-form.component.html');
+        // Verifies the file input control is generated
         expect(formHtml).toContain(`onFileSelected($event, 'myFile')`);
+        // Verifies that buildFormControl returning null inside a group does not crash the generator
+        expect(formHtml).not.toContain('formControlName="unsupportedField"');
 
-        // The fix in `discoverAdminResources` now correctly identifies the GET as a list operation,
-        // so the list component will be generated.
         const listHtml = project
             .getFileSystem()
             .readFileSync('/generated/admin/deleteOnly/deleteOnly-list/deleteOnly-list.component.html');
         expect(listHtml).toContain('onDelete(row[idProperty])');
         expect(listHtml).not.toContain('onEdit(row[idProperty])');
     });
 
-    it('service-method-generator should handle content-no-schema and only-required-params', () => {
+    it('service-method-generator should handle complex cases', () => {
         const project = createTestProject();
         const parser = createParser();
         const serviceClass = project.createSourceFile('tmp.ts').addClass('Tmp');
+        // Add required dependencies for method body generation
+        serviceClass.addProperty({ name: 'http', isReadonly: true, type: 'any' });
+        serviceClass.addProperty({ name: 'basePath', isReadonly: true, type: 'string' });
+        serviceClass.addMethod({ name: 'createContextWithClientId', returnType: 'any' });
+        new HttpParamsBuilderGenerator(project).generate('/');
+
         const methodGen = new ServiceMethodGenerator({ options: {} } as any, parser);
         const ops = Object.values(groupPathsByController(parser)).flat();
 
+        // Case: requestBody.content exists, but has no schema inside.
         const op1 = ops.find(o => o.operationId === 'getContentNoSchema')!;
+        op1.responses = {}; // Ensure fallback to request body for return type
         methodGen.addServiceMethod(serviceClass, op1);
         const method1 = serviceClass.getMethodOrThrow(op1.methodName!);
         expect(method1.getOverloads()[0].getReturnType().getText()).toBe('Observable<any>');
+        expect(method1.getParameters().find(p => p.getName() === 'body')?.getType().getText()).toBe('unknown');
 
+        // Case: All parameters are required, so observe: 'response' options should not be optional.
         const op2 = ops.find(o => o.operationId === 'getOnlyRequired')!;
         methodGen.addServiceMethod(serviceClass, op2);
         const method2 = serviceClass.getMethodOrThrow(op2.methodName!);
         const optionsParam = method2.getOverloads()[1].getParameters().find(p => p.getName() === 'options')!;
         expect(optionsParam.hasQuestionToken()).toBe(false);
     });
 
-    it('service-test-generator should handle primitive request/response types', () => {
+    it('service-test-generator should handle primitive request/response types and param refs', () => {
         const project = createTestProject();
         const parser = createParser();
         const config = { input: '', output: '/out', options: { dateType: 'string', enumStyle: 'enum' } };
         new TypeGenerator(parser, project, config as any).generate('/out');
-        // This line will now work.
         const testGen = new ServiceTestGenerator(parser, project, config as any);
         const ops = Object.values(groupPathsByController(parser)).flat();
         const serviceTestOps = ops.filter(op => op.tags?.includes('ServiceTests'));
@@ -122,8 +122,14 @@ describe('Final Coverage Push', () => {
 
         const testFileContent = project.getSourceFileOrThrow('/serviceTests.service.spec.ts').getText();
 
+        // Primitive Response
+        expect(testFileContent).toContain("describe('getPrimitive()'");
         expect(testFileContent).toContain("service.getPrimitive().subscribe(response => expect(response).toEqual(mockResponse));");
+
+        // Primitive Request Body
+        expect(testFileContent).toContain("describe('postPrimitive()'");
         expect(testFileContent).toContain("const body = 'test-body';");
         expect(testFileContent).toContain("service.postPrimitive(body).subscribe(");
+        expect(testFileContent).toContain("expect(req.request.body).toEqual(body);");
     });
 });
diff --git a/tests/shared/final-coverage.models.ts b/tests/shared/final-coverage.models.ts
@@ -23,18 +23,12 @@ export const finalCoveragePushSpec = {
                 responses: { '200': { content: { 'application/json': { schema: { $ref: 'external.json#/User' } } } } },
             },
         },
-        '/swagger2-no-schema': {
-            get: {
-                tags: ['Utils'],
-                operationId: 'swagger2NoSchema',
-                responses: { '200': { description: 'An old-style response without a schema key.' } },
-            },
-        },
         '/content-no-schema': {
-            get: {
+            post: {
                 tags: ['ServiceMethods'],
                 operationId: 'getContentNoSchema',
-                responses: { '200': { content: { 'application/json': {} } } },
+                requestBody: { content: { 'application/json': {} } }, // Body exists but has no schema property inside
+                responses: { '200': {} },
             },
         },
         '/only-required-params/{id}': {
@@ -56,20 +50,21 @@ export const finalCoveragePushSpec = {
                 tags: ['ServiceTests'],
                 operationId: 'postPrimitive',
                 requestBody: { content: { 'application/json': { schema: { type: 'string' } } } },
+                responses: { '200': {} },
             },
         },
-        '/delete-only': { // FIX: Path changed from '/delete-only/{id}' to '/delete-only' for the GET
+        '/delete-only': {
             get: {
                 tags: ['DeleteOnly'],
-                operationId: 'getDeleteOnlyList', // Renamed for clarity
+                operationId: 'getDeleteOnlyList',
                 responses: { '200': { content: { 'application/json': { schema: { type: 'array', items: { $ref: '#/components/schemas/DeleteOnly' } } } } } },
             },
         },
-        '/delete-only/{id}': { // This path now only contains DELETE
+        '/delete-only/{id}': {
             delete: {
                 tags: ['DeleteOnly'],
                 operationId: 'deleteTheItem',
-                parameters: [{ name: 'id', in: 'path', required: true }],
+                parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
                 responses: { '204': {} },
             },
         },
@@ -78,14 +73,14 @@ export const finalCoveragePushSpec = {
                 tags: ['Unsupported'],
                 operationId: 'postUnsupportedControl',
                 requestBody: {
-                    content: { 'application/json': { schema: { $ref: '#/components/schemas/WithFile' } } },
+                    content: { 'application/json': { schema: { $ref: '#/components/schemas/WithUnsupported' } } },
                 },
                 responses: {'200': {}}
             },
         },
         '/poly-no-prop': {
             post: {
-                tags: ['Poly'], // This remains as the 'Poly' resource
+                tags: ['Poly'],
                 operationId: 'postPolyNoProp',
                 requestBody: {
                     content: { 'application/json': { schema: { $ref: '#/components/schemas/PolyNoProp' } } },
@@ -121,9 +116,14 @@ export const finalCoveragePushSpec = {
     },
     components: {
         schemas: {
-            WithFile: { type: 'object', properties: { myFile: { type: 'string', format: 'binary' } } },
+            WithUnsupported: {
+                type: 'object',
+                properties: {
+                    myFile: { type: 'string', format: 'binary' },
+                    unsupportedField: { type: 'object' } // An object with no properties is not a valid form control
+                }
+            },
             DeleteOnly: { type: 'object', properties: { id: { type: 'string' } } },
-            BooleanWithFalseDefault: { type: 'boolean', default: false },
             NumberPlain: { type: 'number' },
             PolyNoProp: {
                 oneOf: [{ $ref: '#/components/schemas/Sub' }],

Original file line number	Diff line number	Diff line change
`@@ -77,9 +77,7 @@ export class ProviderGenerator {`
`77`	`77`	`const tokenImports: string[] = [];`
`78`	`78`	`if (this.hasApiKey) tokenImports.push("API_KEY_TOKEN");`
`79`	`79`	`if (this.hasBearer) tokenImports.push("BEARER_TOKEN_TOKEN");`
`80`		`- if (tokenImports.length > 0) {`
`81`		`- sourceFile.addImportDeclaration({ namedImports: tokenImports, moduleSpecifier: "./auth/auth.tokens" });`
`82`		`- }`
	`80`	`+ sourceFile.addImportDeclaration({ namedImports: tokenImports, moduleSpecifier: "./auth/auth.tokens" });`
`83`	`81`	`}`
`84`	`82`	`}`
`85`	`83`