Skip to content
Snippets Groups Projects
Commit 62c8a388 authored by Bastien DUMONT's avatar Bastien DUMONT :angel:
Browse files

test(employer): increase coverage

parent 0489a9b4
No related branches found
No related tags found
2 merge requests!404V3.1.0 (sans impression),!396test(employer): increase coverage
Hide whitespace changes
Inline Side-by-side
.vscode/settings.json
+ 1
− 0
View file @ 62c8a388
......@@ -58,6 +58,7 @@
"permanences",
"photonban",
"saturday",
"Sopra",
"spyer",
"sunday",
"thursday",
......
src/users/controllers/employer.controller.spec.ts
+ 60
− 105
View file @ 62c8a388
......@@ -59,86 +59,42 @@ describe('EmployerController', () => {
});
describe('findAll', () => {
it('should return two elements', async () => {
employerServiceMock.findAll.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CAF',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CARSAT',
validated: true,
},
]);
const findAllReply = await employerController.findAll();
expect(findAllReply.length).toBe(2);
it('should call service.findAll', async () => {
await employerController.findAll();
expect(employerServiceMock.findAll).toHaveBeenCalled();
});
it('should return searched elements with query `CA`', async () => {
employerServiceMock.searchByName.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CAF',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CARSAT',
validated: true,
},
]);
const findAllReply = await employerController.findAll({ search: 'CA' });
expect(findAllReply.length).toBe(2);
});
});
describe('resetES', () => {
it('should reset search index', async () => {
employerServiceMock.initEmployerIndex.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CAF',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5a7'),
name: 'CARSAT',
validated: true,
},
]);
const index = await employerController.resetES();
expect(index.length).toBe(2);
it('should service.searchByName', async () => {
await employerController.findAll({ search: 'CA' });
expect(employerServiceMock.searchByName).toHaveBeenCalled();
});
});
describe('Create Employer', () => {
it('should create a employer', async () => {
employerServiceMock.findByName.mockResolvedValueOnce(null);
employerServiceMock.create.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
const req = { user: { _id: '6036721022462b001334c4bb', role: 0 } };
const reply = await employerController.createEmployer({ name: 'Sopra' }, req);
expect(reply).toBeTruthy();
});
const RequestWithRegularUser = { user: { _id: '6036721022462b001334c4bb', role: 0 } };
it('should not create if employer already exists', async () => {
employerServiceMock.findByName.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
const req = { user: { _id: '6036721022462b001334c4bb' }, role: 0 };
try {
await employerController.createEmployer({ name: 'Sopra' }, req);
await employerController.createEmployer({ name: 'Sopra' }, RequestWithRegularUser);
expect(true).toBe(false);
} catch (e) {
expect(e.message).toBe('Employer already exist');
expect(e.status).toBe(HttpStatus.UNPROCESSABLE_ENTITY);
}
});
it('should create a employer', async () => {
employerServiceMock.findByName.mockResolvedValueOnce(null);
employerServiceMock.create.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
await employerController.createEmployer({ name: 'Sopra' }, RequestWithRegularUser);
expect(employerServiceMock.create).toHaveBeenCalled();
});
it('should call create with send notification to true if admin', async () => {
employerServiceMock.findByName.mockResolvedValueOnce(null);
const employer = {
......@@ -147,21 +103,32 @@ describe('EmployerController', () => {
employerServiceMock.create.mockResolvedValueOnce({ ...employer, validated: true });
const req = { user: { _id: '6036721022462b001334c4bb', role: 1 } };
const reply = await employerController.createEmployer(employer, req);
expect(reply).toBeTruthy();
await employerController.createEmployer(employer, req);
expect(employerServiceMock.create).toHaveBeenCalledWith(employer, true, false);
});
});
describe('resetES', () => {
it('should reset search index', async () => {
await employerController.resetES();
expect(employerServiceMock.initEmployerIndex).toHaveBeenCalled();
});
});
describe('Validate Employer', () => {
it('should validate an employer', async () => {
employerServiceMock.validate.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
expect(await employerController.validateEmployer({ id: '6231aefe76598527c8d0b5bc' })).toBeTruthy();
await employerController.validateEmployer({ id: '6231aefe76598527c8d0b5bc' });
expect(employerServiceMock.validate).toHaveBeenCalled();
});
});
describe('update Employers', () => {
it('should update an employer', async () => {
await employerController.updateEmployer('6231aefe76598527c8d0b5bc', { name: 'SopraMod' });
expect(employerServiceMock.update).toHaveBeenCalled();
});
});
describe('Get Employers', () => {
it('should call all validated employers and populate them with users attached to it', async () => {
const spyer = jest.spyOn(userService, 'populateEmployerswithUsers');
......@@ -203,50 +170,29 @@ describe('EmployerController', () => {
});
describe('Edit Employer', () => {
it('should update employer', async () => {
employerServiceMock.update.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'SopraMod',
validated: true,
});
expect(await employerController.updateEmployer('6231aefe76598527c8d0b5bc', { name: 'SopraMod' })).toBeTruthy();
await employerController.updateEmployer('6231aefe76598527c8d0b5bc', { name: 'SopraMod' });
expect(employerServiceMock.update).toHaveBeenCalled();
});
it('should delete an unvalidated employer and replace all its occurence with a chosen validated employer', async () => {
employerServiceMock.mergeEmployer.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
employerServiceMock.deleteOneId.mockResolvedValueOnce({
n: 1,
ok: 1,
deletedCount: 1,
});
const reply = await employerController.mergeEmployer({
it('should delete an unvalidated employer and replace all its occurrence with a chosen validated employer', async () => {
await employerController.mergeEmployer({
sourceEmployerId: '6231aefe76598527c8d0b5ba',
targetEmployerId: '6231aefe76598527c8d0b5bc',
});
expect(reply).toBeTruthy();
expect(employerServiceMock.mergeEmployer).toHaveBeenCalled();
});
});
describe('Delete Employer', () => {
it('should delete employer', async () => {
employerServiceMock.deleteOneId.mockResolvedValueOnce({
n: 1,
ok: 1,
deletedCount: 1,
});
employerServiceMock.findOne.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
const reply = await employerController.deleteEmployer({ id: '6231aefe76598527c8d0b5ba' });
expect(reply).toBeTruthy();
it('should not be able to delete a non existing employer', async () => {
employerServiceMock.findOne.mockResolvedValueOnce(null);
try {
await employerController.deleteEmployer({ id: '6231aefe76598527c8d0b5bc' });
expect(true).toBe(false);
} catch (e) {
expect(e.message).toEqual('Employer does not exists');
expect(e.status).toEqual(HttpStatus.NOT_FOUND);
}
});
it('should not delete employer if a user is linked', async () => {
employerServiceMock.findOne.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
......@@ -261,5 +207,14 @@ describe('EmployerController', () => {
expect(e.status).toEqual(HttpStatus.FORBIDDEN);
}
});
it('should delete employer', async () => {
employerServiceMock.findOne.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
name: 'Sopra',
validated: true,
});
await employerController.deleteEmployer({ id: '6231aefe76598527c8d0b5ba' });
expect(employerServiceMock.deleteOneId).toHaveBeenCalled();
});
});
});
src/users/controllers/employer.controller.ts
+ 9
− 14
View file @ 62c8a388
......@@ -66,8 +66,6 @@ export class EmployerController {
return this.employerService.create(newEmployer);
}
// SEARCH
/**
* Init or reset search index for employer
*/
......@@ -100,9 +98,9 @@ export class EmployerController {
});
}
/*
** All users attached to this employer will be affected to the targeted employer
** The original unvalidated employer will be deleted
/**
* All users attached to this employer will be affected to the targeted employer
* The original unvalidated employer will be deleted
*/
@UseGuards(JwtAuthGuard, RolesGuard)
@ApiBearerAuth('JWT')
......@@ -139,18 +137,15 @@ export class EmployerController {
@ApiParam({ name: 'employer', type: CreateEmployerDto, required: true })
public async deleteEmployer(@Param() params): Promise<Employer> {
this.logger.debug(`deleteEmployer: ${params.id}`);
// look for employer
const researchedEmployer = await this.employerService.findOne(params.id);
// look for any relations within user collection, reject action if found
if (researchedEmployer !== null) {
const isEmployerLinked = await this.usersService.isEmployerLinkedtoUser(researchedEmployer._id);
if (!isEmployerLinked) {
return this.employerService.deleteOneId(params.id);
} else {
throw new HttpException('Cannot delete employer. It has user(s) attached to it.', HttpStatus.FORBIDDEN);
}
} else {
if (researchedEmployer === null) {
throw new HttpException('Employer does not exists', HttpStatus.NOT_FOUND);
}
const isEmployerLinked = await this.usersService.isEmployerLinkedtoUser(researchedEmployer._id);
if (isEmployerLinked) {
throw new HttpException('Cannot delete employer. It has user(s) attached to it.', HttpStatus.FORBIDDEN);
}
return this.employerService.deleteOneId(params.id);
}
}
src/users/services/employer.service.spec.ts
+ 62
− 209
View file @ 62c8a388
......@@ -6,13 +6,23 @@ import { AxiosResponse } from 'axios';
import { Types } from 'mongoose';
import { ConfigurationModule } from '../../configuration/configuration.module';
import { MailerService } from '../../mailer/mailer.service';
import { CreateEmployerDto } from '../dto/create-employer.dto';
import { EmployerDocument } from '../schemas/employer.schema';
import { User } from '../schemas/user.schema';
import { EmployerSearchService } from './employer-search.service';
import { EmployerService } from './employer.service';
import { UsersService } from './users.service';
const mockMetroEmployer = {
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: true,
} as const;
const mockSopraEmployer = {
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
} as const;
describe('EmployerService', () => {
let employerService: EmployerService;
let mailerService: MailerService;
......@@ -72,148 +82,69 @@ describe('EmployerService', () => {
it('findAll', async () => {
mockEmployerModel.sort.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
},
]);
mockEmployerModel.exec.mockResolvedValueOnce([mockMetroEmployer, mockSopraEmployer]);
const reply = await employerService.findAll();
expect(reply.length).toBe(2);
});
it('findOne', async () => {
mockEmployerModel.findById.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
});
const reply = await employerService.findOne('6231aefe76598527c8d0b5bc');
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer);
const reply = await employerService.findOne('0001aefe76598527c8d0b5bc');
expect(reply).toBeTruthy();
});
it('findAllValidated', async () => {
mockEmployerModel.find.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
},
]);
const reply = await employerService.findAllValidated();
expect(reply.length).toBe(1);
});
it('findAllUnvalidated', async () => {
mockEmployerModel.find.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: false,
},
]);
mockEmployerModel.exec.mockResolvedValueOnce([mockSopraEmployer]);
const reply = await employerService.findAllValidated();
expect(reply.length).toBe(1);
});
it('finds all unvalidated employers', async () => {
it('finds all Unvalidated employers', async () => {
mockEmployerModel.find.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: false,
},
]);
mockEmployerModel.exec.mockResolvedValueOnce([{ ...mockMetroEmployer, validated: false }]);
const reply = await employerService.findAllUnvalidated();
expect(reply[0].validated).toBeFalsy();
});
it('finds all validated employers', async () => {
mockEmployerModel.find.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5b2'),
name: 'Sopra',
validated: true,
},
]);
mockEmployerModel.exec.mockResolvedValueOnce([mockMetroEmployer, mockSopraEmployer]);
const reply = await employerService.findAllUnvalidated();
expect(reply.length).toBe(2);
});
it('findByName', async () => {
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
});
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer);
const reply = await employerService.findByName('Sopra');
expect(reply).toBeTruthy();
});
describe('createEmployer', () => {
it('create', async () => {
mockEmployerModel.create.mockResolvedValue({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: false,
});
it('create and send admin notification', async () => {
mockEmployerModel.create.mockResolvedValue(mockSopraEmployer);
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: false,
});
const createEmployer: CreateEmployerDto = {
name: 'Sopra',
};
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer);
jest.spyOn(employerService, 'sendAdminCreateNotification').mockResolvedValueOnce();
const reply = await employerService.create(createEmployer);
const reply = await employerService.create({ name: 'Sopra' });
expect(reply).toBeTruthy();
expect(employerService.sendAdminCreateNotification).toHaveBeenCalledTimes(1);
});
it('should create validated employer and not send email to admins', async () => {
mockEmployerModel.create.mockResolvedValue({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: false,
});
it('should create and not send email to admins', async () => {
mockEmployerModel.create.mockResolvedValueOnce(mockSopraEmployer);
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: false,
});
const createEmployer: CreateEmployerDto = {
name: 'Sopra',
};
const reply = await employerService.create(createEmployer, true, false);
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer);
jest.spyOn(employerService, 'sendAdminCreateNotification').mockResolvedValueOnce();
const reply = await employerService.create({ name: 'Sopra' }, true, false);
expect(employerService.sendAdminCreateNotification).toHaveBeenCalledTimes(0);
expect(reply).toBeTruthy();
});
});
it('delete', async () => {
it('should deleteByName', async () => {
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
});
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer);
mockEmployerModel.deleteOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
n: 1,
......@@ -222,80 +153,44 @@ describe('EmployerService', () => {
});
mockEmployerSearchService.deleteIndex.mockResolvedValueOnce({});
const reply = await employerService.deleteByName('Sopra');
expect(mockEmployerSearchService.deleteIndex).toHaveBeenCalled();
expect(reply).toBeTruthy();
});
describe('Search', () => {
it('searchByName', async () => {
mockEmployerSearchService.search.mockResolvedValue({ name: 'Sopra' });
const reply = await employerService.searchByName('Sopra');
expect(reply).toBeTruthy();
});
it('should searchByName', async () => {
mockEmployerSearchService.search.mockResolvedValue({ name: 'Sopra' });
const reply = await employerService.searchByName('Sopra');
expect(reply).toBeTruthy();
});
it('initEmployerIndex', async () => {
mockEmployerSearchService.dropIndex.mockResolvedValueOnce({});
mockEmployerSearchService.createEmployerIndex.mockResolvedValueOnce({});
mockEmployerModel.sort.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: true,
},
{
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
},
]);
mockEmployerSearchService.indexEmployer
.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Metro',
validated: true,
} as EmployerDocument)
.mockResolvedValueOnce({
_id: new Types.ObjectId('6231aefe76598527c8d0b5bc'),
name: 'Sopra',
validated: true,
} as EmployerDocument);
const reply = await employerService.initEmployerIndex();
expect(reply).toBeTruthy();
expect(reply.length).toBe(2);
});
it('should initEmployerIndex', async () => {
mockEmployerSearchService.dropIndex.mockResolvedValueOnce({});
mockEmployerSearchService.createEmployerIndex.mockResolvedValueOnce({});
mockEmployerModel.sort.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce([mockMetroEmployer, mockSopraEmployer]);
mockEmployerSearchService.indexEmployer
.mockResolvedValueOnce(mockMetroEmployer)
.mockResolvedValueOnce(mockSopraEmployer);
const reply = await employerService.initEmployerIndex();
expect(reply).toBeTruthy();
expect(reply.length).toBe(2);
});
describe('mergeEmployer', () => {
it('should delete source employer', async () => {
const result = {
_id: new Types.ObjectId('623aed68c5d45b6fbbaa7e61'),
name: 'Metro',
validated: true,
};
mockEmployerModel.findById.mockReturnThis();
mockEmployerModel.exec
.mockResolvedValueOnce({
_id: new Types.ObjectId('623aed68c5d45b6fbbaa7e60'),
name: 'Sopra',
validated: false,
})
.mockResolvedValueOnce(result);
mockEmployerModel.exec.mockResolvedValueOnce(mockSopraEmployer).mockResolvedValueOnce(mockMetroEmployer);
mockUserService.replaceEmployers.mockResolvedValueOnce(null);
jest.spyOn(employerService, 'deleteOneId').mockResolvedValueOnce(null);
const reply = await employerService.mergeEmployer({
sourceEmployerId: '623aed68c5d45b6fbbaa7e60',
targetEmployerId: '623aed68c5d45b6fbbaa7e61',
});
expect(reply).toEqual(result);
expect(reply).toEqual(mockMetroEmployer);
});
it('should return error if delete source employer issue', async () => {
const result = {
_id: new Types.ObjectId('623aed68c5d45b6fbbaa7e61'),
name: 'Metro',
validated: true,
};
mockEmployerModel.findById.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce(null).mockResolvedValueOnce(result);
mockEmployerModel.exec.mockResolvedValueOnce(null).mockResolvedValueOnce(mockMetroEmployer);
jest.spyOn(employerService, 'deleteOneId').mockRejectedValueOnce({});
mockUserService.replaceEmployers.mockResolvedValueOnce(null);
try {
......@@ -407,67 +302,25 @@ describe('EmployerService', () => {
});
describe('deleteOneId', () => {
it('should delete', async () => {
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
_id: '6231aefe76598527c8d0b5bc',
validationToken:
'cf1c74c22cedb6b575945098db42d2f493fb759c9142c6aff7980f252886f36ee086574ee99a06bc99119079257116c959c8ec870949cebdef2b293666dbca42',
emailVerified: true,
email: 'admin@admin.com',
password: '$2a$12$vLQjJ9zAWyUwiFLeQDa6w.XzrlgPBhw.2GWrjog/yuEjIaZnQwmZu',
role: 0,
name: 'admin',
surname: 'admin',
personalOffers: [],
deleteOne: jest.fn().mockResolvedValueOnce({
_id: '6231aefe76598527c8d0b5bc',
validationToken:
'cf1c74c22cedb6b575945098db42d2f493fb759c9142c6aff7980f252886f36ee086574ee99a06bc99119079257116c959c8ec870949cebdef2b293666dbca42',
emailVerified: true,
email: 'admin@admin.com',
password: '$2a$12$vLQjJ9zAWyUwiFLeQDa6w.XzrlgPBhw.2GWrjog/yuEjIaZnQwmZu',
role: 0,
name: 'admin',
surname: 'admin',
personalOffers: [],
}),
});
expect(await employerService.deleteOneId('6231aefe76598527c8d0b5bc')).toStrictEqual({
_id: '6231aefe76598527c8d0b5bc',
validationToken:
'cf1c74c22cedb6b575945098db42d2f493fb759c9142c6aff7980f252886f36ee086574ee99a06bc99119079257116c959c8ec870949cebdef2b293666dbca42',
emailVerified: true,
email: 'admin@admin.com',
password: '$2a$12$vLQjJ9zAWyUwiFLeQDa6w.XzrlgPBhw.2GWrjog/yuEjIaZnQwmZu',
role: 0,
name: 'admin',
surname: 'admin',
personalOffers: [],
});
});
it('should throw an error', async () => {
mockEmployerModel.findOne.mockReturnThis();
mockEmployerModel.findById.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce(null);
try {
expect(await employerService.deleteOneId('6231aefe76598527c8d0b5bc')).toStrictEqual({
_id: '6231aefe76598527c8d0b5bc',
validationToken:
'cf1c74c22cedb6b575945098db42d2f493fb759c9142c6aff7980f252886f36ee086574ee99a06bc99119079257116c959c8ec870949cebdef2b293666dbca42',
emailVerified: true,
email: 'admin@admin.com',
password: '$2a$12$vLQjJ9zAWyUwiFLeQDa6w.XzrlgPBhw.2GWrjog/yuEjIaZnQwmZu',
role: 0,
name: 'admin',
surname: 'admin',
personalOffers: [],
});
await employerService.deleteOneId('6231aefe76598527c8d0b5bc');
expect(true).toBe(false);
} catch (e) {
expect(e.message).toBe('Invalid employer id');
expect(e.status).toBe(HttpStatus.BAD_REQUEST);
}
});
it('should delete', async () => {
mockEmployerModel.findById.mockReturnThis();
mockEmployerModel.exec.mockResolvedValueOnce({
...mockMetroEmployer,
deleteOne: jest.fn(),
});
await employerService.deleteOneId('6231aefe76598527c8d0b5bc');
expect(mockEmployerSearchService.deleteIndex).toHaveBeenCalled();
});
});
});
src/users/services/employer.service.ts
+ 11
− 14
View file @ 62c8a388
......@@ -83,26 +83,24 @@ export class EmployerService {
public async validate(employerId: string): Promise<Employer> {
this.logger.debug(`validateEmployer: ${employerId}`);
const employer = await this.employerModel.findById(new Types.ObjectId(employerId)).exec();
if (employer) {
employer.validated = true;
employer.save();
return employer;
} else {
if (!employer) {
throw new HttpException('Cannot validate employer. It might have been already validate', HttpStatus.NOT_FOUND);
}
employer.validated = true;
employer.save();
return employer;
}
public async update(employerId: string, newEmployer: CreateEmployerDto): Promise<Employer> {
this.logger.debug(`editEmployer: ${employerId}`);
const employer = await this.employerModel.findById(new Types.ObjectId(employerId)).exec();
if (employer) {
employer.name = newEmployer.name;
employer.save();
await this.employerSearchService.update(employer, employerId);
return employer;
} else {
if (!employer) {
throw new HttpException('Cannot edit employer. It was not found in database.', HttpStatus.NOT_FOUND);
}
employer.name = newEmployer.name;
employer.save();
await this.employerSearchService.update(employer, employerId);
return employer;
}
public async mergeEmployer({
......@@ -134,20 +132,19 @@ export class EmployerService {
}
public async deleteByName(name: string): Promise<mongodb.DeleteResult> {
this.logger.debug(`deleteByname: ${name}`);
this.logger.debug(`deleteByName: ${name}`);
const document = await this.findByName(name);
this.employerSearchService.deleteIndex(document, document._id);
return this.employerModel.deleteOne({ name }).exec();
}
// SEARCH
public async searchByName(searchString: string): Promise<Employer[]> {
this.logger.debug('searchByName');
return this.employerSearchService.search(searchString);
}
public async initEmployerIndex(): Promise<Employer[]> {
Logger.log('Reset structures indexes');
this.logger.log('Reset structures indexes');
await this.employerSearchService.dropIndex();
await this.employerSearchService.createEmployerIndex();
return this.populateES();
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment