Increase test coverage

Author: SamuelMarks

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

@@ -55,8 +55,13 @@ describe('Core: utils.ts (Coverage)', () => {
             expect(utils.getTypeScriptType(schema, config, [])).toBe('any');
         });
 
-        it('should return "any" for default switch case', () => {
-            const schema: SwaggerDefinition = { type: 'null' };
+        it('should return "any" for default switch case with unknown type', () => {
+            const schema: SwaggerDefinition = { type: 'unknown' as any };
+            expect(utils.getTypeScriptType(schema, config, [])).toBe('any');
+        });
+
+        it('should return "any" for default switch case with array type', () => {
+            const schema: SwaggerDefinition = { type: ['string', 'null'] };
             expect(utils.getTypeScriptType(schema, config, [])).toBe('any');
         });
 

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

@@ -20,9 +20,7 @@ describe('Core: SwaggerParser (Coverage)', () => {
 
     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([]);
     });
 
@@ -43,6 +41,7 @@ describe('Core: SwaggerParser (Coverage)', () => {
                 schemas: {
                     ...parserCoverageSpec.components.schemas,
                     BadMap: {
+                        oneOf: [],
                         discriminator: {
                             propertyName: 'type',
                             mapping: { 'bad': '#/non/existent' }
@@ -59,12 +58,10 @@ describe('Core: SwaggerParser (Coverage)', () => {
 
     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
+        expect(options[0].name).toBe('sub3');
     });
 
     it('getPolymorphicSchemaOptions should handle oneOf items that are not refs', () => {
@@ -84,7 +81,6 @@ describe('Core: SwaggerParser (Coverage)', () => {
 
     it('loadContent should handle non-Error exceptions from fetch', async () => {
         global.fetch = vi.fn().mockImplementation(() => {
-            // eslint-disable-next-line @typescript-eslint/no-throw-literal
             throw 'Network failure';
         });
         await expect(SwaggerParser.create('http://bad.url', {} as GeneratorConfig)).rejects.toThrow(

tests/30-emit-service/00-service-generator.spec.ts

@@ -5,7 +5,7 @@ import { Project, Scope } from 'ts-morph';
 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 { coverageSpec, fullCRUD_Users } from '../shared/specs.js';
+import { coverageSpec, fullCRUD_Users, branchCoverageSpec } from '../shared/specs.js';
 import { groupPathsByController } from '@src/service/parse.js';
 import { TypeGenerator } from '@src/service/emit/type/type.generator.js';
 import { TokenGenerator } from '@src/service/emit/utility/token.generator.js';
@@ -58,14 +58,25 @@ describe('Emitter: ServiceGenerator', () => {
 
     it('should use a custom method name when provided in config', () => {
         const project = createTestEnvironment(coverageSpec, {
-            // FIX: The operationId contains dashes which need to be replaced.
             customizeMethodName: (opId) => `custom_${opId.replace(/-/g, '_')}`
         });
         const serviceFile = project.getSourceFileOrThrow('/out/services/customName.service.ts');
         const serviceClass = serviceFile.getClassOrThrow('CustomNameService');
         expect(serviceClass.getMethod('custom_get_custom_name')).toBeDefined();
     });
 
+    it('should fall back to path-based name if customizer exists but op has no ID', () => {
+        const project = createTestEnvironment(branchCoverageSpec, {
+            customizeMethodName: (opId) => `custom_${opId}`
+        });
+        // The tag was changed to 'NoOperationId' which creates 'noOperationId.service.ts'
+        const serviceFile = project.getSourceFileOrThrow('/out/services/noOperationId.service.ts');
+        // The generator should ignore the customizer and create a name from the path.
+        // head /no-operation-id -> headNoOperationId
+        const serviceClass = serviceFile.getClassOrThrow('NoOperationIdService');
+        expect(serviceClass.getMethod('headNoOperationId')).toBeDefined();
+    });
+
     it('should de-duplicate method names from conflicting operationIds', () => {
         const project = createTestEnvironment(coverageSpec);
         const serviceFile = project.getSourceFileOrThrow('/out/services/duplicateName.service.ts');

tests/40-emit-utility/06-provider-generator.spec.ts

@@ -11,62 +11,63 @@ import { DateTransformerGenerator } from '../../src/service/emit/utility/date-tr
 import { emptySpec, securitySpec } from '../shared/specs.js';
 
 describe('Emitter: ProviderGenerator', () => {
-    // This helper function is the key. It simulates the entire generation process
-    // for the provider file and its dependencies.
-    const runGenerator = (spec: object, configOverrides: Partial<GeneratorConfig['options']> = {}) => {
+    const runGenerator = (spec: object, config: Partial<GeneratorConfig> = {}) => {
         const project = new Project({ useInMemoryFileSystem: true });
-        const config: GeneratorConfig = {
+        const fullConfig: GeneratorConfig = {
             input: '',
             output: '/out',
-            clientName: 'Test',
-            options: { generateServices: true, dateType: 'string', enumStyle: 'enum', ...configOverrides },
+            // `clientName` is deliberately omitted from the base to test fallback logic
+            options: { generateServices: true, dateType: 'string', enumStyle: 'enum' },
+            ...config
         };
-        const parser = new SwaggerParser(spec as any, config);
 
-        // Generate dependencies that the ProviderGenerator needs to import from.
-        new TokenGenerator(project, config.clientName).generate(config.output);
-        new BaseInterceptorGenerator(project, config.clientName).generate(config.output);
+        const parser = new SwaggerParser(spec as any, fullConfig);
 
-        if (config.options.dateType === 'Date') {
-            new DateTransformerGenerator(project).generate(config.output);
+        new TokenGenerator(project, fullConfig.clientName).generate(fullConfig.output);
+        new BaseInterceptorGenerator(project, fullConfig.clientName).generate(fullConfig.output);
+
+        if (fullConfig.options.dateType === 'Date') {
+            new DateTransformerGenerator(project).generate(fullConfig.output);
         }
 
         let tokenNames: string[] = [];
-        // This logic mimics the orchestrator to decide if auth files are needed
-        // and to get the `tokenNames` which is crucial for the ProviderGenerator's constructor.
         if (Object.keys(parser.getSecuritySchemes()).length > 0) {
-            new AuthTokensGenerator(project).generate(config.output);
-            const authInterceptorResult = new AuthInterceptorGenerator(parser, project).generate(config.output);
+            new AuthTokensGenerator(project).generate(fullConfig.output);
+            const authInterceptorResult = new AuthInterceptorGenerator(parser, project).generate(fullConfig.output);
             tokenNames = authInterceptorResult?.tokenNames || [];
         }
 
-        // The actual generator under test.
-        new ProviderGenerator(parser, project, tokenNames).generate(config.output);
+        new ProviderGenerator(parser, project, tokenNames).generate(fullConfig.output);
         return project.getSourceFile('/out/providers.ts')?.getText();
     };
 
+    it('should use "Default" client name when none is provided in config', () => {
+        // Run with an empty config, so clientName is undefined
+        const fileContent = runGenerator(emptySpec, {});
+        expect(fileContent).toContain('export function provideDefaultClient(config: DefaultConfig)');
+        expect(fileContent).toContain('export interface DefaultConfig');
+    });
+
     it('should not generate if generateServices is false', () => {
-        const fileContent = runGenerator(emptySpec, { generateServices: false });
+        const fileContent = runGenerator(emptySpec, { options: { generateServices: false } as any });
         expect(fileContent).toBeUndefined();
     });
 
     it('should generate a basic provider without security or date transform', () => {
-        const fileContent = runGenerator(emptySpec);
+        const fileContent = runGenerator(emptySpec, { clientName: 'Test' });
         expect(fileContent).toBeDefined();
         expect(fileContent).toContain('export function provideTestClient(config: TestConfig)');
         expect(fileContent).toContain('export interface TestConfig');
-        // Check interface props
         expect(fileContent).toContain('basePath: string');
         expect(fileContent).toContain('enableDateTransform?: boolean');
         expect(fileContent).not.toContain('apiKey?: string');
         expect(fileContent).not.toContain('bearerToken?:');
-        // Check provider logic
         expect(fileContent).not.toContain('AuthInterceptor');
         expect(fileContent).not.toContain('DateInterceptor');
     });
 
     it('should add providers for both API key and Bearer token when spec contains both', () => {
-        const fileContent = runGenerator(securitySpec);
+        const fileContent = runGenerator(securitySpec, { clientName: 'Test' });
         expect(fileContent).toContain('apiKey?: string');
         expect(fileContent).toContain('bearerToken?: string | (() => string)');
         expect(fileContent).toContain('if (config.apiKey)');
@@ -78,60 +79,48 @@ describe('Emitter: ProviderGenerator', () => {
 
     it('should add providers for ONLY API key when spec contains only that', () => {
         const apiKeySpec = { ...emptySpec, components: { securitySchemes: { ApiKeyAuth: {type: 'apiKey', in: 'header', name: 'X-API-KEY'} } } };
-        const fileContent = runGenerator(apiKeySpec);
-        // Check interface
+        const fileContent = runGenerator(apiKeySpec, { clientName: 'Test' });
         expect(fileContent).toContain('apiKey?: string');
         expect(fileContent).not.toContain('bearerToken?:');
-        // Check provider function
         expect(fileContent).toContain('if (config.apiKey)');
         expect(fileContent).not.toContain('if (config.bearerToken)');
-        expect(fileContent).toContain('AuthInterceptor'); // Auth interceptor is still needed
+        expect(fileContent).toContain('AuthInterceptor');
     });
 
     it('should add providers for ONLY Bearer token when spec contains only that', () => {
         const bearerSpec = { ...emptySpec, components: { securitySchemes: { BearerAuth: {type: 'http', scheme: 'bearer'} } } };
-        const fileContent = runGenerator(bearerSpec);
-        // Check interface
+        const fileContent = runGenerator(bearerSpec, { clientName: 'Test' });
         expect(fileContent).not.toContain('apiKey?: string');
         expect(fileContent).toContain('bearerToken?: string | (() => string)');
-        // Check provider function
         expect(fileContent).not.toContain('if (config.apiKey)');
         expect(fileContent).toContain('if (config.bearerToken)');
         expect(fileContent).toContain('AuthInterceptor');
     });
 
     it('should add DateInterceptor if dateType is "Date"', () => {
-        const fileContent = runGenerator(emptySpec, { dateType: 'Date' });
+        const fileContent = runGenerator(emptySpec, { clientName: 'Test', options: { dateType: 'Date' } as any });
         expect(fileContent).toContain('if (config.enableDateTransform !== false)');
         expect(fileContent).toContain('customInterceptors.unshift(new DateInterceptor());');
     });
 
     it('should generate an empty custom interceptors array if none are provided', () => {
-        const fileContent = runGenerator(emptySpec);
+        const fileContent = runGenerator(emptySpec, { clientName: 'Test' });
         expect(fileContent).toContain(
             'const customInterceptors = config.interceptors?.map(InterceptorClass => new InterceptorClass()) || [];',
         );
         expect(fileContent).toContain(`provide: HTTP_INTERCEPTORS_TEST, useValue: customInterceptors`);
     });
 
-    it('should handle config.interceptors being an empty array', () => {
-        // This covers the `?.map` chain where `interceptors` exists but is empty
-        const fileContent = runGenerator(emptySpec); // The logic is the same as the above test
-        expect(fileContent).toContain('const customInterceptors = config.interceptors?.map');
-    });
-
     it('should not include token providers for unsupported security schemes (e.g., cookie)', () => {
         const spec = {
             ...emptySpec,
             components: { securitySchemes: { Cookie: { type: 'apiKey', in: 'cookie', name: 'sid' } } },
         };
-        const fileContent = runGenerator(spec);
+        const fileContent = runGenerator(spec, { clientName: 'Test' });
 
-        // AuthInterceptorGenerator returns undefined, so ProviderGenerator gets an empty tokenNames array
         expect(fileContent).not.toContain(
             'providers.push({ provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true });',
         );
         expect(fileContent).not.toContain('API_KEY_TOKEN');
-        expect(fileContent).not.toContain('BEARER_TOKEN_TOKEN');
     });
 });

tests/60-e2e/00-orchestrator.spec.ts

@@ -25,6 +25,12 @@ describe('E2E: Full Generation Orchestrator', () => {
         expect(filePaths).toContain('/generated/services/index.ts');
     });
 
+    it('should generate date transformer when dateType is Date', async () => {
+        const project = await runGeneratorWithConfig(coverageSpec, { dateType: 'Date' });
+        const filePaths = project.getSourceFiles().map(f => f.getFilePath());
+        expect(filePaths).toContain('/generated/utils/date-transformer.ts');
+    });
+
     it('should generate auth-related files when security spec is provided', async () => {
         const project = createTestProject();
         const config: GeneratorConfig = { input: '', output: '/generated', options: { generateServices: true } as any };