structures.controller.spec.ts

import { HttpService } from '@nestjs/axios';
import { HttpStatus } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { of } from 'rxjs';
import { PhotonResponseMock } from '../../test/mock/data/dataPhoton.mock.data';
import { structureDtoMock } from '../../test/mock/data/structure.mock.dto';
import { CategoriesServiceMock } from '../../test/mock/services/categories.mock.service';
import { UsersServiceMock } from '../../test/mock/services/user.mock.service';
import { CategoriesService } from '../categories/services/categories.service';
import { PersonalOffersService } from '../personal-offers/personal-offers.service';
import { TempUserService } from '../temp-user/temp-user.service';
import { UserRole } from '../users/enum/user-role.enum';
import { UsersService } from '../users/services/users.service';
import { CreateStructureDto } from './dto/create-structure.dto';
import { StructuresService } from './services/structures.service';
import { StructuresController } from './structures.controller';
import { mockDeletedStructure, mockStructure } from '../../test/mock/data/structures.mock.data';
import { mockUser } from '../../test/mock/data/users.mock.data';
import { StructuresExportService } from './services/structures-export.service';
import {
  StructuresExportServiceMock,
  mockFormattedStructures,
} from '../../test/mock/services/structures-export.mock.service';
import { StructureFormatted } from './interfaces/structure-formatted.interface';
import { JobDocument } from '../users/schemas/job.schema';
import { getModelToken } from '@nestjs/mongoose';
import { Structure } from './schemas/structure.schema';

describe('StructuresController', () => {
  let structuresController: StructuresController;
  let structuresExportService: StructuresExportService;

  const mockHttpService = {
    get: jest.fn(),
  };

  const mockStructureService = {
    cancelDelete: jest.fn(),
    create: jest.fn(),
    deleteOne: jest.fn(),
    findAll: jest.fn(),
    findAllUnclaimed: jest.fn(),
    findOne: jest.fn(),
    findWithOwners: jest.fn(),
    getAllUserCompletedStructures: jest.fn(),
    initiateStructureIndex: jest.fn(),
    reportStructureError: jest.fn(),
    searchAddress: jest.fn(),
    searchForStructures: jest.fn(),
    update: jest.fn(),
    updateAllDenormalizedFields: jest.fn(),
  };

  const mockTempUserService = {
    findOne: jest.fn(),
    findById: jest.fn(),
    sendUserMail: jest.fn(),
    create: jest.fn(),
    removeFromStructureLinked: jest.fn(),
  };

  const mockUsersService = {
    updateStructureLinkedClaim: jest.fn(),
    findById: jest.fn(),
    removeFromStructureLinked: jest.fn(),
    getPersonalOfferInStructure: jest.fn(),
    getStructureOwners: jest.fn(),
    verifyUserExist: jest.fn(),
  };

  const mockPersonalOffersService = { delete: jest.fn() };

  beforeEach(async () => {
    const module = await Test.createTestingModule({
      imports: [],
      controllers: [StructuresController],
      providers: [
        {
          provide: HttpService,
          useValue: mockHttpService,
        },
        {
          provide: StructuresService,
          useValue: mockStructureService,
        },
        {
          provide: UsersService,
          useValue: mockUsersService,
        },
        {
          provide: PersonalOffersService,
          useValue: mockPersonalOffersService,
        },
        {
          provide: TempUserService,
          useValue: mockTempUserService,
        },
        {
          provide: CategoriesService,
          useClass: CategoriesServiceMock,
        },
        {
          provide: StructuresExportService,
          useClass: StructuresExportServiceMock,
        },
        {
          provide: getModelToken(Structure.name),
          useValue: {},
        },
      ],
    }).compile();
    structuresController = module.get<StructuresController>(StructuresController);
    structuresExportService = module.get<StructuresExportService>(StructuresExportService);
    jest.clearAllMocks();
  });

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

  it('should get structure coordinates', async () => {
    mockHttpService.get.mockImplementationOnce(() => of(PhotonResponseMock));
    const coords = await structuresController.getCoordinates('Lyon');
    expect(coords).toBeTruthy();
  });

  it('should create structure', async () => {
    const structure: CreateStructureDto = {
      userEmail: 'admin@admin.com',
      structure: structureDtoMock,
    };
    await structuresController.create(structure);
    expect(mockStructureService.create).toHaveBeenCalled();
  });

  it('should update structure', async () => {
    await structuresController.update('azerty', {
      deletedAt: null,
      dataShareConsentDate: null,
      personalOffers: [],
    });
    expect(mockStructureService.update).toHaveBeenCalled();
  });

  it('should findAll', async () => {
    mockStructureService.findAll.mockResolvedValueOnce([{ structureName: 'a' }, { structureName: 'b' }]);
    const res = await structuresController.findAll();
    expect(res.length).toBe(2);
  });

  it('should findAllFormatted', async () => {
    const mockResult: StructureFormatted[] = mockFormattedStructures;
    jest.spyOn(structuresExportService, 'exportFormatted').mockResolvedValueOnce(mockResult);

    const result: StructureFormatted[] = await structuresController.findAllFormatted();

    expect(result).toEqual(mockResult);
  });

  it('should search structure', async () => {
    await structuresController.search({ query: 'test', filters: [] }, null);
    expect(mockStructureService.searchForStructures).toHaveBeenCalled();
  });

  it('should reset Search Index', async () => {
    await structuresController.resetES();
    expect(mockStructureService.updateAllDenormalizedFields).toHaveBeenCalled();
    expect(mockStructureService.initiateStructureIndex).toHaveBeenCalled();
  });

  it('should claim structure', async () => {
    const userMock = new UsersServiceMock();
    const user = userMock.findOne('pauline.dupont@mii.com');
    const res = structuresController.claim('1', {
      phone: null,
      resetPasswordToken: null,
      changeEmailToken: null,
      newEmail: null,
      pendingStructuresLink: null,
      structuresLink: null,
      structureOutdatedMailSent: null,
      personalOffers: null,
      email: user.email,
      name: user.name,
      surname: user.surname,
      emailVerified: true,
      createdAt: new Date('2022-05-25T09:48:28.824Z'),
      password: user.password,
      validationToken: null,
      role: null,
      employer: {
        name: 'test',
        validated: true,
      },
      job: {
        name: 'test',
        validated: true,
        hasPersonalOffer: false,
        jobsGroup: null,
      } as JobDocument,
      unattachedSince: null,
      lastLoginDate: null,
    });
    expect(res).toBeTruthy();
  });

  it('should search an address', async () => {
    await structuresController.searchAddress({ searchQuery: 'Rue Alphonse Daudet' });
    expect(mockStructureService.searchAddress).toHaveBeenCalled();
  });

  describe('find(structureId)', () => {
    it('should find structure', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      const res = await structuresController.find({ user: {} }, '6093ba0e2ab5775cfc01ed3e');
      expect(res).toBeTruthy();
    });

    it('should find deleted structure as an admin', async () => {
      mockStructureService.findOne.mockResolvedValue(mockDeletedStructure);
      const response = await structuresController.find({ user: { role: UserRole.admin } }, '6093ba0e2ab5775cfc01ed33');
      expect(response.deletedAt).toBeTruthy();
    });

    it('should not find deleted structure as anonymous', async () => {
      try {
        await structuresController.find({ user: {} }, '6093ba0e2ab5775cfc01ed33');
        expect(true).toBe(false);
      } catch (error) {
        expect(error.status).toEqual(HttpStatus.NOT_FOUND);
      }
    });
  });

  it('should find struct with owners', async () => {
    await structuresController.findWithOwners('6093ba0e2ab5775cfc01ed3e');
    expect(mockStructureService.findWithOwners).toHaveBeenCalled();
  });

  describe('delete', () => {
    it('should delete structure without owners', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      mockUsersService.getStructureOwners.mockResolvedValue([]);
      await structuresController.delete({ user: { _id: 'test' } }, 'test');
      expect(mockStructureService.deleteOne).toHaveBeenCalled();
    });

    // test delete structure with owners
  });

  it('should cancel struct delete', async () => {
    mockStructureService.findOne.mockResolvedValue(mockStructure);
    await structuresController.cancelDelete({ user: { _id: 'id' } }, 'id');
    expect(mockStructureService.cancelDelete).toHaveBeenCalled();
  });

  describe('addOwner', () => {
    // Test if user exists

    // Test if temp user exists

    it('should create temp user if it does not exists', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      mockUsersService.verifyUserExist.mockResolvedValue(null);
      await structuresController.addOwner('6093ba0e2ab5775cfc01ed3e', { email: 'pauline.dupont@mii.com' });
      expect(mockTempUserService.create).toHaveBeenCalled();
    });
  });

  describe('removeOwner', () => {
    it('should return invalid structure', async () => {
      mockStructureService.findOne.mockResolvedValueOnce(null);
      try {
        await structuresController.removeOwner('invalidstructure', '63639058685ba134c32bc495');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toEqual('Invalid Structure');
        expect(e.status).toEqual(HttpStatus.NOT_FOUND);
      }
    });
    it('should return invalid user', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      try {
        await structuresController.removeOwner('6093ba0e2ab5775cfc01ed3e', 'invaliduser');
        expect(true).toBe(false);
      } catch (e) {
        expect(e.message).toEqual('Invalid User');
        expect(e.status).toEqual(HttpStatus.NOT_FOUND);
      }
    });
    it('should remove structure link without offer', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      mockUsersService.findById.mockResolvedValue(mockUser);
      mockUsersService.getPersonalOfferInStructure.mockReturnValue(null);
      await structuresController.removeOwner('6093ba0e2ab5775cfc01ed3e', '63639058685ba134c32bc495');
      expect(mockUsersService.removeFromStructureLinked).toHaveBeenCalledTimes(1);
      expect(mockPersonalOffersService.delete).toHaveBeenCalledTimes(0);
    });

    it('should remove structure link with offer', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      mockUsersService.findById.mockResolvedValue(mockUser);
      mockUsersService.getPersonalOfferInStructure.mockReturnValue({
        _id: '2345ba0e2ab5775cfc01ed4d',
        categories: {
          onlineProcedures: ['caf'],
          baseSkills: [],
          advancedSkills: [],
        },
        createdAt: 'Wed Mar 16 2022 14:29:11 GMT+0100 (heure normale d’Europe centrale)',
        updatedAt: 'Wed Mar 16 2022 17:29:11 GMT+0100 (heure normale d’Europe centrale)',
      });

      await structuresController.removeOwner('6093ba0e2ab5775cfc01ed3e', '63639058685ba134c32bc495');
      expect(mockUsersService.removeFromStructureLinked).toHaveBeenCalled();
      expect(mockPersonalOffersService.delete).toHaveBeenCalled();
    });

    it('should remove user from struct', async () => {
      mockStructureService.findOne.mockResolvedValue(mockStructure);
      mockUsersService.findById.mockResolvedValue(mockUser);
      mockUsersService.getPersonalOfferInStructure.mockReturnValue(null);
      await structuresController.removeOwner('6093ba0e2ab5775cfc01ed3e', '63639058685ba134c32bc495');
      expect(mockUsersService.removeFromStructureLinked).toHaveBeenCalled();
    });

    // test personal offers delete
  });

  it('should remove temp user', async () => {
    mockStructureService.findOne.mockResolvedValue(mockStructure);
    mockTempUserService.findById.mockResolvedValue(mockUser);
    // To test manually, might contain a bug with Types.ObjectId
    // await controller.removeTempUser('6093ba0e2ab5775cfc01ed3e', '63639058685ba134c32bc495');
    // expect(mockTempUserService.removeFromStructureLinked).toBeCalled();
  });

  it('should report any structure error', async () => {
    await structuresController.reportStructureError({ structureId: '6093ba0e2ab5775cfc01ed3e', content: null });
    expect(mockStructureService.reportStructureError).toHaveBeenCalled();
  });
});