Increase test coverage

Author: SamuelMarks

src/service/emit/orchestrator.ts

@@ -1,3 +1,5 @@
+// src/service/emit/orchestrator.ts
+
 import { Project } from 'ts-morph';
 import { posix as path } from 'path';
 import { groupPathsByController } from '../parse.js';
@@ -53,16 +55,16 @@ export async function emitClientLibrary(outputRoot: string, parser: SwaggerParse
 
         // Check for security schemes to determine if auth-related utilities are needed.
         const securitySchemes = parser.getSecuritySchemes();
-        let tokenNames: string[] = [];
+        let tokenNames: string[] = []; // Default to an empty array
         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;
+            const interceptorResult = interceptorGenerator.generate(outputRoot);
+            // FIX: Ensure tokenNames is always an array, even if the interceptor isn't generated.
+            tokenNames = interceptorResult?.tokenNames || [];
 
             if (Object.values(securitySchemes).some(s => s.type === 'oauth2')) {
                 new OAuthHelperGenerator(parser, project).generate(outputRoot);

src/service/emit/utility/auth-interceptor.generator.ts

@@ -15,21 +15,26 @@ export class AuthInterceptorGenerator {
      * @param parser The `SwaggerParser` instance for accessing spec details.
      * @param project The `ts-morph` project for AST manipulation.
      */
-    constructor(private parser: SwaggerParser, private project: Project) { }
+    constructor(private parser: SwaggerParser, private project: Project) {}
 
     /**
-     * Generates the auth interceptor file if any security schemes are defined in the spec.
-     * It analyzes the schemes to determine which tokens (API key, Bearer) are needed and
-     * generates the corresponding injection logic.
+     * Generates the auth interceptor file if any **supported** security schemes are defined in the spec.
+     * A scheme is supported if it's an `apiKey` in the header/query or an `http`/`oauth2` bearer token.
      *
      * @param outputDir The root output directory.
-     * @returns An object containing the names of the tokens used (e.g., `['apiKey', 'bearerToken']`),
-     *          or `void` if no security schemes are found and no file is generated.
+     * @returns An object containing the names of the tokens for supported schemes (e.g., `['apiKey', 'bearerToken']`),
+     *          or `void` if no supported security schemes are found and no file is generated.
      */
     public generate(outputDir: string): { tokenNames: string[] } | void {
         const securitySchemes = Object.values(this.parser.getSecuritySchemes());
-        if (securitySchemes.length === 0) {
-            return; // Don't generate if no security schemes are defined.
+
+        // FIX: Determine which types of authentication are SUPPORTED by this interceptor.
+        const hasSupportedApiKey = securitySchemes.some(s => s.type === 'apiKey' && (s.in === 'header' || s.in === 'query'));
+        const hasBearer = securitySchemes.some(s => (s.type === 'http' && s.scheme === 'bearer') || s.type === 'oauth2');
+
+        // If no supported schemes are found, do not generate the file at all.
+        if (!hasSupportedApiKey && !hasBearer) {
+            return;
         }
 
         const authDir = path.join(outputDir, 'auth');
@@ -38,13 +43,10 @@ export class AuthInterceptorGenerator {
 
         sourceFile.insertText(0, UTILITY_GENERATOR_HEADER_COMMENT);
 
-        const hasApiKey = securitySchemes.some(s => s.type === 'apiKey');
-        const hasBearer = securitySchemes.some(s => (s.type === 'http' && s.scheme === 'bearer') || s.type === 'oauth2');
-
         const tokenImports: string[] = [];
         const tokenNames: string[] = []; // This will be the return value
 
-        if (hasApiKey) {
+        if (hasSupportedApiKey) {
             tokenImports.push('API_KEY_TOKEN');
             tokenNames.push('apiKey');
         }
@@ -54,28 +56,42 @@ export class AuthInterceptorGenerator {
         }
 
         sourceFile.addImportDeclarations([
-            { moduleSpecifier: '@angular/common/http', namedImports: ['HttpEvent', 'HttpHandler', 'HttpInterceptor', 'HttpRequest'] },
+            {
+                moduleSpecifier: '@angular/common/http',
+                namedImports: ['HttpEvent', 'HttpHandler', 'HttpInterceptor', 'HttpRequest'],
+            },
             { moduleSpecifier: '@angular/core', namedImports: ['inject', 'Injectable'] },
             { moduleSpecifier: 'rxjs', namedImports: ['Observable'] },
-            { moduleSpecifier: './auth.tokens', namedImports: tokenImports }
+            { moduleSpecifier: './auth.tokens', namedImports: tokenImports },
         ]);
 
         const interceptorClass = sourceFile.addClass({
             name: `AuthInterceptor`,
             isExported: true,
             decorators: [{ name: 'Injectable', arguments: [`{ providedIn: 'root' }`] }],
             implements: ['HttpInterceptor'],
-            docs: ["Intercepts HTTP requests to apply authentication credentials based on OpenAPI security schemes."]
+            docs: ['Intercepts HTTP requests to apply authentication credentials based on OpenAPI security schemes.'],
         });
 
-        if (hasApiKey) {
-            interceptorClass.addProperty({ name: 'apiKey', isReadonly: true, scope: Scope.Private, type: 'string | null', initializer: `inject(API_KEY_TOKEN, { optional: true })` });
+        if (hasSupportedApiKey) {
+            interceptorClass.addProperty({
+                name: 'apiKey',
+                isReadonly: true,
+                scope: Scope.Private,
+                type: 'string | null',
+                initializer: `inject(API_KEY_TOKEN, { optional: true })`,
+            });
         }
         if (hasBearer) {
-            interceptorClass.addProperty({ name: 'bearerToken', isReadonly: true, scope: Scope.Private, type: '(string | (() => string)) | null', initializer: `inject(BEARER_TOKEN_TOKEN, { optional: true })` });
+            interceptorClass.addProperty({
+                name: 'bearerToken',
+                isReadonly: true,
+                scope: Scope.Private,
+                type: '(string | (() => string)) | null',
+                initializer: `inject(BEARER_TOKEN_TOKEN, { optional: true })`,
+            });
         }
 
-        // FIX: The logic is refactored to chain clones correctly, preventing overwrites.
         let statementsBody = 'let authReq = req;';
 
         const uniqueSchemes = Array.from(new Set(securitySchemes.map(s => JSON.stringify(s)))).map(s => JSON.parse(s));
@@ -88,7 +104,6 @@ export class AuthInterceptorGenerator {
                     statementsBody += `\nif (this.apiKey) { authReq = authReq.clone({ setParams: { ...authReq.params.keys().reduce((acc, key) => ({ ...acc, [key]: authReq.params.getAll(key) }), {}), '${scheme.name}': this.apiKey } }); }`;
                 }
             } else if ((scheme.type === 'http' && scheme.scheme === 'bearer') || scheme.type === 'oauth2') {
-                // De-duplication check for bearer tokens
                 if (!statementsBody.includes('this.bearerToken')) {
                     statementsBody += `\nif (this.bearerToken) { const token = typeof this.bearerToken === 'function' ? this.bearerToken() : this.bearerToken; if (token) { authReq = authReq.clone({ setHeaders: { ...authReq.headers.keys().reduce((acc, key) => ({ ...acc, [key]: authReq.headers.getAll(key) }), {}), 'Authorization': \`Bearer \${token}\` } }); } }`;
                 }

tests/00-core/02-utils-coverage.spec.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 
 import * as utils from '../../src/core/utils.js';
 import { GeneratorConfig, SwaggerDefinition } from '../../src/core/types.js';
-import { typeGenSpec } from '../shared/specs.js';
+import { branchCoverageSpec, typeGenSpec } from '../shared/specs.js';
 
 /**
  * @fileoverview
@@ -51,6 +51,22 @@ describe('Core: utils.ts (Coverage)', () => {
         expect(utils.extractPaths(undefined)).toEqual([]);
     });
 
+    it('extractPaths should handle operations with no request body or body param', () => {
+        const paths = utils.extractPaths(branchCoverageSpec.paths);
+        const op = paths.find(p => p.operationId === 'getNoBody');
+        expect(op).toBeDefined();
+        // This covers the `... : undefined` branch for `requestBody`
+        expect(op!.requestBody).toBeUndefined();
+    });
+
+    it('extractPaths should handle responses with non-json content', () => {
+        const paths = utils.extractPaths(branchCoverageSpec.paths);
+        const op = paths.find(p => p.operationId === 'getNoBody');
+        expect(op).toBeDefined();
+        // The response should be normalized even if it's not JSON
+        expect(op!.responses!['200'].content!['text/plain'].schema).toEqual({ type: 'string' });
+    });
+
     it('getTypeScriptType should handle array with no items', () => {
         const schema: SwaggerDefinition = { type: 'array' };
         expect(utils.getTypeScriptType(schema, config, [])).toBe('any[]');

tests/00-core/03-parser-coverage.spec.ts

@@ -11,7 +11,7 @@ import { GeneratorConfig } from '@src/core/types.js';
  */
 describe('Core: SwaggerParser (Coverage)', () => {
     beforeEach(() => {
-        vi.spyOn(console, 'warn').mockImplementation(() => { });
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
     });
 
     afterEach(() => {
@@ -27,6 +27,16 @@ describe('Core: SwaggerParser (Coverage)', () => {
         expect(options[0].schema.properties).toHaveProperty('type');
     });
 
+    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.
+        const schema = parser.getDefinition('PolyWithInline');
+        const options = parser.getPolymorphicSchemaOptions(schema!);
+        // This covers the `|| {}` branch.
+        expect(options).toHaveLength(1);
+        expect(options[0].name).toBe('sub3'); // Inferred from the sub-schema's enum
+    });
+
     it('getPolymorphicSchemaOptions should handle oneOf items that are not refs', () => {
         const parser = new SwaggerParser(parserCoverageSpec as any, { options: {} } as GeneratorConfig);
         const schema = parser.getDefinition('PolyWithInline');
@@ -47,6 +57,8 @@ describe('Core: SwaggerParser (Coverage)', () => {
             // eslint-disable-next-line @typescript-eslint/no-throw-literal
             throw 'Network failure';
         });
-        await expect(SwaggerParser.create('http://bad.url', {} as GeneratorConfig)).rejects.toThrow('Failed to read content from "http://bad.url": Network failure');
+        await expect(SwaggerParser.create('http://bad.url', {} as GeneratorConfig)).rejects.toThrow(
+            'Failed to read content from "http://bad.url": Network failure',
+        );
     });
 });

tests/30-emit-service/02-coverage.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { ServiceGenerator } from '@src/service/emit/service/service.generator.js';
 import { SwaggerParser } from '@src/core/parser.js';
 import { GeneratorConfig } from '@src/core/types.js';
-import { coverageSpecPart2 } from '../shared/specs.js';
+import { coverageSpecPart2, branchCoverageSpec } from '../shared/specs.js';
 import { groupPathsByController } from '@src/service/parse.js';
 import { createTestProject } from '../shared/helpers.js';
 
@@ -13,10 +13,13 @@ import { createTestProject } from '../shared/helpers.js';
  * primitive return types, ensuring correct method body generation and import handling.
  */
 describe('Emitter: Service Generators (Coverage)', () => {
-
     const run = (spec: object): Project => {
         const project = createTestProject();
-        const config: GeneratorConfig = { input: '', output: '/out', options: { dateType: 'string', enumStyle: 'enum' } };
+        const config: GeneratorConfig = {
+            input: '',
+            output: '/out',
+            options: { dateType: 'string', enumStyle: 'enum' },
+        };
         const parser = new SwaggerParser(spec as any, config);
         const serviceGen = new ServiceGenerator(parser, project, config);
         const controllerGroups = groupPathsByController(parser);
@@ -52,4 +55,30 @@ describe('Emitter: Service Generators (Coverage)', () => {
         expect(modelImport).toBeDefined();
         expect(modelImport!.getNamedImports().map(i => i.getName())).toEqual(['RequestOptions']);
     });
+
+    it('should handle request body without a schema', () => {
+        const project = run(branchCoverageSpec);
+        const serviceFile = project.getSourceFileOrThrow('/out/services/bodyNoSchema.service.ts');
+        const method = serviceFile.getClassOrThrow('BodyNoSchemaService').getMethodOrThrow('postBodyNoSchema');
+        const param = method.getParameters().find(p => p.getName() === 'body');
+        expect(param?.getType().getText()).toBe('unknown');
+    });
+
+    it('should handle operations with only required parameters', () => {
+        const project = run(branchCoverageSpec);
+        const serviceFile = project.getSourceFileOrThrow('/out/services/allRequired.service.ts');
+        const method = serviceFile.getClassOrThrow('AllRequiredService').getMethodOrThrow('getAllRequired');
+        const overloads = method.getOverloads();
+        // The 'options' parameter should NOT be optional in the overloads that require it
+        const responseOverload = overloads.find(o => o.getReturnType().getText().includes('HttpResponse'))!;
+        const optionsParam = responseOverload.getParameters().find(p => p.getName() === 'options')!;
+        expect(optionsParam.hasQuestionToken()).toBe(false);
+    });
+
+    it('should fall back to "any" for responseType when no success response is defined', () => {
+        const project = run(branchCoverageSpec);
+        const serviceFile = project.getSourceFileOrThrow('/out/services/noSuccessResponse.service.ts');
+        const method = serviceFile.getClassOrThrow('NoSuccessResponseService').getMethodOrThrow('getNoSuccess');
+        expect(method.getOverloads()[0].getReturnType().getText()).toBe('Observable<any>');
+    });
 });

tests/40-emit-utility/03-auth-interceptor-generator.spec.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { SwaggerParser } from '../../src/core/parser.js';
 import { AuthInterceptorGenerator } from '../../src/service/emit/utility/auth-interceptor.generator.js';
 import { createTestProject } from '../shared/helpers.js';
-import { emptySpec, securitySpec, providerCoverageSpec } from '../shared/specs.js';
+import { emptySpec, securitySpec, branchCoverageSpec } from '../shared/specs.js';
 import { GeneratorConfig } from '@src/core/types.js';
 
 /**
@@ -36,12 +36,11 @@ describe('Emitter: AuthInterceptorGenerator', () => {
         expect(tokenNames).toEqual(['apiKey', 'bearerToken']);
 
         // Two apiKey schemes (header, query) should generate two distinct logic blocks
-        expect(body).toContain("if (this.apiKey) { authReq = authReq.clone({ setParams");
-        expect(body).toContain("if (this.apiKey) { authReq = authReq.clone({ setHeaders");
+        expect(body).toContain('if (this.apiKey) { authReq = authReq.clone({ setParams');
+        expect(body).toContain('if (this.apiKey) { authReq = authReq.clone({ setHeaders');
 
         // Two bearer types (http, oauth2) should generate only ONE logic block
         expect(body).toContain("if (this.bearerToken) { const token");
-        // FIX: The logic was flawed. Now we check that only one bearer block exists.
         const bearerMatches = body.match(/if \(this.bearerToken\)/g);
         expect(bearerMatches).not.toBeNull();
         expect(bearerMatches!.length).toBe(1);
@@ -57,9 +56,29 @@ describe('Emitter: AuthInterceptorGenerator', () => {
                 },
             },
         });
-        const body = project.getSourceFileOrThrow('/out/auth/auth.interceptor.ts').getClassOrThrow('AuthInterceptor').getMethodOrThrow('intercept')!.getBodyText()!;
+        const body = project
+            .getSourceFileOrThrow('/out/auth/auth.interceptor.ts')
+            .getClassOrThrow('AuthInterceptor')
+            .getMethodOrThrow('intercept')!
+            .getBodyText()!;
         expect(tokenNames).toEqual(['bearerToken']);
         expect(body).toContain('if (this.bearerToken)');
         expect(body).not.toContain('if (this.apiKey)');
     });
+
+    it('should ignore apiKey in cookie', () => {
+        // FIX: The correct behavior is for the generator to return `void`
+        // and not create the file, because the only scheme is unsupported.
+        const { tokenNames, project } = runGenerator({
+            ...emptySpec,
+            components: {
+                securitySchemes: {
+                    CookieAuth: { type: 'apiKey', in: 'cookie', name: 'session_id' },
+                },
+            },
+        });
+
+        expect(tokenNames).toBeUndefined();
+        expect(project.getSourceFile('/out/auth/auth.interceptor.ts')).toBeUndefined();
+    });
 });