tm1npm 1.0.0

package/lib/tests/processService.test.js

@@ -0,0 +1,322 @@
+"use strict";
+/**
+ * ProcessService Tests for tm1npm
+ * Comprehensive tests for TM1 Process operations with proper mocking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ProcessService_1 = require("../services/ProcessService");
+const Process_1 = require("../objects/Process");
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+// Helper function to create mock AxiosResponse
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('ProcessService Tests', () => {
+    let processService;
+    let mockRestService;
+    beforeEach(() => {
+        // Create comprehensive mock for RestService
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {},
+            rest: {},
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        };
+        processService = new ProcessService_1.ProcessService(mockRestService);
+    });
+    describe('Process Retrieval Operations', () => {
+        test('should get all process names', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Process1' },
+                    { Name: 'Process2' },
+                    { Name: 'Process3' }
+                ]
+            }));
+            const processNames = await processService.getAllNames();
+            expect(Array.isArray(processNames)).toBe(true);
+            expect(processNames.length).toBe(3);
+            expect(processNames).toEqual(['Process1', 'Process2', 'Process3']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Processes?$select=Name");
+            console.log('✅ Process names retrieved successfully');
+        });
+        test('should get all processes with skip control processes', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'UserProcess1', HasSecurityAccess: true },
+                    { Name: 'UserProcess2', HasSecurityAccess: true }
+                ]
+            }));
+            const processes = await processService.getAll(true); // skip control processes
+            expect(Array.isArray(processes)).toBe(true);
+            expect(processes.length).toBe(2);
+            expect(processes[0].name).toBe('UserProcess1');
+            expect(processes[1].name).toBe('UserProcess2');
+            console.log('✅ All processes retrieved with control process filtering');
+        });
+        test('should get a specific process if it exists', async () => {
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                value: [{ Name: 'TestProcess' }]
+            }));
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'TestProcess',
+                HasSecurityAccess: true,
+                PrologProcedure: 'sMessage = "Hello World";',
+                MetadataProcedure: '',
+                DataProcedure: '',
+                EpilogProcedure: ''
+            }));
+            const processNames = await processService.getAllNames();
+            expect(processNames).toContain('TestProcess');
+            const process = await processService.get('TestProcess');
+            expect(process).toBeDefined();
+            expect(process.name).toBe('TestProcess');
+            console.log('✅ Specific process retrieved successfully');
+        });
+        test('should check if a process exists', async () => {
+            // Test existing process
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'ExistingProcess',
+                HasSecurityAccess: true
+            }));
+            const exists = await processService.exists('ExistingProcess');
+            expect(exists).toBe(true);
+            console.log('✅ Process existence check working');
+        });
+        test('should check if a process does not exist', async () => {
+            // Test non-existing process - create proper TM1RestException
+            const mockError = new TM1Exception_1.TM1RestException('Process not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await processService.exists('NonExistentProcess');
+            expect(notExists).toBe(false);
+            console.log('✅ Process non-existence check working');
+        });
+    });
+    describe('Process Execution Operations', () => {
+        test('should handle process execution attempts', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessExecuteStatusCode: 'CompletedSuccessfully',
+                ErrorLogFile: ''
+            }));
+            await processService.execute('TestProcess');
+            expect(mockRestService.post).toHaveBeenCalledWith("/Processes('TestProcess')/tm1.Execute", "{}");
+            console.log('✅ Process execution handled successfully');
+        });
+        test('should handle process execution with parameters', async () => {
+            const parameters = [
+                { Name: 'pParam1', Value: 'Value1' },
+                { Name: 'pParam2', Value: 123 }
+            ];
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessExecuteStatusCode: 'CompletedSuccessfully',
+                ErrorLogFile: ''
+            }));
+            await processService.executeWithReturn('TestProcess', parameters);
+            expect(mockRestService.post).toHaveBeenCalled();
+            console.log('✅ Process execution with parameters handled successfully');
+        });
+        test('should handle executeWithReturn attempts', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessExecuteStatusCode: 'CompletedSuccessfully',
+                ErrorLogFile: '',
+                ProcessReturnValue: 'Success'
+            }));
+            const result = await processService.executeWithReturn('TestProcess');
+            expect(result).toBeDefined();
+            expect(mockRestService.post).toHaveBeenCalled();
+            console.log('✅ Process executeWithReturn handled successfully');
+        });
+    });
+    describe('Process Compilation Operations', () => {
+        test('should handle process compilation attempts', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessCompileStatusCode: 'CompletedSuccessfully',
+                ErrorLogFile: ''
+            }));
+            const result = await processService.compile('TestProcess');
+            expect(result).toBeDefined();
+            expect(mockRestService.post).toHaveBeenCalledWith("/Processes('TestProcess')/tm1.Compile", "{}");
+            console.log('✅ Process compilation handled successfully');
+        });
+    });
+    describe('Process Error Handling', () => {
+        test('should handle invalid process names gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 400, statusText: 'Bad Request' }
+            });
+            await expect(processService.get('')).rejects.toMatchObject({
+                response: { status: 400 }
+            });
+            console.log('✅ Invalid process names handled gracefully');
+        });
+        test('should handle network errors gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                code: 'ECONNREFUSED'
+            });
+            await expect(processService.getAllNames()).rejects.toMatchObject({
+                code: 'ECONNREFUSED'
+            });
+            console.log('✅ Network errors handled gracefully');
+        });
+        test('should handle authentication errors', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 401, statusText: 'Unauthorized' }
+            });
+            await expect(processService.getAllNames()).rejects.toMatchObject({
+                response: { status: 401 }
+            });
+            console.log('✅ Authentication errors handled gracefully');
+        });
+    });
+    describe('Process Service Edge Cases', () => {
+        test('should handle empty process lists', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: []
+            }));
+            const processNames = await processService.getAllNames();
+            expect(Array.isArray(processNames)).toBe(true);
+            expect(processNames.length).toBe(0);
+            console.log('✅ Empty process lists handled correctly');
+        });
+        test('should handle concurrent process operations', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [{ Name: 'TestProcess' }]
+            }));
+            const operations = [
+                processService.getAllNames(),
+                processService.getAllNames(),
+                processService.getAllNames()
+            ];
+            const results = await Promise.allSettled(operations);
+            const successful = results.filter(r => r.status === 'fulfilled');
+            expect(successful.length).toBe(3);
+            console.log('✅ Concurrent operations handled successfully');
+        });
+        test('should handle large process lists efficiently', async () => {
+            const largeProcessList = Array(1000).fill(null).map((_, i) => ({
+                Name: `Process${i}`,
+                HasSecurityAccess: true
+            }));
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: largeProcessList
+            }));
+            const startTime = Date.now();
+            const processNames = await processService.getAllNames();
+            const endTime = Date.now();
+            expect(processNames.length).toBe(1000);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast with mocking
+            console.log('✅ Large process lists handled efficiently');
+        });
+    });
+    describe('Process Service Integration', () => {
+        test('should maintain consistent data across operations', async () => {
+            const processData = {
+                value: [
+                    { Name: 'Process1' },
+                    { Name: 'Process2' }
+                ]
+            };
+            mockRestService.get.mockResolvedValue(createMockResponse(processData));
+            const names1 = await processService.getAllNames();
+            const names2 = await processService.getAllNames();
+            expect(names1).toEqual(names2);
+            expect(names1).toEqual(['Process1', 'Process2']);
+            console.log('✅ Data consistency maintained across operations');
+        });
+    });
+    describe('Process CRUD Operations', () => {
+        test('should handle process creation and deletion lifecycle', async () => {
+            const testProcess = new Process_1.Process('TestProcess', true, // hasSecurityAccess
+            '', // uiData
+            [], // parameters
+            [], // variables
+            [], // variablesUiData
+            'sMessage = "Test Process";' // prologProcedure
+            );
+            // Mock process existence check (false initially)
+            const mockError = new TM1Exception_1.TM1RestException('Process not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValueOnce(mockError);
+            const initialExists = await processService.exists('TestProcess');
+            expect(initialExists).toBe(false);
+            // Mock process creation
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await processService.create(testProcess);
+            // Mock process existence check (true after creation)
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'TestProcess',
+                HasSecurityAccess: true
+            }));
+            const afterCreationExists = await processService.exists('TestProcess');
+            expect(afterCreationExists).toBe(true);
+            // Mock process deletion
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            await processService.delete('TestProcess');
+            console.log('✅ Process lifecycle operations handled successfully');
+        });
+    });
+    describe('Process Search Operations', () => {
+        test('should handle searchStringInCode functionality', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    {
+                        Name: 'ProcessWithCode',
+                        PrologProcedure: 'sMessage = "Hello World";',
+                        HasSecurityAccess: true
+                    },
+                    {
+                        Name: 'ProcessWithoutCode',
+                        PrologProcedure: 'nValue = 123;',
+                        HasSecurityAccess: true
+                    }
+                ]
+            }));
+            const results = await processService.searchStringInCode('Hello');
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBe(1);
+            expect(results[0]).toBe('ProcessWithCode'); // Returns process name string, not object
+            console.log('✅ Search string in code functionality working');
+        });
+        test('should handle empty search results gracefully', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    {
+                        Name: 'Process1',
+                        PrologProcedure: 'nValue = 123;',
+                        HasSecurityAccess: true
+                    }
+                ]
+            }));
+            const results = await processService.searchStringInCode('NonExistentString');
+            expect(Array.isArray(results)).toBe(true);
+            expect(results.length).toBe(0);
+            console.log('✅ Empty search results handled gracefully');
+        });
+    });
+    describe('Process Debug Operations', () => {
+        test('should handle debug breakpoint operations for existing processes', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [{ Name: 'DebugProcess' }]
+            }));
+            // Mock debug operations (these would typically return specific debug info)
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                DebugInfo: 'Breakpoint set successfully'
+            }));
+            const processNames = await processService.getAllNames();
+            expect(processNames).toContain('DebugProcess');
+            // In a real implementation, this would set debug breakpoints
+            // For now, we just verify the mock interaction
+            expect(mockRestService.get).toHaveBeenCalled();
+            console.log('✅ Debug operations handled for existing processes');
+        });
+    });
+});
+//# sourceMappingURL=processService.test.js.map

package/lib/tests/restService.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RestService Tests for tm1npm
+ * Comprehensive tests for TM1 REST API operations with proper mocking
+ */
+export {};
+//# sourceMappingURL=restService.test.d.ts.map

package/lib/tests/restService.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"restService.test.d.ts","sourceRoot":"","sources":["../../src/tests/restService.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/lib/tests/restService.test.js

@@ -0,0 +1,177 @@
+"use strict";
+/**
+ * RestService Tests for tm1npm
+ * Comprehensive tests for TM1 REST API operations with proper mocking
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RestService_1 = require("../services/RestService");
+const axios_1 = __importDefault(require("axios"));
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+// Helper function to create mock AxiosResponse
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('RestService Tests', () => {
+    let restService;
+    beforeEach(() => {
+        // Clear all mocks
+        jest.clearAllMocks();
+        // Mock axios.create
+        const mockAxiosInstance = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            interceptors: {
+                request: { use: jest.fn() },
+                response: { use: jest.fn() }
+            }
+        };
+        mockedAxios.create.mockReturnValue(mockAxiosInstance);
+        const config = {
+            baseUrl: 'http://localhost:8879/api/v1',
+            user: 'admin',
+            password: 'password',
+            timeout: 30000
+        };
+        restService = new RestService_1.RestService(config);
+    });
+    describe('Basic HTTP Operations', () => {
+        test('should handle GET requests', async () => {
+            const mockResponse = createMockResponse({ value: '11.8.0' });
+            restService.axiosInstance.get.mockResolvedValue(mockResponse);
+            const response = await restService.get('/Configuration/ProductVersion');
+            expect(response.status).toBe(200);
+            expect(response.data.value).toBe('11.8.0');
+        });
+        test('should handle POST requests', async () => {
+            const mockResponse = createMockResponse({}, 201);
+            restService.axiosInstance.post.mockResolvedValue(mockResponse);
+            const response = await restService.post('/test', { data: 'test' });
+            expect(response.status).toBe(201);
+        });
+        test('should handle PATCH requests', async () => {
+            const mockResponse = createMockResponse({}, 200);
+            restService.axiosInstance.patch.mockResolvedValue(mockResponse);
+            const response = await restService.patch('/test', { data: 'updated' });
+            expect(response.status).toBe(200);
+        });
+        test('should handle DELETE requests', async () => {
+            const mockResponse = createMockResponse({}, 204);
+            restService.axiosInstance.delete.mockResolvedValue(mockResponse);
+            const response = await restService.delete('/test');
+            expect(response.status).toBe(204);
+        });
+        test('should handle PUT requests', async () => {
+            const mockResponse = createMockResponse({}, 200);
+            restService.axiosInstance.put.mockResolvedValue(mockResponse);
+            const response = await restService.put('/test', { data: 'test' });
+            expect(response.status).toBe(200);
+        });
+    });
+    describe('Configuration and Setup', () => {
+        test('should build base URL correctly', () => {
+            expect(restService).toBeDefined();
+            expect(restService.config.baseUrl).toContain('localhost:8879');
+        });
+        test('should set timeout correctly', () => {
+            expect(restService.config.timeout).toBe(30000);
+        });
+        test('should handle authentication config', () => {
+            expect(restService.config.user).toBe('admin');
+            expect(restService.config.password).toBe('password');
+        });
+    });
+    describe('Session Management', () => {
+        test('should handle session ID', () => {
+            restService.setSandbox('TestSandbox');
+            expect(restService.getSandbox()).toBe('TestSandbox');
+        });
+        test('should check login status', () => {
+            // Initially not logged in
+            expect(restService.isLoggedIn()).toBe(false);
+        });
+    });
+    describe('Error Handling', () => {
+        test('should handle network errors', async () => {
+            const networkError = new Error('Network Error');
+            restService.axiosInstance.get.mockRejectedValue(networkError);
+            await expect(restService.get('/test')).rejects.toThrow('Network Error');
+        });
+        test('should handle HTTP errors', async () => {
+            const httpError = {
+                response: {
+                    status: 404,
+                    statusText: 'Not Found',
+                    data: { error: 'Resource not found' }
+                }
+            };
+            restService.axiosInstance.get.mockRejectedValue(httpError);
+            await expect(restService.get('/nonexistent')).rejects.toMatchObject(httpError);
+        });
+        test('should handle timeout errors', async () => {
+            const timeoutError = {
+                code: 'ECONNABORTED',
+                message: 'timeout of 30000ms exceeded'
+            };
+            restService.axiosInstance.get.mockRejectedValue(timeoutError);
+            await expect(restService.get('/slow-endpoint')).rejects.toMatchObject(timeoutError);
+        });
+    });
+    describe('API Metadata', () => {
+        test('should get API metadata', async () => {
+            const mockResponse = createMockResponse({
+                version: '1.0',
+                capabilities: ['read', 'write']
+            });
+            restService.axiosInstance.get.mockResolvedValue(mockResponse);
+            const metadata = await restService.getApiMetadata();
+            expect(metadata.version).toBe('1.0');
+            expect(metadata.capabilities).toEqual(['read', 'write']);
+        });
+    });
+    describe('RestService Integration', () => {
+        test('should handle complex request scenarios', async () => {
+            // Mock a sequence of operations
+            const getMockResponse = createMockResponse({ id: 'test123' });
+            const postMockResponse = createMockResponse({}, 201);
+            const patchMockResponse = createMockResponse({}, 200);
+            const deleteMockResponse = createMockResponse({}, 204);
+            restService.axiosInstance.get
+                .mockResolvedValueOnce(getMockResponse);
+            restService.axiosInstance.post
+                .mockResolvedValueOnce(postMockResponse);
+            restService.axiosInstance.patch
+                .mockResolvedValueOnce(patchMockResponse);
+            restService.axiosInstance.delete
+                .mockResolvedValueOnce(deleteMockResponse);
+            // Execute sequence
+            const getResponse = await restService.get('/test');
+            expect(getResponse.data.id).toBe('test123');
+            const postResponse = await restService.post('/test', { name: 'test' });
+            expect(postResponse.status).toBe(201);
+            const patchResponse = await restService.patch('/test', { name: 'updated' });
+            expect(patchResponse.status).toBe(200);
+            const deleteResponse = await restService.delete('/test');
+            expect(deleteResponse.status).toBe(204);
+        });
+        test('should maintain consistency across operations', async () => {
+            const mockResponse = createMockResponse({ consistent: true });
+            restService.axiosInstance.get.mockResolvedValue(mockResponse);
+            const response1 = await restService.get('/test');
+            const response2 = await restService.get('/test');
+            expect(response1.data).toEqual(response2.data);
+        });
+    });
+});
+//# sourceMappingURL=restService.test.js.map

package/lib/tests/security.advanced.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Advanced Security and Validation Tests for tm1npm
+ * Comprehensive security testing covering injection, validation, and edge cases
+ */
+export {};
+//# sourceMappingURL=security.advanced.test.d.ts.map

package/lib/tests/security.advanced.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.advanced.test.d.ts","sourceRoot":"","sources":["../../src/tests/security.advanced.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}