@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.20

package/services/AssetStorageService.js

@@ -1,169 +0,0 @@
-import { API_PROJECT_ASSET_PATH_URL, API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, API_PROJECT_ASSET_URL, API_PROJECT_FLOW_ASSET_PATH_URL, API_PROJECT_MISSION_ASSETS_PATH_URL, API_PROJECT_MISSION_ASSET_PATH_URL, API_PROJECT_ROBOT_ASSET_PATH_URL, } from '../constants/api';
-import { RocosError, errorCodes } from '../models/RocosError';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { RocosLogger } from '../logger/RocosLogger';
-import { formatServiceUrl } from '../helpers/formatServiceUrl';
-export class AssetStorageService extends BaseServiceAbstract {
-    constructor(config) {
-        super(config);
-        this.logger = RocosLogger.getInstance(`AssetStorageService(${this.config.url})`);
-    }
-    getError(e) {
-        return new RocosError(e, errorCodes.ASSET_STORAGE_SERVICE_ERROR);
-    }
-    getStatus() {
-        return true;
-    }
-    /**
-     * Create a new project asset
-     *
-     * @param projectId - Project Id
-     * @param filePath - Path to asset file
-     * @param file - File payload
-     */
-    // TODO: map the response object
-    async create(projectId, filePath, file) {
-        const formData = new FormData();
-        formData.append('file', file);
-        return this.callPut(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to create asset for ${projectId}, filePath ${filePath}.`);
-    }
-    /**
-     * Update a project asset
-     *
-     * @param projectId - Project Id
-     * @param filePath - Path to asset file
-     * @param file - File payload
-     */
-    // TODO: map the response object
-    async update(projectId, filePath, file) {
-        const formData = new FormData();
-        formData.append('file', file);
-        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to update asset for ${projectId}, filePath ${filePath}.`);
-    }
-    /**
-     * Delete a project asset
-     *
-     * @param projectId - Project Id
-     * @param filePath - Path to asset file
-     */
-    // TODO: map the response object
-    async delete(projectId, filePath) {
-        return this.callDelete(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to delete asset for ${projectId}, filePath ${filePath}.`);
-    }
-    /**
-     * Lost assets for a project or project file path
-     *
-     * @param projectId - Project Id
-     * @param filePath - Path to asset file
-     */
-    // TODO: map the response object
-    async list(projectId, filePath) {
-        let url = '';
-        if (filePath) {
-            url = formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure);
-        }
-        else {
-            url = formatServiceUrl(API_PROJECT_ASSET_URL, { url: this.config.url, projectId }, this.config.insecure);
-        }
-        return this.callGet(url, `Failed to get asset list for ${projectId}, filePath ${filePath}.`);
-    }
-    /**
-     * Get a project asset
-     *
-     * @param projectId - Project Id
-     * @param filePath - Path to asset file
-     */
-    // TODO: map the response object
-    async getAsset(projectId, filePath) {
-        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to get asset for ${projectId}, filePath ${filePath}.`, undefined, {
-            responseType: 'blob',
-        });
-    }
-    /**
-     * List assets for a robot
-     *
-     * @param projectId
-     * @param callsign
-     * @param parent
-     * @param signedURL
-     */
-    async listRobotAssets(projectId, callsign, parent = '/', signedURL = false) {
-        return this.callGet(formatServiceUrl(API_PROJECT_ROBOT_ASSET_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, { parent, signedURL });
-    }
-    /**
-     * List assets for a flow
-     *
-     * @param projectId
-     * @param flowId
-     * @param flowInstance
-     * @param parent
-     * @param signedURL
-     */
-    async listFlowAssets(projectId, flowId, flowInstance, parent = '/', signedURL = false) {
-        return this.callGet(formatServiceUrl(API_PROJECT_FLOW_ASSET_PATH_URL, { url: this.config.url, projectId, flowId, flowInstance }, this.config.insecure), `Failed to get asset for ${projectId}, flow ${flowId}, flow instance ${flowInstance}.`, { parent, signedURL });
-    }
-    /**
-     * List assets for a mission
-     *
-     * @param projectId
-     * @param assetIdList
-     */
-    async listMissionAssets(projectId, assetIdList) {
-        const searchParams = new URLSearchParams();
-        assetIdList.forEach((assetId) => searchParams.append('assetID', assetId));
-        return this.callGet(formatServiceUrl(API_PROJECT_MISSION_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset for ${projectId}, assetIdList ${assetIdList}.`, searchParams);
-    }
-    /**
-     * Get a single asset for a mission
-     *
-     * @param projectId
-     * @param assetId
-     */
-    async getMissionAsset(projectId, assetId) {
-        return this.callGet(formatServiceUrl(API_PROJECT_MISSION_ASSET_PATH_URL, { url: this.config.url, projectId, assetId }, this.config.insecure), `Failed to get asset for ${projectId}, dataUUID ${assetId}.`, undefined);
-    }
-    /**
-     * Set Robot Sync Definitions
-     * @param projectId
-     * @param callsign
-     * @param definition
-     */
-    setRobotSyncDefinitions(projectId, callsign, definition) {
-        const httpOptions = {
-            headers: {
-                'content-type': 'application/json',
-            },
-        };
-        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), definition, `Failed to update asset for ${projectId}, callsign ${callsign}.`, httpOptions);
-    }
-    /**
-     * Get Robot Sync Definitions
-     * @param projectId
-     * @param callsign
-     */
-    getRobotSyncDefinitions(projectId, callsign) {
-        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, undefined);
-    }
-    /**
-     * Set Profile Sync Definitions
-     * @param projectId
-     * @param profileId
-     * @param definition
-     */
-    setProfileSyncDefinitions(projectId, profileId, definition) {
-        const httpOptions = {
-            headers: {
-                'content-type': 'application/json',
-            },
-        };
-        return this.callPost(formatServiceUrl(API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), definition, `Failed to update sync-definition for ${projectId}, callsign ${profileId}.`, httpOptions);
-    }
-    /**
-     * Get Profile Sync Definitions
-     * @param projectId
-     * @param profileId
-     */
-    getProfileSyncDefinition(projectId, profileId) {
-        return this.callGet(formatServiceUrl(API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), `Failed to get sync-definition for ${projectId}, callsign ${profileId}.`, undefined);
-    }
-}

package/services/AuthService.d.ts

@@ -1,93 +0,0 @@
-import { IBaseService, IRocosSDKConfig, RocosError, Token } from '../models';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-export declare class AuthService extends BaseServiceAbstract implements IBaseService {
-    protected config: IRocosSDKConfig;
-    private token?;
-    private tokenRefreshTimeoutId?;
-    constructor(config: IRocosSDKConfig);
-    getStatus(): boolean;
-    teardown(): void;
-    protected getError(e: RocosError): RocosError;
-    /**
-     * Set the Auth token
-     * @param value - Token value
-     */
-    setToken(value: string | Token): void;
-    /**
-     * @deprecated `expiresIn` is now derived from the token. Use `setToken(value: string | Token)` instead
-     */
-    setToken(value: string | Token, expiresIn: number): void;
-    /**
-     * Clear token
-     */
-    clearToken(): void;
-    /**
-     * Get the authentication token for application Id and application Key.
-     */
-    getAppToken(): Promise<Token>;
-    /**
-     * Get new auth token for a user
-     * @desc This only works for user auth tokens, not appId auth tokens
-     */
-    getNewUserToken(): Promise<Token>;
-    /**
-     * Get new auth token for a user.
-     *
-     * Uses the OTP flow to exchange an external token for a user token.
-     *
-     * @desc This only works for user auth tokens, not appId auth tokens
-     */
-    private getNewUserTokenFromExternalToken;
-    /**
-     * Get the authentication token
-     *
-     * This will return the current token if it is not expired, otherwise it will get a new token based on your config.
-     */
-    getToken(): Promise<Token>;
-    /**
-     * Refresh the authentication token
-     *
-     * This only works for user auth tokens, not appId auth tokens.
-     *
-     * The new token is not automatically set as the current token. Use `setToken` to set the new token.
-     *
-     * @see setToken
-     * @param token the token to refresh. If not provided, the current token will be used.
-     */
-    refreshToken(token?: Token): Promise<Token>;
-    /** Refresh the token if it is expired or will expire in the next `minutes` minutes
-     *
-     * This only works for user auth tokens, not appId auth tokens.
-     *
-     * If you want to refresh the token regardless of the expiry time, use `refreshToken`.
-     *
-     * @param minutes the number of minutes before the token expires to refresh the token
-     * @see refreshToken
-     */
-    refreshTokenIfExpired(minutes: number): Promise<void>;
-    /** Start a 5-minute loop to check if the token needs to be refreshed
-     *
-     * This is useful when you are using GRPC services (i.e. telemetry) which does not automatically refresh the token.
-     * It is not required when using REST services as the token is refreshed automatically.
-     *
-     * The loop will stop when `stopTokenRefreshChecker` is called.
-     *
-     * @see stopTokenRefreshChecker
-     */
-    startTokenRefreshChecker(): void;
-    /**
-     * Stop the token refresh checker
-     * @see startTokenRefreshChecker
-     */
-    stopTokenRefreshChecker(): void;
-    /** Check if the token refresh checker is running
-     *
-     * @see startTokenRefreshChecker
-     * @see stopTokenRefreshChecker
-     * @returns true if the token refresh checker is running
-     */
-    isTokenRefreshCheckerRunning(): boolean;
-    /** Checks if the token is valid for use with the API */
-    isTokenValid(token: Token): boolean;
-    private isTokenIssuedByApp;
-}

package/services/AuthService.js

@@ -1,235 +0,0 @@
-import { API_APPLICATION_AUTH_URL, API_OTP_AUTH_URL, API_OTP_URL, API_USER_TOKEN_URL } from '../constants/api';
-import { RocosError, Token, errorCodes } from '../models';
-import { BaseServiceAbstract } from './BaseServiceAbstract';
-import { RocosLogger } from '../logger/RocosLogger';
-import { RocosStore } from '../store/RocosStore';
-import { formatServiceUrl } from '../helpers/formatServiceUrl';
-import { issuer } from '../constants/auth';
-export class AuthService extends BaseServiceAbstract {
-    constructor(config) {
-        super(config);
-        this.config = config;
-        this.config = config;
-        this.logger = RocosLogger.getInstance(`AuthService(${this.config.url})`);
-        if (this.config.token) {
-            this.setToken(this.config.token);
-        }
-    }
-    getStatus() {
-        return true;
-    }
-    teardown() {
-        if (this.isTokenRefreshCheckerRunning()) {
-            this.logger.debug('Stopping token refresh checker');
-            this.stopTokenRefreshChecker();
-        }
-    }
-    getError(e) {
-        return new RocosError(e, errorCodes.AUTH_ERROR, e?.statusCode);
-    }
-    setToken(value, expiresIn) {
-        if (expiresIn !== undefined) {
-            this.logger.warn('setToken(value, expiresIn) is deprecated. Use setToken(value) instead');
-        }
-        if (typeof value === 'string') {
-            this.token = new Token(value);
-        }
-        else {
-            this.token = value;
-        }
-        this.config.token = this.token.value;
-        // output a message for token change
-        RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: this.token.value });
-    }
-    /**
-     * Clear token
-     */
-    clearToken() {
-        this.token = undefined;
-        this.config.token = undefined;
-    }
-    /**
-     * Get the authentication token for application Id and application Key.
-     */
-    async getAppToken() {
-        if (!('appId' in this.config) || !this.config.appId || !('appKey' in this.config) || !this.config.appKey) {
-            throw new RocosError('Can not get app token, missing appId and appKey', errorCodes.AUTH_ERROR);
-        }
-        const res = await this.callPost(formatServiceUrl(API_APPLICATION_AUTH_URL, { url: this.config.url }, this.config.insecure), {
-            applicationId: this.config.appId,
-            secret: this.config.appKey,
-        }, 'Failed to get users auth token.', { public: true });
-        return new Token(res.token);
-    }
-    /**
-     * Get new auth token for a user
-     * @desc This only works for user auth tokens, not appId auth tokens
-     */
-    async getNewUserToken() {
-        if (!('token' in this.config) || !this.config.token) {
-            throw new RocosError('Can not get new app token, missing token', errorCodes.AUTH_ERROR);
-        }
-        const token = new Token(this.config.token, this.config.refreshToken);
-        if (token?.isExpired()) {
-            throw new RocosError('Token expired', errorCodes.AUTH_ERROR);
-        }
-        if (!this.isTokenIssuedByApp(token)) {
-            this.logger.info('Token is not issued by app. Getting new token from DD token.');
-            return this.getNewUserTokenFromExternalToken();
-        }
-        return this.refreshToken(token);
-    }
-    /**
-     * Get new auth token for a user.
-     *
-     * Uses the OTP flow to exchange an external token for a user token.
-     *
-     * @desc This only works for user auth tokens, not appId auth tokens
-     */
-    async getNewUserTokenFromExternalToken() {
-        if (!('token' in this.config) || !this.config.token) {
-            throw new RocosError('Can not get new token, missing token', errorCodes.AUTH_ERROR);
-        }
-        const ddToken = new Token(this.config.token);
-        const { otp } = await this.callPost(formatServiceUrl(API_OTP_URL, { url: this.config.url }, this.config.insecure), undefined, 'Failed to get one time password.', { public: true, headers: { Authorization: ddToken.bearer } });
-        const { token, refreshToken } = await this.callPost(formatServiceUrl(API_OTP_AUTH_URL, { url: this.config.url }, this.config.insecure), { otp }, 'Failed to get users auth token.', { public: true });
-        return new Token(token, refreshToken);
-    }
-    /**
-     * Get the authentication token
-     *
-     * This will return the current token if it is not expired, otherwise it will get a new token based on your config.
-     */
-    async getToken() {
-        if (this.token && this.isTokenValid(this.token)) {
-            if (this.token.isExpiredIn(15, 'minutes')) {
-                this.logger.info('Token expires within 15 minutes. Refreshing.');
-                const newToken = await this.refreshToken();
-                this.setToken(newToken);
-                return newToken;
-            }
-            return this.token;
-        }
-        let token;
-        try {
-            if ('appId' in this.config && 'appKey' in this.config) {
-                token = await this.getAppToken();
-            }
-            else if ('token' in this.config) {
-                token = await this.getNewUserToken();
-            }
-        }
-        catch (e) {
-            const message = 'Failed to get auth token.';
-            this.logger.error(message, e);
-            if (e instanceof Error) {
-                e.message = message;
-                throw new RocosError(e, errorCodes.AUTH_ERROR);
-            }
-            else {
-                throw new RocosError(message, errorCodes.AUTH_ERROR);
-            }
-        }
-        if (!token) {
-            const message = 'Failed to get auth token. Config invalid.';
-            this.logger.error(message);
-            throw new RocosError(message, errorCodes.AUTH_ERROR);
-        }
-        this.setToken(token);
-        return token;
-    }
-    /**
-     * Refresh the authentication token
-     *
-     * This only works for user auth tokens, not appId auth tokens.
-     *
-     * The new token is not automatically set as the current token. Use `setToken` to set the new token.
-     *
-     * @see setToken
-     * @param token the token to refresh. If not provided, the current token will be used.
-     */
-    async refreshToken(token) {
-        const tokenToRefresh = token ?? this.token;
-        if (!tokenToRefresh) {
-            throw new RocosError('No token to refresh', errorCodes.AUTH_ERROR);
-        }
-        const res = await this.callGet(formatServiceUrl(API_USER_TOKEN_URL, { url: this.config.url }, this.config.insecure), 'Failed to get users auth token.', undefined, { public: true, headers: { Authorization: tokenToRefresh.bearer } });
-        return new Token(res.token, res.refreshToken);
-    }
-    /** Refresh the token if it is expired or will expire in the next `minutes` minutes
-     *
-     * This only works for user auth tokens, not appId auth tokens.
-     *
-     * If you want to refresh the token regardless of the expiry time, use `refreshToken`.
-     *
-     * @param minutes the number of minutes before the token expires to refresh the token
-     * @see refreshToken
-     */
-    async refreshTokenIfExpired(minutes) {
-        if (this.token?.isExpiredIn(minutes, 'minutes')) {
-            this.logger.info('Token expires in 15 minutes. Refreshing.');
-            const newToken = await this.refreshToken();
-            this.setToken(newToken);
-        }
-    }
-    /** Start a 5-minute loop to check if the token needs to be refreshed
-     *
-     * This is useful when you are using GRPC services (i.e. telemetry) which does not automatically refresh the token.
-     * It is not required when using REST services as the token is refreshed automatically.
-     *
-     * The loop will stop when `stopTokenRefreshChecker` is called.
-     *
-     * @see stopTokenRefreshChecker
-     */
-    startTokenRefreshChecker() {
-        const maxInterval = 1000 * 60 * 10; // 10 minutes
-        const minInterval = 1000 * 60; // 1 minute
-        const threshold = 1000 * 60 * 15; // 15 minutes
-        if (this.isTokenRefreshCheckerRunning())
-            return;
-        if (!this.token)
-            throw new RocosError('No token to refresh', errorCodes.AUTH_ERROR);
-        if (!this.isTokenValid(this.token))
-            throw new RocosError('Token is not valid', errorCodes.AUTH_ERROR);
-        const loop = () => {
-            this.logger.debug('Checking scheduled token refresh');
-            this.refreshTokenIfExpired(15)
-                .catch((e) => {
-                this.logger.error('Failed to refresh token', e);
-            })
-                .finally(() => {
-                if (!this.token?.expires)
-                    return;
-                // schedule next check
-                const timeTillThreshold = this.token.expires.getTime() - Date.now() - threshold;
-                const interval = Math.max(minInterval, Math.min(maxInterval, timeTillThreshold));
-                this.tokenRefreshTimeoutId = setTimeout(() => loop(), interval);
-            });
-        };
-        loop();
-    }
-    /**
-     * Stop the token refresh checker
-     * @see startTokenRefreshChecker
-     */
-    stopTokenRefreshChecker() {
-        clearTimeout(this.tokenRefreshTimeoutId);
-        this.tokenRefreshTimeoutId = undefined;
-    }
-    /** Check if the token refresh checker is running
-     *
-     * @see startTokenRefreshChecker
-     * @see stopTokenRefreshChecker
-     * @returns true if the token refresh checker is running
-     */
-    isTokenRefreshCheckerRunning() {
-        return this.tokenRefreshTimeoutId !== undefined;
-    }
-    /** Checks if the token is valid for use with the API */
-    isTokenValid(token) {
-        return !token.isExpired() && this.isTokenIssuedByApp(token);
-    }
-    isTokenIssuedByApp(token) {
-        return token.issuer === issuer;
-    }
-}

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