2021-04-09 13:46:53 +02:00
|
|
|
import test from 'ava';
|
|
|
|
import dbInit from '../helpers/database-init';
|
|
|
|
import getLogger from '../../fixtures/no-logger';
|
|
|
|
import UserService from '../../../lib/services/user-service';
|
|
|
|
import { AccessService, RoleName } from '../../../lib/services/access-service';
|
|
|
|
import UserStore from '../../../lib/db/user-store';
|
2021-04-22 23:40:52 +02:00
|
|
|
import User from '../../../lib/types/user';
|
2021-04-09 13:46:53 +02:00
|
|
|
import { IRole } from '../../../lib/db/access-store';
|
2021-04-16 15:29:23 +02:00
|
|
|
import ResetTokenService from '../../../lib/services/reset-token-service';
|
|
|
|
import { EmailService } from '../../../lib/services/email-service';
|
2021-04-22 15:04:08 +02:00
|
|
|
import { createTestConfig } from '../../config/test-config';
|
2021-04-27 09:16:44 +02:00
|
|
|
import SessionService from '../../../lib/services/session-service';
|
2021-04-29 10:54:11 +02:00
|
|
|
import NotFoundError from '../../../lib/error/notfound-error';
|
2021-04-09 13:46:53 +02:00
|
|
|
|
|
|
|
let db;
|
|
|
|
let stores;
|
|
|
|
let userService: UserService;
|
|
|
|
let userStore: UserStore;
|
|
|
|
let adminRole: IRole;
|
2021-04-29 10:54:11 +02:00
|
|
|
let sessionService: SessionService;
|
2021-04-09 13:46:53 +02:00
|
|
|
|
|
|
|
test.before(async () => {
|
|
|
|
db = await dbInit('user_service_serial', getLogger);
|
|
|
|
stores = db.stores;
|
2021-04-22 15:04:08 +02:00
|
|
|
const config = createTestConfig();
|
2021-04-09 13:46:53 +02:00
|
|
|
const accessService = new AccessService(stores, config);
|
2021-04-16 15:29:23 +02:00
|
|
|
const resetTokenService = new ResetTokenService(stores, config);
|
2021-04-22 10:07:10 +02:00
|
|
|
const emailService = new EmailService(undefined, config.getLogger);
|
2021-04-29 10:54:11 +02:00
|
|
|
sessionService = new SessionService(stores, config);
|
2021-04-16 15:29:23 +02:00
|
|
|
|
|
|
|
userService = new UserService(stores, config, {
|
|
|
|
accessService,
|
|
|
|
resetTokenService,
|
|
|
|
emailService,
|
2021-04-27 09:16:44 +02:00
|
|
|
sessionService,
|
2021-04-16 15:29:23 +02:00
|
|
|
});
|
2021-04-09 13:46:53 +02:00
|
|
|
userStore = stores.userStore;
|
|
|
|
const rootRoles = await accessService.getRootRoles();
|
|
|
|
adminRole = rootRoles.find(r => r.name === RoleName.ADMIN);
|
|
|
|
});
|
|
|
|
|
|
|
|
test.after(async () => {
|
|
|
|
await db.destroy();
|
|
|
|
});
|
|
|
|
|
|
|
|
test.afterEach(async () => {
|
2021-04-29 10:54:11 +02:00
|
|
|
await userStore.deleteAll();
|
2021-04-09 13:46:53 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
test.serial('should create initial admin user', async t => {
|
|
|
|
await userService.initAdminUser();
|
2021-04-26 11:51:53 +02:00
|
|
|
await t.notThrowsAsync(userService.loginUser('admin', 'unleash4all'));
|
2021-04-09 13:46:53 +02:00
|
|
|
await t.throwsAsync(userService.loginUser('admin', 'wrong-password'));
|
|
|
|
});
|
|
|
|
|
|
|
|
test.serial('should not be allowed to create existing user', async t => {
|
2021-04-22 23:40:52 +02:00
|
|
|
await userStore.insert({ username: 'test', name: 'Hans Mola' });
|
2021-04-09 13:46:53 +02:00
|
|
|
await t.throwsAsync(
|
|
|
|
userService.createUser({ username: 'test', rootRole: adminRole.id }),
|
|
|
|
);
|
|
|
|
});
|
|
|
|
|
|
|
|
test.serial('should create user with password', async t => {
|
|
|
|
await userService.createUser({
|
|
|
|
username: 'test',
|
|
|
|
password: 'A very strange P4ssw0rd_',
|
|
|
|
rootRole: adminRole.id,
|
|
|
|
});
|
|
|
|
const user = await userService.loginUser(
|
|
|
|
'test',
|
|
|
|
'A very strange P4ssw0rd_',
|
|
|
|
);
|
|
|
|
t.is(user.username, 'test');
|
|
|
|
});
|
|
|
|
|
|
|
|
test.serial('should login for user _without_ password', async t => {
|
|
|
|
const email = 'some@test.com';
|
|
|
|
await userService.createUser({
|
|
|
|
email,
|
|
|
|
password: 'A very strange P4ssw0rd_',
|
|
|
|
rootRole: adminRole.id,
|
|
|
|
});
|
|
|
|
const user = await userService.loginUserWithoutPassword(email);
|
|
|
|
t.is(user.email, email);
|
|
|
|
});
|
|
|
|
|
|
|
|
test.serial('should get user with root role', async t => {
|
|
|
|
const email = 'some@test.com';
|
|
|
|
const u = await userService.createUser({
|
|
|
|
email,
|
|
|
|
password: 'A very strange P4ssw0rd_',
|
|
|
|
rootRole: adminRole.id,
|
|
|
|
});
|
|
|
|
const user = await userService.getUser(u.id);
|
|
|
|
t.is(user.email, email);
|
|
|
|
t.is(user.id, u.id);
|
|
|
|
t.is(user.rootRole, adminRole.id);
|
|
|
|
});
|
2021-04-29 10:54:11 +02:00
|
|
|
|
|
|
|
test.serial(`deleting a user should delete the user's sessions`, async t => {
|
|
|
|
const email = 'some@test.com';
|
|
|
|
const user = await userService.createUser({
|
|
|
|
email,
|
|
|
|
password: 'A very strange P4ssw0rd_',
|
|
|
|
rootRole: adminRole.id,
|
|
|
|
});
|
|
|
|
const testComSession = {
|
|
|
|
sid: 'xyz321',
|
|
|
|
sess: {
|
|
|
|
cookie: {
|
|
|
|
originalMaxAge: 2880000,
|
|
|
|
expires: new Date(Date.now() + 86400000).toDateString(),
|
|
|
|
secure: false,
|
|
|
|
httpOnly: true,
|
|
|
|
path: '/',
|
|
|
|
},
|
|
|
|
user,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
await sessionService.insertSession(testComSession);
|
|
|
|
const userSessions = await sessionService.getSessionsForUser(user.id);
|
|
|
|
t.is(userSessions.length, 1);
|
|
|
|
await userService.deleteUser(user.id);
|
|
|
|
await t.throwsAsync(
|
|
|
|
async () => sessionService.getSessionsForUser(user.id),
|
|
|
|
{
|
|
|
|
instanceOf: NotFoundError,
|
|
|
|
},
|
|
|
|
);
|
|
|
|
});
|