diff --git a/.vscode/settings.json b/.vscode/settings.json
index e63d44f162999a6ac418339c8ecb8cc0f5e6f73f..467c869b223e597afcb3fe5b152280c914ce9c88 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -58,6 +58,7 @@
"permanences",
"photonban",
"saturday",
+ "Sopra",
"spyer",
"sunday",
"thursday",
diff --git a/src/users/controllers/employer.controller.spec.ts b/src/users/controllers/employer.controller.spec.ts
index 8375b402be74debc5452c70888ecb9e04f6f539f..57703050ed60ce0ae63d7ce88ddca1c54cead32a 100644
--- a/src/users/controllers/employer.controller.spec.ts
+++ b/src/users/controllers/employer.controller.spec.ts
@@ -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();
+ });
});
});
diff --git a/src/users/controllers/employer.controller.ts b/src/users/controllers/employer.controller.ts
index fd6083cec41a6f194bca4e2325d2bdc9bb92919e..30aaef49e7dbe21e7f4dd3eb0ce63e3e3c36e458 100644
--- a/src/users/controllers/employer.controller.ts
+++ b/src/users/controllers/employer.controller.ts
@@ -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);
}
}
diff --git a/src/users/services/employer.service.spec.ts b/src/users/services/employer.service.spec.ts
index c6628da155320f1d7becb3f3cd0d6888b967a4a0..9601a6496f5f325cb083801da497c497ff399e56 100644
--- a/src/users/services/employer.service.spec.ts
+++ b/src/users/services/employer.service.spec.ts
@@ -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();
+ });
});
});
diff --git a/src/users/services/employer.service.ts b/src/users/services/employer.service.ts
index 083f638e5451f8313dac4d43bb55af744103d738..dded7bf5d48f07cd5992d389bd1782f9d707d8d8 100644
--- a/src/users/services/employer.service.ts
+++ b/src/users/services/employer.service.ts
@@ -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();