temp-user.service.spec.ts

import { HttpModule } from '@nestjs/axios';
import { HttpStatus } from '@nestjs/common';
import { getModelToken } from '@nestjs/mongoose';
import { Test, TestingModule } from '@nestjs/testing';
import { MailerModule } from '../mailer/mailer.module';
import { TempUserService } from './temp-user.service';

describe('TempUserService', () => {
  let service: TempUserService;

  const tempUserModelMock = {
    create: jest.fn(),
    findOne: jest.fn(),
    findById: jest.fn(),
    findByIdAndUpdate: jest.fn(),
    deleteOne: jest.fn(),
    find: jest.fn(),
    exec: jest.fn(),
    updateOne: jest.fn(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [HttpModule, MailerModule],
      providers: [
        TempUserService,
        {
          provide: getModelToken('TempUser'),
          useValue: tempUserModelMock,
        },
      ],
    }).compile();

    service = module.get<TempUserService>(TempUserService);
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });
  describe('create', () => {
    const tmpUser = { email: 'test@test.com', pendingStructuresLink: [] };
    it('should not create temporary user: already exist', async () => {
      tempUserModelMock.findOne.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce(tmpUser);
      try {
        await service.create(tmpUser, 'PIMMS Framboise');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toEqual('User already exists');
        expect(e.status).toEqual(HttpStatus.BAD_REQUEST);
      }
    });
    it('should create temporary user', async () => {
      tempUserModelMock.findOne.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce(null).mockResolvedValueOnce(tmpUser);
      tempUserModelMock.create.mockResolvedValueOnce(tmpUser);
      expect(await service.create(tmpUser, 'PIMMS Framboise')).toEqual(tmpUser);
    });
  });
  it('should find one', async () => {
    const tmpUser = { email: 'test2@test.com', pendingStructuresLink: [] };
    tempUserModelMock.findOne.mockReturnThis();
    tempUserModelMock.exec.mockResolvedValueOnce(tmpUser);
    expect(await service.findOne('test2@test.com')).toEqual(tmpUser);
  });

  it('should find one by id', async () => {
    const tmpUser = { email: 'test2@test.com', pendingStructuresLink: [] };
    tempUserModelMock.findById.mockReturnThis();
    tempUserModelMock.exec.mockResolvedValueOnce(tmpUser);
    expect(await service.findById('5fbb92e480a5c257dc0161f0')).toEqual(tmpUser);
  });

  describe('delete', () => {
    it('should delete a temp user', async () => {
      const tmpUser = { email: 'test2@test.com', pendingStructuresLink: [] };
      tempUserModelMock.findOne.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce(tmpUser);
      tempUserModelMock.deleteOne.mockReturnThis();
      tempUserModelMock.exec.mockImplementationOnce(() => ({}));
      expect(await service.delete('toto@test.com')).toEqual(tmpUser);
    });
    it('should return an error : user does not exist', async () => {
      tempUserModelMock.findOne.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce(null);
      try {
        await service.delete('toto@test.com');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toEqual('User does not exists');
        expect(e.status).toEqual(HttpStatus.BAD_REQUEST);
      }
    });
  });

  describe('updateStructureLinked', () => {
    it('should update structure linked', async () => {
      const tmpUser = { email: 'test2@test.com', structuresLink: [] };
      tempUserModelMock.find.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce([]).mockResolvedValueOnce(tmpUser);
      tempUserModelMock.findByIdAndUpdate.mockReturnThis();
      expect(await service.updateStructureLinked(tmpUser)).toEqual(tmpUser);
    });
    it('should not update structure linked: User already linked', async () => {
      const tmpUser = { email: 'test2@test.com', structuresLink: [] };
      tempUserModelMock.find.mockReturnThis();
      tempUserModelMock.findByIdAndUpdate.mockReturnThis();
      tempUserModelMock.exec.mockResolvedValueOnce([tmpUser]);
      try {
        await service.updateStructureLinked(tmpUser);
      } catch (e) {
        expect(e.message).toEqual('User already linked');
        expect(e.status).toEqual(HttpStatus.UNPROCESSABLE_ENTITY);
      }
    });
  });
});