tm1npm 1.5.3 → 2.0.0

package/src/tests/asyncOperationService.test.ts

@@ -381,8 +381,11 @@ describe('AsyncOperationService', () => {
             });
             asyncService.updateOperationStatus(id3, OperationStatus.COMPLETED);
 
+            // HTTP 202 = still running on the /_async endpoint.
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Running' }
+                status: 202,
+                headers: {},
+                data: {}
             });
 
             const activeOps = await asyncService.listActiveAsyncOperations();
@@ -641,91 +644,92 @@ describe('AsyncOperationService', () => {
         });
     });
 
+    // Status is inferred from the /_async('{id}') HTTP status code and the
+    // v12 `asyncresult` header; there is no `.Status` envelope on the new endpoint.
+    // These tests bypass createAsyncOperation (which tags operations as
+    // trackedLocally: true) to exercise the server-polling branch directly.
     describe('Server Status Mapping', () => {
-        test('should map CompletedSuccessfully to COMPLETED', async () => {
-            const operationId = await asyncService.createAsyncOperation({
+        const injectServerOperation = (id: string) => {
+            (asyncService as any).operations.set(id, {
+                id,
                 type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
+                name: 'TestProcess',
+                status: OperationStatus.RUNNING,
+                startTime: new Date(),
+                trackedLocally: false
             });
+        };
 
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 200 without asyncresult header to COMPLETED', async () => {
+            injectServerOperation('srv-1');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'CompletedSuccessfully', Result: { value: 42 } }
+                status: 200,
+                headers: {},
+                data: { value: 42 }
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
+            const status = await asyncService.getAsyncOperationStatus('srv-1');
             expect(status).toBe(OperationStatus.COMPLETED);
 
-            const operation = asyncService.getOperation(operationId);
+            const operation = asyncService.getOperation('srv-1');
             expect(operation?.result).toEqual({ value: 42 });
         });
 
-        test('should map CompletedWithErrors to FAILED', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
-
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 200 with non-2xx asyncresult header to FAILED', async () => {
+            injectServerOperation('srv-2');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'CompletedWithErrors', Error: 'Process failed at line 10' }
+                status: 200,
+                headers: { asyncresult: '500 Internal Server Error' },
+                data: {}
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
+            const status = await asyncService.getAsyncOperationStatus('srv-2');
             expect(status).toBe(OperationStatus.FAILED);
 
-            const operation = asyncService.getOperation(operationId);
-            expect(operation?.error).toBe('Process failed at line 10');
+            const operation = asyncService.getOperation('srv-2');
+            expect(operation?.error).toBe('500 Internal Server Error');
         });
 
-        test('should map Cancelled status correctly', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
+        test('should map thrown TM1RestException to FAILED', async () => {
+            injectServerOperation('srv-3');
 
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
-
-            mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Cancelled' }
-            });
+            const { TM1RestException } = require('../exceptions/TM1Exception');
+            mockRestService.get = jest.fn().mockRejectedValue(
+                new TM1RestException('Server error', 500)
+            );
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.CANCELLED);
+            const status = await asyncService.getAsyncOperationStatus('srv-3');
+            expect(status).toBe(OperationStatus.FAILED);
         });
 
-        test('should map Timeout status correctly', async () => {
-            const operationId = await asyncService.createAsyncOperation({
-                type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
-            });
-
-            asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
+        test('should map HTTP 202 to RUNNING', async () => {
+            injectServerOperation('srv-4');
 
             mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'Timeout' }
+                status: 202,
+                headers: {},
+                data: {}
             });
 
-            const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.TIMEOUT);
+            const status = await asyncService.getAsyncOperationStatus('srv-4');
+            expect(status).toBe(OperationStatus.RUNNING);
         });
 
-        test('should default to PENDING for unknown status', async () => {
+        test('locally-tracked operations skip server polling and return cached status', async () => {
             const operationId = await asyncService.createAsyncOperation({
                 type: OperationType.PROCESS_EXECUTION,
-                name: 'TestProcess'
+                name: 'LocalProcess'
             });
-
             asyncService.updateOperationStatus(operationId, OperationStatus.RUNNING);
 
-            mockRestService.get = jest.fn().mockResolvedValue({
-                data: { Status: 'UnknownStatus' }
-            });
+            const getSpy = jest.fn();
+            mockRestService.get = getSpy;
 
             const status = await asyncService.getAsyncOperationStatus(operationId);
-            expect(status).toBe(OperationStatus.PENDING);
+            expect(status).toBe(OperationStatus.RUNNING);
+            expect(getSpy).not.toHaveBeenCalled();
         });
     });
 

package/src/tests/bugfix28.test.ts

@@ -11,6 +11,7 @@ import { SubsetService } from '../services/SubsetService';
 import { ApplicationService } from '../services/ApplicationService';
 import { SessionService } from '../services/SessionService';
 import { RestService } from '../services/RestService';
+import { TM1RestException } from '../exceptions/TM1Exception';
 import { Subset } from '../objects/Subset';
 import { CubeApplication, ApplicationTypes } from '../objects/Application';
 
@@ -166,13 +167,20 @@ describe('Bug #12 - ApplicationService getNames() should not inject /api/v1/ pre
     });
 
     test('getNames() with isPrivate should use PrivateContents', async () => {
-        mockRest.get.mockResolvedValue(createMockResponse({ value: [{ Name: 'App1' }] }));
+        // _resolvePath probes public path first (returns 404), then tries private
+        const notFound = new TM1RestException('Not Found', 404, { status: 404 });
+        mockRest.get
+            .mockRejectedValueOnce(notFound)   // public probe → 404
+            .mockRejectedValueOnce(notFound)   // private probe → 404 (falls through to findBoundary)
+            .mockResolvedValueOnce(createMockResponse({ value: [] }))  // boundary probe succeeds
+            .mockResolvedValueOnce(createMockResponse({ value: [{ Name: 'App1' }] }));  // actual getNames
 
         await appService.getNames('Planning', true);
 
-        const calledUrl = mockRest.get.mock.calls[0][0] as string;
-        expect(calledUrl).not.toContain('/api/v1/');
-        expect(calledUrl).toBe("/Contents('Applications')/Contents('Planning')/PrivateContents");
+        // The final GET should target PrivateContents
+        const lastCall = mockRest.get.mock.calls[mockRest.get.mock.calls.length - 1][0] as string;
+        expect(lastCall).not.toContain('/api/v1/');
+        expect(lastCall).toContain('PrivateContents');
     });
 
     test('getNames() with empty path', async () => {