tm1npm 1.0.0

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

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

package/lib/tests/subsetService.test.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * SubsetService Tests for tm1npm
+ * Comprehensive tests for TM1 Subset operations with proper mocking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const SubsetService_1 = require("../services/SubsetService");
+const Subset_1 = require("../objects/Subset");
+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('SubsetService Tests', () => {
+    let subsetService;
+    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()
+        };
+        subsetService = new SubsetService_1.SubsetService(mockRestService);
+    });
+    describe('Subset Retrieval Operations', () => {
+        test('should get all subset names for dimension/hierarchy', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Default' },
+                    { Name: 'TopLevel' },
+                    { Name: 'CustomSubset' }
+                ]
+            }));
+            const subsetNames = await subsetService.getAllNames('TestDimension', 'TestHierarchy');
+            expect(Array.isArray(subsetNames)).toBe(true);
+            expect(subsetNames.length).toBe(3);
+            expect(subsetNames).toEqual(['Default', 'TopLevel', 'CustomSubset']);
+            console.log('✅ Subset names retrieved successfully');
+        });
+        test('should get all subsets with full details', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    {
+                        Name: 'Default',
+                        UniqueName: '[TestDimension].[TestHierarchy].[Default]',
+                        Expression: '',
+                        Hierarchy: {
+                            Name: 'TestHierarchy',
+                            Dimension: { Name: 'TestDimension' }
+                        }
+                    },
+                    {
+                        Name: 'TopLevel',
+                        UniqueName: '[TestDimension].[TestHierarchy].[TopLevel]',
+                        Expression: '{TM1FILTERBYLEVEL({TM1SUBSETALL([TestDimension])}, 0)}',
+                        Hierarchy: {
+                            Name: 'TestHierarchy',
+                            Dimension: { Name: 'TestDimension' }
+                        }
+                    }
+                ]
+            }));
+            const response = await subsetService.getAllNames('TestDimension', 'TestHierarchy');
+            expect(Array.isArray(response)).toBe(true);
+            expect(response.length).toBe(2);
+            expect(response[0]).toBe('Default');
+            expect(response[1]).toBe('TopLevel');
+            console.log('✅ All subsets retrieved successfully');
+        });
+        test('should get specific subset by name', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'SpecificSubset',
+                UniqueName: '[TestDimension].[TestHierarchy].[SpecificSubset]',
+                Expression: '{[Element1], [Element2], [Element3]}',
+                Hierarchy: {
+                    Name: 'TestHierarchy',
+                    Dimension: { Name: 'TestDimension' }
+                },
+                Elements: [
+                    { Name: 'Element1' },
+                    { Name: 'Element2' },
+                    { Name: 'Element3' }
+                ]
+            }));
+            const subset = await subsetService.get('TestDimension', 'TestHierarchy', 'SpecificSubset');
+            expect(subset).toBeDefined();
+            expect(subset.Name).toBe('SpecificSubset');
+            console.log('✅ Specific subset retrieved successfully');
+        });
+        test('should check if subset exists', async () => {
+            // Test existing subset
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'ExistingSubset'
+            }));
+            const exists = await subsetService.exists('TestDimension', 'TestHierarchy', 'ExistingSubset');
+            expect(exists).toBe(true);
+            console.log('✅ Subset existence check working correctly');
+        });
+        test('should check if subset does not exist', async () => {
+            // Test non-existing subset
+            const mockError = new TM1Exception_1.TM1RestException('Subset not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await subsetService.exists('TestDimension', 'TestHierarchy', 'NonExistent');
+            expect(notExists).toBe(false);
+            console.log('✅ Subset non-existence check working correctly');
+        });
+    });
+    describe('Subset CRUD Operations', () => {
+        test('should create new subset', async () => {
+            const mockSubset = new Subset_1.Subset('NewSubset', 'TestDimension', 'TestHierarchy');
+            mockSubset.expression = '{[Element1], [Element2]}';
+            mockRestService.post.mockResolvedValue(createMockResponse({
+                Name: 'NewSubset'
+            }, 201));
+            const result = await subsetService.create('TestDimension', 'TestHierarchy', mockSubset);
+            expect(result.status).toBe(201);
+            expect(mockRestService.post).toHaveBeenCalled();
+            console.log('✅ Subset creation successful');
+        });
+        test('should update existing subset', async () => {
+            const mockSubset = new Subset_1.Subset('UpdatedSubset', 'TestDimension', 'TestHierarchy');
+            mockSubset.expression = '{[Element1], [Element2], [Element3]}';
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            const result = await subsetService.update('TestDimension', 'TestHierarchy', mockSubset);
+            expect(result.status).toBe(200);
+            console.log('✅ Subset update successful');
+        });
+        test('should delete subset', async () => {
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            const result = await subsetService.delete('TestDimension', 'TestHierarchy', 'SubsetToDelete');
+            expect(result.status).toBe(204);
+            console.log('✅ Subset deletion successful');
+        });
+    });
+    describe('Subset Element Operations', () => {
+        test('should get subset elements', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [
+                    { Name: 'Element1' },
+                    { Name: 'Element2' },
+                    { Name: 'Element3' }
+                ]
+            }));
+            const subset = await subsetService.get('TestDimension', 'TestHierarchy', 'TestSubset');
+            expect(subset).toBeDefined();
+            expect(Array.isArray(subset.value)).toBe(true);
+            console.log('✅ Subset elements retrieved successfully');
+        });
+        test('should handle empty subset', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'EmptySubset',
+                Elements: []
+            }));
+            const subset = await subsetService.get('TestDimension', 'TestHierarchy', 'EmptySubset');
+            expect(subset).toBeDefined();
+            expect(subset.Name).toBe('EmptySubset');
+            console.log('✅ Empty subset handling working');
+        });
+    });
+    describe('Subset Error Handling', () => {
+        test('should handle invalid subset names gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 400, statusText: 'Bad Request' }
+            });
+            await expect(subsetService.get('TestDimension', 'TestHierarchy', ''))
+                .rejects.toMatchObject({
+                response: { status: 400 }
+            });
+            console.log('✅ Invalid subset name handling working');
+        });
+        test('should handle network errors gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                code: 'ECONNREFUSED'
+            });
+            await expect(subsetService.getAllNames('TestDimension', 'TestHierarchy'))
+                .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(subsetService.get('TestDimension', 'TestHierarchy', 'TestSubset'))
+                .rejects.toMatchObject({
+                response: { status: 401 }
+            });
+            console.log('✅ Authentication error handling working');
+        });
+    });
+    describe('Subset Service Edge Cases', () => {
+        test('should handle large subset lists', async () => {
+            const largeSubsetData = Array(1000).fill(null).map((_, i) => ({
+                Name: `Subset${i}`,
+                Expression: `{[Element${i}]}`
+            }));
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: largeSubsetData
+            }));
+            const startTime = Date.now();
+            const subsets = await subsetService.getAllNames('LargeDimension', 'LargeHierarchy');
+            const endTime = Date.now();
+            expect(subsets.length).toBe(1000);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast with mocking
+            console.log('✅ Large subset list processing efficient');
+        });
+        test('should handle concurrent operations efficiently', async () => {
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: [{ Name: 'TestSubset' }]
+            }));
+            const operations = Array(5).fill(null).map(() => subsetService.getAllNames('TestDimension', 'TestHierarchy'));
+            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');
+        });
+    });
+    describe('Subset Service Integration', () => {
+        test('should maintain data consistency across operations', async () => {
+            const subsetList = [
+                { Name: 'Subset1' },
+                { Name: 'Subset2' }
+            ];
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                value: subsetList
+            }));
+            const names1 = await subsetService.getAllNames('TestDimension', 'TestHierarchy');
+            const names2 = await subsetService.getAllNames('TestDimension', 'TestHierarchy');
+            expect(names1).toEqual(names2);
+            expect(names1).toEqual(['Subset1', 'Subset2']);
+            console.log('✅ Data consistency maintained');
+        });
+        test('should handle subset lifecycle operations', async () => {
+            const testSubset = new Subset_1.Subset('LifecycleSubset', 'TestDimension', 'TestHierarchy');
+            testSubset.expression = '{[Element1]}';
+            // Mock create
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            // Mock get (exists)
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'LifecycleSubset'
+            }));
+            // Mock update
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            // Mock delete
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            // Test lifecycle operations
+            const createResult = await subsetService.create('TestDimension', 'TestHierarchy', testSubset);
+            expect(createResult.status).toBe(201);
+            const exists = await subsetService.exists('TestDimension', 'TestHierarchy', 'LifecycleSubset');
+            expect(exists).toBe(true);
+            const updateResult = await subsetService.update('TestDimension', 'TestHierarchy', testSubset);
+            expect(updateResult.status).toBe(200);
+            const deleteResult = await subsetService.delete('TestDimension', 'TestHierarchy', 'LifecycleSubset');
+            expect(deleteResult.status).toBe(204);
+            console.log('✅ Subset lifecycle operations working');
+        });
+    });
+});
+//# sourceMappingURL=subsetService.test.js.map

package/lib/tests/testConfig.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration interface for TM1 connection in tests
+ */
+export interface TM1TestConfig {
+    address: string;
+    port: number;
+    user: string;
+    password: string;
+    ssl: boolean;
+    namespace?: string;
+    gateway?: string;
+}
+/**
+ * Load configuration from environment variables
+ * Throws error if required environment variables are not set
+ */
+export declare function loadTestConfig(): TM1TestConfig;
+//# sourceMappingURL=testConfig.d.ts.map

package/lib/tests/testConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testConfig.d.ts","sourceRoot":"","sources":["../../src/tests/testConfig.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAcD;;;GAGG;AACH,wBAAgB,cAAc,IAAI,aAAa,CAkB9C"}

package/lib/tests/testConfig.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestConfig = loadTestConfig;
+const dotenv_1 = require("dotenv");
+// Load environment variables from .env file
+(0, dotenv_1.config)();
+/**
+ * Default test configuration - all values should come from environment variables
+ * These are fallback values only and should not contain real credentials
+ */
+const defaultTestConfig = {
+    address: "localhost",
+    port: 8879,
+    user: "admin",
+    password: "", // No default password - must be set via environment
+    ssl: false
+};
+/**
+ * Load configuration from environment variables
+ * Throws error if required environment variables are not set
+ */
+function loadTestConfig() {
+    // Check for required environment variables
+    if (!process.env.TM1_PASSWORD) {
+        throw new Error('TM1_PASSWORD environment variable is required. ' +
+            'Please set it in your .env file or environment.');
+    }
+    return {
+        address: process.env.TM1_ADDRESS || defaultTestConfig.address,
+        port: parseInt(process.env.TM1_PORT || defaultTestConfig.port.toString()),
+        user: process.env.TM1_USER || defaultTestConfig.user,
+        password: process.env.TM1_PASSWORD, // Required from environment
+        ssl: process.env.TM1_SSL === 'true' || defaultTestConfig.ssl,
+        namespace: process.env.TM1_NAMESPACE,
+        gateway: process.env.TM1_GATEWAY
+    };
+}
+//# sourceMappingURL=testConfig.js.map

package/lib/tests/testUtils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Test utility decorators for Jest testing - equivalent to Python test decorators
+ */
+export declare function skipIfNoPandas(target: any, propertyName: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function skipIfVersionLowerThan(version: string): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function skipIfVersionHigherOrEqualThan(version: string): (target: any, propertyName: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare function skipIfAuthNotBasic(target: any, propertyName: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+export declare function skipIfPaoc(target: any, propertyName: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+//# sourceMappingURL=testUtils.d.ts.map

package/lib/tests/testUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testUtils.d.ts","sourceRoot":"","sources":["../../src/tests/testUtils.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,wBAAgB,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,sBAY/F;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,IAKjC,QAAQ,GAAG,EAAE,cAAc,MAAM,EAAE,YAAY,kBAAkB,wBAarF;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,IAKzC,QAAQ,GAAG,EAAE,cAAc,MAAM,EAAE,YAAY,kBAAkB,wBAarF;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,sBAenG;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,sBAe3F"}

package/lib/tests/testUtils.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipIfNoPandas = skipIfNoPandas;
+exports.skipIfVersionLowerThan = skipIfVersionLowerThan;
+exports.skipIfVersionHigherOrEqualThan = skipIfVersionHigherOrEqualThan;
+exports.skipIfAuthNotBasic = skipIfAuthNotBasic;
+exports.skipIfPaoc = skipIfPaoc;
+const RestService_1 = require("../services/RestService");
+const Utils_1 = require("../utils/Utils");
+/**
+ * Test utility decorators for Jest testing - equivalent to Python test decorators
+ */
+function skipIfNoPandas(target, propertyName, descriptor) {
+    /**
+     * Checks whether pandas equivalent exists and skips the test if not
+     * Note: In JavaScript/TypeScript, we don't have pandas, so this always skips
+     */
+    const method = descriptor.value;
+    descriptor.value = function (...args) {
+        // In JavaScript environment, we don't have pandas equivalent
+        console.log(`Test '${propertyName}' requires pandas equivalent - skipping`);
+        return;
+    };
+    return descriptor;
+}
+function skipIfVersionLowerThan(version) {
+    /**
+     * Checks whether TM1 version is lower than a certain version and skips the test
+     * if this is the case. This function is useful if a test needs a minimum required version.
+     */
+    return function (target, propertyName, descriptor) {
+        const method = descriptor.value;
+        descriptor.value = function (...args) {
+            // @ts-ignore - accessing tm1 from test context
+            if (!(0, Utils_1.verifyVersion)(version, this.tm1.version)) {
+                console.log(`Function '${propertyName}' requires TM1 server version >= '${version}' - skipping`);
+                return;
+            }
+            else {
+                return method.apply(this, args);
+            }
+        };
+        return descriptor;
+    };
+}
+function skipIfVersionHigherOrEqualThan(version) {
+    /**
+     * Checks whether TM1 version is higher or equal than a certain version and skips the test
+     * if this is the case. This function is useful if a test should not run for higher versions.
+     */
+    return function (target, propertyName, descriptor) {
+        const method = descriptor.value;
+        descriptor.value = function (...args) {
+            // @ts-ignore - accessing tm1 from test context
+            if ((0, Utils_1.verifyVersion)(version, this.tm1.version)) {
+                console.log(`Function '${propertyName}' requires TM1 server version < '${version}' - skipping`);
+                return;
+            }
+            else {
+                return method.apply(this, args);
+            }
+        };
+        return descriptor;
+    };
+}
+function skipIfAuthNotBasic(target, propertyName, descriptor) {
+    /**
+     * Checks whether TM1 authentication is basic (user+password). Skip test if authentication is not basic
+     */
+    const method = descriptor.value;
+    descriptor.value = function (...args) {
+        // @ts-ignore - accessing tm1 from test context
+        if (this.tm1.connection.authenticationMode !== RestService_1.AuthenticationMode.BASIC) {
+            console.log(`Function '${propertyName}' requires IntegratedSecurityMode1 (Basic) - skipping`);
+            return;
+        }
+        else {
+            return method.apply(this, args);
+        }
+    };
+    return descriptor;
+}
+function skipIfPaoc(target, propertyName, descriptor) {
+    /**
+     * Checks whether TM1 is deployed as Planning Analytics on Cloud (PAoC)
+     */
+    const method = descriptor.value;
+    descriptor.value = function (...args) {
+        // @ts-ignore - accessing tm1 from test context
+        if (this.tm1.connection.baseUrl.includes("planning-analytics.ibmcloud.com/tm1/api")) {
+            console.log(`Function '${propertyName}' requires on prem TM1 instead of PAoC - skipping`);
+            return;
+        }
+        else {
+            return method.apply(this, args);
+        }
+    };
+    return descriptor;
+}
+//# sourceMappingURL=testUtils.js.map

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

@@ -0,0 +1,7 @@
+/**
+ * TM1Service Tests
+ * Comprehensive test suite for the main TM1Service class
+ * Target: Improve coverage from 0% to 40%+
+ */
+export {};
+//# sourceMappingURL=tm1Service.test.d.ts.map

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

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