Increase test coverage

Author: SamuelMarks

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

@@ -28,15 +28,58 @@ describe('E2E: Full Generation Orchestrator', () => {
     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 };
-        // Use the spec with security schemes
         await generateFromConfig(config, project, { spec: securitySpec });
 
         const filePaths = project.getSourceFiles().map(f => f.getFilePath());
-
-        // This covers the entire `if (Object.keys(securitySchemes).length > 0)` block in orchestrator.ts
         expect(filePaths).toContain('/generated/auth/auth.interceptor.ts');
         expect(filePaths).toContain('/generated/auth/auth.tokens.ts');
-        expect(filePaths).toContain('/generated/auth/oauth.service.ts'); // because oauth2 is in securitySpec
+        expect(filePaths).toContain('/generated/auth/oauth.service.ts');
+    });
+
+    it('should handle specs with only unsupported security schemes', async () => {
+        const project = createTestProject();
+        const config: GeneratorConfig = { input: '', output: '/generated', options: { generateServices: true } as any };
+        const unsupportedSecuritySpec = {
+            openapi: '3.0.0', info: { title: 'Test API', version: '1.0.0' }, paths: {},
+            components: {
+                securitySchemes: {
+                    CookieAuth: { type: 'apiKey', in: 'cookie', name: 'session_id' },
+                },
+            },
+        };
+
+        await generateFromConfig(config, project, { spec: unsupportedSecuritySpec });
+
+        const filePaths = project.getSourceFiles().map(f => f.getFilePath());
+        expect(filePaths).toContain('/generated/auth/auth.tokens.ts');
+        expect(filePaths).not.toContain('/generated/auth/auth.interceptor.ts');
+        expect(filePaths).not.toContain('/generated/auth/oauth.service.ts');
+        expect(filePaths).toContain('/generated/providers.ts');
+        const providerContent = project.getSourceFileOrThrow('/generated/providers.ts').getText();
+        expect(providerContent).not.toContain('apiKey');
+        expect(providerContent).not.toContain('bearerToken');
+    });
+
+    it('should default to generating services and tests when options are absent', async () => {
+        const project = await runGeneratorWithConfig(coverageSpec, {});
+        const filePaths = project.getSourceFiles().map(f => f.getFilePath());
+
+        expect(filePaths).toContain('/generated/services/users.service.ts');
+        expect(filePaths).toContain('/generated/services/users.service.spec.ts');
+    });
+
+    it('should default to generating admin tests when admin option is present but test option is absent', async () => {
+        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+        await runGeneratorWithConfig(coverageSpec, { admin: true });
+
+        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.')]));
+
+        consoleSpy.mockRestore();
     });
 
     it('should skip service generation when config is false', async () => {
@@ -61,7 +104,11 @@ describe('E2E: Full Generation Orchestrator', () => {
         const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
         await runGeneratorWithConfig(coverageSpec, { admin: true, generateAdminTests: false });
         const logCalls = consoleSpy.mock.calls.flat();
-        expect(logCalls).not.toContain(expect.stringContaining('Test generation for admin UI is stubbed.'));
+
+        // ** 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);
+
         consoleSpy.mockRestore();
     });
 

tests/70-generated-code/00-service-test-gen.spec.ts

@@ -1,12 +1,12 @@
 import { describe, it, expect } from 'vitest';
 import { ServiceTestGenerator } from '@src/service/emit/test/service-test-generator.js';
 import { SwaggerParser } from '@src/core/parser.js';
-import { GeneratorConfig } from '@src/core/types.js';
+import { GeneratorConfig, PathInfo } from '@src/core/types.js';
 import { fullCRUD_Users, adminFormSpec, finalCoverageSpec, branchCoverageSpec } from '../shared/specs.js';
 import { createTestProject } from '../shared/helpers.js';
 import { groupPathsByController } from '@src/service/parse.js';
 import { TypeGenerator } from '../../src/service/emit/type/type.generator.js';
-import { MockDataGenerator } from '../../src/service/emit/test/mock-data.generator.js';
+import { MockDataGenerator } from "../../src/service/emit/test/mock-data.generator";
 
 /**
  * @fileoverview
@@ -31,7 +31,6 @@ describe('Generated Code: Service Test Generators', () => {
             const mockString = generator.generate('User');
             const mock = JSON.parse(mockString);
 
-            // `id` is readOnly, so it's excluded from the mock for a request body.
             expect(mock).not.toHaveProperty('id');
             expect(mock).toHaveProperty('name', 'string-value');
             expect(mock.email).toBe('[email protected]');
@@ -42,11 +41,11 @@ describe('Generated Code: Service Test Generators', () => {
             const mockString = generator.generate('Widget');
             const mock = JSON.parse(mockString);
 
-            expect(mock.launchDate).toBeTypeOf('string'); // From format: 'date-time'
+            expect(mock.launchDate).toBeTypeOf('string');
             expect(Array.isArray(mock.uniqueTags)).toBe(true);
             expect(mock.config).toBeTypeOf('object');
             expect(mock.config).toHaveProperty('key');
-            expect(mock.config).not.toHaveProperty('readOnlyKey'); // Should be excluded
+            expect(mock.config).not.toHaveProperty('readOnlyKey');
         });
 
         it('should return an empty object for an unresolvable schema', () => {
@@ -57,18 +56,23 @@ describe('Generated Code: Service Test Generators', () => {
     });
 
     describe('ServiceTestGenerator', () => {
-        it('should generate a valid Angular spec file for a full CRUD service', () => {
+        const setupTestGen = (spec: object) => {
             const project = createTestProject();
             const config: GeneratorConfig = {
                 input: '',
                 output: '/out',
                 clientName: 'Api',
                 options: { dateType: 'string', enumStyle: 'enum' },
             };
-            const parser = new SwaggerParser(fullCRUD_Users as any, config);
+            const parser = new SwaggerParser(spec as any, config);
             new TypeGenerator(parser, project, config).generate('/out');
             const testGenerator = new ServiceTestGenerator(parser, project, config);
             const controllerGroups = groupPathsByController(parser);
+            return { testGenerator, controllerGroups, project, parser };
+        };
+
+        it('should generate a valid Angular spec file for a full CRUD service', () => {
+            const { testGenerator, controllerGroups, project } = setupTestGen(fullCRUD_Users);
             testGenerator.generateServiceTestFile('Users', controllerGroups['Users'], '/out/services');
 
             const specFile = project.getSourceFileOrThrow('/out/services/users.service.spec.ts');
@@ -79,43 +83,37 @@ describe('Generated Code: Service Test Generators', () => {
         });
 
         it('should generate tests for primitive request bodies and param refs', () => {
-            const project = createTestProject();
-            const config: GeneratorConfig = {
-                input: '',
-                output: '/out',
-                clientName: 'TestApi',
-                options: { dateType: 'string', enumStyle: 'enum' },
-            };
             const spec = { ...finalCoverageSpec, ...branchCoverageSpec };
-            const parser = new SwaggerParser(spec as any, config);
-            new TypeGenerator(parser, project, config).generate('/out');
-            const testGenerator = new ServiceTestGenerator(parser, project, config);
-            const controllerGroups = groupPathsByController(parser);
+            const { testGenerator, controllerGroups, project } = setupTestGen(spec);
 
             if (controllerGroups['ParamIsRef']) {
                 testGenerator.generateServiceTestFile('ParamIsRef', controllerGroups['ParamIsRef'], '/out/services');
                 const paramIsRefTest = project.getSourceFileOrThrow('/out/services/paramIsRef.service.spec.ts').getText();
-                // This is the real test. The generator's implementation is now fixed, so this will pass.
                 expect(paramIsRefTest).toContain('import { User } from "../models";');
             }
         });
 
         it('should handle operations where the parameters key is missing', () => {
-            const project = createTestProject();
-            const config: GeneratorConfig = { input: '', output: '/out', options: {} as any };
-            const parser = new SwaggerParser(branchCoverageSpec as any, config);
-            new TypeGenerator(parser, project, config).generate('/out');
-            const testGenerator = new ServiceTestGenerator(parser, project, config);
-            const controllerGroups = groupPathsByController(parser);
-
-            // This should not throw an error
+            const { testGenerator, controllerGroups, project } = setupTestGen(branchCoverageSpec);
             testGenerator.generateServiceTestFile('NoParamsKey', controllerGroups['NoParamsKey'], '/out/services');
 
             const specFile = project.getSourceFileOrThrow('/out/services/noParamsKey.service.spec.ts');
             const content = specFile.getText();
 
-            // The generated test should have a method call with no arguments
             expect(content).toContain('service.getNoParamsKey().subscribe');
         });
+
+        it('collectModelImports should return an empty set if operations are undefined', () => {
+            const { parser } = setupTestGen(fullCRUD_Users);
+            // We only need the generator instance to call the private method, project doesn't matter here.
+            const testGenerator = new ServiceTestGenerator(parser, createTestProject(), {} as any);
+
+            // This directly calls the private method with undefined to hit the uncovered branch.
+            // We cast to `any` to bypass TypeScript's type checking for the test.
+            const result = (testGenerator as any).collectModelImports(undefined);
+
+            expect(result).toBeInstanceOf(Set);
+            expect(result.size).toBe(0);
+        });
     });
 });