tm1npm 1.0.0

package/src/tests/enhancedCellService.test.ts

@@ -0,0 +1,237 @@
+import { CellService } from '../services/CellService';
+import { RestService } from '../services/RestService';
+import axios, { AxiosResponse } from 'axios';
+
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Enhanced CellService Tests', () => {
+    let cellService: CellService;
+    let mockRestService: jest.Mocked<RestService>;
+
+    const createMockResponse = (data: any, status: number = 200): AxiosResponse => ({
+        data,
+        status,
+        statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : 'Error',
+        headers: {},
+        config: {} as any
+    });
+
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn()
+        } as any;
+
+        cellService = new CellService(mockRestService);
+    });
+
+    describe('Enhanced Data Writing Functions', () => {
+        test('writeDataframe should write tabular data to cube', async () => {
+            const dataFrame = [
+                ['2024', 'Actual', 'London', 100],
+                ['2024', 'Forecast', 'Paris', 200]
+            ];
+            const dimensions = ['Year', 'Version', 'Region'];
+
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+
+            await cellService.writeDataframe('SalesCube', dataFrame, dimensions);
+
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.Update",
+                expect.objectContaining({
+                    Cells: expect.arrayContaining([
+                        expect.objectContaining({
+                            Coordinates: [
+                                { Name: '2024' },
+                                { Name: 'Actual' },
+                                { Name: 'London' }
+                            ],
+                            Value: 100
+                        })
+                    ])
+                })
+            );
+            
+            console.log('✅ writeDataframe test passed');
+        });
+
+        test('writeAsync should return async operation ID', async () => {
+            const cellset = { '2024,Actual,London': 100 };
+
+            mockRestService.patch.mockResolvedValue(createMockResponse(
+                { ID: 'async-123' }
+            ));
+
+            const asyncId = await cellService.writeAsync('SalesCube', cellset);
+
+            expect(asyncId).toBe('async-123');
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.UpdateAsync",
+                expect.objectContaining({
+                    Cells: expect.any(Array)
+                })
+            );
+            
+            console.log('✅ writeAsync test passed');
+        });
+
+        test('writeThroughUnboundProcess should execute TI statements', async () => {
+            const cellset = { '2024,Actual,London': 100 };
+
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessExecuteStatusCode: 'CompletedSuccessfully'
+            }));
+
+            const result = await cellService.writeThroughUnboundProcess('SalesCube', cellset);
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                '/ExecuteProcessWithReturn',
+                expect.objectContaining({
+                    PrologProcedure: expect.stringContaining("CubeDataSet('SalesCube'")
+                })
+            );
+            
+            console.log('✅ writeThroughUnboundProcess test passed');
+        });
+
+        test('writeThroughBlob should upload CSV and load from blob', async () => {
+            const csvData = "Year,Version,Region,Value\\n2024,Actual,London,100";
+
+            mockRestService.post
+                .mockResolvedValueOnce(createMockResponse({ ID: 'blob-123' })) // Blob upload
+                .mockResolvedValueOnce(createMockResponse({})); // Cube load
+
+            await cellService.writeThroughBlob('SalesCube', csvData);
+
+            expect(mockRestService.post).toHaveBeenCalledTimes(2);
+            expect(mockRestService.post).toHaveBeenNthCalledWith(1, '/Blobs', csvData, {
+                headers: { 'Content-Type': 'text/csv' }
+            });
+            expect(mockRestService.post).toHaveBeenNthCalledWith(2, 
+                "/Cubes('SalesCube')/tm1.LoadFromBlob",
+                { BlobId: 'blob-123' }
+            );
+            
+            console.log('✅ writeThroughBlob test passed');
+        });
+    });
+
+    describe('Enhanced Data Reading Functions', () => {
+        test('executeMdxElementsValueDict should return element-value dictionary', async () => {
+            const mockData = { 'London': 100, 'Paris': 200, 'Berlin': 150 };
+
+            mockRestService.post.mockResolvedValue(createMockResponse(mockData));
+
+            const result = await cellService.executeMdxElementsValueDict(
+                'SELECT NON EMPTY {[Region].Members} ON 0 FROM [SalesCube]'
+            );
+
+            expect(result).toEqual(mockData);
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                '/ExecuteMDXElementsValue',
+                { MDX: 'SELECT NON EMPTY {[Region].Members} ON 0 FROM [SalesCube]' }
+            );
+            
+            console.log('✅ executeMdxElementsValueDict test passed');
+        });
+    });
+
+    describe('Advanced Operations', () => {
+        test('clearWithDataframe should clear based on DataFrame coordinates', async () => {
+            const dataFrame = [
+                ['2024', 'Actual', 'London'],
+                ['2024', 'Forecast', 'Paris']
+            ];
+            const dimensions = ['Year', 'Version', 'Region'];
+
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cellService.clearWithDataframe('SalesCube', dataFrame, dimensions);
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.Clear",
+                expect.objectContaining({
+                    MDX: expect.stringContaining("('2024','Actual','London')")
+                })
+            );
+            
+            console.log('✅ clearWithDataframe test passed');
+        });
+
+        test('relativeProportionalSpread should execute proportional spread', async () => {
+            const coordinates = ['2024', 'Actual', 'Total'];
+
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cellService.relativeProportionalSpread('SalesCube', coordinates, 1000);
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.ProportionalSpread(coordinates=['2024','Actual','Total'],value=1000)"
+            );
+            
+            console.log('✅ relativeProportionalSpread test passed');
+        });
+
+        test('clearSpread should execute clear spread', async () => {
+            const coordinates = ['2024', 'Actual', 'Total'];
+
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cellService.clearSpread('SalesCube', coordinates);
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.ClearSpread(coordinates=['2024','Actual','Total'])"
+            );
+            
+            console.log('✅ clearSpread test passed');
+        });
+
+        test('checkCellFeeders should return feeder status', async () => {
+            const coordinates = ['2024', 'Actual', 'London'];
+
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: true }));
+
+            const hasFeeders = await cellService.checkCellFeeders('SalesCube', coordinates);
+
+            expect(hasFeeders).toBe(true);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.CheckCellFeeders(coordinates=['2024','Actual','London'])"
+            );
+            
+            console.log('✅ checkCellFeeders test passed');
+        });
+    });
+
+    describe('Error Handling', () => {
+        test('should handle write errors gracefully', async () => {
+            const cellset = { '2024,Actual,London': 100 };
+
+            mockRestService.patch.mockRejectedValue(new Error('Server Error'));
+
+            await expect(cellService.write('SalesCube', cellset)).rejects.toThrow('Server Error');
+            
+            console.log('✅ Error handling test passed');
+        });
+
+        test('should handle sandbox operations', async () => {
+            const cellset = { '2024,Actual,London': 100 };
+
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+
+            await cellService.write('SalesCube', cellset, undefined, { sandbox_name: 'TestSandbox' });
+
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('SalesCube')/tm1.Update?$sandbox=TestSandbox",
+                expect.any(Object)
+            );
+            
+            console.log('✅ Sandbox operations test passed');
+        });
+    });
+});

package/src/tests/enhancedCubeService.test.ts

@@ -0,0 +1,384 @@
+import { CubeService } from '../services/CubeService';
+import { RestService } from '../services/RestService';
+import { Cube } from '../objects/Cube';
+import { Rules } from '../objects/Rules';
+import axios, { AxiosResponse } from 'axios';
+
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+describe('Enhanced CubeService Tests', () => {
+    let cubeService: CubeService;
+    let mockRestService: jest.Mocked<RestService>;
+
+    const createMockResponse = (data: any, status: number = 200): AxiosResponse => ({
+        data,
+        status,
+        statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : 'Error',
+        headers: {},
+        config: {} as any
+    });
+
+    const mockCube = {
+        name: 'TestCube',
+        dimensions: ['Year', 'Region', 'Product'],
+        rules: { text: 'RULE; C: = 1; FEEDERS;' }
+    };
+
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn()
+        } as any;
+
+        cubeService = new CubeService(mockRestService);
+    });
+
+    describe('Cube Analysis Functions', () => {
+        test('searchForDimensionSubstring should find cubes with matching dimensions', async () => {
+            const mockCubes = [
+                { name: 'SalesCube', dimensions: ['Year', 'Region', 'Product'] },
+                { name: 'BudgetCube', dimensions: ['Year', 'Department', 'Account'] },
+                { name: 'PlanningCube', dimensions: ['Month', 'Region', 'Scenario'] }
+            ];
+
+            jest.spyOn(cubeService, 'getAll').mockResolvedValue(mockCubes as any);
+
+            const result = await cubeService.searchForDimensionSubstring('Reg');
+
+            expect(result).toEqual({
+                'SalesCube': ['Region'],
+                'PlanningCube': ['Region']
+            });
+            
+            console.log('✅ searchForDimensionSubstring test passed');
+        });
+
+        test('searchForRuleSubstring should find cubes with matching rules', async () => {
+            const mockCubes = [
+                { 
+                    name: 'TestCube1', 
+                    dimensions: ['Year'], 
+                    rules: { text: 'RULE; N: C = 1; FEEDERS;' }
+                },
+                { 
+                    name: 'TestCube2', 
+                    dimensions: ['Month'], 
+                    rules: { text: 'RULE; S: C = "Test"; FEEDERS;' }
+                }
+            ];
+
+            jest.spyOn(cubeService, 'getAll').mockResolvedValue(mockCubes as any);
+
+            const result = await cubeService.searchForRuleSubstring('RULE');
+
+            expect(result).toHaveLength(2);
+            expect(result[0].name).toBe('TestCube1');
+            expect(result[1].name).toBe('TestCube2');
+            
+            console.log('✅ searchForRuleSubstring test passed');
+        });
+
+        test('getStorageDimensionOrder should return ordered dimension names', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Year' },
+                    { Name: 'Region' },
+                    { Name: 'Product' }
+                ]
+            }));
+
+            const result = await cubeService.getStorageDimensionOrder('TestCube');
+
+            expect(result).toEqual(['Year', 'Region', 'Product']);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/Dimensions?$select=Name"
+            );
+            
+            console.log('✅ getStorageDimensionOrder test passed');
+        });
+
+        test('updateStorageDimensionOrder should reorder dimensions', async () => {
+            const newOrder = ['Product', 'Region', 'Year'];
+
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.updateStorageDimensionOrder('TestCube', newOrder);
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.UpdateStorageOrder",
+                { Dimensions: newOrder }
+            );
+            
+            console.log('✅ updateStorageDimensionOrder test passed');
+        });
+
+        test('getRandomIntersection should return random intersection', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: ['2024', 'North', 'ProductA']
+            }));
+
+            const result = await cubeService.getRandomIntersection('TestCube');
+
+            expect(result).toEqual(['2024', 'North', 'ProductA']);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.GetRandomIntersection"
+            );
+            
+            console.log('✅ getRandomIntersection test passed');
+        });
+
+        test('getRandomIntersection with unique names should include uniqueNames parameter', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: ['[Year].[2024]', '[Region].[North]', '[Product].[ProductA]']
+            }));
+
+            const result = await cubeService.getRandomIntersection('TestCube', true);
+
+            expect(result).toEqual(['[Year].[2024]', '[Region].[North]', '[Product].[ProductA]']);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.GetRandomIntersection?uniqueNames=true"
+            );
+            
+            console.log('✅ getRandomIntersection with unique names test passed');
+        });
+    });
+
+    describe('Memory Management Functions', () => {
+        test('load should load cube into memory', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.load('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.Load"
+            );
+            
+            console.log('✅ load test passed');
+        });
+
+        test('unload should unload cube from memory', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.unload('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.Unload"
+            );
+            
+            console.log('✅ unload test passed');
+        });
+
+        test('lock should lock cube', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.lock('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.Lock"
+            );
+            
+            console.log('✅ lock test passed');
+        });
+
+        test('unlock should unlock cube', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.unlock('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.Unlock"
+            );
+            
+            console.log('✅ unlock test passed');
+        });
+
+        test('cubeSaveData should save cube data to disk', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.cubeSaveData('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.SaveData"
+            );
+            
+            console.log('✅ cubeSaveData test passed');
+        });
+    });
+
+    describe('Memory Configuration Functions', () => {
+        test('getVmm should get view storage max memory', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('256'));
+
+            const result = await cubeService.getVmm('TestCube');
+
+            expect(result).toBe(256);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/ViewStorageMaxMemory/$value"
+            );
+            
+            console.log('✅ getVmm test passed');
+        });
+
+        test('setVmm should set view storage max memory', async () => {
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.setVmm('TestCube', 512);
+
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/ViewStorageMaxMemory",
+                { Value: 512 }
+            );
+            
+            console.log('✅ setVmm test passed');
+        });
+
+        test('getVmt should get view storage min time', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('30'));
+
+            const result = await cubeService.getVmt('TestCube');
+
+            expect(result).toBe(30);
+            expect(mockRestService.get).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/ViewStorageMinTime/$value"
+            );
+            
+            console.log('✅ getVmt test passed');
+        });
+
+        test('setVmt should set view storage min time', async () => {
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.setVmt('TestCube', 60);
+
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/ViewStorageMinTime",
+                { Value: 60 }
+            );
+            
+            console.log('✅ setVmt test passed');
+        });
+    });
+
+    describe('Rules Management Functions', () => {
+        test('checkRules should validate cube rules syntax', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                Errors: [],
+                Valid: true
+            }));
+
+            const result = await cubeService.checkRules('TestCube');
+
+            expect(result.data.Valid).toBe(true);
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/tm1.CheckRules"
+            );
+            
+            console.log('✅ checkRules test passed');
+        });
+
+        test('updateOrCreateRules should update rules with string input', async () => {
+            const rulesText = 'RULE; N: = C * 1.1; FEEDERS;';
+
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.updateOrCreateRules('TestCube', rulesText);
+
+            expect(mockRestService.patch).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/Rules",
+                { Text: rulesText }
+            );
+            
+            console.log('✅ updateOrCreateRules with string test passed');
+        });
+
+        test('updateOrCreateRules should create rules if update fails', async () => {
+            const rulesText = 'RULE; N: = C * 1.1; FEEDERS;';
+
+            mockRestService.patch.mockRejectedValue(new Error('Not Found'));
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+
+            await cubeService.updateOrCreateRules('TestCube', rulesText);
+
+            expect(mockRestService.patch).toHaveBeenCalled();
+            expect(mockRestService.post).toHaveBeenCalledWith(
+                "/Cubes('TestCube')/Rules",
+                { Text: rulesText }
+            );
+            
+            console.log('✅ updateOrCreateRules fallback to create test passed');
+        });
+    });
+
+    describe('Error Handling', () => {
+        test('should handle empty search results', async () => {
+            const mockCubes = [
+                { name: 'TestCube', dimensions: ['Year', 'Month'], rules: null }
+            ];
+
+            jest.spyOn(cubeService, 'getAll').mockResolvedValue(mockCubes as any);
+
+            const result = await cubeService.searchForDimensionSubstring('NonExistent');
+
+            expect(result).toEqual({});
+            
+            console.log('✅ Empty search results handling test passed');
+        });
+
+        test('should handle cubes without rules in rule search', async () => {
+            const mockCubes = [
+                { name: 'TestCube', dimensions: ['Year'], rules: null }
+            ];
+
+            jest.spyOn(cubeService, 'getAll').mockResolvedValue(mockCubes as any);
+
+            const result = await cubeService.searchForRuleSubstring('RULE');
+
+            expect(result).toEqual([]);
+            
+            console.log('✅ No rules handling test passed');
+        });
+
+        test('should handle invalid memory values gracefully', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('invalid'));
+
+            const result = await cubeService.getVmm('TestCube');
+
+            expect(result).toBe(0);
+            
+            console.log('✅ Invalid memory value handling test passed');
+        });
+    });
+
+    describe('Integration Tests', () => {
+        test('should perform complete cube memory management workflow', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+            mockRestService.get.mockResolvedValue(createMockResponse('128'));
+
+            // Load cube
+            await cubeService.load('TestCube');
+            
+            // Set memory configuration
+            await cubeService.setVmm('TestCube', 256);
+            await cubeService.setVmt('TestCube', 30);
+            
+            // Verify settings
+            const vmm = await cubeService.getVmm('TestCube');
+            
+            // Save and unload
+            await cubeService.cubeSaveData('TestCube');
+            await cubeService.unload('TestCube');
+
+            expect(mockRestService.post).toHaveBeenCalledTimes(3); // load, save, unload
+            expect(mockRestService.patch).toHaveBeenCalledTimes(2); // set vmm, set vmt
+            expect(vmm).toBe(128);
+            
+            console.log('✅ Complete memory management workflow test passed');
+        });
+    });
+});