@dronedeploy/rocos-js-sdk 1.0.0-alpha-2 → 2.6.1

package/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/services/BaseStreamService.d.ts

@@ -1,18 +0,0 @@
-import { IBaseService, IBaseStream, IRocosSDKConfig, IStreamConfig, SubscriberStatusEnum } from '../models';
-import { ISubscriberStatus } from '../models/ISubscriberStatus';
-import { Logger } from 'loglevel';
-import { Subject } from 'rxjs';
-export declare abstract class BaseStreamService<T extends IBaseStream, C extends IStreamConfig = IStreamConfig> implements IBaseService, ISubscriberStatus {
-    protected config: IRocosSDKConfig;
-    protected logger: Logger;
-    protected status: boolean;
-    status$: Subject<SubscriberStatusEnum>;
-    protected constructor(name: string, config: IRocosSDKConfig);
-    getStatus(): boolean;
-    protected initStream(stream: T): Promise<void>;
-    protected createStreamFromConfig(identifier: string, config: C): Promise<{
-        stream: T;
-        isNew: boolean;
-    }>;
-    protected abstract getStream(config: C): T;
-}

package/services/BaseStreamService.js

@@ -1,47 +0,0 @@
-import { SubscriberStatusEnum, Token } from '../models';
-import { RocosLogger } from '../logger/RocosLogger';
-import { RocosStore } from '../store/RocosStore';
-import { StreamRegister } from '../api/StreamRegister';
-import { Subject } from 'rxjs';
-export class BaseStreamService {
-    constructor(name, config) {
-        this.status = false;
-        this.status$ = new Subject();
-        this.config = config;
-        this.logger = RocosLogger.getInstance(`${name}(${this.config.url})`);
-    }
-    getStatus() {
-        return this.status;
-    }
-    async initStream(stream) {
-        const authService = RocosStore.getSDKInstance(this.config).getAuthService();
-        if (!this.config.token || !authService.isTokenValid(new Token(this.config.token))) {
-            try {
-                const token = await authService.getToken();
-                stream.setToken(token.value);
-            }
-            catch (e) {
-                this.logger.error('Can not retrieve auth token', e);
-                throw new Error('Can not retrieve auth token');
-            }
-        }
-        authService.startTokenRefreshChecker();
-    }
-    async createStreamFromConfig(identifier, config) {
-        const identifierWithScope = StreamRegister.getIdentifier(identifier);
-        const streamRegister = StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifierWithScope);
-        let isNew = false;
-        if (!stream) {
-            isNew = true;
-            stream = this.getStream(config);
-            stream.statusStream$.subscribe((msg) => {
-                this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
-                this.status$.next(msg);
-            });
-            await streamRegister.addStream(stream);
-            await this.initStream(stream);
-        }
-        return { stream, isNew };
-    }
-}

package/services/PlatformTimeService.spec.d.ts

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

package/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/services/TelemetryService.spec.d.ts

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

package/services/TelemetryService.spec.js

@@ -1,37 +0,0 @@
-import { TelemetryService } from './TelemetryService';
-import { delay, from, lastValueFrom, NEVER, take, throwError } from 'rxjs';
-import { CallsignStatus } from '../models';
-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);
-        });
-    });
-});