@dronedeploy/rocos-js-sdk 3.0.1-alpha.11 → 3.0.1-alpha.14

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);
-            });
-        });
-    });
-});

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

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

package/esm/services/PlatformTimeService.spec.js

@@ -1,180 +0,0 @@
-import { PlatFormTimeService } from "./PlatformTimeService";
-import { TimeSyncerService } from "./TimeSyncerService";
-import { standardDeviation } from "../helpers";
-// Subclass PlatformTimeService so that we can test the protected methods
-class PlatformtimeServicePublic extends PlatFormTimeService {
-    constructor(timeSyncerService) {
-        super(timeSyncerService);
-    }
-    isReliableServerTime(platformTimeMeasurement) {
-        return super.isReliableServerTime(platformTimeMeasurement);
-    }
-    calculateOffset(platformTimeMeasurement) {
-        return super.calculateOffset(platformTimeMeasurement);
-    }
-    removeLongestAndShortest(platformTimeMeasurement) {
-        return super.removeLongestAndShortest(platformTimeMeasurement);
-    }
-    static getInstance(timeSyncerService) {
-        const instance = super.getInstance(timeSyncerService);
-        return instance;
-    }
-}
-describe('platformTimeService', () => {
-    it('should calculate standard deviation correctly', () => {
-        let numbers = [10, 12, 23, 23, 16, 23, 21, 16];
-        let stdDev = standardDeviation(numbers);
-        expect(Math.abs(stdDev - 4.8989794855664)).toBeLessThan(0.000001);
-        numbers = [100, 12, 23, 23, 116, 23, 21, 162];
-        stdDev = standardDeviation(numbers);
-        expect(Math.abs(stdDev - 53.702886328394)).toBeLessThan(0.000001);
-    });
-    it('should be able to tell reliable server time response', () => {
-        jest.useFakeTimers();
-        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
-        const mock = {
-            clientTimeStampEnd: 100,
-            clientTimeStampStart: 20,
-            serverTime: {
-                now: 0,
-                duration: 0,
-            },
-        };
-        const mocks = [];
-        mocks.push(mock);
-        let isReliableServerTime = p.isReliableServerTime(mocks);
-        expect(isReliableServerTime).toBeTruthy();
-        for (let i = 0; i < 4; i++) {
-            mocks.push({ ...mock });
-            isReliableServerTime = p.isReliableServerTime(mocks);
-            expect(isReliableServerTime).toBeTruthy();
-        }
-    });
-    it('should be able to tell unreliable server time response', () => {
-        jest.useFakeTimers();
-        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
-        const mock = {
-            clientTimeStampEnd: 100,
-            clientTimeStampStart: 0,
-            serverTime: {
-                now: 0,
-                duration: 0,
-            },
-        };
-        const mocks = [];
-        let isReliableServerTime = false;
-        for (let i = 0; i < 5; i++) {
-            const mockClone = { ...mock };
-            mockClone.clientTimeStampEnd += i * 60;
-            mocks.push(mockClone);
-        }
-        isReliableServerTime = p.isReliableServerTime(mocks);
-        expect(isReliableServerTime).toBeTruthy();
-        for (let i = 0; i < 5; i++) {
-            const mockClone = { ...mock };
-            mockClone.clientTimeStampEnd += i * 70;
-            mocks.push(mockClone);
-        }
-        isReliableServerTime = p.isReliableServerTime(mocks);
-        expect(isReliableServerTime).toBeTruthy();
-        for (let i = 0; i < 5; i++) {
-            const mockClone = { ...mock };
-            mockClone.clientTimeStampEnd += i * 80;
-            mocks.push(mockClone);
-        }
-        isReliableServerTime = p.isReliableServerTime(mocks);
-        // std dev = 113.13708498985
-        expect(isReliableServerTime).toBeFalsy();
-        for (let i = 0; i < 5; i++) {
-            const mockClone = { ...mock };
-            mockClone.clientTimeStampEnd += i * 100;
-            mocks.push(mockClone);
-        }
-        isReliableServerTime = p.isReliableServerTime(mocks);
-        expect(isReliableServerTime).toBeFalsy();
-    });
-    it('should be able to remove shortest and longest correctly', () => {
-        jest.useFakeTimers();
-        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
-        const mock = {
-            clientTimeStampEnd: 100,
-            clientTimeStampStart: 0,
-            serverTime: {
-                now: 0,
-                duration: 0,
-            },
-        };
-        const mocks = [];
-        let mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 100;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 200;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 500;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 400;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 300;
-        mocks.push(mockClone);
-        const platformTimeMeasurement = p.removeLongestAndShortest(mocks);
-        platformTimeMeasurement.forEach((p) => {
-            expect(p.clientTimeStampEnd).not.toEqual(100);
-            expect(p.clientTimeStampEnd).not.toEqual(500);
-        });
-    });
-    it('should be able to calculate the offset correctly', () => {
-        jest.useFakeTimers();
-        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
-        const mock = {
-            clientTimeStampEnd: 100,
-            clientTimeStampStart: 0,
-            serverTime: {
-                now: 0,
-                duration: 0,
-            },
-        };
-        const mocks = [];
-        let mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 200;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 500;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 400;
-        mocks.push(mockClone);
-        const offset = p.calculateOffset(mocks);
-        // (200-(200)/2 + 500 - (500)/2 + 400 - (400)/2)/3 = 183.333333333, round to 183
-        expect(offset).toEqual(183);
-    });
-    it('should be able to filter where service time is not provided', () => {
-        jest.useFakeTimers();
-        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService({}));
-        const mock = {
-            clientTimeStampEnd: 100,
-            clientTimeStampStart: 0,
-            serverTime: {
-                now: 0,
-                duration: 0,
-            },
-        };
-        const mocks = [];
-        let mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 200;
-        mockClone.serverTime = undefined;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 500;
-        mocks.push(mockClone);
-        mockClone = { ...mock };
-        mockClone.clientTimeStampEnd = 400;
-        mocks.push(mockClone);
-        const offset = p.calculateOffset(mocks);
-        // (500 - (500)/2 + 400 - (400)/2)/2 = 225
-        expect(offset).toEqual(225);
-    });
-});

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

@@ -1,4 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-export {};

package/esm/services/RTPWebRTCService.spec.js

@@ -1,169 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import { lastValueFrom, takeUntil, toArray } from 'rxjs';
-import { RTPWebRTCService } from './RTPWebRTCService';
-class WebRTCMockHelper {
-    constructor() {
-        this.dataChannel = {
-            label: 'submanager',
-            onopen: () => void 0,
-            onclose: () => void 0,
-            onmessage: (e) => void 0,
-            send: this.sendMessage.bind(this),
-            close: this.close.bind(this),
-        };
-        this.connection = {
-            ontrack: (event) => void 0,
-            oniceconnectionstatechange: () => void 0,
-            onicecandidate: async (event) => void 0,
-            setRemoteDescription: jest.fn(),
-            iceConnectionState: 'new',
-            localDescription: null,
-            createDataChannel: jest.fn().mockReturnValue(this.dataChannel),
-            addTransceiver: jest.fn(),
-            createOffer: this.createOffer.bind(this),
-            setLocalDescription: jest.fn(),
-            close: this.close.bind(this),
-        };
-        this.streams = [];
-    }
-    installMocks() {
-        ;
-        global.RTCPeerConnection = jest.fn().mockReturnValue(this.connection);
-        global.RTCSessionDescription = jest.fn();
-        this.mockFetch();
-    }
-    async createOffer() {
-        await this.connection.onicecandidate({
-            candidate: null,
-        });
-        this.connection.iceConnectionState = 'checking';
-        this.connection.oniceconnectionstatechange();
-        this.addTrack('my-stream-1');
-        this.addTrack('my-stream-2');
-        this.connection.iceConnectionState = 'connected';
-        this.connection.oniceconnectionstatechange();
-        this.dataChannel.onopen();
-        return {
-            sdp: 'my-sdp',
-            type: 'offer',
-        };
-    }
-    addTrack(name) {
-        const stream = { name, active: true };
-        this.streams.push(stream);
-        this.connection.ontrack({
-            streams: [stream],
-        });
-    }
-    close() {
-        this.streams.forEach((stream) => {
-            stream.active = false;
-        });
-        this.dataChannel.onclose();
-        this.connection.iceConnectionState = 'closed';
-        this.connection.oniceconnectionstatechange();
-    }
-    sendMessage(message) {
-        const { logLevel } = JSON.parse(message);
-        if (logLevel === 'trace') {
-            this.dataChannel.onmessage({
-                data: message,
-            });
-        }
-    }
-    mockFetch() {
-        global.fetch = jest.fn().mockImplementation((url) => {
-            switch (url) {
-                case 'https://localhost:0/sdp/configs':
-                    return Promise.resolve({
-                        json: () => ({
-                            iceServers: [
-                                {
-                                    urls: ['stun:turn.localhost:443'],
-                                },
-                            ],
-                        }),
-                    });
-                case 'https://localhost:0/sdp':
-                    return Promise.resolve({
-                        json: () => ({
-                            answer: btoa('null'),
-                        }),
-                    });
-                default:
-                    throw new Error(`Unexpected URL: ${url}`);
-            }
-        });
-    }
-}
-describe('RTPWebRTCService', () => {
-    let service;
-    beforeEach(() => {
-        service = new RTPWebRTCService({
-            url: 'localhost',
-            port: 0,
-            token: 'test',
-        });
-    });
-    describe('streams$', () => {
-        it('should emit a stream when a new stream is added', async () => {
-            // Arrange
-            new WebRTCMockHelper().installMocks();
-            const connection = service.createPeerConnection({
-                projectId: 'my-project',
-                callsign: 'my-callsign',
-                logLevel: 'trace',
-            });
-            // Act
-            const streams = await lastValueFrom(connection.streams$.pipe(takeUntil(connection.connect()), toArray()));
-            // Assert
-            expect(streams).toEqual([
-                [
-                    {
-                        name: 'my-stream-1',
-                        active: true,
-                    },
-                ],
-                [
-                    {
-                        name: 'my-stream-1',
-                        active: true,
-                    },
-                    {
-                        name: 'my-stream-2',
-                        active: true,
-                    },
-                ],
-            ]);
-        });
-        it('should reset the streams when the connection is disconnected and the streams become inactive', async () => {
-            // Arrange
-            new WebRTCMockHelper().installMocks();
-            const connection = service.createPeerConnection({
-                projectId: 'my-project',
-                callsign: 'my-callsign',
-                logLevel: 'trace',
-            });
-            // Act
-            const streams = await lastValueFrom(connection.streams$.pipe(takeUntil((async () => {
-                await connection.connect();
-                connection.disconnect();
-                await connection.connect();
-            })()), toArray()));
-            expect(streams).toEqual([
-                [{ name: 'my-stream-1', active: false }],
-                [
-                    { name: 'my-stream-1', active: false },
-                    { name: 'my-stream-2', active: false },
-                ],
-                [{ name: 'my-stream-1', active: true }],
-                [
-                    { name: 'my-stream-1', active: true },
-                    { name: 'my-stream-2', active: true },
-                ],
-            ]);
-        });
-    });
-});

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

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

package/esm/services/TelemetryService.spec.js

@@ -1,37 +0,0 @@
-import { CallsignStatus } from '../models';
-import { NEVER, delay, from, lastValueFrom, take, throwError } from 'rxjs';
-import { TelemetryService } from './TelemetryService';
-describe('TelemetryService', () => {
-    describe('getRobotStatusChanges', () => {
-        it('should emit unknown to begin with', async () => {
-            const service = new TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue(NEVER);
-            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign').pipe(take(1)));
-            expect(lastValue).toEqual(CallsignStatus.UNKNOWN);
-        });
-        it('should emit online if the robot emits a heartbeat', async () => {
-            const service = new TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest
-                .spyOn(service, 'subscribe')
-                .mockReturnValue(from([0, 1, 2, 3, 4]).pipe(delay(100)));
-            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 1000, 10).pipe(take(2)));
-            expect(lastValue).toEqual(CallsignStatus.ONLINE);
-        }, 10000);
-        it('should emit offline if the robot never emits', async () => {
-            const service = new TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue(NEVER);
-            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe(take(2)));
-            expect(lastValue).toEqual(CallsignStatus.OFFLINE);
-        });
-        it('should emit an error if the telemetry errors', async () => {
-            const service = new TelemetryService({ url: '', token: '' });
-            // Mock 5 heartbeat messages
-            jest.spyOn(service, 'subscribe').mockReturnValue(throwError(() => new Error('test')));
-            const lastValue = await lastValueFrom(service.getRobotStatusChanges('project', 'callsign', 100, 10).pipe(take(2)));
-            expect(lastValue).toEqual(CallsignStatus.ERROR);
-        });
-    });
-});