tm1npm 1.0.0

package/lib/tests/dimensionService.test.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * DimensionService Tests for tm1npm
+ * Comprehensive tests for TM1 Dimension operations with proper mocking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const DimensionService_1 = require("../services/DimensionService");
+const Dimension_1 = require("../objects/Dimension");
+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('DimensionService Tests', () => {
+    let dimensionService;
+    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()
+        };
+        dimensionService = new DimensionService_1.DimensionService(mockRestService);
+    });
+    describe('Dimension Retrieval Operations', () => {
+        test('should get all dimension names', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Time' },
+                    { Name: 'Account' },
+                    { Name: 'Version' }
+                ]
+            }));
+            const dimensionNames = await dimensionService.getAllNames();
+            expect(Array.isArray(dimensionNames)).toBe(true);
+            expect(dimensionNames.length).toBe(3);
+            expect(dimensionNames).toEqual(['Time', 'Account', 'Version']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Dimensions?$select=Name");
+            console.log('✅ Dimension names retrieved successfully');
+        });
+        test('should get all dimensions with skip control dimensions', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Time', Hierarchies: [{ Name: 'Time' }] },
+                    { Name: 'Account', Hierarchies: [{ Name: 'Account' }] }
+                ]
+            }));
+            const dimensions = await dimensionService.getAll(true); // skip control dimensions
+            expect(Array.isArray(dimensions)).toBe(true);
+            expect(dimensions.length).toBe(2);
+            expect(dimensions[0].name).toBe('Time');
+            expect(dimensions[1].name).toBe('Account');
+            console.log('✅ All dimensions retrieved with control dimension filtering');
+        });
+        test('should get a specific dimension if it exists', async () => {
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                value: [{ Name: 'Time' }]
+            }));
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'Time',
+                Hierarchies: [{ Name: 'Time', Elements: [] }]
+            }));
+            const dimensionNames = await dimensionService.getAllNames();
+            expect(dimensionNames).toContain('Time');
+            const dimension = await dimensionService.get('Time');
+            expect(dimension).toBeDefined();
+            expect(dimension.name).toBe('Time');
+            console.log('✅ Specific dimension retrieved successfully');
+        });
+        test('should check if a dimension exists', async () => {
+            // Test existing dimension
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'Time',
+                Hierarchies: []
+            }));
+            const exists = await dimensionService.exists('Time');
+            expect(exists).toBe(true);
+            console.log('✅ Dimension existence check working');
+        });
+        test('should check if a dimension does not exist', async () => {
+            // Test non-existing dimension
+            const mockError = new TM1Exception_1.TM1RestException('Dimension not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await dimensionService.exists('NonExistentDimension');
+            expect(notExists).toBe(false);
+            console.log('✅ Dimension non-existence check working');
+        });
+    });
+    describe('Hierarchy Operations', () => {
+        test('should get hierarchies count for existing dimensions', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'Time',
+                Hierarchies: [
+                    { Name: 'Time' },
+                    { Name: 'TimeAlternate' }
+                ]
+            }));
+            const dimension = await dimensionService.get('Time');
+            expect(dimension.hierarchies).toBeDefined();
+            expect(dimension.hierarchies.length).toBe(2);
+            expect(dimension.hierarchies[0].name).toBe('Time');
+            console.log('✅ Hierarchy operations working');
+        });
+        test('should get elements count for dimension', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'Account',
+                Hierarchies: [{
+                        Name: 'Account',
+                        Elements: [
+                            { Name: 'Revenue' },
+                            { Name: 'Expenses' },
+                            { Name: 'NetIncome' }
+                        ]
+                    }]
+            }));
+            const dimension = await dimensionService.get('Account');
+            const elements = dimension.hierarchies[0].elements;
+            expect(elements).toBeDefined();
+            expect(elements.length).toBe(3);
+            expect(elements[0].name).toBe('Revenue');
+            console.log('✅ Elements count operations working');
+        });
+    });
+    describe('Element Operations', () => {
+        test('should get dimension names for cube', async () => {
+            // This would typically be handled by CubeService, but can test dimension context
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Time' },
+                    { Name: 'Account' },
+                    { Name: 'Version' }
+                ]
+            }));
+            const dimensionNames = await dimensionService.getAllNames();
+            expect(dimensionNames.includes('Time')).toBe(true);
+            expect(dimensionNames.includes('Account')).toBe(true);
+            expect(dimensionNames.includes('Version')).toBe(true);
+            console.log('✅ Dimension names for cube context working');
+        });
+        test('should handle elements count operation', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'Time',
+                Hierarchies: [{
+                        Name: 'Time',
+                        Elements: Array(12).fill(null).map((_, i) => ({
+                            Name: `Month${i + 1}`,
+                            Type: 'Numeric'
+                        }))
+                    }]
+            }));
+            const dimension = await dimensionService.get('Time');
+            const elementCount = dimension.hierarchies[0].elements.length;
+            expect(elementCount).toBe(12);
+            console.log('✅ Elements count operation working');
+        });
+    });
+    describe('Dimension Error Handling', () => {
+        test('should handle invalid dimension names gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 400, statusText: 'Bad Request' }
+            });
+            await expect(dimensionService.get('')).rejects.toMatchObject({
+                response: { status: 400 }
+            });
+            console.log('✅ Invalid dimension names handled gracefully');
+        });
+        test('should handle network errors gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                code: 'ECONNREFUSED'
+            });
+            await expect(dimensionService.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(dimensionService.getAllNames()).rejects.toMatchObject({
+                response: { status: 401 }
+            });
+            console.log('✅ Authentication errors handled gracefully');
+        });
+    });
+    describe('Dimension Service Edge Cases', () => {
+        test('should handle empty dimension lists', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: []
+            }));
+            const dimensionNames = await dimensionService.getAllNames();
+            expect(Array.isArray(dimensionNames)).toBe(true);
+            expect(dimensionNames.length).toBe(0);
+            console.log('✅ Empty dimension lists handled correctly');
+        });
+        test('should handle concurrent dimension operations', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [{ Name: 'TestDimension' }]
+            }));
+            const operations = [
+                dimensionService.getAllNames(),
+                dimensionService.getAllNames(),
+                dimensionService.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 dimension lists efficiently', async () => {
+            const largeDimensionList = Array(1000).fill(null).map((_, i) => ({
+                Name: `Dimension${i}`,
+                Hierarchies: [{ Name: `Dimension${i}` }]
+            }));
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: largeDimensionList
+            }));
+            const startTime = Date.now();
+            const dimensionNames = await dimensionService.getAllNames();
+            const endTime = Date.now();
+            expect(dimensionNames.length).toBe(1000);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast with mocking
+            console.log('✅ Large dimension lists handled efficiently');
+        });
+    });
+    describe('Dimension Service Integration', () => {
+        test('should maintain consistent data across operations', async () => {
+            const dimensionData = {
+                value: [
+                    { Name: 'Time' },
+                    { Name: 'Account' }
+                ]
+            };
+            mockRestService.get.mockResolvedValue(createMockResponse(dimensionData));
+            const names1 = await dimensionService.getAllNames();
+            const names2 = await dimensionService.getAllNames();
+            expect(names1).toEqual(names2);
+            expect(names1).toEqual(['Time', 'Account']);
+            console.log('✅ Data consistency maintained across operations');
+        });
+        test('should handle dimension hierarchy consistency', async () => {
+            const timeDimension = {
+                Name: 'Time',
+                Hierarchies: [
+                    { Name: 'Time', Elements: [{ Name: 'Jan' }, { Name: 'Feb' }] }
+                ]
+            };
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                value: [{ Name: 'Time' }]
+            }));
+            mockRestService.get.mockResolvedValueOnce(createMockResponse(timeDimension));
+            const dimensionNames = await dimensionService.getAllNames();
+            expect(dimensionNames).toContain('Time');
+            const dimension = await dimensionService.get('Time');
+            expect(dimension.hierarchies[0].elements.length).toBe(2);
+            console.log('✅ Dimension hierarchy consistency maintained');
+        });
+    });
+    describe('Dimension CRUD Operations', () => {
+        test('should handle dimension creation and deletion lifecycle', async () => {
+            const testDimension = new Dimension_1.Dimension('TestDimension');
+            // Mock dimension existence check (false) for create method's internal check
+            const mockError = new TM1Exception_1.TM1RestException('Dimension not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValueOnce(mockError);
+            // Mock dimension creation
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            await dimensionService.create(testDimension);
+            // Mock dimension existence check (true after creation)
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'TestDimension',
+                Hierarchies: []
+            }));
+            const afterCreationExists = await dimensionService.exists('TestDimension');
+            expect(afterCreationExists).toBe(true);
+            // Mock dimension deletion
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            await dimensionService.delete('TestDimension');
+            console.log('✅ Dimension lifecycle operations handled successfully');
+        });
+    });
+});
+//# sourceMappingURL=dimensionService.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Edge Cases Tests for tm1npm
+ * Tests for boundary conditions, unusual inputs, and corner cases
+ */
+export {};
+//# sourceMappingURL=edgeCases.test.d.ts.map

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

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

package/lib/tests/edgeCases.test.js

@@ -0,0 +1,301 @@
+"use strict";
+/**
+ * Edge Cases Tests for tm1npm
+ * Tests for boundary conditions, unusual inputs, and corner cases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const Utils_1 = require("../utils/Utils");
+describe('Edge Cases Tests', () => {
+    describe('String Edge Cases', () => {
+        test('should handle empty strings', () => {
+            expect((0, Utils_1.formatUrl)('', '')).toBe('');
+            expect((0, Utils_1.formatUrl)('/test/{}', '')).toBe('/test/');
+            expect((0, Utils_1.verifyVersion)('', '')).toBeFalsy(); // Changed to toBeFalsy since empty strings return false
+            expect((0, Utils_1.abbreviateString)('', 10)).toBe('');
+            expect((0, Utils_1.tidy)('')).toBe('');
+            expect((0, Utils_1.readObjectNameFromUrl)('')).toBe('');
+        });
+        test('should handle whitespace-only strings', () => {
+            const whitespaces = [' ', '\t', '\n', '\r', '   ', '\t\n\r'];
+            whitespaces.forEach(ws => {
+                expect(() => (0, Utils_1.formatUrl)('/test/{}', ws)).not.toThrow();
+                expect(() => (0, Utils_1.verifyVersion)(ws, '1.0')).not.toThrow();
+                expect((0, Utils_1.tidy)(ws)).toBe('');
+            });
+        });
+        test('should handle extremely long strings', () => {
+            const longString = 'A'.repeat(100000); // 100KB string
+            expect(() => (0, Utils_1.formatUrl)('/test/{}', longString)).not.toThrow();
+            expect(() => (0, Utils_1.abbreviateString)(longString, 50)).not.toThrow();
+            const abbreviated = (0, Utils_1.abbreviateString)(longString, 50);
+            expect(abbreviated.length).toBeLessThanOrEqual(50);
+            expect(abbreviated.endsWith('...')).toBe(true);
+        });
+        test('should handle special Unicode characters', () => {
+            const unicodeTests = [
+                '🚀🎉💯', // Emojis
+                '测试数据', // Chinese
+                'тестовые данные', // Cyrillic
+                'テストデータ', // Japanese
+                '🇺🇸🇯🇵🇨🇳', // Flag emojis
+                'café naïve résumé', // Accented characters
+                '\\u0000\\u001f\\u007f', // Control characters
+                '𝕋𝔼𝕊𝕋', // Mathematical symbols
+            ];
+            unicodeTests.forEach(test => {
+                expect(() => (0, Utils_1.formatUrl)('/test/{}', test)).not.toThrow();
+                expect(() => (0, Utils_1.abbreviateString)(test, 10)).not.toThrow();
+                expect(() => (0, Utils_1.tidy)(test)).not.toThrow();
+            });
+        });
+    });
+    describe('Number Edge Cases', () => {
+        test('should handle extreme version numbers', () => {
+            const extremeVersions = [
+                ['0', '0'],
+                ['999.999.999', '1.0.0'],
+                ['1.0.0', '999.999.999'],
+                ['10000.50000.90000', '1.2.3'],
+                ['1', '1.0.0.0.0.0'],
+                ['1.2.3.4.5.6.7.8.9', '1.2.3']
+            ];
+            extremeVersions.forEach(([v1, v2]) => {
+                expect(() => (0, Utils_1.verifyVersion)(v1, v2)).not.toThrow();
+                expect(() => (0, Utils_1.integerizeVersion)(v1)).not.toThrow();
+            });
+        });
+        test('should handle malformed version strings', () => {
+            const malformedVersions = [
+                'abc.def.ghi',
+                '1.2.3-alpha',
+                '1.2.3+build',
+                'v1.2.3',
+                '1..2..3',
+                '.1.2.3',
+                '1.2.3.',
+                '1,2,3',
+                '1-2-3'
+            ];
+            malformedVersions.forEach(version => {
+                expect(() => (0, Utils_1.verifyVersion)(version, '1.0.0')).not.toThrow();
+                expect(() => (0, Utils_1.integerizeVersion)(version)).not.toThrow();
+            });
+        });
+        test('should handle extreme abbreviation lengths', () => {
+            const text = 'This is a test string for abbreviation';
+            expect((0, Utils_1.abbreviateString)(text, 0)).toBe('...');
+            expect((0, Utils_1.abbreviateString)(text, 1)).toBe('...');
+            expect((0, Utils_1.abbreviateString)(text, 2)).toBe('...');
+            expect((0, Utils_1.abbreviateString)(text, 3)).toBe('...');
+            expect((0, Utils_1.abbreviateString)(text, 4)).toBe('T...');
+            expect((0, Utils_1.abbreviateString)(text, -1)).toBe('...');
+            expect((0, Utils_1.abbreviateString)(text, 1000)).toBe(text);
+        });
+    });
+    describe('Array and Iterable Edge Cases', () => {
+        test('should handle empty arrays', () => {
+            expect((0, Utils_1.buildMdxFromAxes)([])).toBe('');
+            expect((0, Utils_1.buildElementsStringFromIterable)([])).toBe('');
+            expect((0, Utils_1.wrapTupleInBrackets)([])).toBe('()');
+        });
+        test('should handle single-element arrays', () => {
+            expect((0, Utils_1.wrapTupleInBrackets)(['Element1'])).toBe('[Element1]');
+            expect((0, Utils_1.buildElementsStringFromIterable)(['Element1'])).toBe('Element1');
+        });
+        test('should handle large arrays', () => {
+            const largeArray = Array(10000).fill(null).map((_, i) => `Element${i}`);
+            expect(() => (0, Utils_1.buildElementsStringFromIterable)(largeArray)).not.toThrow();
+            expect(() => (0, Utils_1.wrapTupleInBrackets)(largeArray)).not.toThrow();
+            const result = (0, Utils_1.buildElementsStringFromIterable)(largeArray);
+            expect(result.split(',').length).toBe(10000);
+        });
+        test('should handle arrays with special characters', () => {
+            const specialElements = [
+                'Element with spaces',
+                'Element,with,commas',
+                'Element[with]brackets',
+                'Element{with}braces',
+                'Element(with)parens',
+                'Element"with"quotes',
+                "Element'with'apostrophes",
+                'Element\nwith\nnewlines',
+                'Element\twith\ttabs'
+            ];
+            expect(() => (0, Utils_1.buildElementsStringFromIterable)(specialElements)).not.toThrow();
+            expect(() => (0, Utils_1.wrapTupleInBrackets)(specialElements)).not.toThrow();
+        });
+        test('should handle different iterable types', () => {
+            const set = new Set(['a', 'b', 'c']);
+            const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
+            expect(() => (0, Utils_1.buildElementsStringFromIterable)(set)).not.toThrow();
+            expect(() => (0, Utils_1.buildElementsStringFromIterable)(map.keys())).not.toThrow();
+            const setResult = (0, Utils_1.buildElementsStringFromIterable)(set);
+            expect(setResult.split(',').length).toBe(3);
+        });
+    });
+    describe('Object Edge Cases', () => {
+        test('should handle null and undefined in various contexts', () => {
+            expect(() => (0, Utils_1.formatUrl)('/test/{}', null)).not.toThrow();
+            expect(() => (0, Utils_1.formatUrl)('/test/{}', undefined)).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)(null, '1.0')).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)('1.0', null)).not.toThrow();
+            expect(() => (0, Utils_1.abbreviateString)(null, 10)).not.toThrow();
+            expect(() => (0, Utils_1.tidy)(null)).not.toThrow();
+        });
+        test('should handle complex nested objects', () => {
+            const complexAxes = [
+                {
+                    Tuples: [
+                        {
+                            Members: [
+                                { UniqueName: '[Dimension1].[Hierarchy1].[Element1]' },
+                                { UniqueName: '[Dimension2].[Hierarchy2].[Element2]' }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    Tuples: []
+                },
+                {
+                    Tuples: null
+                }
+            ];
+            expect(() => (0, Utils_1.buildMdxFromAxes)(complexAxes)).not.toThrow();
+        });
+    });
+    describe('CaseAndSpaceInsensitiveMap Edge Cases', () => {
+        test('should handle edge cases in keys', () => {
+            const map = new Utils_1.CaseAndSpaceInsensitiveMap();
+            const edgeKeys = [
+                '',
+                ' ',
+                '   ',
+                '\t',
+                '\n',
+                '\r\n',
+                'a',
+                'A',
+                ' a ',
+                ' A ',
+                'TEST KEY',
+                'test key',
+                'Test Key',
+                'TESTKEY',
+                'testkey',
+                'TestKey'
+            ];
+            edgeKeys.forEach((key, index) => {
+                expect(() => map.set(key, `value${index}`)).not.toThrow();
+            });
+            // All variations should be treated as the same key for case-insensitive ones
+            expect(map.has('test key')).toBe(true);
+            expect(map.has('TEST KEY')).toBe(true);
+            expect(map.has('testkey')).toBe(true);
+            expect(map.has('TESTKEY')).toBe(true);
+        });
+        test('should handle rapid operations', () => {
+            const map = new Utils_1.CaseAndSpaceInsensitiveMap();
+            // Rapid set/get/delete cycles
+            for (let i = 0; i < 1000; i++) {
+                map.set(`key ${i}`, i);
+                expect(map.get(`KEY ${i}`)).toBe(i);
+                if (i % 2 === 0) {
+                    map.delete(`key ${i}`);
+                }
+            }
+            expect(map.size).toBe(500);
+        });
+    });
+    describe('CaseAndSpaceInsensitiveSet Edge Cases', () => {
+        test('should handle duplicate-like values', () => {
+            const set = new Utils_1.CaseAndSpaceInsensitiveSet();
+            const duplicateLikeValues = [
+                'test',
+                'TEST',
+                'Test',
+                'TeSt',
+                ' test ',
+                ' TEST ',
+                'test ',
+                ' test',
+                '\ttest\t',
+                '\ntest\n'
+            ];
+            duplicateLikeValues.forEach(value => {
+                set.add(value);
+            });
+            // Should only have one item (all are equivalent)
+            expect(set.size).toBe(1);
+            expect(set.has('test')).toBe(true);
+            expect(set.has('TEST')).toBe(true);
+            expect(set.has(' test ')).toBe(true);
+        });
+    });
+    describe('URL Parsing Edge Cases', () => {
+        test('should handle malformed URLs', () => {
+            const malformedUrls = [
+                '',
+                '/',
+                '//',
+                '///',
+                "Dimensions('')",
+                "Dimensions(')",
+                "Dimensions('')",
+                "Dimensions('test'',)",
+                "Dimensions(test)",
+                "/Dimensions('/test/')",
+                "/Dimensions('test with spaces')",
+                "/Dimensions('test\"with\"quotes')"
+            ];
+            malformedUrls.forEach(url => {
+                expect(() => (0, Utils_1.readObjectNameFromUrl)(url)).not.toThrow();
+            });
+        });
+        test('should handle complex dimension hierarchy element tuples', () => {
+            const complexTuples = [
+                '',
+                'SingleElement',
+                'Dimension.Element',
+                'Dimension.Hierarchy.Element',
+                'Dimension.Hierarchy.Element.Extra',
+                '[Dimension].[Hierarchy].[Element]',
+                '[Dimension with spaces].[Hierarchy].[Element]',
+                '[Dimension].[Hierarchy].[Element with spaces]',
+                'Dimension..Element', // Double dot
+                '.Dimension.Element', // Leading dot
+                'Dimension.Element.', // Trailing dot
+                '[Malformed].[Tuple',
+                'Malformed].[Tuple]'
+            ];
+            complexTuples.forEach(tuple => {
+                expect(() => (0, Utils_1.dimensionHierarchyElementTupleFromString)(tuple)).not.toThrow();
+                const result = (0, Utils_1.dimensionHierarchyElementTupleFromString)(tuple);
+                expect(Array.isArray(result)).toBe(true);
+                expect(result.length).toBe(3);
+            });
+        });
+    });
+    describe('Boundary Value Testing', () => {
+        test('should handle minimum and maximum safe integers', () => {
+            const minSafe = Number.MIN_SAFE_INTEGER;
+            const maxSafe = Number.MAX_SAFE_INTEGER;
+            expect(() => (0, Utils_1.formatUrl)('/test/{}', minSafe.toString())).not.toThrow();
+            expect(() => (0, Utils_1.formatUrl)('/test/{}', maxSafe.toString())).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)(minSafe.toString(), maxSafe.toString())).not.toThrow();
+        });
+        test('should handle very small and very large version numbers', () => {
+            const versionTests = [
+                ['0.0.0', '0.0.1'],
+                ['999999.999999.999999', '1.0.0'],
+                ['0', '999999999'],
+                ['1.0', '1.0.0.0.0.0.0.0.1']
+            ];
+            versionTests.forEach(([v1, v2]) => {
+                expect(() => (0, Utils_1.verifyVersion)(v1, v2)).not.toThrow();
+                expect(typeof (0, Utils_1.verifyVersion)(v1, v2)).toBe('boolean');
+            });
+        });
+    });
+});
+//# sourceMappingURL=edgeCases.test.js.map

package/lib/tests/elementService.comprehensive.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Comprehensive ElementService Tests
+ * Target: Achieve 80%+ coverage for ElementService (currently 48%)
+ * Testing all element operations including CRUD, hierarchy management, attributes, and advanced features
+ */
+export {};
+//# sourceMappingURL=elementService.comprehensive.test.d.ts.map

package/lib/tests/elementService.comprehensive.test.d.ts.map

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