tm1npm 1.0.0

package/src/tests/simpleCoverage.test.ts

@@ -0,0 +1,287 @@
+/**
+ * Simple Coverage Tests
+ * Basic tests to increase function coverage across existing services
+ */
+
+import { CellService } from '../services/CellService';
+import { ElementService } from '../services/ElementService';
+import { ProcessService } from '../services/ProcessService';
+
+describe('Simple Coverage Tests', () => {
+    const mockResponse = {
+        data: { 
+            value: [
+                { Name: 'TestElement', Type: 'Numeric' }
+            ]
+        },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {}
+    };
+
+    const mockStringResponse = {
+        data: { value: 'test' },
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {}
+    };
+
+    describe('CellService Tests', () => {
+        test('CellService should have async methods', () => {
+            const mockRest = {
+                get: jest.fn().mockResolvedValue(mockStringResponse),
+                post: jest.fn().mockResolvedValue(mockStringResponse),
+                patch: jest.fn().mockResolvedValue(mockStringResponse),
+                delete: jest.fn().mockResolvedValue(mockStringResponse),
+                put: jest.fn().mockResolvedValue(mockStringResponse)
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            
+            // Test basic method existence
+            expect(typeof cellService.getValue).toBe('function');
+            expect(typeof cellService.writeValue).toBe('function');
+            expect(typeof cellService.executeMdx).toBe('function');
+            expect(typeof cellService.writeDataframe).toBe('function');
+            expect(typeof cellService.writeAsync).toBe('function');
+        });
+
+        test('CellService async operations should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue({
+                    data: { ID: 'test-id' },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+                })
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            
+            // Test writeDataframeAsync
+            const result = await cellService.writeDataframeAsync(
+                'TestCube', 
+                [['Jan', 'Revenue', 1000]], 
+                ['Time', 'Account']
+            );
+            
+            expect(result).toBe('test-id');
+            expect(mockRest.post).toHaveBeenCalled();
+        });
+
+        test('CellService executeMdxAsync should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue({
+                    data: { ID: 'mdx-test-id' },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+                })
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            
+            const result = await cellService.executeMdxAsync('SELECT * FROM [TestCube]');
+            expect(result).toBe('mdx-test-id');
+        });
+    });
+
+    describe('ElementService Tests', () => {
+        test('ElementService should have advanced methods', () => {
+            const mockRest = {
+                get: jest.fn().mockResolvedValue(mockResponse),
+                post: jest.fn().mockResolvedValue(mockResponse),
+                patch: jest.fn().mockResolvedValue(mockResponse),
+                delete: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const elementService = new ElementService(mockRest);
+            
+            // Test method existence
+            expect(typeof elementService.deleteElementsUseTi).toBe('function');
+            expect(typeof elementService.deleteEdgesUseBlob).toBe('function');
+            expect(typeof elementService.getElementsByLevel).toBe('function');
+            expect(typeof elementService.getElementsFilteredByWildcard).toBe('function');
+            expect(typeof elementService.elementLock).toBe('function');
+            expect(typeof elementService.elementUnlock).toBe('function');
+        });
+
+        test('ElementService TI operations should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue(mockResponse),
+                delete: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const elementService = new ElementService(mockRest);
+            
+            await elementService.deleteElementsUseTi('TestDim', 'TestHier', ['Element1']);
+            expect(mockRest.post).toHaveBeenCalled();
+        });
+
+        test('ElementService lock operations should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const elementService = new ElementService(mockRest);
+            
+            await elementService.elementLock('TestDim', 'TestHier', 'Element1');
+            await elementService.elementUnlock('TestDim', 'TestHier', 'Element1');
+            expect(mockRest.post).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe('ProcessService Tests', () => {
+        test('ProcessService should have debug methods', () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const processService = new ProcessService(mockRest);
+            
+            // Test method existence
+            expect(typeof processService.debugStepOver).toBe('function');
+            expect(typeof processService.debugStepIn).toBe('function');
+            expect(typeof processService.debugStepOut).toBe('function');
+            expect(typeof processService.debugContinue).toBe('function');
+            expect(typeof processService.evaluateBooleanTiExpression).toBe('function');
+        });
+
+        test('ProcessService debug operations should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const processService = new ProcessService(mockRest);
+            
+            await processService.debugStepOver('TestProcess');
+            await processService.debugStepIn('TestProcess');
+            await processService.debugStepOut('TestProcess');
+            await processService.debugContinue('TestProcess');
+            
+            expect(mockRest.post).toHaveBeenCalledTimes(4);
+        });
+
+        test('ProcessService boolean expression evaluation should work', async () => {
+            const mockRest = {
+                post: jest.fn().mockResolvedValue({
+                    data: { value: true },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+                }),
+                get: jest.fn().mockResolvedValue({
+                    data: { Cells: [{ Value: true }] },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {}
+                }),
+                delete: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const processService = new ProcessService(mockRest);
+            
+            const result = await processService.evaluateBooleanTiExpression('1=1');
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('Error Handling Coverage', () => {
+        test('should handle service errors gracefully', async () => {
+            const mockRest = {
+                get: jest.fn().mockRejectedValue(new Error('Service error')),
+                post: jest.fn().mockRejectedValue(new Error('Service error'))
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            
+            await expect(cellService.getValue('TestCube', ['Jan']))
+                .rejects.toThrow('Service error');
+                
+            await expect(cellService.executeMdx('SELECT * FROM [TestCube]'))
+                .rejects.toThrow('Service error');
+        });
+
+        test('should handle timeout errors', async () => {
+            const mockRest = {
+                post: jest.fn().mockRejectedValue(new Error('Timeout'))
+            } as any;
+
+            const processService = new ProcessService(mockRest);
+            
+            await expect(processService.debugStepOver('TestProcess'))
+                .rejects.toThrow('Timeout');
+        });
+    });
+
+    describe('Method Signature Coverage', () => {
+        test('should test method existence and signatures', () => {
+            const mockRest = {
+                get: jest.fn().mockResolvedValue(mockResponse),
+                post: jest.fn().mockResolvedValue(mockResponse)
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            const elementService = new ElementService(mockRest);
+            
+            // Test method existence (don't call async methods synchronously)
+            expect(typeof cellService.getValue).toBe('function');
+            expect(typeof elementService.getLevelsCount).toBe('function');
+            expect(typeof elementService.getLevelNames).toBe('function');
+            
+            // Test that services are properly initialized
+            expect(cellService).toBeInstanceOf(CellService);
+            expect(elementService).toBeInstanceOf(ElementService);
+        });
+    });
+
+    describe('Constructor and Initialization Coverage', () => {
+        test('should properly initialize services', () => {
+            const mockRest = {} as any;
+            
+            const cellService = new CellService(mockRest);
+            const elementService = new ElementService(mockRest);
+            const processService = new ProcessService(mockRest);
+            
+            expect(cellService).toBeDefined();
+            expect(elementService).toBeDefined();
+            expect(processService).toBeDefined();
+        });
+    });
+
+    describe('Promise and Async Coverage', () => {
+        test('should handle promise chains', async () => {
+            const mockRest = {
+                post: jest.fn()
+                    .mockResolvedValueOnce({
+                        data: { ID: 'step1' },
+                        status: 200,
+                        statusText: 'OK',
+                        headers: {},
+                        config: {}
+                    })
+                    .mockResolvedValueOnce({
+                        data: { ID: 'step2' },
+                        status: 200,
+                        statusText: 'OK',
+                        headers: {},
+                        config: {}
+                    })
+            } as any;
+
+            const cellService = new CellService(mockRest);
+            
+            const result1 = await cellService.executeMdxAsync('SELECT * FROM [Cube1]');
+            const result2 = await cellService.executeMdxAsync('SELECT * FROM [Cube2]');
+            
+            expect(result1).toBe('step1');
+            expect(result2).toBe('step2');
+        });
+    });
+});