@dronedeploy/rocos-js-sdk 3.0.1-alpha.9 → 3.0.2

package/esm/helpers/websandbox/frame/worker/manager.spec.js

@@ -1,127 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import WorkerManager from './manager';
-const WorkerMocks = {
-    postMessage: jest.fn(),
-    terminate: jest.fn(),
-    addEventListener: jest.fn(),
-    removeEventListener: jest.fn(),
-    onerror: jest.fn(),
-    onmessage: jest.fn(),
-    onmessageerror: jest.fn(),
-    dispatchEvent: jest.fn(),
-    clearAllMocks() {
-        this.postMessage.mockClear();
-        this.terminate.mockClear();
-        this.addEventListener.mockClear();
-        this.removeEventListener.mockClear();
-        this.onerror.mockClear();
-        this.onmessage.mockClear();
-        this.onmessageerror.mockClear();
-        this.dispatchEvent.mockClear();
-    },
-};
-class MockWorkerClass {
-    constructor() {
-        this.postMessage = WorkerMocks.postMessage;
-        this.terminate = WorkerMocks.terminate;
-        this.addEventListener = WorkerMocks.addEventListener;
-        this.removeEventListener = WorkerMocks.removeEventListener;
-        this.onerror = WorkerMocks.onerror;
-        this.onmessage = WorkerMocks.onmessage;
-        this.onmessageerror = WorkerMocks.onmessageerror;
-        this.dispatchEvent = WorkerMocks.dispatchEvent;
-    }
-}
-Object.defineProperty(window, 'Worker', {
-    value: MockWorkerClass,
-    writable: true,
-});
-Object.defineProperty(window, 'URL', {
-    value: {
-        createObjectURL: jest.fn(),
-    },
-});
-// add mock to AbortSignal.timeout
-Object.defineProperty(AbortSignal, 'timeout', {
-    value: jest.fn().mockImplementation((timeout) => {
-        return new AbortController().signal;
-    }),
-});
-const task = {
-    id: 'test',
-    code: '1',
-    timeout: 1000,
-};
-const response = {
-    data: {
-        id: 'test',
-        success: true,
-        result: 'test',
-    },
-};
-describe('WorkerManager', () => {
-    beforeEach(() => {
-        WorkerMocks.clearAllMocks();
-    });
-    it('should send a task to the worker', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.postMessage.mockImplementation((msg) => {
-            listeners.forEach((listener) => {
-                listener(response);
-            });
-        });
-        const manager = new WorkerManager();
-        const result = await manager.execute(task);
-        expect(result).toEqual('test');
-    });
-    it('should handle listener for a single task', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.removeEventListener.mockImplementation((_, listener) => {
-            const index = listeners.indexOf(listener);
-            listeners.splice(index, 1);
-        });
-        const manager = new WorkerManager();
-        expect(listeners.length).toEqual(0);
-        const result = manager.execute(task);
-        expect(listeners.length).toEqual(1);
-        listeners[0](response);
-        await result;
-        expect(listeners.length).toEqual(0);
-    });
-    it('should handle listener for multiple simultaneous task', async () => {
-        const listeners = [];
-        WorkerMocks.addEventListener.mockImplementation((_, listener) => {
-            listeners.push(listener);
-        });
-        WorkerMocks.removeEventListener.mockImplementation((_, listener) => {
-            const index = listeners.indexOf(listener);
-            listeners.splice(index, 1);
-        });
-        const manager = new WorkerManager();
-        expect(listeners.length).toEqual(0);
-        const result1 = manager.execute(task);
-        const result2 = manager.execute(task);
-        expect(listeners.length).toEqual(2);
-        const result3 = manager.execute(task);
-        expect(listeners.length).toEqual(3);
-        const [listener1, listener2, listener3] = listeners;
-        listener1(response);
-        await result1;
-        expect(listeners.length).toEqual(2);
-        listener3(response);
-        await result3;
-        expect(listeners.length).toEqual(1);
-        listener2(response);
-        await result2;
-        expect(listeners.length).toEqual(0);
-        expect(WorkerMocks.removeEventListener).toHaveBeenCalledTimes(3);
-    });
-});

package/esm/models/CallsignStatus.d.ts

@@ -1,6 +0,0 @@
-export declare enum CallsignStatus {
-    UNKNOWN = "unknown",
-    ONLINE = "online",
-    OFFLINE = "offline",
-    ERROR = "error"
-}

package/esm/models/CallsignStatus.js

@@ -1,7 +0,0 @@
-export var CallsignStatus;
-(function (CallsignStatus) {
-    CallsignStatus["UNKNOWN"] = "unknown";
-    CallsignStatus["ONLINE"] = "online";
-    CallsignStatus["OFFLINE"] = "offline";
-    CallsignStatus["ERROR"] = "error";
-})(CallsignStatus || (CallsignStatus = {}));

package/esm/models/ExternalProject.d.ts

@@ -1,6 +0,0 @@
-export declare class ExternalProject {
-    id?: string;
-    name?: string;
-    createdAt?: number;
-    isLinked?: boolean;
-}

package/esm/models/ExternalProject.js

@@ -1,2 +0,0 @@
-export class ExternalProject {
-}

package/esm/models/Token.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/models/Token.spec.js

@@ -1,108 +0,0 @@
-import { Token } from './Token';
-const generateToken = (config) => {
-    const defaultPayload = {
-        iat: 1234567890,
-        exp: 9876543210,
-        iss: 'myissuer',
-        aud: 'myaudience',
-        sub: 'mysubject',
-    };
-    const encodedHeader = Buffer.from(JSON.stringify(config?.header ?? { alg: 'HS256', typ: 'JWT' })).toString('base64');
-    const encodedPayload = Buffer.from(JSON.stringify(config?.payload ?? defaultPayload)).toString('base64');
-    if (config?.signature === null) {
-        return `${encodedHeader}.${encodedPayload}`;
-    }
-    return `${encodedHeader}.${encodedPayload}.${config?.signature ?? 'signature'}`;
-};
-describe('Token', () => {
-    describe('constructor', () => {
-        it('can get information from a valid token', () => {
-            const token = new Token(generateToken());
-            expect(token.issuedAt).toEqual(new Date(1234567890000));
-            expect(token.expires).toEqual(new Date(9876543210000));
-            expect(token.issuer).toEqual('myissuer');
-            expect(token.audience).toEqual('myaudience');
-            expect(token.subject).toEqual('mysubject');
-        });
-        it('should throw an error for a non-jwt', () => {
-            // completely invalid string
-            expect(() => new Token('not a jwt')).toThrowError('Invalid token');
-            // invalid header
-            expect(() => {
-                new Token(generateToken({
-                    header: {
-                        alg: 'HS256',
-                        typ: 'Not-a-JWT',
-                    },
-                }));
-            }).toThrowError('Invalid token');
-            // too many parts
-            expect(() => {
-                new Token('a.b.c.d');
-            }).toThrowError('Invalid token');
-        });
-        it('should allow a token with no signature', () => {
-            const token = new Token(generateToken({ signature: null }));
-            expect(token.issuedAt).toEqual(new Date(1234567890000));
-            expect(token.expires).toEqual(new Date(9876543210000));
-            expect(token.issuer).toEqual('myissuer');
-            expect(token.audience).toEqual('myaudience');
-            expect(token.subject).toEqual('mysubject');
-        });
-    });
-    describe('isExpired', () => {
-        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        afterEach(() => {
-            jest.useRealTimers();
-        });
-        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
-        const notExpiredDate = (baseDate.getTime() + 1000 * 60 * 60 * 24) / 1000; // 1 day from now
-        it('should return true if the token is expired', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredDate } }));
-            expect(token.isExpired()).toEqual(true);
-        });
-        it('should return false if the token is not expired', () => {
-            const token = new Token(generateToken({ payload: { exp: notExpiredDate } }));
-            expect(token.isExpired()).toEqual(false);
-        });
-    });
-    describe('isExpiredIn', () => {
-        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-        beforeEach(() => {
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        afterEach(() => {
-            jest.useRealTimers();
-        });
-        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
-        const expiredIn5MinsDate = (baseDate.getTime() + 1000 * 60 * 5) / 1000; // 5 minutes from now
-        const expiredIn25MinsDate = (baseDate.getTime() + 1000 * 60 * 25) / 1000; // 25 minutes from now
-        const expiredIn2HoursDate = (baseDate.getTime() + 1000 * 60 * 60 * 2) / 1000; // 2 hours from now
-        it('should return true if the token is expired in the given time', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
-            expect(token.isExpiredIn(5, 'minutes')).toEqual(true);
-            expect(token.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token.isExpiredIn(2, 'hours')).toEqual(true);
-            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
-            expect(token2.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token2.isExpiredIn(2, 'hours')).toEqual(true);
-            const token3 = new Token(generateToken({ payload: { exp: expiredDate } }));
-            expect(token3.isExpiredIn(5, 'minutes')).toEqual(true);
-            expect(token3.isExpiredIn(25, 'minutes')).toEqual(true);
-            expect(token3.isExpiredIn(2, 'hours')).toEqual(true);
-        });
-        it('should return false if the token is not expired in the given time', () => {
-            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
-            expect(token.isExpiredIn(4, 'minutes')).toEqual(false);
-            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
-            expect(token2.isExpiredIn(24, 'minutes')).toEqual(false);
-            const token3 = new Token(generateToken({ payload: { exp: expiredIn2HoursDate } }));
-            expect(token3.isExpiredIn(1, 'hours')).toEqual(false);
-        });
-    });
-});

package/esm/models/asset-storage/AssetModelItem.js

@@ -1 +0,0 @@
-export {};

package/esm/services/AuthService.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/services/AuthService.spec.js

@@ -1,163 +0,0 @@
-import { issuer } from '../constants/auth';
-import { AuthService } from './AuthService';
-import { Token } from '../models';
-describe('authService', () => {
-    const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
-    beforeEach(() => {
-        jest.useFakeTimers();
-        jest.setSystemTime(baseDate);
-    });
-    const expiredDate = new Date(baseDate.getTime() - 1000 * 60 * 5); // 5 minutes ago
-    const almostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 5); // 5 minutes from now
-    const almostAlmostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 25); // 35 minutes from now
-    const notExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 60 * 24); // 1 day from now
-    const getToken = (config) => {
-        const header = {
-            alg: 'HS256',
-            typ: 'JWT',
-        };
-        const payload = {
-            iat: Math.floor((config.iat ?? expiredDate).getTime() / 1000),
-            exp: Math.floor((config.exp ?? notExpiredDate).getTime() / 1000),
-            iss: config.iss ?? issuer,
-            aud: config.aud ?? 'myaudience',
-            sub: config.sub ?? 'mysubject',
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64');
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
-        if (config.signature === false) {
-            return `${encodedHeader}.${encodedPayload}`;
-        }
-        return `${encodedHeader}.${encodedPayload}.signature`;
-    };
-    afterAll(() => jest.useRealTimers());
-    describe('getToken', () => {
-        it('should return the current token if it is not expired', async () => {
-            // Arrange
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).toEqual(token);
-        });
-        it('should refresh the token if it is about to expire', async () => {
-            // Arrange
-            const token = getToken({ exp: almostExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            const expected = getToken({ signature: false });
-            jest.spyOn(AuthService.prototype, 'refreshToken').mockResolvedValue(new Token(expected));
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).not.toEqual(token);
-            expect(newToken.value).toEqual(expected);
-            expect(AuthService.prototype.refreshToken).toHaveBeenCalled();
-        });
-        it('should get a new token if there is no current token', async () => {
-            // Arrange
-            const token = getToken({ signature: false });
-            const service = new AuthService({
-                url: 'http://localhost:0',
-                token,
-            });
-            service.clearToken();
-            const expected = getToken({ signature: false });
-            jest.spyOn(AuthService.prototype, 'getNewUserToken').mockResolvedValue(new Token(expected));
-            // Act
-            const newToken = await service.getToken();
-            // Assert
-            expect(newToken.value).toEqual(expected);
-            expect(AuthService.prototype.getNewUserToken).toHaveBeenCalled();
-        });
-    });
-    describe('tokenRefreshLoop', () => {
-        jest.spyOn(AuthService.prototype, 'refreshTokenIfExpired').mockImplementation(() => {
-            // make sure the promise is resolved synchronously
-            return {
-                catch: () => {
-                    return {
-                        finally(onfinally) {
-                            onfinally?.();
-                            return Promise.resolve();
-                        },
-                    };
-                },
-            };
-        });
-        beforeEach(() => {
-            jest.clearAllTimers();
-            jest.clearAllMocks();
-            jest.useFakeTimers();
-            jest.setSystemTime(baseDate);
-        });
-        it('should check the token every 10 minutes', async () => {
-            // Arrange
-            const token = getToken({ exp: almostAlmostExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            service.startTokenRefreshChecker();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(2);
-            jest.advanceTimersByTime(1000 * 60); // 1 minutes - 24 minutes left
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(3);
-            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes - 14 minutes left
-            jest.runOnlyPendingTimers(); // wait for the next timer to run
-            service.stopTokenRefreshChecker();
-        });
-        it('should not run again when cancelled', () => {
-            // Arrange
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            // Act
-            service.startTokenRefreshChecker();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-            service.stopTokenRefreshChecker();
-            jest.runOnlyPendingTimers();
-            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
-        });
-        it('should correctly report running status', () => {
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-            service.startTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
-            service.stopTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-        });
-        it('should correctly report running status', () => {
-            const token = getToken({ exp: notExpiredDate });
-            const service = new AuthService({
-                token,
-                url: 'http://localhost:0',
-            });
-            service.setToken(token);
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-            service.startTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
-            service.stopTokenRefreshChecker();
-            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
-        });
-    });
-});

package/esm/services/CallerService.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/services/CallerService.spec.js

@@ -1,227 +0,0 @@
-import { AckStatus, ResultStatus, Stage, UIDVersion, } from '../models';
-import { concatMap, delay, from, of } from 'rxjs';
-import { CallerService } from './CallerService';
-import { TestScheduler } from 'rxjs/testing';
-const makeCallerMessage = (responses) => ({
-    responses: {
-        responses: responses ?? [],
-    },
-});
-const makeCallerChunkedMessage = (responses) => {
-    return responses.map((response, index) => {
-        if ('return' in response) {
-            throw new Error('Cannot create chunked message with return');
-        }
-        const chunk = response;
-        chunk.chunkIndex = index;
-        chunk.chunkCount = responses.length;
-        chunk.header = {
-            created: '0',
-            meta: {},
-        };
-        return {
-            chunks: {
-                chunks: [chunk],
-            },
-        };
-    });
-};
-const uid = {
-    hash: 'hash',
-    version: UIDVersion.HEADER_HASH_RAND,
-};
-const ack = (id) => ({
-    uid,
-    ack: {
-        status: AckStatus.PROGRESS,
-        message: id,
-        stage: Stage.AGENT,
-    },
-});
-const ret = (id) => {
-    const encoder = new TextEncoder();
-    const payload = encoder.encode(JSON.stringify({ id }));
-    return {
-        uid,
-        return: {
-            payload,
-        },
-    };
-};
-const chunkRet = (payload) => {
-    const array = new TextEncoder().encode(payload);
-    return {
-        uid,
-        payload: array,
-        chunkIndex: 0,
-        chunkCount: 1,
-        header: {
-            created: '0',
-            meta: {},
-        },
-    };
-};
-const res = (ok) => ({
-    uid,
-    result: {
-        status: ok ? ResultStatus.COMPLETE_SUCCESS : ResultStatus.FATAL,
-        message: ok ? 'everything is fine' : 'nothing is fine',
-    },
-});
-let testScheduler;
-let service;
-describe('CallerService', () => {
-    beforeEach(() => {
-        service = new CallerService({
-            url: 'http://localhost:8080',
-            token: 'token',
-        });
-        testScheduler = new TestScheduler((actual, expected) => {
-            expect(actual).toEqual(expected);
-        });
-    });
-    describe('callRaw', () => {
-        it('should handle a successful call', () => {
-            // Arrange
-            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
-                return from([
-                    makeCallerMessage([ack('a')]),
-                    makeCallerMessage([ack('b')]),
-                    makeCallerMessage([ack('c'), ret(1)]),
-                    makeCallerMessage([ret(2)]),
-                    makeCallerMessage([ret(3), ret(4)]),
-                    makeCallerMessage([ack('d')]),
-                    makeCallerMessage([ack('e')]),
-                    makeCallerMessage([ack('f')]),
-                    makeCallerMessage([ack('g'), res(true)]),
-                    makeCallerMessage([ack('h')]),
-                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
-            });
-            testScheduler.run(({ expectObservable }) => {
-                // Act
-                const call = service.call({
-                    callsign: 'callsign',
-                    projectId: 'project',
-                    source: '/test',
-                });
-                // Assert
-                const expectedAckMarbles = '-abc--def|';
-                const expectedRetMarbles = '---ab(cd)|';
-                const expectedResMarbles = '---------(a|)';
-                const expectedAckValues = {
-                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
-                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
-                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
-                    d: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'd' },
-                    e: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'e' },
-                    f: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'f' },
-                };
-                const expectedReturnValues = {
-                    a: { id: 1 },
-                    b: { id: 2 },
-                    c: { id: 3 },
-                    d: { id: 4 },
-                };
-                const expectedResultValues = {
-                    a: { status: ResultStatus.COMPLETE_SUCCESS, message: 'everything is fine' },
-                };
-                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues);
-                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues);
-                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
-            });
-        });
-        it('should handle a failed call', () => {
-            // Arrange
-            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
-                return from([
-                    makeCallerMessage([ack('a')]),
-                    makeCallerMessage([ack('b')]),
-                    makeCallerMessage([ack('c'), ret(1)]),
-                    makeCallerMessage([ret(2)]),
-                    makeCallerMessage([ret(3), ret(4)]),
-                    makeCallerMessage([ack('d')]),
-                    makeCallerMessage([ack('e')]),
-                    makeCallerMessage([ack('f')]),
-                    makeCallerMessage([ack('g'), res(false)]),
-                    makeCallerMessage([ack('h')]),
-                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
-            });
-            testScheduler.run(({ expectObservable }) => {
-                // Act
-                const call = service.call({
-                    callsign: 'callsign',
-                    projectId: 'project',
-                    source: '/test',
-                });
-                // Assert
-                const expectedAckMarbles = '-abc--def#';
-                const expectedRetMarbles = '---ab(cd)#';
-                const expectedResMarbles = '---------(a|)';
-                const expectedAckValues = {
-                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
-                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
-                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
-                    d: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'd' },
-                    e: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'e' },
-                    f: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'f' },
-                };
-                const expectedReturnValues = {
-                    a: { id: 1 },
-                    b: { id: 2 },
-                    c: { id: 3 },
-                    d: { id: 4 },
-                };
-                const expectedResultValues = {
-                    a: { status: ResultStatus.FATAL, message: 'nothing is fine' },
-                };
-                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues, res(false).result);
-                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues, res(false).result);
-                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
-            });
-        });
-        it('should handle a successful chunked call', () => {
-            // Arrange
-            jest.spyOn(service, 'invokeRequest').mockImplementation(() => {
-                return from([
-                    ...makeCallerChunkedMessage([
-                        chunkRet('[{"'),
-                        chunkRet('id":1},'),
-                        ack('a'),
-                        chunkRet('{"id":2}'),
-                        ack('b'),
-                        chunkRet(']'),
-                    ]),
-                    makeCallerMessage([ack('c'), ret(3)]),
-                    makeCallerMessage([res(true)]),
-                ]).pipe(concatMap((item) => of(item).pipe(delay(1))));
-            });
-            testScheduler.run(({ expectObservable }) => {
-                // Act
-                const call = service.call({
-                    callsign: 'callsign',
-                    projectId: 'project',
-                    source: '/test',
-                });
-                // Assert
-                const expectedAckMarbles = '---a-b-c|';
-                const expectedRetMarbles = '------ab|';
-                const expectedResMarbles = '--------(a|)';
-                const expectedAckValues = {
-                    a: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'a' },
-                    b: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'b' },
-                    c: { stage: Stage.AGENT, status: AckStatus.PROGRESS, message: 'c' },
-                };
-                const expectedReturnValues = {
-                    a: [{ id: 1 }, { id: 2 }],
-                    b: { id: 3 },
-                };
-                const expectedResultValues = {
-                    a: { status: ResultStatus.COMPLETE_SUCCESS, message: 'everything is fine' },
-                };
-                expectObservable(call.ack$).toBe(expectedAckMarbles, expectedAckValues);
-                expectObservable(call.return$).toBe(expectedRetMarbles, expectedReturnValues);
-                expectObservable(call.result$).toBe(expectedResMarbles, expectedResultValues);
-            });
-        });
-    });
-});