@dronedeploy/rocos-js-sdk 3.0.1-alpha.8 → 3.0.1

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