@sync-in/server
Version:
The secure, open-source platform for file storage, sharing, collaboration, and sync
151 lines (150 loc) • 7.46 kB
JavaScript
/*
* Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
* This file is part of Sync-in | The open source file sync and share solution
* See the LICENSE file for licensing details
*/ "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
const _testing = require("@nestjs/testing");
const _authmanagerservice = require("../../../authentication/services/auth-manager.service");
const _image = require("../../../common/image");
const _cacheservice = require("../../../infrastructure/cache/services/cache.service");
const _constants = require("../../../infrastructure/database/constants");
const _files = require("../../files/utils/files");
const _user = require("../constants/user");
const _usermodel = require("../models/user.model");
const _test = require("../utils/test");
const _adminusersmanagerservice = require("./admin-users-manager.service");
const _adminusersqueriesservice = require("./admin-users-queries.service");
const _usersmanagerservice = require("./users-manager.service");
const _usersqueriesservice = require("./users-queries.service");
describe(_usersmanagerservice.UsersManager.name, ()=>{
let usersManager;
let adminUsersManager;
let adminUsersQueries;
let usersQueriesService;
let userTest;
let deleteUserDto;
beforeAll(async ()=>{
const module = await _testing.Test.createTestingModule({
providers: [
_adminusersmanagerservice.AdminUsersManager,
_adminusersqueriesservice.AdminUsersQueries,
_usersmanagerservice.UsersManager,
_usersqueriesservice.UsersQueries,
{
provide: _authmanagerservice.AuthManager,
useValue: {}
},
{
provide: _constants.DB_TOKEN_PROVIDER,
useValue: {}
},
{
provide: _cacheservice.Cache,
useValue: {}
}
]
}).compile();
module.useLogger([
'fatal'
]);
usersManager = module.get(_usersmanagerservice.UsersManager);
adminUsersManager = module.get(_adminusersmanagerservice.AdminUsersManager);
adminUsersQueries = module.get(_adminusersqueriesservice.AdminUsersQueries);
usersQueriesService = module.get(_usersqueriesservice.UsersQueries);
// mocks
userTest = new _usermodel.UserModel((0, _test.generateUserTest)(), false);
deleteUserDto = {
deleteSpace: true
};
});
afterAll(async ()=>{
// clean created user path
await expect(adminUsersManager.deleteUserSpace(userTest.login)).resolves.not.toThrow();
});
it('should be defined', ()=>{
expect(usersManager).toBeDefined();
expect(adminUsersManager).toBeDefined();
expect(usersQueriesService).toBeDefined();
expect(userTest).toBeDefined();
});
it('should get the user with|without password', async ()=>{
usersQueriesService.from = jest.fn().mockReturnValue(userTest);
const findUserWithoutPwd = await usersManager.findUser(userTest.login, true);
expect(findUserWithoutPwd).toBeInstanceOf(_usermodel.UserModel);
expect(findUserWithoutPwd.password).toBeUndefined();
const findUserWithPwd = await usersManager.findUser(userTest.login, false);
expect(findUserWithPwd).toBeInstanceOf(_usermodel.UserModel);
expect(findUserWithPwd.password).toBeDefined();
expect(usersQueriesService.from).toHaveBeenCalledTimes(2);
const me = await usersManager.me(userTest);
// check the default value of the findUser function
expect(me).toBeInstanceOf(Object);
expect(me.user.password).toBeUndefined();
expect(await usersManager.me(userTest)).toBeInstanceOf(Object);
usersQueriesService.from = jest.fn().mockReturnValue(null);
await expect(usersManager.me({
id: 0
})).rejects.toThrow();
expect(usersQueriesService.from).toHaveBeenCalled();
});
it('should create the user paths', async ()=>{
await expect(userTest.makePaths()).resolves.not.toThrow();
expect(await (0, _files.isPathExists)(userTest.filesPath)).toBe(true);
});
it('should get the default user avatar', async ()=>{
usersQueriesService.from = jest.fn().mockReturnValueOnce(userTest);
const [path, mime] = await usersManager.getAvatar(userTest.login);
expect((0, _files.fileName)(path)).toBe('avatar.svg');
expect(mime).toBe(_image.svgMimeType);
});
it('should generate the user avatar', async ()=>{
usersQueriesService.from = jest.fn().mockReturnValueOnce(null);
await expect(usersManager.getAvatar('#', true)).rejects.toThrow('does not exist');
usersQueriesService.from = jest.fn().mockReturnValue(userTest);
expect(await usersManager.getAvatar(userTest.login, true)).toBeUndefined();
const [path, mime] = await usersManager.getAvatar(userTest.login);
expect((0, _files.fileName)(path)).toBe('avatar.png');
expect(mime).toBe(_image.pngMimeType);
});
it('should create user that does not exist', async ()=>{
usersQueriesService.checkUserExists = jest.fn().mockReturnValue(undefined);
usersQueriesService.createUserOrGuest = jest.fn().mockReturnValue(888);
const user = await adminUsersManager.createUserOrGuest(userTest, _user.USER_ROLE.USER);
expect(user).toBeInstanceOf(_usermodel.UserModel);
expect(await (0, _files.isPathExists)(user.filesPath)).toBe(true);
});
it('should not create an existing user', async ()=>{
usersQueriesService.checkUserExists = jest.fn().mockReturnValueOnce({
login: userTest.login,
email: ''
}).mockReturnValueOnce({
login: '',
email: userTest.email
}).mockReturnValueOnce(undefined);
await expect(adminUsersManager.createUserOrGuest(userTest, _user.USER_ROLE.USER)).rejects.toThrow();
await expect(adminUsersManager.createUserOrGuest(userTest, _user.USER_ROLE.USER)).rejects.toThrow();
usersQueriesService.createUserOrGuest = jest.fn().mockImplementation(()=>{
throw new Error('testing');
});
await expect(adminUsersManager.createUserOrGuest(userTest, _user.USER_ROLE.USER)).rejects.toThrow();
});
it('should delete user', async ()=>{
adminUsersQueries.deleteUser = jest.fn().mockReturnValue(true);
await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).resolves.not.toThrow();
expect(await (0, _files.isPathExists)(userTest.filesPath)).toBe(false);
});
it('should pass even if the user does not exist', async ()=>{
adminUsersQueries.deleteUser = jest.fn().mockReturnValue(false);
await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).resolves.not.toThrow();
});
it('should throw an error on user creation', async ()=>{
adminUsersQueries.deleteUser = jest.fn().mockImplementation(()=>{
throw new Error('testing');
});
await expect(adminUsersManager.deleteUserOrGuest(userTest.id, userTest.login, deleteUserDto)).rejects.toThrow();
});
});
//# sourceMappingURL=users-manager.service.spec.js.map