personal-offers.service.spec.ts

import { getModelToken } from '@nestjs/mongoose';
import { Test } from '@nestjs/testing';
import {
  createPersonalOffersDtoDataMock,
  personalOffersDataMock,
  updatePersonalOffersDtoDataMock,
} from '../../test/mock/data/personalOffers.mock.data';
import { UsersServiceMock } from '../../test/mock/services/user.mock.service';
import { UsersService } from '../users/services/users.service';
import { StructuresServiceMock } from './../../test/mock/services/structures.mock.service';
import { StructuresService } from './../structures/services/structures.service';
import { PersonalOffersService } from './personal-offers.service';

describe('PersonalOffersService', () => {
  let personalOffersService: PersonalOffersService;

  const personalOfferModelMock = {
    findById: jest.fn(),
    create: jest.fn(),
    findByIdAndUpdate: jest.fn(),
    findByIdAndDelete: jest.fn(),
    exec: jest.fn(),
  };

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [
        PersonalOffersService,
        {
          provide: getModelToken('PersonalOffer'),
          useValue: personalOfferModelMock,
        },
        {
          provide: StructuresService,
          useClass: StructuresServiceMock,
        },
        {
          provide: UsersService,
          useClass: UsersServiceMock,
        },
      ],
    }).compile();

    personalOffersService = module.get<PersonalOffersService>(PersonalOffersService);
  });

  afterEach(async () => {
    jest.clearAllMocks();
  });

  it('should be defined', () => {
    expect(personalOffersService).toBeDefined();
  });

  describe('findOne', () => {
    it('should return personal offer', async () => {
      personalOfferModelMock.findById.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[0]);
      expect(await personalOffersService.findOne('1234ba0e2ab5775cfc01ed3e')).toEqual(personalOffersDataMock[0]);
    });
    it('should return exception if personal offer is not found for given id', async () => {
      personalOfferModelMock.findById.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(null);
      try {
        await personalOffersService.findOne('abcd');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toBe('Personal offer does not exist');
        expect(e.status).toBe(404);
      }
    });
  });

  describe('create', () => {
    it('should create personal offer', async () => {
      personalOfferModelMock.create.mockResolvedValueOnce(personalOffersDataMock[0]);
      expect(await personalOffersService.create(createPersonalOffersDtoDataMock[0])).toEqual(personalOffersDataMock[0]);
    });
  });

  describe('update', () => {
    it('should update personal offer', async () => {
      personalOfferModelMock.findByIdAndUpdate.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[1]);
      expect(
        await personalOffersService.update('2345ba0e2ab5775cfc01ed4d', updatePersonalOffersDtoDataMock[1])
      ).toEqual(personalOffersDataMock[1]);
    });
    it('should return exception if personal offer is not found for given id', async () => {
      personalOfferModelMock.findById.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(null);
      try {
        await personalOffersService.update('abcd', updatePersonalOffersDtoDataMock[1]);
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toBe('Invalid personal offer id for update');
        expect(e.status).toBe(400);
      }
    });
  });

  describe('delete', () => {
    it('should update personal offer', async () => {
      personalOfferModelMock.findByIdAndDelete.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(personalOffersDataMock[0]);
      expect(await personalOffersService.delete('2345ba0e2ab5775cfc01ed4d')).toEqual(personalOffersDataMock[0]);
    });
    it('should return exception if personal offer is not found for given id', async () => {
      personalOfferModelMock.findById.mockReturnThis();
      personalOfferModelMock.exec.mockResolvedValueOnce(null);
      try {
        await personalOffersService.delete('abcd');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toBe('Invalid personal offer id for deletion');
        expect(e.status).toBe(400);
      }
    });
  });
});