@thoughtspot/visual-embed-sdk
Version:
ThoughtSpot Embed SDK
127 lines • 6.58 kB
JavaScript
import { getAuthenticationToken, resetCachedAuthToken, validateAuthToken } from './authToken';
import * as authTokenModule from './authToken';
import * as authServiceInstance from './utils/authService/authService';
import { AuthType } from './types';
import { formatTemplate, storeValueInWindow } from './utils';
import { logger } from './utils/logger';
import { ERROR_MESSAGE } from './errors';
describe('AuthToken Unit tests', () => {
test('getAuthenticationToken: When verification is disabled', async () => {
jest.spyOn(authServiceInstance, 'verifyTokenService');
const token = await getAuthenticationToken({
getAuthToken: async () => 'abc3',
disableTokenVerification: true,
});
expect(token).toBe('abc3');
expect(authServiceInstance.verifyTokenService).not.toHaveBeenCalled();
});
test('getAuthenticationToken: When verification is enabled', async () => {
resetCachedAuthToken();
jest.clearAllMocks();
jest.spyOn(authServiceInstance, 'verifyTokenService').mockImplementation(() => Promise.resolve(true));
const token = await getAuthenticationToken({
thoughtSpotHost: 'test',
getAuthToken: async () => 'abc2',
disableTokenVerification: false,
});
expect(token).toBe('abc2');
expect(authServiceInstance.verifyTokenService).toHaveBeenCalledWith('test', 'abc2');
});
test('validateAuthToken : When token is invalid by type number', async () => {
jest.spyOn(logger, 'error').mockImplementation(() => { });
const loggerSpy = jest.spyOn(logger, 'error');
const authToken = 123;
const errorMessage = formatTemplate(ERROR_MESSAGE.INVALID_TOKEN_TYPE_ERROR, {
invalidType: typeof authToken,
});
await expect(validateAuthToken({
thoughtSpotHost: 'test',
}, authToken)).rejects.toThrow(errorMessage);
expect(loggerSpy).toHaveBeenCalledWith(errorMessage);
loggerSpy.mockRestore();
});
test('validateAuthToken : When token is invalid by type object', async () => {
jest.spyOn(logger, 'error').mockImplementation(() => { });
const loggerSpy = jest.spyOn(logger, 'error');
const authToken = {};
const errorMessage = formatTemplate(ERROR_MESSAGE.INVALID_TOKEN_TYPE_ERROR, {
invalidType: typeof authToken,
});
await expect(validateAuthToken({
thoughtSpotHost: 'test',
}, authToken)).rejects.toThrow(errorMessage);
expect(loggerSpy).toHaveBeenCalledWith(errorMessage);
loggerSpy.mockRestore();
});
describe('getAuthenticationToken: cached token skip validation condition', () => {
beforeEach(() => {
resetCachedAuthToken();
jest.clearAllMocks();
});
test('should validate cached token when validation is not skipped', async () => {
const cachedToken = 'cached-token-123';
storeValueInWindow('cachedAuthToken', cachedToken);
const validateAuthTokenSpy = jest.spyOn(authTokenModule, 'validateAuthToken')
.mockImplementation(() => Promise.resolve(true));
const getAuthTokenMock = jest.fn().mockResolvedValue('new-token-456');
const config = {
thoughtSpotHost: 'test',
authType: AuthType.TrustedAuthToken,
getAuthToken: getAuthTokenMock,
disableTokenVerification: false,
};
const token = await getAuthenticationToken(config, false);
expect(token).toBe(cachedToken);
// Should validate cached token (condition at line 23 is true)
expect(validateAuthTokenSpy).toHaveBeenCalledWith(config, cachedToken, true);
expect(getAuthTokenMock).not.toHaveBeenCalled();
validateAuthTokenSpy.mockReset();
});
test('should skip cached token validation when disableTokenVerification is true', async () => {
const cachedToken = 'cached-token-123';
storeValueInWindow('cachedAuthToken', cachedToken);
const validateAuthTokenSpy = jest.spyOn(authTokenModule, 'validateAuthToken')
.mockImplementation(() => Promise.resolve(true));
const newToken = 'new-token-456';
const getAuthTokenMock = jest.fn().mockResolvedValue(newToken);
const config = {
thoughtSpotHost: 'test',
authType: AuthType.TrustedAuthToken,
getAuthToken: getAuthTokenMock,
disableTokenVerification: true,
};
const token = await getAuthenticationToken(config, false);
expect(token).toBe(newToken);
// Should not validate cached token (condition at line 23 is false)
expect(validateAuthTokenSpy).not.toHaveBeenCalledWith(config, cachedToken, true);
// But should validate new token (though it returns early when
// disableTokenVerification is true)
expect(validateAuthTokenSpy).toHaveBeenCalledWith(config, newToken);
expect(getAuthTokenMock).toHaveBeenCalled();
validateAuthTokenSpy.mockReset();
});
test('should skip cached token validation when skipvalidation is true', async () => {
const cachedToken = 'cached-token-123';
storeValueInWindow('cachedAuthToken', cachedToken);
const validateAuthTokenSpy = jest.spyOn(authTokenModule, 'validateAuthToken')
.mockImplementation(() => Promise.resolve(true));
const newToken = 'new-token-456';
const getAuthTokenMock = jest.fn().mockResolvedValue(newToken);
const config = {
thoughtSpotHost: 'test',
authType: AuthType.TrustedAuthToken,
getAuthToken: getAuthTokenMock,
disableTokenVerification: false,
};
const token = await getAuthenticationToken(config, true);
expect(token).toBe(newToken);
// Should not validate cached token (condition at line 23 is false)
expect(validateAuthTokenSpy).not.toHaveBeenCalledWith(config, cachedToken, true);
// But should validate new token
expect(validateAuthTokenSpy).toHaveBeenCalledWith(config, newToken);
expect(getAuthTokenMock).toHaveBeenCalled();
validateAuthTokenSpy.mockReset();
});
});
});
//# sourceMappingURL=authToken.spec.js.map