tm1npm 1.0.0

package/lib/tests/exceptions.test.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Exception Classes Tests
+ * Comprehensive test suite for TM1 exception classes
+ * Target: Improve coverage from 0% to 100% for TM1RestException and TM1TimeoutException
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+const TM1RestException_1 = require("../exceptions/TM1RestException");
+const TM1TimeoutException_1 = require("../exceptions/TM1TimeoutException");
+describe('TM1 Exception Classes', () => {
+    describe('TM1RestException', () => {
+        test('should create TM1RestException with message only', () => {
+            const message = 'REST API error occurred';
+            const exception = new TM1RestException_1.TM1RestException(message);
+            expect(exception).toBeInstanceOf(Error);
+            expect(exception).toBeInstanceOf(TM1Exception_1.TM1Exception);
+            expect(exception).toBeInstanceOf(TM1RestException_1.TM1RestException);
+            expect(exception.message).toBe(message);
+            expect(exception.name).toBe('TM1RestException');
+            expect(exception.status).toBeUndefined();
+            expect(exception.response).toBeUndefined();
+        });
+        test('should create TM1RestException with message and status', () => {
+            const message = 'Unauthorized access';
+            const status = 401;
+            const exception = new TM1RestException_1.TM1RestException(message, status);
+            expect(exception.message).toBe(message);
+            expect(exception.name).toBe('TM1RestException');
+            expect(exception.status).toBe(status);
+            expect(exception.response).toBeUndefined();
+        });
+        test('should create TM1RestException with message, status, and response', () => {
+            const message = 'Bad Request';
+            const status = 400;
+            const response = {
+                error: 'Invalid parameter',
+                details: 'Parameter X is required'
+            };
+            const exception = new TM1RestException_1.TM1RestException(message, status, response);
+            expect(exception.message).toBe(message);
+            expect(exception.name).toBe('TM1RestException');
+            expect(exception.status).toBe(status);
+            expect(exception.response).toEqual(response);
+        });
+        test('should handle status 0 (network error)', () => {
+            const message = 'Network connection failed';
+            const status = 0;
+            const exception = new TM1RestException_1.TM1RestException(message, status);
+            expect(exception.status).toBe(0);
+            expect(exception.message).toBe(message);
+        });
+        test('should handle various HTTP status codes', () => {
+            const statusCodes = [200, 404, 500, 502, 503];
+            statusCodes.forEach(status => {
+                const exception = new TM1RestException_1.TM1RestException(`HTTP ${status} error`, status);
+                expect(exception.status).toBe(status);
+                expect(exception.name).toBe('TM1RestException');
+            });
+        });
+        test('should handle complex response objects', () => {
+            const complexResponse = {
+                error: {
+                    code: 'INVALID_OPERATION',
+                    message: 'Operation not supported',
+                    details: {
+                        operation: 'deleteElement',
+                        reason: 'Element is in use'
+                    }
+                },
+                timestamp: '2025-01-15T10:30:00Z',
+                requestId: 'req-12345'
+            };
+            const exception = new TM1RestException_1.TM1RestException('Complex error', 422, complexResponse);
+            expect(exception.response).toEqual(complexResponse);
+            expect(exception.response.error.code).toBe('INVALID_OPERATION');
+        });
+        test('should be throwable and catchable', () => {
+            const message = 'Test exception';
+            const status = 500;
+            expect(() => {
+                throw new TM1RestException_1.TM1RestException(message, status);
+            }).toThrow(TM1RestException_1.TM1RestException);
+            try {
+                throw new TM1RestException_1.TM1RestException(message, status);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(TM1RestException_1.TM1RestException);
+                expect(error.status).toBe(status);
+            }
+        });
+        test('should inherit Error properties correctly', () => {
+            const exception = new TM1RestException_1.TM1RestException('Test error', 500);
+            expect(exception.stack).toBeDefined();
+            expect(exception.toString()).toContain('TM1RestException');
+            expect(exception.toString()).toContain('Test error');
+        });
+    });
+    describe('TM1TimeoutException', () => {
+        test('should create TM1TimeoutException with message only', () => {
+            const message = 'Operation timed out';
+            const exception = new TM1TimeoutException_1.TM1TimeoutException(message);
+            expect(exception).toBeInstanceOf(Error);
+            expect(exception).toBeInstanceOf(TM1Exception_1.TM1Exception);
+            expect(exception).toBeInstanceOf(TM1TimeoutException_1.TM1TimeoutException);
+            expect(exception.message).toBe(message);
+            expect(exception.name).toBe('TM1TimeoutException');
+            expect(exception.timeout).toBe(0); // Default timeout value
+        });
+        test('should create TM1TimeoutException with message and timeout', () => {
+            const message = 'Request timed out after 30 seconds';
+            const timeout = 30000; // 30 seconds in ms
+            const exception = new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            expect(exception.message).toBe(message);
+            expect(exception.name).toBe('TM1TimeoutException');
+            expect(exception.timeout).toBe(timeout);
+        });
+        test('should handle zero timeout value', () => {
+            const message = 'Immediate timeout';
+            const timeout = 0;
+            const exception = new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            expect(exception.timeout).toBe(0);
+            expect(exception.message).toBe(message);
+        });
+        test('should handle large timeout values', () => {
+            const message = 'Long operation timeout';
+            const timeout = 3600000; // 1 hour in ms
+            const exception = new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            expect(exception.timeout).toBe(timeout);
+            expect(exception.message).toBe(message);
+        });
+        test('should handle negative timeout values', () => {
+            const message = 'Invalid timeout';
+            const timeout = -1000;
+            const exception = new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            expect(exception.timeout).toBe(timeout); // Should accept negative values
+            expect(exception.message).toBe(message);
+        });
+        test('should default to 0 when no timeout provided', () => {
+            const exception = new TM1TimeoutException_1.TM1TimeoutException('Default timeout test');
+            expect(exception.timeout).toBe(0);
+        });
+        test('should be throwable and catchable', () => {
+            const message = 'Timeout test';
+            const timeout = 5000;
+            expect(() => {
+                throw new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            }).toThrow(TM1TimeoutException_1.TM1TimeoutException);
+            try {
+                throw new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(TM1TimeoutException_1.TM1TimeoutException);
+                expect(error.timeout).toBe(timeout);
+            }
+        });
+        test('should inherit Error properties correctly', () => {
+            const exception = new TM1TimeoutException_1.TM1TimeoutException('Test timeout', 1000);
+            expect(exception.stack).toBeDefined();
+            expect(exception.toString()).toContain('TM1TimeoutException');
+            expect(exception.toString()).toContain('Test timeout');
+        });
+        test('should handle various timeout scenarios', () => {
+            const scenarios = [
+                { message: 'Connection timeout', timeout: 5000 },
+                { message: 'Read timeout', timeout: 30000 },
+                { message: 'Write timeout', timeout: 15000 },
+                { message: 'Process timeout', timeout: 300000 }
+            ];
+            scenarios.forEach(({ message, timeout }) => {
+                const exception = new TM1TimeoutException_1.TM1TimeoutException(message, timeout);
+                expect(exception.timeout).toBe(timeout);
+                expect(exception.message).toBe(message);
+                expect(exception.name).toBe('TM1TimeoutException');
+            });
+        });
+    });
+    describe('Exception Inheritance and Polymorphism', () => {
+        test('should properly inherit from TM1Exception', () => {
+            const restException = new TM1RestException_1.TM1RestException('REST error', 500);
+            const timeoutException = new TM1TimeoutException_1.TM1TimeoutException('Timeout error', 5000);
+            expect(restException).toBeInstanceOf(TM1Exception_1.TM1Exception);
+            expect(timeoutException).toBeInstanceOf(TM1Exception_1.TM1Exception);
+        });
+        test('should properly inherit from Error', () => {
+            const restException = new TM1RestException_1.TM1RestException('REST error', 500);
+            const timeoutException = new TM1TimeoutException_1.TM1TimeoutException('Timeout error', 5000);
+            expect(restException).toBeInstanceOf(Error);
+            expect(timeoutException).toBeInstanceOf(Error);
+        });
+        test('should be distinguishable in catch blocks', () => {
+            const testCatch = (exception) => {
+                if (exception instanceof TM1RestException_1.TM1RestException) {
+                    return 'REST';
+                }
+                else if (exception instanceof TM1TimeoutException_1.TM1TimeoutException) {
+                    return 'TIMEOUT';
+                }
+                else if (exception instanceof TM1Exception_1.TM1Exception) {
+                    return 'TM1';
+                }
+                else {
+                    return 'OTHER';
+                }
+            };
+            expect(testCatch(new TM1RestException_1.TM1RestException('test', 500))).toBe('REST');
+            expect(testCatch(new TM1TimeoutException_1.TM1TimeoutException('test', 1000))).toBe('TIMEOUT');
+        });
+        test('should maintain proper prototype chain', () => {
+            const restException = new TM1RestException_1.TM1RestException('test', 500);
+            const timeoutException = new TM1TimeoutException_1.TM1TimeoutException('test', 1000);
+            expect(Object.getPrototypeOf(restException)).toBe(TM1RestException_1.TM1RestException.prototype);
+            expect(Object.getPrototypeOf(timeoutException)).toBe(TM1TimeoutException_1.TM1TimeoutException.prototype);
+        });
+    });
+    describe('Real-world Usage Scenarios', () => {
+        test('should handle typical REST API error scenarios', () => {
+            // 404 Not Found
+            const notFound = new TM1RestException_1.TM1RestException('Cube not found', 404, {
+                error: 'CUBE_NOT_FOUND',
+                cubeName: 'Sales'
+            });
+            expect(notFound.status).toBe(404);
+            expect(notFound.response.cubeName).toBe('Sales');
+            // 401 Unauthorized
+            const unauthorized = new TM1RestException_1.TM1RestException('Authentication failed', 401);
+            expect(unauthorized.status).toBe(401);
+            // 500 Internal Server Error
+            const serverError = new TM1RestException_1.TM1RestException('Internal server error', 500, {
+                error: 'INTERNAL_ERROR',
+                details: 'Database connection failed'
+            });
+            expect(serverError.status).toBe(500);
+            expect(serverError.response.details).toBe('Database connection failed');
+        });
+        test('should handle typical timeout scenarios', () => {
+            // Connection timeout
+            const connectionTimeout = new TM1TimeoutException_1.TM1TimeoutException('Connection timeout after 30 seconds', 30000);
+            expect(connectionTimeout.timeout).toBe(30000);
+            // Process execution timeout
+            const processTimeout = new TM1TimeoutException_1.TM1TimeoutException('Process execution exceeded maximum time', 600000 // 10 minutes
+            );
+            expect(processTimeout.timeout).toBe(600000);
+            // Query timeout
+            const queryTimeout = new TM1TimeoutException_1.TM1TimeoutException('MDX query timeout', 120000 // 2 minutes
+            );
+            expect(queryTimeout.timeout).toBe(120000);
+        });
+        test('should support error chaining and context', () => {
+            const originalError = new Error('Network failure');
+            const restException = new TM1RestException_1.TM1RestException('Failed to connect to TM1 server', 0, { originalError, timestamp: Date.now() });
+            expect(restException.response.originalError).toBe(originalError);
+            expect(restException.response.timestamp).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=exceptions.test.js.map

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

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

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

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

package/lib/tests/hierarchyService.test.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * HierarchyService Tests for tm1npm
+ * Comprehensive tests for TM1 Hierarchy operations with proper mocking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const HierarchyService_1 = require("../services/HierarchyService");
+const Hierarchy_1 = require("../objects/Hierarchy");
+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('HierarchyService Tests', () => {
+    let hierarchyService;
+    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()
+        };
+        hierarchyService = new HierarchyService_1.HierarchyService(mockRestService);
+    });
+    describe('Hierarchy Retrieval Operations', () => {
+        test('should get all hierarchy names for dimension', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Hierarchy1' },
+                    { Name: 'Hierarchy2' }
+                ]
+            }));
+            const hierarchyNames = await hierarchyService.getAllNames('TestDimension');
+            expect(Array.isArray(hierarchyNames)).toBe(true);
+            expect(hierarchyNames).toEqual(['Hierarchy1', 'Hierarchy2']);
+            console.log('✅ Hierarchy names retrieved successfully');
+        });
+        test('should get all hierarchies with full details', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    {
+                        Name: 'MainHierarchy',
+                        UniqueName: '[TestDimension].[MainHierarchy]',
+                        Visible: true,
+                        Elements: []
+                    },
+                    {
+                        Name: 'AlternateHierarchy',
+                        UniqueName: '[TestDimension].[AlternateHierarchy]',
+                        Visible: false,
+                        Elements: []
+                    }
+                ]
+            }));
+            const hierarchies = await hierarchyService.getAll('TestDimension');
+            expect(Array.isArray(hierarchies)).toBe(true);
+            expect(hierarchies.length).toBe(2);
+            expect(hierarchies[0].name).toBe('MainHierarchy');
+            expect(hierarchies[1].name).toBe('AlternateHierarchy');
+            console.log('✅ All hierarchies retrieved successfully');
+        });
+        test('should get specific hierarchy by name', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'SpecificHierarchy',
+                UniqueName: '[TestDimension].[SpecificHierarchy]',
+                Visible: true,
+                Elements: []
+            }));
+            const hierarchy = await hierarchyService.get('TestDimension', 'SpecificHierarchy');
+            expect(hierarchy).toBeDefined();
+            expect(hierarchy.name).toBe('SpecificHierarchy');
+            console.log('✅ Specific hierarchy retrieved successfully');
+        });
+        test('should check if hierarchy exists', async () => {
+            // Test existing hierarchy
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'ExistingHierarchy'
+            }));
+            const exists = await hierarchyService.exists('TestDimension', 'ExistingHierarchy');
+            expect(exists).toBe(true);
+            console.log('✅ Hierarchy existence check working correctly');
+        });
+        test('should check if hierarchy does not exist', async () => {
+            // Test non-existing hierarchy
+            const mockError = new TM1Exception_1.TM1RestException('Hierarchy not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await hierarchyService.exists('TestDimension', 'NonExistent');
+            expect(notExists).toBe(false);
+            console.log('✅ Hierarchy non-existence check working correctly');
+        });
+    });
+    describe('Hierarchy CRUD Operations', () => {
+        test('should create new hierarchy', async () => {
+            const mockHierarchy = new Hierarchy_1.Hierarchy('NewHierarchy', 'TestDimension');
+            // Mock exists() to return false (hierarchy doesn't exist yet)
+            const mockError = new TM1Exception_1.TM1RestException('Hierarchy not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValueOnce(mockError); // for exists() check
+            // Mock create
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                Name: 'NewHierarchy'
+            }, 201));
+            const result = await hierarchyService.create(mockHierarchy);
+            expect(result.status).toBe(201);
+            expect(mockRestService.post).toHaveBeenCalled();
+            console.log('✅ Hierarchy creation successful');
+        });
+        test('should update existing hierarchy', async () => {
+            const mockHierarchy = new Hierarchy_1.Hierarchy('UpdatedHierarchy', 'TestDimension');
+            // Mock the various calls that update() makes internally
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // removeAllElements
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // removeAllEdges
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // getElementAttributes
+            await hierarchyService.update(mockHierarchy);
+            expect(mockRestService.get).toHaveBeenCalled();
+            console.log('✅ Hierarchy update successful');
+        });
+        test('should delete hierarchy', async () => {
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            const result = await hierarchyService.delete('TestDimension', 'HierarchyToDelete');
+            expect(result.status).toBe(204);
+            console.log('✅ Hierarchy deletion successful');
+        });
+    });
+    describe('Hierarchy Element Attribute Operations', () => {
+        test('should get element attributes', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    {
+                        Name: 'Description',
+                        Type: 'String',
+                        '@odata.type': '#ibm.tm1.api.v1.ElementAttribute'
+                    },
+                    {
+                        Name: 'Code',
+                        Type: 'Alias',
+                        '@odata.type': '#ibm.tm1.api.v1.ElementAttribute'
+                    }
+                ]
+            }));
+            const attributes = await hierarchyService.getElementAttributes('TestDimension', 'TestHierarchy');
+            expect(Array.isArray(attributes)).toBe(true);
+            expect(attributes.length).toBe(2);
+            expect(attributes[0].name).toBe('Description');
+            console.log('✅ Element attributes retrieved successfully');
+        });
+        test('should check if element attribute exists', async () => {
+            // Test existing attribute
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'ExistingAttribute'
+            }));
+            const exists = await hierarchyService.elementAttributeExists('TestDimension', 'TestHierarchy', 'ExistingAttribute');
+            expect(exists).toBe(true);
+            console.log('✅ Element attribute existence check working');
+        });
+        test('should check if element attribute does not exist', async () => {
+            const mockError = new TM1Exception_1.TM1RestException('Attribute not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await hierarchyService.elementAttributeExists('TestDimension', 'TestHierarchy', 'NonExistentAttribute');
+            expect(notExists).toBe(false);
+            console.log('✅ Element attribute non-existence check working');
+        });
+        test('should delete element attribute', async () => {
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            const result = await hierarchyService.deleteElementAttribute('TestDimension', 'TestHierarchy', 'AttributeToDelete');
+            expect(result.status).toBe(204);
+            console.log('✅ Element attribute deletion successful');
+        });
+    });
+    describe('Hierarchy Error Handling', () => {
+        test('should handle invalid hierarchy names gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 400, statusText: 'Bad Request' }
+            });
+            await expect(hierarchyService.get('TestDimension', ''))
+                .rejects.toMatchObject({
+                response: { status: 400 }
+            });
+            console.log('✅ Invalid hierarchy name handling working');
+        });
+        test('should handle network errors gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                code: 'ECONNREFUSED'
+            });
+            await expect(hierarchyService.getAllNames('TestDimension'))
+                .rejects.toMatchObject({
+                code: 'ECONNREFUSED'
+            });
+            console.log('✅ Network error handling working');
+        });
+        test('should handle authentication errors', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 401, statusText: 'Unauthorized' }
+            });
+            await expect(hierarchyService.get('TestDimension', 'TestHierarchy'))
+                .rejects.toMatchObject({
+                response: { status: 401 }
+            });
+            console.log('✅ Authentication error handling working');
+        });
+    });
+    describe('Hierarchy Service Edge Cases', () => {
+        test('should handle empty hierarchy lists', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: []
+            }));
+            const hierarchies = await hierarchyService.getAll('EmptyDimension');
+            expect(Array.isArray(hierarchies)).toBe(true);
+            expect(hierarchies.length).toBe(0);
+            console.log('✅ Empty hierarchy list handling working');
+        });
+        test('should handle concurrent operations efficiently', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [{ Name: 'TestHierarchy' }]
+            }));
+            const operations = Array(5).fill(null).map(() => hierarchyService.getAllNames('TestDimension'));
+            const results = await Promise.allSettled(operations);
+            const successful = results.filter(r => r.status === 'fulfilled');
+            expect(successful.length).toBe(5);
+            console.log('✅ Concurrent operations handling working');
+        });
+        test('should handle large hierarchy data efficiently', async () => {
+            const largeHierarchyData = Array(1000).fill(null).map((_, i) => ({
+                Name: `Hierarchy${i}`,
+                Visible: true,
+                Elements: []
+            }));
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: largeHierarchyData
+            }));
+            const startTime = Date.now();
+            const hierarchies = await hierarchyService.getAll('LargeDimension');
+            const endTime = Date.now();
+            expect(hierarchies.length).toBe(1000);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast with mocking
+            console.log('✅ Large hierarchy data processing efficient');
+        });
+    });
+    describe('Hierarchy Service Integration', () => {
+        test('should maintain data consistency across operations', async () => {
+            const hierarchyList = [
+                { Name: 'Hierarchy1' },
+                { Name: 'Hierarchy2' }
+            ];
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: hierarchyList
+            }));
+            const names1 = await hierarchyService.getAllNames('TestDimension');
+            const names2 = await hierarchyService.getAllNames('TestDimension');
+            expect(names1).toEqual(names2);
+            expect(names1).toEqual(['Hierarchy1', 'Hierarchy2']);
+            console.log('✅ Data consistency maintained');
+        });
+        test('should handle hierarchy lifecycle operations', async () => {
+            const testHierarchy = new Hierarchy_1.Hierarchy('LifecycleHierarchy', 'TestDimension');
+            // Mock exists() to return false for create
+            const mockError = new TM1Exception_1.TM1RestException('Hierarchy not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValueOnce(mockError); // for exists() in create()
+            // Mock create
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            // Mock get for exists() check after creation (should return true)
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'LifecycleHierarchy'
+            }));
+            // Mock update dependencies
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // for removeAllElements
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // for removeAllEdges  
+            mockRestService.get.mockResolvedValue(createMockResponse({ value: [] })); // for getElementAttributes
+            // Mock delete
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            // Test lifecycle operations
+            const createResult = await hierarchyService.create(testHierarchy);
+            expect(createResult.status).toBe(201);
+            const exists = await hierarchyService.exists('TestDimension', 'LifecycleHierarchy');
+            expect(exists).toBe(true);
+            await hierarchyService.update(testHierarchy);
+            // update returns void, so just ensure it doesn't throw
+            const deleteResult = await hierarchyService.delete('TestDimension', 'LifecycleHierarchy');
+            expect(deleteResult.status).toBe(204);
+            console.log('✅ Hierarchy lifecycle operations working');
+        });
+    });
+});
+//# sourceMappingURL=hierarchyService.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Main Index Export Tests
+ * Comprehensive test suite for main module exports
+ * Target: Improve coverage from 0% to 50%+ for src/index.ts
+ */
+//# sourceMappingURL=index.test.d.ts.map

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

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