admin.controller.spec.ts

import { HttpModule } from '@nestjs/axios';
import { getModelToken } from '@nestjs/mongoose';
import { Test, TestingModule } from '@nestjs/testing';
import { Types } from 'mongoose';
import { structuresDocumentDataMock } from '../../test/mock/data/structures.mock.data';
import { mockJwtAuthGuard } from '../../test/mock/guards/jwt-auth.mock.guard';
import { mockRoleGuard } from '../../test/mock/guards/role.mock.guard';
import { NewsletterServiceMock } from '../../test/mock/services/newsletter.mock.service';
import { StructuresServiceMock } from '../../test/mock/services/structures.mock.service';
import { UsersServiceMock } from '../../test/mock/services/user.mock.service';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
import { ConfigurationModule } from '../configuration/configuration.module';
import { EspaceCoopCNFS } from '../espaceCoop/schemas/espaceCoopCNFS.schema';
import { EspaceCoopService } from '../espaceCoop/services/espaceCoop.service';
import { MailerService } from '../mailer/mailer.service';
import { NewsletterSubscription } from '../newsletter/newsletter-subscription.schema';
import { NewsletterService } from '../newsletter/newsletter.service';
import { SearchModule } from '../search/search.module';
import { Structure } from '../structures/schemas/structure.schema';
import { StructuresSearchService } from '../structures/services/structures-search.service';
import { StructuresService } from '../structures/services/structures.service';
import { RolesGuard } from '../users/guards/roles.guard';
import { User } from '../users/schemas/user.schema';
import { EmployerSearchService } from '../users/services/employer-search.service';
import { EmployerService } from '../users/services/employer.service';
import { JobsService } from '../users/services/jobs.service';
import { UsersService } from '../users/services/users.service';
import { AdminController } from './admin.controller';
import { AdminService } from './admin.service';
import { PendingStructureDto } from './dto/pending-structure.dto';

describe('AdminController', () => {
  let adminController: AdminController;
  let userService: UsersService;

  const mockEmployerSearchService = {
    indexEmployer: jest.fn(),
    search: jest.fn(),
    dropIndex: jest.fn(),
    createEmployerIndex: jest.fn(),
    deleteIndex: jest.fn(),
  };

  const mockEmployerService = {
    findOne: jest.fn(),
    deleteOneId: jest.fn(),
    findByName: jest.fn(),
    findAllValidated: jest.fn(),
    findAllUnvalidated: jest.fn(),
    createEmployerFromAdmin: jest.fn(),
    validate: jest.fn(),
    update: jest.fn(),
    mergeEmployer: jest.fn(),
    deleteInvalidEmployer: jest.fn(),
  };

  const mockJobService = {
    findOne: jest.fn(),
    findByName: jest.fn(),
    deleteOneId: jest.fn(),
    findAll: jest.fn(),
    findAllUnvalidated: jest.fn(),
    createJobFromAdmin: jest.fn(),
    validate: jest.fn(),
    update: jest.fn(),
    mergeJob: jest.fn(),
    deleteInvalidJob: jest.fn(),
  };

  const mockStructureService = {
    findOne: jest.fn(),
    deleteOne: jest.fn(),
    findAll: jest.fn(),
    getAllUserCompletedStructures: jest.fn(),
    findAllUnclaimed: jest.fn(),
  };

  const mockAdminService = {
    isDateOutdated: jest.fn(),
    getLastUpdateDate: jest.fn(),
  };

  const pendingStructureTest: PendingStructureDto = {
    structureId: new Types.ObjectId('6093ba0e2ab5775cfc01ed3e'),
    structureName: 'test',
    userEmail: 'jean.paul@mii.com',
    createdAt: new Date('2021-02-02T10:07:48.000Z'),
    updatedAt: new Date('2021-03-02T10:07:48.000Z'),
  };
  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [ConfigurationModule, HttpModule, SearchModule],
      providers: [
        {
          provide: UsersService,
          useClass: UsersServiceMock,
        },
        {
          provide: StructuresService,
          useValue: mockStructureService,
        },
        {
          provide: NewsletterService,
          useClass: NewsletterServiceMock,
        },
        {
          provide: AdminService,
          useValue: mockAdminService,
        },
        StructuresSearchService,
        MailerService,
        EspaceCoopService,
        {
          provide: EmployerService,
          useValue: mockEmployerService,
        },
        {
          provide: JobsService,
          useValue: mockJobService,
        },
        {
          provide: EmployerSearchService,
          useValue: mockEmployerSearchService,
        },
        {
          provide: getModelToken('User'),
          useValue: User,
        },
        {
          provide: getModelToken('NewsletterSubscription'),
          useValue: NewsletterSubscription,
        },
        {
          provide: getModelToken('Structure'),
          useValue: Structure,
        },
        {
          provide: getModelToken('EspaceCoopCNFS'),
          useValue: EspaceCoopCNFS,
        },
      ],
      controllers: [AdminController],
    })
      .overrideGuard(JwtAuthGuard)
      .useValue(mockJwtAuthGuard)
      .overrideGuard(RolesGuard)
      .useValue(mockRoleGuard)
      .compile();

    adminController = module.get<AdminController>(AdminController);
    userService = module.get<UsersService>(UsersService);
  });

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

  it('should get pending attachments', async () => {
    mockStructureService.findOne.mockResolvedValue({ structureName: 'structure', updatedAt: '' });
    expect((await adminController.getPendingAttachments()).length).toBe(2);
    expect(Object.keys((await adminController.getPendingAttachments())[0]).length).toBe(5);
  });

  describe('Pending structures validation', () => {
    it('should validate pending structure', async () => {
      mockStructureService.findOne.mockResolvedValue({ structureName: 'structure' });
      expect((await adminController.validatePendingStructure(pendingStructureTest)).length).toBe(2);
      expect(Object.keys((await adminController.validatePendingStructure(pendingStructureTest))[0]).length).toBe(5);
    });

    it('should get structure does not exist', async () => {
      try {
        await adminController.validatePendingStructure(pendingStructureTest);
      } catch (e) {
        expect(e.message).toBe('Structure does not exist');
        expect(e.status).toBe(404);
      }
    });
  });

  describe('Pending structures cancel', () => {
    it('should refuse pending structure', async () => {
      mockStructureService.findOne.mockResolvedValue({ structureName: 'structure' });
      expect((await adminController.refusePendingStructure(pendingStructureTest)).length).toBe(2);
      expect(Object.keys((await adminController.refusePendingStructure(pendingStructureTest))[0]).length).toBe(5);
    });

    it('should get structure does not exist', async () => {
      try {
        await adminController.refusePendingStructure(pendingStructureTest);
      } catch (e) {
        expect(e.message).toBe('Structure does not exist');
        expect(e.status).toBe(404);
      }
    });
  });

  describe('Delete user', () => {
    it('should delete user', async () => {
      jest.spyOn(StructuresServiceMock.prototype, 'deleteOne').mockImplementationOnce(() => null);
      const user = await adminController.deleteUser({ id: 'tsfsf6296' });
      expect(user.email).toBe('pauline.dupont@mii.com');
    });
    it('should return nonexisting user', async () => {
      try {
        await adminController.deleteUser({ id: 'userDoesNotExist' });
      } catch (e) {
        expect(e.message).toBe('Invalid user id');
        expect(e.status).toBe(400);
      }
    });
  });

  describe('setUserEmployer', () => {
    it('should set a new employer to the user', async () => {
      const spyer = jest.spyOn(userService, 'updateUserEmployer');
      const mockUserId = '6231aefe76598527c8d0b5bc';
      const mockEmployer = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(mockEmployer);
      const reply = await adminController.setUserEmployer({
        userId: mockUserId,
        employerId: String(mockEmployer._id),
      });
      expect(spyer).toBeCalledTimes(1);
      expect(spyer).toBeCalledWith(mockUserId, mockEmployer);
      expect(reply).toBeTruthy();
    });

    it('should not set a new employer to the user if the employer does not exist', async () => {
      const spyer = jest.spyOn(userService, 'updateUserEmployer');
      const mockUserId = '6231aefe76598527c8d0b5bc';
      const mockEmployer = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(null);
      try {
        await adminController.setUserEmployer({
          userId: mockUserId,
          employerId: String(mockEmployer._id),
        });
        expect(true).toBe(false);
      } catch (e) {
        expect(spyer).toBeCalledTimes(0);
        expect(e.message).toBe('Employer does not exist');
        expect(e.status).toBe(400);
      }
    });

    it('should not set a new employer to the user if the user does not exist', async () => {
      const spyer = jest.spyOn(userService, 'updateUserEmployer');
      const mockUserId = 'thisUserDoesNotExist';
      const mockEmployer = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(mockEmployer);
      try {
        await adminController.setUserEmployer({
          userId: mockUserId,
          employerId: String(mockEmployer._id),
        });
        expect(true).toBe(false);
      } catch (e) {
        expect(spyer).toBeCalledTimes(0);
        expect(e.message).toBe('User does not exist');
        expect(e.status).toBe(400);
      }
    });
  });

  describe('setUserJob', () => {
    it('should set a new job to the user', async () => {
      const spyer = jest.spyOn(userService, 'updateUserJob');
      const mockUserId = '6231aefe76598527c8d0b5bc';
      const mockJob = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Toto',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(mockJob);
      const reply = await adminController.setUserJob({
        userId: mockUserId,
        jobId: String(mockJob._id),
      });
      expect(spyer).toBeCalledTimes(1);
      expect(spyer).toBeCalledWith(mockUserId, mockJob);
      expect(reply).toBeTruthy();
    });

    it('should not set a new job to the user if the job does not exist', async () => {
      const spyer = jest.spyOn(userService, 'updateUserJob');
      const mockUserId = '6231aefe76598527c8d0b5bc';
      const mockJob = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Dev',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(null);
      try {
        await adminController.setUserJob({
          userId: mockUserId,
          jobId: String(mockJob._id),
        });
        expect(true).toBe(false);
      } catch (e) {
        expect(spyer).toBeCalledTimes(0);
        expect(e.message).toBe('Job does not exist');
        expect(e.status).toBe(400);
      }
    });

    it('should not set a new job to the user if the user does not exist', async () => {
      const spyer = jest.spyOn(userService, 'updateUserJob');
      const mockUserId = 'thisuserdoesntexist';
      const mockJob = {
        _id: new Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Dev',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(mockJob);
      try {
        await adminController.setUserJob({
          userId: mockUserId,
          jobId: String(mockJob._id),
        });
        expect(true).toBe(false);
      } catch (e) {
        expect(spyer).toBeCalledTimes(0);
        expect(e.message).toBe('User does not exist');
        expect(e.status).toBe(400);
      }
    });
  });

  describe('Search user', () => {
    it('should return all users, empty string', async () => {
      expect((await adminController.searchUsers({ searchString: '' })).length).toBe(2);
    });
    it('should return all users, null input', async () => {
      expect((await adminController.searchUsers({ searchString: null })).length).toBe(2);
    });
    it('should one user', async () => {
      expect((await adminController.searchUsers({ searchString: 'a@a.com' })).length).toBe(1);
      expect((await adminController.searchUsers({ searchString: 'a@a.com' }))[0].email).toBe('a@a.com');
    });
    it('should no user', async () => {
      expect((await adminController.searchUsers({ searchString: 'dfqfqsfqfqfa@a.com' })).length).toBe(0);
    });
  });

  it('should get pending structure list for admin', async () => {
    mockAdminService.isDateOutdated.mockReturnValue(false);
    mockAdminService.getLastUpdateDate.mockReturnValue('');
    mockStructureService.findOne.mockResolvedValue({ structureName: 'structure' });
    // using _id for unclaimed
    mockStructureService.findAllUnclaimed.mockResolvedValueOnce([
      { structureName: 'name', structureId: 'a', _id: 'a' },
      { structureName: 'name', structureId: 'b', _id: 'b' },
    ]);
    mockStructureService.findAll.mockResolvedValueOnce([
      { structureName: 'name', structureId: 'c' },
      { structureName: 'name', structureId: 'd' },
    ]);
    mockStructureService.findAll.mockResolvedValueOnce([
      { structureName: 'name', structureId: 'e', id: 'e' },
      { structureName: 'name', structureId: 'f', id: 'f' },
    ]);

    const adminList = await adminController.getAdminStructuresList();
    expect(adminList.inClaim.length).toBe(2);
    expect(adminList.toClaim.length).toBe(2);
    expect(adminList.claimed.length).toBe(2);
    expect(adminList.incomplete.length).toBe(2);
  });

  it('should find attached users', async () => {
    mockStructureService.getAllUserCompletedStructures.mockResolvedValueOnce([]);
    expect((await adminController.findAttachedUsers()).length).toBe(0);
  });

  it('should find unattached users', async () => {
    expect((await adminController.findUnattachedUsers()).length).toBe(0);
  });

  it('should find unverified users', async () => {
    mockStructureService.getAllUserCompletedStructures.mockResolvedValueOnce([]);
    expect((await adminController.findUnVerifiedUsers()).length).toBe(0);
  });

  describe('should test getDeletedStructures()', () => {
    it('should find getDeletedStructures', async () => {
      mockStructureService.findAll.mockResolvedValue(structuresDocumentDataMock);
      expect((await adminController.getDeletedStructures()).length).toBeGreaterThan(0);
    });
  });
});