tm1npm 1.0.0

package/lib/tests/enhancedCubeService.test.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CubeService_1 = require("../services/CubeService");
+const axios_1 = __importDefault(require("axios"));
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('Enhanced CubeService Tests', () => {
+    let cubeService;
+    let mockRestService;
+    const createMockResponse = (data, status = 200) => ({
+        data,
+        status,
+        statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : 'Error',
+        headers: {},
+        config: {}
+    });
+    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()
+        };
+        cubeService = new CubeService_1.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);
+            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);
+            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);
+            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);
+            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');
+        });
+    });
+});
+//# sourceMappingURL=enhancedCubeService.test.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=enhancedElementService.test.d.ts.map

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

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

package/lib/tests/enhancedElementService.test.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ElementService_1 = require("../services/ElementService");
+const axios_1 = __importDefault(require("axios"));
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('Enhanced ElementService Tests', () => {
+    let elementService;
+    let mockRestService;
+    const createMockResponse = (data, status = 200) => ({
+        data,
+        status,
+        statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : 'Error',
+        headers: {},
+        config: {}
+    });
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn()
+        };
+        elementService = new ElementService_1.ElementService(mockRestService);
+    });
+    describe('Bulk Operations', () => {
+        test('deleteElements should delete multiple elements via REST', async () => {
+            const elementNames = ['Element1', 'Element2', 'Element3'];
+            mockRestService.delete.mockResolvedValue(createMockResponse({}));
+            await elementService.deleteElements('TestDim', 'TestHier', elementNames, false);
+            expect(mockRestService.delete).toHaveBeenCalledTimes(3);
+            expect(mockRestService.delete).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements('Element1')");
+            console.log('✅ deleteElements via REST test passed');
+        });
+        test('deleteElements should delete multiple elements via TI', async () => {
+            const elementNames = ['Element1', 'Element2'];
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                ProcessExecuteStatusCode: 'CompletedSuccessfully'
+            }));
+            await elementService.deleteElements('TestDim', 'TestHier', elementNames, true);
+            expect(mockRestService.post).toHaveBeenCalledWith('/ExecuteProcessWithReturn', expect.objectContaining({
+                PrologProcedure: expect.stringContaining("HierarchyElementDelete('TestDim','TestHier','Element1')")
+            }));
+            console.log('✅ deleteElements via TI test passed');
+        });
+        test('addEdges should create parent-child relationships', async () => {
+            const edges = [
+                { parent: 'Total', child: 'Region1', weight: 1 },
+                { parent: 'Total', child: 'Region2', weight: 2 }
+            ];
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+            await elementService.addEdges('TestDim', 'TestHier', edges);
+            expect(mockRestService.post).toHaveBeenCalledTimes(2);
+            expect(mockRestService.post).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements('Total')/Components", { Name: 'Region1', Weight: 1 });
+            console.log('✅ addEdges test passed');
+        });
+        test('deleteEdges should remove parent-child relationships via REST', async () => {
+            const edges = [
+                { parent: 'Total', child: 'Region1' },
+                { parent: 'Total', child: 'Region2' }
+            ];
+            mockRestService.delete.mockResolvedValue(createMockResponse({}));
+            await elementService.deleteEdges('TestDim', 'TestHier', edges, false);
+            expect(mockRestService.delete).toHaveBeenCalledTimes(2);
+            expect(mockRestService.delete).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements('Total')/Components('Region1')");
+            console.log('✅ deleteEdges via REST test passed');
+        });
+        test('deleteEdges should remove parent-child relationships via TI', async () => {
+            const edges = [{ parent: 'Total', child: 'Region1' }];
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+            await elementService.deleteEdges('TestDim', 'TestHier', edges, true);
+            expect(mockRestService.post).toHaveBeenCalledWith('/ExecuteProcessWithReturn', expect.objectContaining({
+                PrologProcedure: expect.stringContaining("HierarchyElementComponentDelete('TestDim','TestHier','Total','Region1')")
+            }));
+            console.log('✅ deleteEdges via TI test passed');
+        });
+    });
+    describe('DataFrame Integration', () => {
+        test('getElementsDataframe should return tabular data', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Element1', Type: 'Numeric', Attributes: { Code: 'E1', Description: 'First' } },
+                    { Name: 'Element2', Type: 'String', Attributes: { Code: 'E2', Description: 'Second' } }
+                ]
+            }));
+            const result = await elementService.getElementsDataframe('TestDim', 'TestHier', ['Code', 'Description']);
+            expect(result).toEqual([
+                ['Name', 'Type', 'Code', 'Description'],
+                ['Element1', 'Numeric', 'E1', 'First'],
+                ['Element2', 'String', 'E2', 'Second']
+            ]);
+            console.log('✅ getElementsDataframe test passed');
+        });
+        test('createHierarchyFromDataframe should create elements and relationships', async () => {
+            const dataFrame = [
+                ['Name', 'Type', 'Parent1', 'Weight1'],
+                ['Total', 'Consolidated', '', ''],
+                ['Region1', 'Numeric', 'Total', '1'],
+                ['Region2', 'Numeric', 'Total', '2']
+            ];
+            mockRestService.post.mockResolvedValue(createMockResponse({}));
+            await elementService.createHierarchyFromDataframe('TestDim', 'TestHier', dataFrame);
+            // Should create 3 elements
+            expect(mockRestService.post).toHaveBeenCalledTimes(5); // 3 creates + 2 edges
+            // Check element creation calls
+            expect(mockRestService.post).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements", JSON.stringify({
+                Name: 'Total',
+                Type: 'Consolidated'
+            }));
+            console.log('✅ createHierarchyFromDataframe test passed');
+        });
+    });
+    describe('Enhanced Element Retrieval', () => {
+        test('getElementsCount should return element count', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('25'));
+            const count = await elementService.getElementsCount('TestDim', 'TestHier');
+            expect(count).toBe(25);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements/$count");
+            console.log('✅ getElementsCount test passed');
+        });
+        test('getElementsCount should filter consolidated elements', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('15'));
+            const count = await elementService.getElementsCount('TestDim', 'TestHier', true);
+            expect(count).toBe(15);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements/$count?$filter=Type ne 'Consolidated'");
+            console.log('✅ getElementsCount with filter test passed');
+        });
+        test('getLeafElements should return non-consolidated elements', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Element1', Type: 'Numeric' },
+                    { Name: 'Element2', Type: 'String' }
+                ]
+            }));
+            const elements = await elementService.getLeafElements('TestDim', 'TestHier');
+            expect(elements).toHaveLength(2);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements?$expand=*&$filter=Type ne 'Consolidated'");
+            console.log('✅ getLeafElements test passed');
+        });
+        test('getConsolidatedElements should return consolidated elements only', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Total', Type: 'Consolidated' },
+                    { Name: 'Region', Type: 'Consolidated' }
+                ]
+            }));
+            const elements = await elementService.getConsolidatedElements('TestDim', 'TestHier');
+            expect(elements).toHaveLength(2);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements?$expand=*&$filter=Type eq 'Consolidated'");
+            console.log('✅ getConsolidatedElements test passed');
+        });
+    });
+    describe('Element Attributes', () => {
+        test('updateElementAttribute should update attribute value', async () => {
+            mockRestService.patch.mockResolvedValue(createMockResponse({}));
+            await elementService.updateElementAttribute('TestDim', 'TestHier', 'Element1', 'Code', 'E1-NEW');
+            expect(mockRestService.patch).toHaveBeenCalledWith("/Dimensions('TestDim')/Hierarchies('TestHier')/Elements('Element1')/Attributes('Code')", { Value: 'E1-NEW' });
+            console.log('✅ updateElementAttribute test passed');
+        });
+    });
+    describe('MDX Operations', () => {
+        test('executeSetMdxElementNames should return element names from MDX set', async () => {
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                value: ['Element1', 'Element2', 'Element3']
+            }));
+            const elements = await elementService.executeSetMdxElementNames('TestDim', 'TestHier', '{[TestDim].[TestHier].Members}');
+            expect(elements).toEqual(['Element1', 'Element2', 'Element3']);
+            expect(mockRestService.post).toHaveBeenCalledWith('/ExecuteMDXSetExpression', {
+                MDX: '{[TestDim].[TestHier].Members}',
+                Dimension: 'TestDim',
+                Hierarchy: 'TestHier'
+            });
+            console.log('✅ executeSetMdxElementNames test passed');
+        });
+    });
+    describe('Error Handling', () => {
+        test('should handle empty element list gracefully', async () => {
+            await elementService.deleteElements('TestDim', 'TestHier', [], true);
+            // Should not make any API calls
+            expect(mockRestService.post).not.toHaveBeenCalled();
+            expect(mockRestService.delete).not.toHaveBeenCalled();
+            console.log('✅ Empty element list handling test passed');
+        });
+        test('should handle invalid DataFrame format', async () => {
+            const invalidDataFrame = [
+                ['InvalidColumn', 'AnotherColumn'],
+                ['Data1', 'Data2']
+            ];
+            await expect(elementService.createHierarchyFromDataframe('TestDim', 'TestHier', invalidDataFrame)).rejects.toThrow('DataFrame must contain Name and Type columns');
+            console.log('✅ Invalid DataFrame handling test passed');
+        });
+    });
+});
+//# sourceMappingURL=enhancedElementService.test.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=enhancedViewService.test.d.ts.map

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

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