tm1npm 1.5.3 → 2.0.0

package/src/tests/subsetService.issue38.test.ts

@@ -0,0 +1,182 @@
+/**
+ * SubsetService Tests — Issue #38 new methods
+ */
+
+import { SubsetService } from '../services/SubsetService';
+import { RestService } from '../services/RestService';
+import { Subset } from '../objects/Subset';
+import { Element, ElementType } from '../objects/Element';
+
+const createMockResponse = (data: any, status: number = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {} as any
+});
+
+describe('SubsetService — Issue #38 new methods', () => {
+    let subsetService: SubsetService;
+    let mockRestService: jest.Mocked<RestService>;
+
+    beforeEach(() => {
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {} as any,
+            rest: {} as any,
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        } as any;
+
+        subsetService = new SubsetService(mockRestService);
+    });
+
+    // ===== updateStaticElements =====
+
+    describe('updateStaticElements', () => {
+        test('should PUT to Elements/$ref with correct @odata.id body', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            await subsetService.updateStaticElements(
+                'MySubset',
+                'TestDimension',
+                'TestHierarchy',
+                false,
+                ['ElemA', 'ElemB']
+            );
+
+            expect(mockRestService.put).toHaveBeenCalledTimes(1);
+            const [url, body] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Dimensions('TestDimension')/Hierarchies('TestHierarchy')");
+            expect(url).toContain("Subsets('MySubset')/Elements/$ref");
+
+            const parsed = JSON.parse(body);
+            expect(Array.isArray(parsed.value)).toBe(true);
+            expect(parsed.value).toHaveLength(2);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('ElemA')");
+            expect(parsed.value[1]['@odata.id']).toContain("Elements('ElemB')");
+        });
+
+        test('should accept a Subset object and use its elements', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            const subset = new Subset('MySubset', 'TestDimension', 'TestHierarchy', undefined, undefined, ['X', 'Y', 'Z']);
+
+            await subsetService.updateStaticElements(subset);
+
+            expect(mockRestService.put).toHaveBeenCalledTimes(1);
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toHaveLength(3);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('X')");
+            expect(parsed.value[2]['@odata.id']).toContain("Elements('Z')");
+        });
+
+        test('should accept a Subset object with overriding elements array', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            const subset = new Subset('MySubset', 'TestDimension', 'TestHierarchy', undefined, undefined, ['X', 'Y']);
+            // Override elements explicitly
+            await subsetService.updateStaticElements(subset, undefined, undefined, false, ['Override1']);
+
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toHaveLength(1);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('Override1')");
+        });
+
+        test('should accept Element objects (not just strings)', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            const elem1 = new Element('Alpha', ElementType.NUMERIC);
+            const elem2 = new Element('Beta', ElementType.NUMERIC);
+
+            await subsetService.updateStaticElements(
+                'MySubset',
+                'TestDimension',
+                'TestHierarchy',
+                false,
+                [elem1, elem2]
+            );
+
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value[0]['@odata.id']).toContain("Elements('Alpha')");
+            expect(parsed.value[1]['@odata.id']).toContain("Elements('Beta')");
+        });
+
+        test('should use PrivateSubsets collection when isPrivate=true', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            await subsetService.updateStaticElements(
+                'PrivateSubset',
+                'TestDimension',
+                'TestHierarchy',
+                true,
+                ['E1']
+            );
+
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain('PrivateSubsets');
+            // PrivateSubsets is the only subsets segment — there must be no plain '/Subsets(' prefix
+            expect(url).not.toMatch(/\/Subsets\(/);
+        });
+
+        test('should use public Subsets collection when isPrivate=false', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            await subsetService.updateStaticElements(
+                'PublicSubset',
+                'TestDimension',
+                'TestHierarchy',
+                false,
+                ['E1']
+            );
+
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Subsets('PublicSubset')");
+            expect(url).not.toContain('PrivateSubsets');
+        });
+
+        test('should throw when dimensionName is missing for string argument', async () => {
+            await expect(
+                subsetService.updateStaticElements('MySubset', undefined, 'TestHierarchy', false, ['E1'])
+            ).rejects.toThrow('dimensionName is required when passing subset name as string');
+        });
+
+        test('should default hierarchyName to dimensionName for string argument', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            await subsetService.updateStaticElements(
+                'MySubset',
+                'TestDimension',
+                undefined, // no hierarchyName — should default to dimensionName
+                false,
+                ['E1']
+            );
+
+            const [url] = mockRestService.put.mock.calls[0];
+            expect(url).toContain("Hierarchies('TestDimension')");
+        });
+
+        test('should send empty value array when no elements provided', async () => {
+            mockRestService.put.mockResolvedValue(createMockResponse({}, 200));
+
+            await subsetService.updateStaticElements(
+                'EmptySubset',
+                'TestDimension',
+                'TestHierarchy',
+                false,
+                []
+            );
+
+            const [, body] = mockRestService.put.mock.calls[0];
+            const parsed = JSON.parse(body);
+            expect(parsed.value).toEqual([]);
+        });
+    });
+});

package/src/tests/tm1Service.test.ts

@@ -6,6 +6,7 @@
 
 import { TM1Service } from '../services/TM1Service';
 import { RestService, RestServiceConfig } from '../services/RestService';
+import { User, UserType } from '../objects/User';
 
 // Mock all service dependencies
 jest.mock('../services/RestService');
@@ -22,6 +23,19 @@ jest.mock('../services/FileService');
 jest.mock('../services/SessionService');
 jest.mock('../services/ServerService');
 jest.mock('../services/MonitoringService');
+jest.mock('../services/AnnotationService');
+jest.mock('../services/ChoreService');
+jest.mock('../services/GitService');
+jest.mock('../services/ApplicationService');
+jest.mock('../services/SandboxService');
+jest.mock('../services/JobService');
+jest.mock('../services/UserService');
+jest.mock('../services/ThreadService');
+jest.mock('../services/TransactionLogService');
+jest.mock('../services/MessageLogService');
+jest.mock('../services/ConfigurationService');
+jest.mock('../services/AuditLogService');
+jest.mock('../services/LoggerService');
 
 describe('TM1Service', () => {
     let tm1Service: TM1Service;
@@ -61,6 +75,8 @@ describe('TM1Service', () => {
             setSandbox: jest.fn(),
             getSandbox: jest.fn().mockReturnValue('test-sandbox'),
             isLoggedIn: jest.fn().mockReturnValue(true),
+            getVersion: jest.fn().mockResolvedValue('12.0.0'),
+            version: undefined,
         } as any;
 
         // Mock RestService constructor
@@ -83,6 +99,7 @@ describe('TM1Service', () => {
             expect(tm1Service.security).toBeDefined();
             expect(tm1Service.files).toBeDefined();
             expect(tm1Service.sessions).toBeDefined();
+            expect(tm1Service.applications).toBeDefined();
         });
 
         test('should create RestService with provided config', () => {
@@ -145,16 +162,18 @@ describe('TM1Service', () => {
     });
 
     describe('User and Authentication', () => {
-        test('should get current user with whoami', async () => {
-            // Mock security service getCurrentUser method
+        test('should get current user as User object with whoami', async () => {
+            const expectedUser = new User('test-user', ['ADMIN'], 'Test User', undefined, UserType.Admin, true);
             const mockSecurityService = {
-                getCurrentUser: jest.fn().mockResolvedValue({ name: 'test-user' })
+                getCurrentUser: jest.fn().mockResolvedValue(expectedUser)
             };
             (tm1Service.security as any) = mockSecurityService;
 
             const result = await tm1Service.whoami();
-            
-            expect(result).toBe('test-user');
+
+            expect(result).toBeInstanceOf(User);
+            expect(result.name).toBe('test-user');
+            expect(result).toBe(expectedUser);
             expect(mockSecurityService.getCurrentUser).toHaveBeenCalledTimes(1);
         });
 
@@ -175,10 +194,11 @@ describe('TM1Service', () => {
 
         test('should re-authenticate successfully', async () => {
             await tm1Service.reAuthenticate();
-            
+
             expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
             expect(mockRestService.connect).toHaveBeenCalledTimes(1);
         });
+
     });
 
     describe('Metadata and Version', () => {
@@ -191,13 +211,13 @@ describe('TM1Service', () => {
             expect(mockRestService.get).toHaveBeenCalledWith('/$metadata');
         });
 
-        test('should get TM1 version', async () => {
-            mockRestService.get.mockResolvedValueOnce(mockResponse({ value: '12.0.0' }));
+        test('should get TM1 version via cached RestService.getVersion', async () => {
+            mockRestService.getVersion.mockResolvedValueOnce('12.0.0');
 
             const result = await tm1Service.getVersion();
-            
+
             expect(result).toBe('12.0.0');
-            expect(mockRestService.get).toHaveBeenCalledWith('/Configuration/ProductVersion');
+            expect(mockRestService.getVersion).toHaveBeenCalledTimes(1);
         });
 
         test('should handle metadata retrieval errors', async () => {
@@ -209,7 +229,7 @@ describe('TM1Service', () => {
 
         test('should handle version retrieval errors', async () => {
             const versionError = new Error('Version not available');
-            mockRestService.get.mockRejectedValueOnce(versionError);
+            mockRestService.getVersion.mockRejectedValueOnce(versionError);
 
             await expect(tm1Service.getVersion()).rejects.toThrow('Version not available');
         });
@@ -358,4 +378,68 @@ describe('TM1Service', () => {
             expect(monitoring1).toBe(monitoring2);
         });
     });
+
+    describe('Lazy Services (Issue #82)', () => {
+        const lazyServiceNames: Array<keyof TM1Service> = [
+            'annotations',
+            'chores',
+            'git',
+            'sandboxes',
+            'jobs',
+            'users',
+            'threads',
+            'transactionLogs',
+            'messageLogs',
+            'configuration',
+            'auditLogs',
+            'loggers',
+        ];
+
+        test.each(lazyServiceNames)('should lazy-initialize %s service', (serviceName) => {
+            const instance = tm1Service[serviceName];
+            expect(instance).toBeDefined();
+        });
+
+        test.each(lazyServiceNames)('should cache %s service instance across accesses', (serviceName) => {
+            const first = tm1Service[serviceName];
+            const second = tm1Service[serviceName];
+            expect(second).toBe(first);
+        });
+    });
+
+    describe('Version Getter (Issue #82)', () => {
+        test('should expose cached version via sync getter', () => {
+            Object.defineProperty(mockRestService, 'version', {
+                get: () => '11.8.0',
+                configurable: true,
+            });
+
+            expect(tm1Service.version).toBe('11.8.0');
+        });
+
+        test('should return undefined when version has not been fetched yet', () => {
+            Object.defineProperty(mockRestService, 'version', {
+                get: () => undefined,
+                configurable: true,
+            });
+
+            expect(tm1Service.version).toBeUndefined();
+        });
+    });
+
+    describe('reConnect (Issue #82)', () => {
+        test('should call connect without disconnecting (tm1py parity)', async () => {
+            await tm1Service.reConnect();
+
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+            expect(mockRestService.disconnect).not.toHaveBeenCalled();
+        });
+
+        test('should propagate errors from connect', async () => {
+            mockRestService.connect.mockRejectedValueOnce(new Error('Connect failed'));
+
+            await expect(tm1Service.reConnect()).rejects.toThrow('Connect failed');
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+        });
+    });
 });