admin.controller.spec.ts

import { HttpModule } from '@nestjs/common';
import { getModelToken } from '@nestjs/mongoose';
import { Test, TestingModule } from '@nestjs/testing';
import { Types } from 'mongoose';
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 { 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';

describe('AdminController', () => {
  let controller: 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(),
  };

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [ConfigurationModule, HttpModule, SearchModule],
      providers: [
        {
          provide: UsersService,
          useClass: UsersServiceMock,
        },
        {
          provide: StructuresService,
          useClass: StructuresServiceMock,
        },
        {
          provide: NewsletterService,
          useClass: NewsletterServiceMock,
        },
        {
          provide: AdminService,
          useClass: AdminService,
        },
        StructuresSearchService,
        MailerService,
        {
          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,
        },
      ],
      controllers: [AdminController],
    })
      .overrideGuard(JwtAuthGuard)
      .useValue(mockJwtAuthGuard)
      .overrideGuard(RolesGuard)
      .useValue(mockRoleGuard)
      .compile();

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

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

  it('should get pending attachments', async () => {
    expect((await controller.getPendingAttachments()).length).toBe(2);
    expect(Object.keys((await controller.getPendingAttachments())[0]).length).toBe(5);
  });

  describe('Pending structures validation', () => {
    it('should validate pending structure', async () => {
      const pendingStructureTest = {
        structureId: '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'),
      };
      expect((await controller.validatePendingStructure(pendingStructureTest)).length).toBe(2);
      expect(Object.keys((await controller.validatePendingStructure(pendingStructureTest))[0]).length).toBe(5);
    });

    it('should get structure does not exist', async () => {
      const pendingStructureTest = {
        structureId: '1093ba0e2ab5775cfc01z2ki',
        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'),
      };
      try {
        await controller.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 () => {
      const pendingStructureTest = {
        structureId: '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'),
      };
      expect((await controller.refusePendingStructure(pendingStructureTest)).length).toBe(2);
      expect(Object.keys((await controller.refusePendingStructure(pendingStructureTest))[0]).length).toBe(5);
    });

    it('should get structure does not exist', async () => {
      const pendingStructureTest = {
        structureId: '1093ba0e2ab5775cfc01z2ki',
        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'),
      };
      try {
        await controller.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 () => {
      expect((await controller.deleteUser({ id: 'tsfsf6296' })).email).toBe('pauline.dupont@mii.com');
    });
    it('should return unexisting user', async () => {
      try {
        await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(mockEmployer);
      const reply = await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(null);
      try {
        await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Sopra',
        validated: true,
      };
      mockEmployerService.findOne.mockResolvedValueOnce(mockEmployer);
      try {
        await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Toto',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(mockJob);
      const reply = await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Dev',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(null);
      try {
        await controller.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: Types.ObjectId('6231aefe76598527c8d0b5ba'),
        name: 'Dev',
        validated: true,
      };
      mockJobService.findOne.mockResolvedValueOnce(mockJob);
      try {
        await controller.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 controller.searchUsers({ searchString: '' })).length).toBe(2);
    });
    it('should return all users, null input', async () => {
      expect((await controller.searchUsers({ searchString: null })).length).toBe(2);
    });
    it('should one user', async () => {
      expect((await controller.searchUsers({ searchString: 'a@a.com' })).length).toBe(1);
      expect((await controller.searchUsers({ searchString: 'a@a.com' }))[0].email).toBe('a@a.com');
    });
    it('should no user', async () => {
      expect((await controller.searchUsers({ searchString: 'dfqfqsfqfqfa@a.com' })).length).toBe(0);
    });
  });

  describe('Search user newsletter subscription', () => {
    it('should return all subscribed users, empty string', async () => {
      expect((await controller.getNewsletterSubscriptions({ searchString: '' })).length).toBe(3);
    });
    it('should return all subscribed users, null input', async () => {
      expect((await controller.getNewsletterSubscriptions({ searchString: null })).length).toBe(3);
    });
    it('should find one user', async () => {
      expect((await controller.getNewsletterSubscriptions({ searchString: 'a@a.com' })).length).toBe(1);
      expect((await controller.getNewsletterSubscriptions({ searchString: 'a@a.com' }))[0].email).toBe('a@a.com');
    });
    it('should find no user', async () => {
      expect((await controller.getNewsletterSubscriptions({ searchString: 'adgdgsdg@a.com' })).length).toBe(0);
    });
  });

  it('should count user subscribed to newsletter', async () => {
    expect(await controller.countNewsletterSubscriptions()).toBe(246);
  });

  describe('Search delete a user subscription', () => {
    it('should return a deleted object', async () => {
      expect((await controller.unsubscribeUserFromNewsletter('a@a.com')).email).toBe('a@a.com');
      expect(Object.keys(await controller.unsubscribeUserFromNewsletter('a@a.com')).length).toBe(4);
    });
    it('should throw an error', async () => {
      try {
        await controller.unsubscribeUserFromNewsletter('test@test.com');
      } catch (e) {
        expect(e.message).toBe('Invalid  email');
        expect(e.status).toBe(401);
      }
    });
  });

  it('should get pending structure list for admin', async () => {
    expect((await controller.getAdminStructuresList()).inClaim.length).toBe(2);
    expect((await controller.getAdminStructuresList()).toClaim.length).toEqual(2);
    expect((await controller.getAdminStructuresList()).claimed.length).toEqual(0);
    expect((await controller.getAdminStructuresList()).incomplete.length).toEqual(2);
  });

  it('should find attached users', async () => {
    expect((await controller.findAttachedUsers()).length).toBe(0);
  });

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

  it('should find unverified users', async () => {
    expect((await controller.findUnVerifiedUsers()).length).toBe(0);
  });
});