accounts-frontend/packages/app/services/api/authentication.test.ts

335 lines
8.3 KiB
TypeScript
Raw Normal View History

2019-12-07 16:58:52 +05:30
/* eslint-disable @typescript-eslint/camelcase */
import expect from 'app/test/unexpected';
import sinon from 'sinon';
2016-11-05 15:41:41 +05:30
import request from 'app/services/request';
import * as authentication from 'app/services/api/authentication';
import * as accounts from 'app/services/api/accounts';
2016-11-05 15:41:41 +05:30
describe('authentication api', () => {
let server;
beforeEach(() => {
server = sinon.createFakeServer({
autoRespond: true,
});
['get', 'post'].forEach(method => {
server[method] = (url, resp = {}, status = 200, headers = {}) => {
server.respondWith(method, url, [
status,
{ 'Content-Type': 'application/json', ...headers },
JSON.stringify(resp),
]);
};
});
});
afterEach(() => {
server.restore();
});
describe('#login', () => {
const params = {
login: 'foo',
password: 'secret',
rememberMe: false,
};
2019-02-05 02:44:58 +05:30
beforeEach(() => {
sinon.stub(request, 'post').named('request.post');
2019-02-05 02:44:58 +05:30
2019-12-07 16:58:52 +05:30
(request.post as any).returns(Promise.resolve());
2019-02-05 02:44:58 +05:30
});
afterEach(() => {
2019-12-07 16:58:52 +05:30
(request.post as any).restore();
2019-02-05 02:44:58 +05:30
});
it('should post to login api', () => {
authentication.login(params);
expect(request.post, 'to have a call satisfying', [
'/api/authentication/login',
params,
{},
]);
});
it('should disable any token', () => {
authentication.login(params);
expect(request.post, 'to have a call satisfying', [
'/api/authentication/login',
params,
{ token: null },
]);
});
});
describe('#validateToken()', () => {
const validToken = 'foo';
const validRefreshToken = 'bar';
const user = { id: 1 };
2019-12-07 16:58:52 +05:30
const validateTokenArgs: [number, string, string] = [
user.id,
validToken,
validRefreshToken,
];
beforeEach(() => {
sinon.stub(accounts, 'getInfo');
2019-12-07 16:58:52 +05:30
(accounts.getInfo as any).returns(Promise.resolve(user));
});
afterEach(() => {
2019-12-07 16:58:52 +05:30
(accounts.getInfo as any).restore();
});
2016-11-05 15:41:41 +05:30
it('should request accounts.getInfo', () =>
expect(
authentication.validateToken(...validateTokenArgs),
'to be fulfilled',
).then(() => {
expect(accounts.getInfo, 'to have a call satisfying', [
user.id,
validToken,
]);
}));
it('should resolve with both tokens and user object', () =>
expect(
authentication.validateToken(...validateTokenArgs),
'to be fulfilled with',
{
token: validToken,
refreshToken: validRefreshToken,
user,
},
));
it('rejects if token has a bad type', () =>
expect(
2019-12-07 16:58:52 +05:30
authentication.validateToken(user.id, {} as any),
'to be rejected with',
'token must be a string',
));
it('should allow empty refreshToken', () =>
expect(
authentication.validateToken(user.id, 'foo', null),
'to be fulfilled',
));
it('rejects if accounts.getInfo request is unexpectedly failed', () => {
const error = 'Something wrong';
2019-12-07 16:58:52 +05:30
(accounts.getInfo as any).returns(Promise.reject(error));
return expect(
authentication.validateToken(...validateTokenArgs),
'to be rejected with',
error,
);
});
2016-11-05 15:41:41 +05:30
describe('when token is expired', () => {
const expiredResponse = {
name: 'Unauthorized',
message: 'Token expired',
code: 0,
status: 401,
type: 'yii\\web\\UnauthorizedHttpException',
};
const newToken = 'baz';
beforeEach(() => {
sinon.stub(authentication, 'requestToken');
2019-12-07 16:58:52 +05:30
(accounts.getInfo as any)
.onCall(0)
.returns(Promise.reject(expiredResponse));
(authentication.requestToken as any).returns(Promise.resolve(newToken));
});
afterEach(() => {
2019-12-07 16:58:52 +05:30
(authentication.requestToken as any).restore();
});
it('resolves with new token and user object', async () => {
server.post('/api/authentication/refresh-token', {
access_token: newToken,
refresh_token: validRefreshToken,
success: true,
expires_in: 50000,
2016-11-05 15:41:41 +05:30
});
await expect(
authentication.validateToken(...validateTokenArgs),
'to be fulfilled with',
{ token: newToken, refreshToken: validRefreshToken, user },
2016-11-05 15:41:41 +05:30
);
expect(
server.requests[0].requestBody,
'to equal',
`refresh_token=${validRefreshToken}`,
2016-11-05 15:41:41 +05:30
);
});
2016-11-05 15:41:41 +05:30
it('rejects if token request failed', () => {
const error = { error: 'Unexpected error example' };
server.post('/api/authentication/refresh-token', error, 500);
2016-11-05 15:41:41 +05:30
return expect(
authentication.validateToken(...validateTokenArgs),
'to be rejected with',
error,
2016-11-05 15:41:41 +05:30
);
});
});
2016-11-05 15:41:41 +05:30
describe('when token is incorrect', () => {
const expiredResponse = {
name: 'Unauthorized',
message: 'Incorrect token',
code: 0,
status: 401,
type: 'yii\\web\\UnauthorizedHttpException',
};
const newToken = 'baz';
beforeEach(() => {
2019-12-07 16:58:52 +05:30
(accounts.getInfo as any)
.onCall(0)
.returns(Promise.reject(expiredResponse));
});
it('resolves with new token and user object', async () => {
server.post('/api/authentication/refresh-token', {
access_token: newToken,
refresh_token: validRefreshToken,
success: true,
expires_in: 50000,
2016-11-05 15:41:41 +05:30
});
await expect(
authentication.validateToken(...validateTokenArgs),
'to be fulfilled with',
{ token: newToken, refreshToken: validRefreshToken, user },
);
expect(
server.requests[0].requestBody,
'to equal',
`refresh_token=${validRefreshToken}`,
);
});
it('rejects if token request failed', () => {
const error = { error: 'Unexpected error example' };
server.post('/api/authentication/refresh-token', error, 500);
return expect(
authentication.validateToken(...validateTokenArgs),
'to be rejected with',
error,
);
});
2016-11-05 15:41:41 +05:30
});
});
describe('#logout', () => {
beforeEach(() => {
sinon.stub(request, 'post').named('request.post');
});
afterEach(() => {
2019-12-07 16:58:52 +05:30
(request.post as any).restore();
});
it('should request logout api', () => {
authentication.logout();
expect(request.post, 'to have a call satisfying', [
'/api/authentication/logout',
{},
{},
]);
});
it('returns a promise', () => {
2019-12-07 16:58:52 +05:30
(request.post as any).returns(Promise.resolve());
return expect(authentication.logout(), 'to be fulfilled');
});
it('overrides token if provided', () => {
const token = 'foo';
authentication.logout(token);
expect(request.post, 'to have a call satisfying', [
'/api/authentication/logout',
{},
{ token },
]);
});
});
describe('#requestToken', () => {
const refreshToken = 'refresh-token';
beforeEach(() => {
sinon.stub(request, 'post').named('request.post');
});
afterEach(() => {
2019-12-07 16:58:52 +05:30
(request.post as any).restore();
});
it('should request refresh-token api', () => {
2019-12-07 16:58:52 +05:30
(request.post as any).returns(Promise.resolve({}));
authentication.requestToken(refreshToken);
expect(request.post, 'to have a call satisfying', [
'/api/authentication/refresh-token',
{
refresh_token: refreshToken, // eslint-disable-line
},
{},
]);
});
it('should disable bearer auth for request', () => {
2019-12-07 16:58:52 +05:30
(request.post as any).returns(Promise.resolve({}));
authentication.requestToken(refreshToken);
expect(request.post, 'to have a call satisfying', [
'/api/authentication/refresh-token',
{
refresh_token: refreshToken, // eslint-disable-line
},
{ token: null },
]);
});
it('should resolve with token', () => {
const token = 'token';
2019-12-07 16:58:52 +05:30
(request.post as any).returns(
Promise.resolve({
access_token: token, // eslint-disable-line
}),
);
return expect(
authentication.requestToken(refreshToken),
'to be fulfilled with',
token,
);
});
});
2016-11-05 15:41:41 +05:30
});