ts-openapi-codegen 1.0.0-beta.8 → 1.0.0

package/dist/core/utils/__tests__/stripNamespace.test.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const stripNamespace_1 = require("../stripNamespace");
-(0, node_test_1.describe)('stripNamespace', () => {
-    (0, node_test_1.test)('@unit: should strip namespace', () => {
+(0, node_test_1.describe)('@unit: stripNamespace', () => {
+    (0, node_test_1.test)('should strip namespace', () => {
         node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('package/componentClass.yml#/components/TestComponent'), 'package/TestComponent');
         node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('package/componentClass.yml'), 'package/ComponentClass');
         node_assert_1.default.strictEqual((0, stripNamespace_1.stripNamespace)('#/components/schemas/Item'), 'Item');

package/dist/core/utils/__tests__/unique.test.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const unique_1 = require("../unique");
-(0, node_test_1.describe)('unique', () => {
-    (0, node_test_1.test)('@unit: should return correct index', () => {
+(0, node_test_1.describe)('@unit: unique', () => {
+    (0, node_test_1.test)('should return correct index', () => {
         node_assert_1.default.equal((0, unique_1.unique)('a', 0, ['a', 'b', 'c']), true);
         node_assert_1.default.equal((0, unique_1.unique)('a', 1, ['a', 'b', 'c']), false);
         node_assert_1.default.equal((0, unique_1.unique)('a', 2, ['a', 'b', 'c']), false);

package/dist/core/utils/__tests__/writeClientCore.test.js

@@ -5,56 +5,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
+const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const WriteClient_1 = require("../../WriteClient");
-const fileSystem_1 = require("../fileSystem");
-(0, node_test_1.test)('@unit: writeClientCore writes to filesystem', async () => {
-    const writeFileCalls = [];
-    // Re-assigning the function manually with a mock
-    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
-    fileSystem_1.fileSystem.writeFile = async (path, content) => {
-        writeFileCalls.push([path, content]);
-    };
-    const client = {
-        server: 'http://localhost:8080',
-        version: '1.0',
-        models: [],
-        services: [],
-    };
-    const templates = {
-        indexes: {
-            full: () => 'fullIndex',
-            simple: () => 'simpleIndex',
-            core: () => 'coreIndex',
-            models: () => 'modelsIndex',
-            schemas: () => 'schemasIndex',
-            services: () => 'servicesIndex',
-        },
-        exports: {
-            model: () => 'model',
-            schema: () => 'schema',
-            service: () => 'service',
-        },
-        core: {
-            settings: () => 'settings',
-            apiError: () => 'apiError',
-            apiRequestOptions: () => 'apiRequestOptions',
-            apiResult: () => 'apiResult',
-            request: () => 'request',
-            cancelablePromise: () => 'cancelablePromise',
-            httpStatusCode: () => 'httpStatusCode',
-        },
-    };
-    const useCancelableRequest = true;
-    const writeClient = new WriteClient_1.WriteClient();
-    await writeClient.writeClientCore({ client, templates, outputCorePath: '/', httpClient: HttpClient_enum_1.HttpClient.FETCH, useCancelableRequest });
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('OpenAPI.ts') && content.toString().includes('settings')), 'Expected writeFile to be called with settings content for OpenAPI.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiError.ts') && content.toString().includes('apiError')), 'Expected writeFile to be called with apiError content for ApiError.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiRequestOptions.ts') && content.toString().includes('apiRequestOptions')), 'Expected writeFile to be called with apiRequestOptions content for ApiRequestOptions.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiResult.ts') && content.toString().includes('apiResult')), 'Expected writeFile to be called with apiResult content for ApiResult.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('request.ts') && content.toString().includes('request')), 'Expected writeFile to be called with request content for request.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('CancelablePromise.ts') && content.toString().includes('cancelablePromise')), 'Expected writeFile to be called with cancelablePromise content for CancelablePromise.ts');
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('HttpStatusCode.ts') && content.toString().includes('httpStatusCode')), 'Expected writeFile to be called with httpStatusCode content for HttpStatusCode.ts');
-    // Restoring the original function
-    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+(0, node_test_1.describe)('@unit: writeClientCore', () => {
+    (0, node_test_1.test)('writes to filesystem', async () => {
+        const writeFileCalls = [];
+        // Re-assigning the function manually with a mock
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const client = {
+            server: 'http://localhost:8080',
+            version: '1.0',
+            models: [],
+            services: [],
+        };
+        const templates = {
+            indexes: {
+                full: () => 'fullIndex',
+                simple: () => 'simpleIndex',
+                core: () => 'coreIndex',
+                models: () => 'modelsIndex',
+                schemas: () => 'schemasIndex',
+                services: () => 'servicesIndex',
+            },
+            exports: {
+                model: () => 'model',
+                schema: () => 'schema',
+                service: () => 'service',
+            },
+            core: {
+                settings: () => 'settings',
+                apiError: () => 'apiError',
+                apiRequestOptions: () => 'apiRequestOptions',
+                apiResult: () => 'apiResult',
+                request: () => 'request',
+                cancelablePromise: () => 'cancelablePromise',
+                httpStatusCode: () => 'httpStatusCode',
+            },
+        };
+        const useCancelableRequest = true;
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientCore({ client, templates, outputCorePath: '/', httpClient: HttpClient_enum_1.HttpClient.FETCH, useCancelableRequest });
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('OpenAPI.ts') && content.toString().includes('settings')), 'Expected writeFile to be called with settings content for OpenAPI.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiError.ts') && content.toString().includes('apiError')), 'Expected writeFile to be called with apiError content for ApiError.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiRequestOptions.ts') && content.toString().includes('apiRequestOptions')), 'Expected writeFile to be called with apiRequestOptions content for ApiRequestOptions.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('ApiResult.ts') && content.toString().includes('apiResult')), 'Expected writeFile to be called with apiResult content for ApiResult.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('request.ts') && content.toString().includes('request')), 'Expected writeFile to be called with request content for request.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('CancelablePromise.ts') && content.toString().includes('cancelablePromise')), 'Expected writeFile to be called with cancelablePromise content for CancelablePromise.ts');
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('HttpStatusCode.ts') && content.toString().includes('httpStatusCode')), 'Expected writeFile to be called with httpStatusCode content for HttpStatusCode.ts');
+        // Restoring the original function
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
+    });
 });

package/dist/core/utils/__tests__/writeClientFullIndex.test.js

@@ -5,42 +5,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
+const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const WriteClient_1 = require("../../WriteClient");
-const fileSystem_1 = require("../fileSystem");
-(0, node_test_1.test)('@unit: writeClientFullIndex writes to filesystem', async () => {
-    const writeFileCalls = [];
-    // Re-assigning the function manually with a mock
-    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
-    fileSystem_1.fileSystem.writeFile = async (path, content) => {
-        writeFileCalls.push([path, content]);
-    };
-    const templates = {
-        indexes: {
-            full: () => 'fullIndex',
-            simple: () => 'simpleIndex',
-            core: () => 'coreIndex',
-            models: () => 'modelsIndex',
-            schemas: () => 'schemasIndex',
-            services: () => 'servicesIndex',
-        },
-        exports: {
-            model: () => 'model',
-            schema: () => 'schema',
-            service: () => 'service',
-        },
-        core: {
-            settings: () => 'settings',
-            apiError: () => 'apiError',
-            apiRequestOptions: () => 'apiRequestOptions',
-            apiResult: () => 'apiResult',
-            request: () => 'request',
-            cancelablePromise: () => 'cancelablePromise',
-            httpStatusCode: () => 'httpStatusCode',
-        },
-    };
-    const writeClient = new WriteClient_1.WriteClient();
-    await writeClient.writeClientFullIndex({ templates, outputPath: '/', core: [], models: [], schemas: [], services: [] });
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('index.ts') && content.toString().includes('fullIndex')), 'Expected writeFile to be called with index content for index.ts');
-    // Restoring the original function
-    fileSystem_1.fileSystem.writeFile = originalWriteFile;
+(0, node_test_1.describe)('@unit: writeClientFullIndex', () => {
+    (0, node_test_1.test)('writes to filesystem', async () => {
+        const writeFileCalls = [];
+        // Re-assigning the function manually with a mock
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const templates = {
+            indexes: {
+                full: () => 'fullIndex',
+                simple: () => 'simpleIndex',
+                core: () => 'coreIndex',
+                models: () => 'modelsIndex',
+                schemas: () => 'schemasIndex',
+                services: () => 'servicesIndex',
+            },
+            exports: {
+                model: () => 'model',
+                schema: () => 'schema',
+                service: () => 'service',
+            },
+            core: {
+                settings: () => 'settings',
+                apiError: () => 'apiError',
+                apiRequestOptions: () => 'apiRequestOptions',
+                apiResult: () => 'apiResult',
+                request: () => 'request',
+                cancelablePromise: () => 'cancelablePromise',
+                httpStatusCode: () => 'httpStatusCode',
+            },
+        };
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientFullIndex({ templates, outputPath: '/', core: [], models: [], schemas: [], services: [] });
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('index.ts') && content.toString().includes('fullIndex')), 'Expected writeFile to be called with index content for index.ts');
+        // Restoring the original function
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
+    });
 });

package/dist/core/utils/__tests__/writeClientModels.test.js

@@ -5,70 +5,72 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
+const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const WriteClient_1 = require("../../WriteClient");
-const fileSystem_1 = require("../fileSystem");
-(0, node_test_1.test)('@unit: writeClientModels writes to filesystem', async () => {
-    const writeFileCalls = [];
-    // Re-assigning the function manually with a mock
-    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
-    fileSystem_1.fileSystem.writeFile = async (path, content) => {
-        writeFileCalls.push([path, content]);
-    };
-    const models = [
-        {
-            export: 'interface',
-            name: 'MyModel',
-            path: 'MyModel',
-            type: 'MyModel',
-            base: 'MyModel',
-            template: null,
-            link: null,
-            description: null,
-            isDefinition: true,
-            isReadOnly: false,
-            isRequired: false,
-            isNullable: false,
-            imports: [],
-            enum: [],
-            enums: [],
-            properties: [],
-            alias: '',
-        },
-    ];
-    const templates = {
-        indexes: {
-            full: () => 'fullIndex',
-            simple: () => 'simpleIndex',
-            core: () => 'coreIndex',
-            models: () => 'modelsIndex',
-            schemas: () => 'schemasIndex',
-            services: () => 'servicesIndex',
-        },
-        exports: {
-            model: () => 'model',
-            schema: () => 'schema',
-            service: () => 'service',
-        },
-        core: {
-            settings: () => 'settings',
-            apiError: () => 'apiError',
-            apiRequestOptions: () => 'apiRequestOptions',
-            apiResult: () => 'apiResult',
-            request: () => 'request',
-            cancelablePromise: () => 'cancelablePromise',
-            httpStatusCode: () => 'httpStatusCode',
-        },
-    };
-    const writeClient = new WriteClient_1.WriteClient();
-    await writeClient.writeClientModels({
-        models,
-        templates,
-        outputModelsPath: '/',
-        httpClient: HttpClient_enum_1.HttpClient.FETCH,
-        useUnionTypes: false,
+(0, node_test_1.describe)('@unit: writeClientModels', () => {
+    (0, node_test_1.test)('writes to filesystem', async () => {
+        const writeFileCalls = [];
+        // Re-assigning the function manually with a mock
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const models = [
+            {
+                export: 'interface',
+                name: 'MyModel',
+                path: 'MyModel',
+                type: 'MyModel',
+                base: 'MyModel',
+                template: null,
+                link: null,
+                description: null,
+                isDefinition: true,
+                isReadOnly: false,
+                isRequired: false,
+                isNullable: false,
+                imports: [],
+                enum: [],
+                enums: [],
+                properties: [],
+                alias: '',
+            },
+        ];
+        const templates = {
+            indexes: {
+                full: () => 'fullIndex',
+                simple: () => 'simpleIndex',
+                core: () => 'coreIndex',
+                models: () => 'modelsIndex',
+                schemas: () => 'schemasIndex',
+                services: () => 'servicesIndex',
+            },
+            exports: {
+                model: () => 'model',
+                schema: () => 'schema',
+                service: () => 'service',
+            },
+            core: {
+                settings: () => 'settings',
+                apiError: () => 'apiError',
+                apiRequestOptions: () => 'apiRequestOptions',
+                apiResult: () => 'apiResult',
+                request: () => 'request',
+                cancelablePromise: () => 'cancelablePromise',
+                httpStatusCode: () => 'httpStatusCode',
+            },
+        };
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientModels({
+            models,
+            templates,
+            outputModelsPath: '/',
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useUnionTypes: false,
+        });
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModel.ts') && content.toString().includes('model')), 'Expected writeFile to be called with model content for MyModel.ts');
+        // Restoring the original function
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
     });
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModel.ts') && content.toString().includes('model')), 'Expected writeFile to be called with model content for MyModel.ts');
-    // Restoring the original function
-    fileSystem_1.fileSystem.writeFile = originalWriteFile;
 });

package/dist/core/utils/__tests__/writeClientSchemas.test.js

@@ -5,70 +5,72 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
+const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const WriteClient_1 = require("../../WriteClient");
-const fileSystem_1 = require("../fileSystem");
-(0, node_test_1.test)('@unit: writeClientSchemas writes to filesystem', async () => {
-    const writeFileCalls = [];
-    // Re-assigning the function manually with a mock
-    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
-    fileSystem_1.fileSystem.writeFile = async (path, content) => {
-        writeFileCalls.push([path, content]);
-    };
-    const models = [
-        {
-            export: 'interface',
-            name: 'MyModel',
-            alias: '',
-            path: 'MyModel',
-            type: 'MyModel',
-            base: 'MyModel',
-            template: null,
-            link: null,
-            description: null,
-            isDefinition: true,
-            isReadOnly: false,
-            isRequired: false,
-            isNullable: false,
-            imports: [],
-            enum: [],
-            enums: [],
-            properties: [],
-        },
-    ];
-    const templates = {
-        indexes: {
-            full: () => 'fullIndex',
-            simple: () => 'simpleIndex',
-            core: () => 'coreIndex',
-            models: () => 'modelsIndex',
-            schemas: () => 'schemasIndex',
-            services: () => 'servicesIndex',
-        },
-        exports: {
-            model: () => 'model',
-            schema: () => 'schema',
-            service: () => 'service',
-        },
-        core: {
-            settings: () => 'settings',
-            apiError: () => 'apiError',
-            apiRequestOptions: () => 'apiRequestOptions',
-            apiResult: () => 'apiResult',
-            request: () => 'request',
-            cancelablePromise: () => 'cancelablePromise',
-            httpStatusCode: () => 'httpStatusCode',
-        },
-    };
-    const writeClient = new WriteClient_1.WriteClient();
-    await writeClient.writeClientSchemas({
-        models,
-        templates,
-        outputSchemasPath: '/',
-        httpClient: HttpClient_enum_1.HttpClient.FETCH,
-        useUnionTypes: false,
+(0, node_test_1.describe)('@unit: writeClientSchemas', () => {
+    (0, node_test_1.test)('writes to filesystem', async () => {
+        const writeFileCalls = [];
+        // Re-assigning the function manually with a mock
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const models = [
+            {
+                export: 'interface',
+                name: 'MyModel',
+                alias: '',
+                path: 'MyModel',
+                type: 'MyModel',
+                base: 'MyModel',
+                template: null,
+                link: null,
+                description: null,
+                isDefinition: true,
+                isReadOnly: false,
+                isRequired: false,
+                isNullable: false,
+                imports: [],
+                enum: [],
+                enums: [],
+                properties: [],
+            },
+        ];
+        const templates = {
+            indexes: {
+                full: () => 'fullIndex',
+                simple: () => 'simpleIndex',
+                core: () => 'coreIndex',
+                models: () => 'modelsIndex',
+                schemas: () => 'schemasIndex',
+                services: () => 'servicesIndex',
+            },
+            exports: {
+                model: () => 'model',
+                schema: () => 'schema',
+                service: () => 'service',
+            },
+            core: {
+                settings: () => 'settings',
+                apiError: () => 'apiError',
+                apiRequestOptions: () => 'apiRequestOptions',
+                apiResult: () => 'apiResult',
+                request: () => 'request',
+                cancelablePromise: () => 'cancelablePromise',
+                httpStatusCode: () => 'httpStatusCode',
+            },
+        };
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientSchemas({
+            models,
+            templates,
+            outputSchemasPath: '/',
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useUnionTypes: false,
+        });
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModelSchema.ts') && content.toString().includes('schema')), 'Expected writeFile to be called with schema content for MyModelSchema.ts');
+        // Restoring the original function
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
     });
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyModelSchema.ts') && content.toString().includes('schema')), 'Expected writeFile to be called with schema content for MyModelSchema.ts');
-    // Restoring the original function
-    fileSystem_1.fileSystem.writeFile = originalWriteFile;
 });

package/dist/core/utils/__tests__/writeClientServices.test.js

@@ -5,65 +5,67 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
+const fileSystemHelpers_1 = require("../../../common/utils/fileSystemHelpers");
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const WriteClient_1 = require("../../WriteClient");
-const fileSystem_1 = require("../fileSystem");
-(0, node_test_1.test)('@unit: writeClientServices  writes to filesystem', async () => {
-    const writeFileCalls = [];
-    // Re-assigning the function manually with a mock
-    const originalWriteFile = fileSystem_1.fileSystem.writeFile;
-    fileSystem_1.fileSystem.writeFile = async (path, content) => {
-        writeFileCalls.push([path, content]);
-    };
-    const services = [
-        {
-            name: 'MyService',
-            originName: 'MyService',
-            operations: [],
-            imports: [],
-        },
-    ];
-    const templates = {
-        indexes: {
-            full: () => 'fullIndex',
-            simple: () => 'simpleIndex',
-            core: () => 'coreIndex',
-            models: () => 'modelsIndex',
-            schemas: () => 'schemasIndex',
-            services: () => 'servicesIndex',
-        },
-        exports: {
-            model: () => 'model',
-            schema: () => 'schema',
-            service: () => 'service',
-        },
-        core: {
-            settings: () => 'settings',
-            apiError: () => 'apiError',
-            apiRequestOptions: () => 'apiRequestOptions',
-            apiResult: () => 'apiResult',
-            request: () => 'request',
-            cancelablePromise: () => 'cancelablePromise',
-            httpStatusCode: () => 'httpStatusCode',
-        },
-    };
-    const writeClient = new WriteClient_1.WriteClient();
-    await writeClient.writeClientServices({
-        services,
-        templates,
-        outputPaths: {
-            outputCore: '/',
-            outputModels: '/',
-            outputServices: '/',
-        },
-        httpClient: HttpClient_enum_1.HttpClient.FETCH,
-        useUnionTypes: false,
-        useOptions: false,
-        useCancelableRequest: false,
+(0, node_test_1.describe)('@unit: writeClientServices', () => {
+    (0, node_test_1.test)('writes to filesystem', async () => {
+        const writeFileCalls = [];
+        // Re-assigning the function manually with a mock
+        const originalWriteFile = fileSystemHelpers_1.fileSystemHelpers.writeFile;
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = async (path, content) => {
+            writeFileCalls.push([path, content]);
+        };
+        const services = [
+            {
+                name: 'MyService',
+                originName: 'MyService',
+                operations: [],
+                imports: [],
+            },
+        ];
+        const templates = {
+            indexes: {
+                full: () => 'fullIndex',
+                simple: () => 'simpleIndex',
+                core: () => 'coreIndex',
+                models: () => 'modelsIndex',
+                schemas: () => 'schemasIndex',
+                services: () => 'servicesIndex',
+            },
+            exports: {
+                model: () => 'model',
+                schema: () => 'schema',
+                service: () => 'service',
+            },
+            core: {
+                settings: () => 'settings',
+                apiError: () => 'apiError',
+                apiRequestOptions: () => 'apiRequestOptions',
+                apiResult: () => 'apiResult',
+                request: () => 'request',
+                cancelablePromise: () => 'cancelablePromise',
+                httpStatusCode: () => 'httpStatusCode',
+            },
+        };
+        const writeClient = new WriteClient_1.WriteClient();
+        await writeClient.writeClientServices({
+            services,
+            templates,
+            outputPaths: {
+                outputCore: '/',
+                outputModels: '/',
+                outputServices: '/',
+            },
+            httpClient: HttpClient_enum_1.HttpClient.FETCH,
+            useUnionTypes: false,
+            useOptions: false,
+            useCancelableRequest: false,
+        });
+        node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyService.ts') && content.toString().includes('service')), 'Expected writeFile to be called with service content for MyService.ts');
+        // Restoring the original function
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        fileSystemHelpers_1.fileSystemHelpers.writeFile = originalWriteFile;
     });
-    node_assert_1.default.ok(writeFileCalls.some(([filePath, content]) => filePath.toString().includes('MyService.ts') && content.toString().includes('service')), 'Expected writeFile to be called with service content for MyService.ts');
-    // Restoring the original function
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    fileSystem_1.fileSystem.writeFile = originalWriteFile;
 });