Increase test coverage (TODO: fix skipped tests)

Author: SamuelMarks

src/core/utils.ts

@@ -243,19 +243,21 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
                 const bodyParam = allParams.find(p => p.in === 'body') as BodyParameter | undefined;
 
                 const parameters = nonBodyParams.map((p): Parameter => {
-                    const { name, in: paramIn, required, description, type, format, items, ...schemaProps } = p;
-                    const schema: SwaggerDefinition = schemaProps as SwaggerDefinition;
-                    if (type) schema.type = type as any;
-                    if (format) schema.format = format;
-                    if (items) schema.items = items;
+                    // **THE FIX**: This logic correctly uses the OAS3 `schema` property if it exists,
+                    // and falls back to constructing a schema object from OAS2 properties otherwise.
+                    const finalSchema = p.schema || {
+                        type: p.type as any,
+                        format: p.format,
+                        items: p.items,
+                    };
 
                     return {
-                        name,
-                        in: paramIn as "query" | "path" | "header" | "cookie",
-                        required,
-                        schema,
-                        description
-                    }
+                        name: p.name,
+                        in: p.in as "query" | "path" | "header" | "cookie",
+                        required: p.required,
+                        schema: finalSchema as SwaggerDefinition,
+                        description: p.description
+                    };
                 });
 
                 const requestBody = (operation as any).requestBody
@@ -301,7 +303,8 @@ export function extractPaths(swaggerPaths: { [p: string]: Path } | undefined): P
  * @internal
  */
 export function getRequestBodyType(requestBody: RequestBody | undefined, config: GeneratorConfig, knownTypes: string[]): string {
-    const schema = requestBody?.content?.['application/json']?.schema;
+    if (!requestBody?.content) return 'any';
+    const schema = requestBody.content[Object.keys(requestBody.content)[0]]?.schema;
     return getTypeScriptType(schema as SwaggerDefinition, config, knownTypes);
 }
 

src/service/emit/admin/resource-discovery.ts

@@ -80,8 +80,6 @@ function getResourceName(path: PathInfo): string {
  * @returns A string representing the classified action.
  */
 function classifyAction(path: PathInfo, method: string): ResourceOperation['action'] {
-    if (typeof method !== 'string') { return 'unknown'; }
-
     const nonParamSegments = path.path.split('/').filter(s => s && !s.startsWith('{'));
     const hasIdSuffix = path.path.endsWith('}');
     const m = method.toLowerCase();

src/service/emit/orchestrator.ts

@@ -16,7 +16,7 @@ import { OAuthHelperGenerator } from './utility/oauth-helper.generator.js';
 import { BaseInterceptorGenerator } from './utility/base-interceptor.generator.js';
 import { ProviderGenerator } from './utility/provider.generator.js';
 import { MainIndexGenerator, ServiceIndexGenerator } from './utility/index.generator.js';
-import { ServiceTestGenerator } from "./test/service-test.generator.js";
+import { ServiceTestGenerator } from "./test/service-test-generator.js";
 
 /**
  * Orchestrates the entire code generation process for the Angular client library.

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

@@ -1,87 +1,88 @@
 import { SwaggerParser } from '../../../core/parser.js';
 import { SwaggerDefinition } from '../../../core/types.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) {}
 
     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());
-        return JSON.stringify(mockObject, null, 2);
+        const schemaDef = this.parser.schemas.find(s => s.name === schemaName)?.definition;
+        if (!schemaDef) return '{}';
+        const value = this.generateValue(schemaDef, new Set<SwaggerDefinition>());
+        return typeof value === 'undefined' ? '{}' : JSON.stringify(value, 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;
+    private generateValue(schema: SwaggerDefinition | undefined, visited: Set<SwaggerDefinition>): any {
+        if (!schema) return undefined;
+        if (schema.$ref) {
+            const resolved = this.parser.resolve<SwaggerDefinition>(schema);
+            return this.generateValue(resolved, visited);
         }
+        if (visited.has(schema)) return {};
 
-        if (visited.has(schema)) {
-            return {};
-        }
-        visited.add(schema);
+        if ('example' in schema && schema.example !== undefined) return schema.example;
 
-        if (schema.allOf) {
-            const combined = schema.allOf.reduce((acc, subSchemaRef) => {
-                const subSchema = this.parser.resolve(subSchemaRef);
-                if (!subSchema) return acc;
-                return { ...acc, ...this.generateValue(subSchema, visited) };
-            }, {});
-            visited.delete(schema);
-            return combined;
-        }
+        visited.add(schema);
+        try {
+            if (schema.allOf) {
+                let mergedObj: any = {};
+                let mergedObjHasKeys = false;
+                let lastPrimitiveValue: any = undefined;
+                for (const sub of schema.allOf) {
+                    const val = this.generateValue(sub, visited);
+                    if (typeof val === 'object' && val !== null && !Array.isArray(val)) {
+                        Object.assign(mergedObj, val);
+                        mergedObjHasKeys = mergedObjHasKeys || Object.keys(val).length > 0;
+                    } else if (typeof val !== 'undefined') {
+                        lastPrimitiveValue = val;
+                    }
+                }
+                if (mergedObjHasKeys) return mergedObj;
+                if (typeof lastPrimitiveValue !== 'undefined') return lastPrimitiveValue;
+                return undefined;
+            }
 
-        if (schema.$ref) {
-            const resolved = this.parser.resolve(schema);
-            const result = resolved ? this.generateValue(resolved, visited) : {};
-            visited.delete(schema);
-            return result;
-        }
+            let type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+            if (!type && schema.properties) type = 'object';
 
-        switch (schema.type) {
-            case 'string':
-                if (schema.format === 'date-time' || schema.format === 'date') return new Date().toISOString();
-                if (schema.format === 'email') return '[email protected]';
-                if (schema.format === 'uuid') return '123e4567-e89b-12d3-a456-426614174000';
-                return 'string-value';
-            case 'number':
-            case 'integer':
-                return schema.minimum ?? (schema.default ?? 123);
-            case 'boolean':
-                return schema.default ?? true;
-            case 'array':
-                if (schema.items && !Array.isArray(schema.items)) {
-                    return [this.generateValue(schema.items as SwaggerDefinition, visited)];
-                }
-                return [];
-            case 'object':
-                const obj: Record<string, any> = {};
-                if (schema.properties) {
-                    for (const [propName, propSchema] of Object.entries(schema.properties)) {
-                        if (!propSchema.readOnly) {
-                            obj[propName] = this.generateValue(propSchema, visited);
+            switch (type) {
+                case 'object': {
+                    if (!schema.properties) return {};
+                    const obj: any = {};
+                    for (const [k, v] of Object.entries(schema.properties)) {
+                        if (v && !v.readOnly) {
+                            const propValue = this.generateValue(v, visited);
+                            if (typeof propValue !== 'undefined') obj[k] = propValue;
                         }
                     }
+                    return obj;
+                }
+                case 'array': {
+                    if (schema.items && !Array.isArray(schema.items)) {
+                        const val = this.generateValue(schema.items as SwaggerDefinition, visited);
+                        return typeof val === 'undefined' ? [] : [val];
+                    }
+                    return [];
                 }
-                visited.delete(schema);
-                return obj;
-            default:
-                visited.delete(schema);
-                return null;
+                case 'string':
+                    if (schema.format === 'date-time' || schema.format === 'date') return new Date().toISOString();
+                    if (schema.format === 'email') return "[email protected]";
+                    if (schema.format === 'uuid') return "123e4567-e89b-12d3-a456-426614174000";
+                    return 'string-value';
+                case 'number':
+                case 'integer':
+                    if (typeof schema.minimum !== 'undefined') return schema.minimum;
+                    if (typeof schema.default !== 'undefined') return schema.default;
+                    return 123;
+                case 'boolean':
+                    if (typeof schema.default !== 'undefined') return schema.default;
+                    return true;
+                case 'null':
+                    return null;
+                default:
+                    return undefined;
+            }
+        } finally {
+            visited.delete(schema);
         }
     }
 }