tm1npm 1.0.0

package/lib/tests/enhancedViewService.test.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ViewService_1 = require("../services/ViewService");
+const axios_1 = __importDefault(require("axios"));
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios_1.default;
+describe('Enhanced ViewService Tests', () => {
+    let viewService;
+    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()
+        };
+        viewService = new ViewService_1.ViewService(mockRestService);
+    });
+    describe('View Search Functions', () => {
+        test('searchStringInName should find views by name substring', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Sales_View_Q1' },
+                    { Name: 'Sales_View_Q2' },
+                    { Name: 'Budget_View_2024' }
+                ]
+            }));
+            const result = await viewService.searchStringInName('TestCube', 'Sales');
+            expect(result).toEqual(['Sales_View_Q1', 'Sales_View_Q2', 'Budget_View_2024']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views?$select=Name&$filter=indexof(tolower(Name), 'sales') ge 0");
+            console.log('✅ searchStringInName test passed');
+        });
+        test('searchStringInName should search private views', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Private_Sales_View' }
+                ]
+            }));
+            const result = await viewService.searchStringInName('TestCube', 'Sales', true);
+            expect(result).toEqual(['Private_Sales_View']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/PrivateViews?$select=Name&$filter=indexof(tolower(Name), 'sales') ge 0");
+            console.log('✅ searchStringInName private views test passed');
+        });
+        test('searchStringInMdx should find views by MDX content', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT {[Year].Members} ON 0 FROM [SalesCube]' },
+                    { Name: 'MDXView2', MDX: 'SELECT {[Product].Members} ON 0 FROM [BudgetCube]' },
+                    { Name: 'NativeView1', MDX: null }
+                ]
+            }));
+            const result = await viewService.searchStringInMdx('TestCube', 'SalesCube');
+            expect(result).toEqual(['MDXView1']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views?$select=Name,MDX");
+            console.log('✅ searchStringInMdx test passed');
+        });
+        test('searchStringInMdx should be case insensitive by default', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT {[YEAR].Members} ON 0 FROM [SalesCube]' }
+                ]
+            }));
+            const result = await viewService.searchStringInMdx('TestCube', 'year');
+            expect(result).toEqual(['MDXView1']);
+            console.log('✅ searchStringInMdx case insensitive test passed');
+        });
+        test('searchStringInMdx should respect case sensitivity when disabled', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT {[YEAR].Members} ON 0 FROM [SalesCube]' }
+                ]
+            }));
+            const result = await viewService.searchStringInMdx('TestCube', 'year', false, false);
+            expect(result).toEqual([]);
+            console.log('✅ searchStringInMdx case sensitive test passed');
+        });
+    });
+    describe('View Type Detection', () => {
+        test('isMdxView should return true for MDX views', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                MDX: 'SELECT {[Year].Members} ON 0 FROM [TestCube]'
+            }));
+            const result = await viewService.isMdxView('TestCube', 'TestView');
+            expect(result).toBe(true);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views('TestView')/?$select=MDX");
+            console.log('✅ isMdxView positive test passed');
+        });
+        test('isMdxView should return false for native views', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                MDX: null
+            }));
+            const result = await viewService.isMdxView('TestCube', 'TestView');
+            expect(result).toBe(false);
+            console.log('✅ isMdxView negative test passed');
+        });
+        test('isNativeView should return opposite of isMdxView', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                MDX: null
+            }));
+            const result = await viewService.isNativeView('TestCube', 'TestView');
+            expect(result).toBe(true);
+            console.log('✅ isNativeView test passed');
+        });
+        test('isMdxView should check private views', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                MDX: 'SELECT {[Product].Members} ON 0 FROM [TestCube]'
+            }));
+            const result = await viewService.isMdxView('TestCube', 'PrivateView', true);
+            expect(result).toBe(true);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/PrivateViews('PrivateView')/?$select=MDX");
+            console.log('✅ isMdxView private view test passed');
+        });
+    });
+    describe('View Count Functions', () => {
+        test('getViewCount should return total count for both view types', async () => {
+            mockRestService.get
+                .mockResolvedValueOnce(createMockResponse('5')) // private count
+                .mockResolvedValueOnce(createMockResponse('10')); // public count
+            const result = await viewService.getViewCount('TestCube');
+            expect(result).toBe(15);
+            expect(mockRestService.get).toHaveBeenCalledTimes(2);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/PrivateViews/$count");
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views/$count");
+            console.log('✅ getViewCount total test passed');
+        });
+        test('getViewCount should return private view count only', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('3'));
+            const result = await viewService.getViewCount('TestCube', true);
+            expect(result).toBe(3);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/PrivateViews/$count");
+            console.log('✅ getViewCount private test passed');
+        });
+        test('getViewCount should return public view count only', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('7'));
+            const result = await viewService.getViewCount('TestCube', false);
+            expect(result).toBe(7);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views/$count");
+            console.log('✅ getViewCount public test passed');
+        });
+    });
+    describe('View Name Retrieval by Type', () => {
+        test('getMdxViewNames should return only MDX view names', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT {[Year].Members} ON 0 FROM [TestCube]' },
+                    { Name: 'NativeView1', MDX: null },
+                    { Name: 'MDXView2', MDX: 'SELECT {[Product].Members} ON 0 FROM [TestCube]' }
+                ]
+            }));
+            const result = await viewService.getMdxViewNames('TestCube');
+            expect(result).toEqual(['MDXView1', 'MDXView2']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views?$select=Name,MDX");
+            console.log('✅ getMdxViewNames test passed');
+        });
+        test('getNativeViewNames should return only native view names', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT {[Year].Members} ON 0 FROM [TestCube]' },
+                    { Name: 'NativeView1', MDX: null },
+                    { Name: 'NativeView2', MDX: null }
+                ]
+            }));
+            const result = await viewService.getNativeViewNames('TestCube');
+            expect(result).toEqual(['NativeView1', 'NativeView2']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/Views?$select=Name,MDX");
+            console.log('✅ getNativeViewNames test passed');
+        });
+        test('getMdxViewNames should work with private views', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'PrivateMDXView', MDX: 'SELECT {[Month].Members} ON 0 FROM [TestCube]' }
+                ]
+            }));
+            const result = await viewService.getMdxViewNames('TestCube', true);
+            expect(result).toEqual(['PrivateMDXView']);
+            expect(mockRestService.get).toHaveBeenCalledWith("/Cubes('TestCube')/PrivateViews?$select=Name,MDX");
+            console.log('✅ getMdxViewNames private test passed');
+        });
+    });
+    describe('Update or Create Functionality', () => {
+        test('updateOrCreate should update existing view', async () => {
+            const mockView = {
+                cube: 'TestCube',
+                name: 'TestView',
+                mdx: 'SELECT {[Year].Members} ON 0 FROM [TestCube]'
+            };
+            // Mock exists to return true
+            jest.spyOn(viewService, 'exists').mockResolvedValue(true);
+            jest.spyOn(viewService, 'update').mockResolvedValue(createMockResponse({}));
+            await viewService.updateOrCreate(mockView, false);
+            expect(viewService.update).toHaveBeenCalledWith(mockView, false);
+            console.log('✅ updateOrCreate update test passed');
+        });
+        test('updateOrCreate should create non-existing view', async () => {
+            const mockView = {
+                cube: 'TestCube',
+                name: 'NewView',
+                mdx: 'SELECT {[Product].Members} ON 0 FROM [TestCube]'
+            };
+            // Mock exists to return false
+            jest.spyOn(viewService, 'exists').mockResolvedValue(false);
+            jest.spyOn(viewService, 'create').mockResolvedValue(createMockResponse({}));
+            await viewService.updateOrCreate(mockView, false);
+            expect(viewService.create).toHaveBeenCalledWith(mockView, false);
+            console.log('✅ updateOrCreate create test passed');
+        });
+        test('updateOrCreate should handle complex exists response for private views', async () => {
+            const mockView = {
+                cube: 'TestCube',
+                name: 'TestView'
+            };
+            // Mock exists to return [true, false] (private exists, public doesn't)
+            jest.spyOn(viewService, 'exists').mockResolvedValue([true, false]);
+            jest.spyOn(viewService, 'update').mockResolvedValue(createMockResponse({}));
+            await viewService.updateOrCreate(mockView, true);
+            expect(viewService.update).toHaveBeenCalledWith(mockView, true);
+            console.log('✅ updateOrCreate complex exists test passed');
+        });
+    });
+    describe('Error Handling', () => {
+        test('should handle empty search results gracefully', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: []
+            }));
+            const result = await viewService.searchStringInName('TestCube', 'NonExistent');
+            expect(result).toEqual([]);
+            console.log('✅ Empty search results handling test passed');
+        });
+        test('should handle invalid count responses', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse('invalid'));
+            const result = await viewService.getViewCount('TestCube', false);
+            expect(result).toBe(0);
+            console.log('✅ Invalid count handling test passed');
+        });
+        test('should handle views without MDX in search', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'NativeView1', MDX: null },
+                    { Name: 'NativeView2', MDX: undefined }
+                ]
+            }));
+            const result = await viewService.searchStringInMdx('TestCube', 'SELECT');
+            expect(result).toEqual([]);
+            console.log('✅ Views without MDX handling test passed');
+        });
+    });
+});
+//# sourceMappingURL=enhancedViewService.test.js.map

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

@@ -0,0 +1,6 @@
+/**
+ * Error Handling Tests for tm1npm
+ * Tests various error scenarios and edge cases
+ */
+export {};
+//# sourceMappingURL=errorHandling.test.d.ts.map

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

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

package/lib/tests/errorHandling.test.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Error Handling Tests for tm1npm
+ * Tests various error scenarios and edge cases
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+const Utils_1 = require("../utils/Utils");
+const testConfig_1 = require("./testConfig");
+describe('Error Handling Tests', () => {
+    const config = (0, testConfig_1.loadTestConfig)();
+    const baseUrl = `http://${config.address}:${config.port}/api/v1`;
+    describe('Network Error Handling', () => {
+        test('should handle connection refused errors', async () => {
+            const invalidConfig = {
+                baseURL: 'http://localhost:9999/api/v1', // Non-existent server
+                user: config.user,
+                password: config.password,
+                timeout: 5000
+            };
+            await expect(axios_1.default.get('/Configuration/ProductVersion', invalidConfig))
+                .rejects.toMatchObject({
+                code: 'ECONNREFUSED'
+            });
+        });
+        test('should handle DNS resolution errors', async () => {
+            const invalidConfig = {
+                baseURL: 'http://nonexistent-tm1-server-12345.com/api/v1',
+                user: config.user,
+                password: config.password,
+                timeout: 5000
+            };
+            await expect(axios_1.default.get('/Configuration/ProductVersion', invalidConfig))
+                .rejects.toMatchObject({
+                code: expect.stringMatching(/ENOTFOUND|ECONNREFUSED/)
+            });
+        });
+        test('should handle timeout errors gracefully', async () => {
+            const timeoutConfig = {
+                baseURL: baseUrl,
+                user: config.user,
+                password: config.password,
+                timeout: 1 // 1ms timeout - will definitely timeout
+            };
+            await expect(axios_1.default.get('/Configuration/ProductVersion', timeoutConfig))
+                .rejects.toMatchObject({
+                code: 'ECONNABORTED'
+            });
+        }, 15000);
+    });
+    describe('HTTP Error Handling', () => {
+        const validConfig = {
+            baseURL: baseUrl,
+            user: config.user,
+            password: config.password,
+            timeout: 30000
+        };
+        test('should handle 404 Not Found errors', async () => {
+            var _a, _b, _c;
+            try {
+                await axios_1.default.get('/NonExistentEndpoint', validConfig);
+            }
+            catch (error) {
+                // Should get some kind of error response (401 or 404 are both acceptable for non-existent endpoints)
+                expect((_a = error.response) === null || _a === void 0 ? void 0 : _a.status).toBeDefined();
+                expect((_b = error.response) === null || _b === void 0 ? void 0 : _b.status).toBeGreaterThanOrEqual(400);
+                expect([401, 404]).toContain((_c = error.response) === null || _c === void 0 ? void 0 : _c.status);
+            }
+        });
+        test('should handle 400 Bad Request errors', async () => {
+            var _a, _b;
+            // Invalid OData query
+            try {
+                await axios_1.default.get('/Dimensions?$invalid=query', validConfig);
+                // If it doesn't throw, that's also acceptable
+            }
+            catch (error) {
+                // Should get some kind of error response
+                expect((_a = error.response) === null || _a === void 0 ? void 0 : _a.status).toBeDefined();
+                expect((_b = error.response) === null || _b === void 0 ? void 0 : _b.status).toBeGreaterThanOrEqual(400);
+            }
+        });
+        test('should handle 500 Internal Server Error gracefully', async () => {
+            try {
+                // Attempt to create invalid data that might cause server error
+                await axios_1.default.post('/Dimensions', { InvalidData: true }, validConfig);
+            }
+            catch (error) {
+                if (error.response) {
+                    expect(error.response.status).toBeGreaterThanOrEqual(400);
+                    expect(error.response.status).toBeLessThan(600);
+                }
+            }
+        });
+    });
+    describe('Exception Class Testing', () => {
+        test('TM1Exception should be properly constructed', () => {
+            const error = new TM1Exception_1.TM1Exception('Test error message');
+            expect(error.message).toBe('Test error message');
+            expect(error.name).toBe('TM1Exception');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(TM1Exception_1.TM1Exception);
+        });
+        test('TM1RestException should include status and response', () => {
+            const mockResponse = { error: 'Not found' };
+            const error = new TM1Exception_1.TM1RestException('REST error', 404, mockResponse);
+            expect(error.message).toBe('REST error');
+            expect(error.name).toBe('TM1RestException');
+            expect(error.status).toBe(404);
+            expect(error.response).toEqual(mockResponse);
+            expect(error).toBeInstanceOf(TM1Exception_1.TM1Exception);
+        });
+        test('TM1TimeoutException should include timeout info', () => {
+            const error = new TM1Exception_1.TM1TimeoutException('Request timed out', 30000);
+            expect(error.message).toBe('Request timed out');
+            expect(error.name).toBe('TM1TimeoutException');
+            expect(error.timeout).toBe(30000);
+            expect(error).toBeInstanceOf(TM1Exception_1.TM1Exception);
+        });
+    });
+    describe('Utility Function Error Handling', () => {
+        test('formatUrl should handle missing parameters', () => {
+            expect(() => (0, Utils_1.formatUrl)("/test/{}/{}", "param1")).not.toThrow();
+            expect((0, Utils_1.formatUrl)("/test/{}/{}", "param1")).toContain("param1");
+        });
+        test('formatUrl should handle null/undefined parameters', () => {
+            expect(() => (0, Utils_1.formatUrl)("/test/{}", null)).not.toThrow();
+            expect(() => (0, Utils_1.formatUrl)("/test/{}", undefined)).not.toThrow();
+        });
+        test('verifyVersion should handle malformed version strings', () => {
+            expect(() => (0, Utils_1.verifyVersion)("invalid", "1.0.0")).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)("1.0.0", "invalid")).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)("", "")).not.toThrow();
+            expect(() => (0, Utils_1.verifyVersion)("1", "1.0.0.0.0")).not.toThrow();
+        });
+        test('CaseAndSpaceInsensitiveMap should handle edge cases', () => {
+            const map = new Utils_1.CaseAndSpaceInsensitiveMap();
+            expect(() => map.set('', 'empty')).not.toThrow();
+            expect(() => map.set('   ', 'spaces')).not.toThrow();
+            expect(() => map.get('')).not.toThrow();
+            expect(() => map.has('')).not.toThrow();
+            expect(() => map.delete('')).not.toThrow();
+            // Test with null-like values
+            map.set('test', null);
+            expect(map.get('test')).toBeNull();
+        });
+    });
+    describe('Data Validation Error Handling', () => {
+        test('should handle extremely long strings', () => {
+            const longString = 'A'.repeat(10000);
+            expect(() => (0, Utils_1.formatUrl)("/test/{}", longString)).not.toThrow();
+            const map = new Utils_1.CaseAndSpaceInsensitiveMap();
+            expect(() => map.set(longString, 'value')).not.toThrow();
+        });
+        test('should handle special characters in URLs', () => {
+            const specialChars = ['%', '&', '=', '+', ' ', '\n', '\t', '\r'];
+            for (const char of specialChars) {
+                expect(() => (0, Utils_1.formatUrl)("/test/{}", char)).not.toThrow();
+            }
+        });
+        test('should handle Unicode characters', () => {
+            const unicodeStrings = [
+                '测试', // Chinese
+                'тест', // Cyrillic
+                'テスト', // Japanese
+                '🚀🎉', // Emojis
+                'café' // Accented characters
+            ];
+            for (const str of unicodeStrings) {
+                expect(() => (0, Utils_1.formatUrl)("/test/{}", str)).not.toThrow();
+                const result = (0, Utils_1.formatUrl)("/test/{}", str);
+                expect(result).toContain(encodeURIComponent(str));
+            }
+        });
+    });
+    describe('Memory and Resource Error Handling', () => {
+        test('should handle large data structures gracefully', () => {
+            const largeMap = new Utils_1.CaseAndSpaceInsensitiveMap();
+            // Add many items
+            for (let i = 0; i < 1000; i++) {
+                largeMap.set(`key${i}`, `value${i}`);
+            }
+            expect(largeMap.size).toBe(1000);
+            expect(largeMap.get('key500')).toBe('value500');
+            expect(largeMap.has('KEY500')).toBe(true); // Case insensitive
+        });
+        test('should handle rapid successive operations', () => {
+            const map = new Utils_1.CaseAndSpaceInsensitiveMap();
+            // Rapid add/remove cycles
+            for (let cycle = 0; cycle < 10; cycle++) {
+                for (let i = 0; i < 100; i++) {
+                    map.set(`temp${i}`, i);
+                }
+                for (let i = 0; i < 100; i++) {
+                    map.delete(`temp${i}`);
+                }
+            }
+            expect(map.size).toBe(0);
+        });
+    });
+    describe('Async Error Handling', () => {
+        test('should handle promise rejection in utility functions', async () => {
+            // Simulate async utility function errors
+            const asyncTest = async () => {
+                throw new TM1Exception_1.TM1Exception('Async error');
+            };
+            await expect(asyncTest()).rejects.toThrow('Async error');
+            await expect(asyncTest()).rejects.toBeInstanceOf(TM1Exception_1.TM1Exception);
+        });
+        test('should handle multiple concurrent errors', async () => {
+            const errorPromises = Array(5).fill(null).map(async (_, index) => {
+                throw new TM1Exception_1.TM1Exception(`Error ${index}`);
+            });
+            const results = await Promise.allSettled(errorPromises);
+            expect(results).toHaveLength(5);
+            results.forEach((result, index) => {
+                expect(result.status).toBe('rejected');
+                expect(result.reason.message).toBe(`Error ${index}`);
+            });
+        });
+    });
+});
+//# sourceMappingURL=errorHandling.test.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * Exception Classes Tests
+ * Comprehensive test suite for TM1 exception classes
+ * Target: Improve coverage from 0% to 100% for TM1RestException and TM1TimeoutException
+ */
+export {};
+//# sourceMappingURL=exceptions.test.d.ts.map

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

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