(#129) adiciona testes unitarios

Author: HenriqueAmorim20

src/app.controller.spec.ts

@@ -19,7 +19,7 @@ describe('AppController', () => {
   });
 
   it('should make health check', () => {
-    expect(controller.heathCheck()).toEqual({
+    expect(controller.healthCheck()).toEqual({
       message: 'GEROcuidadoApiUsuario health check Ok!',
       data: {},
     });

src/app.service.spec.ts

@@ -16,7 +16,7 @@ describe('AppService', () => {
   });
 
   it('should make health check', () => {
-    expect(service.heathCheck()).toEqual({
+    expect(service.healthCheck()).toEqual({
       message: 'GEROcuidadoApiUsuario health check Ok!',
       data: {},
     });

src/usuario/usuario.controller.spec.ts

@@ -0,0 +1,129 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Filtering } from '../shared/decorators/filtrate.decorator';
+import { OrderParams, Ordering } from '../shared/decorators/ordenate.decorator';
+import {
+  Pagination,
+  PaginationParams,
+} from '../shared/decorators/paginate.decorator';
+import { Usuario } from './entities/usuario.entity';
+import { IUsuarioFilter } from './interfaces/usuario-filter.interface';
+import { UsuarioController } from './usuario.controller';
+import { UsuarioService } from './usuario.service';
+
+describe('UsuarioController', () => {
+  let controller: UsuarioController;
+  let service: UsuarioService;
+
+  const userDto = {
+    nome: 'Henrique',
+    email: 'hacmelo@gmail.com',
+    senha: '123',
+    foto: '1',
+    admin: false,
+  };
+
+  const user = {
+    ...userDto,
+    id: 1,
+    foto: Buffer.from('1'),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      controllers: [UsuarioController],
+      providers: [
+        {
+          provide: UsuarioService,
+          useValue: {
+            create: jest.fn(),
+            findOne: jest.fn(),
+            remove: jest.fn(),
+            update: jest.fn(),
+            findAll: jest.fn(),
+          },
+        },
+        {
+          provide: getRepositoryToken(Usuario),
+          useValue: {},
+        },
+      ],
+    }).compile();
+
+    controller = module.get<UsuarioController>(UsuarioController);
+    service = module.get<UsuarioService>(UsuarioService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  it('should create Usuario', async () => {
+    jest.spyOn(service, 'create').mockReturnValue(Promise.resolve(user));
+
+    const response = await controller.create(userDto);
+    expect(response.data).toEqual(user);
+    expect(response.message).toEqual('Salvo com sucesso!');
+  });
+
+  it('should find Usuario', async () => {
+    jest.spyOn(service, 'findOne').mockReturnValue(Promise.resolve(user));
+
+    const response = await controller.findOne({ id: 1 });
+    expect(response).toEqual(user);
+  });
+
+  it('should remove Usuario', async () => {
+    jest.spyOn(service, 'remove').mockReturnValue(Promise.resolve(user));
+
+    const response = await controller.remove({ id: 1 });
+    expect(response.data).toEqual(user);
+    expect(response.message).toEqual('Excluído com sucesso!');
+  });
+
+  it('should update Usuario', async () => {
+    jest.spyOn(service, 'update').mockReturnValue(Promise.resolve(user));
+
+    const response = await controller.update({ id: 1 }, { nome: 'Henrique' });
+    expect(response.data).toEqual(user);
+    expect(response.message).toEqual('Atualizado com sucesso!');
+  });
+
+  describe('findAll', () => {
+    const filter: IUsuarioFilter = {
+      nome: 'Henrique',
+      id: 1,
+      email: 'email@email.com',
+    };
+    const filtering = new Filtering<IUsuarioFilter>(JSON.stringify(filter));
+
+    const order: OrderParams = {
+      column: 'id',
+      dir: 'ASC',
+    };
+    const ordering: Ordering = new Ordering(JSON.stringify(order));
+
+    const paginate: PaginationParams = {
+      limit: 10,
+      offset: 0,
+    };
+    const pagination: Pagination = new Pagination(paginate);
+
+    it('should findAll Usuario', async () => {
+      const expected = { data: [user], count: 1, pageSize: 1 };
+
+      jest.spyOn(service, 'findAll').mockReturnValue(Promise.resolve(expected));
+
+      const { data, count, pageSize } = await controller.findAll(
+        filtering,
+        pagination,
+        ordering,
+      );
+
+      expect(count).toEqual(1);
+      expect(pageSize).toEqual(1);
+      expect(data).toEqual([user]);
+    });
+  });
+});

src/usuario/usuario.service.spec.ts

@@ -0,0 +1,120 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { OrderParams, Ordering } from '../shared/decorators/ordenate.decorator';
+import {
+  Pagination,
+  PaginationParams,
+} from '../shared/decorators/paginate.decorator';
+import { Usuario } from './entities/usuario.entity';
+import { UsuarioService } from './usuario.service';
+
+describe('UsuarioService', () => {
+  let service: UsuarioService;
+  let repository: Repository<Usuario>;
+
+  const mockRepository = {
+    save: jest.fn(),
+    findOneOrFail: jest.fn(),
+    remove: jest.fn(),
+    createQueryBuilder: jest.fn(() => ({
+      where: jest.fn().mockReturnThis(),
+      limit: jest.fn().mockReturnThis(),
+      offset: jest.fn().mockReturnThis(),
+      orderBy: jest.fn().mockReturnThis(),
+      getManyAndCount: jest.fn(),
+    })),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        UsuarioService,
+        {
+          provide: getRepositoryToken(Usuario),
+          useValue: mockRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<UsuarioService>(UsuarioService);
+    repository = module.get<Repository<Usuario>>(getRepositoryToken(Usuario));
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  it('should create Usuario', async () => {
+    const user = { nome: 'Henrique' } as any;
+    jest.spyOn(repository, 'save').mockReturnValue({ id: 1 } as any);
+
+    const created = await service.create(user);
+    expect(created.id).toEqual(1);
+  });
+
+  it('should find Usuario', async () => {
+    jest.spyOn(repository, 'findOneOrFail').mockReturnValue({ id: 1 } as any);
+
+    const found = await service.findOne(1);
+    expect(found.id).toEqual(1);
+  });
+
+  it('should remove Usuario', async () => {
+    jest.spyOn(repository, 'findOneOrFail').mockReturnValue({ id: 1 } as any);
+    jest.spyOn(repository, 'remove').mockReturnValue({ id: 1 } as any);
+
+    const removed = await service.remove(1);
+    expect(removed.id).toEqual(1);
+  });
+
+  it('should update Usuario', async () => {
+    jest.spyOn(repository, 'findOneOrFail').mockReturnValue({ id: 1 } as any);
+    jest
+      .spyOn(repository, 'save')
+      .mockReturnValue({ id: 1, nome: 'Henrique' } as any);
+
+    const found = await service.update(1, { nome: 'Henrique' });
+    expect(found).toEqual({ id: 1, nome: 'Henrique' });
+  });
+
+  describe('findAll', () => {
+    const usuario = {
+      id: 1,
+      nome: 'Henrique',
+      email: 'email@email.com',
+    };
+
+    const order: OrderParams = {
+      column: 'id',
+      dir: 'ASC',
+    };
+    const ordering: Ordering = new Ordering(JSON.stringify(order));
+
+    const paginate: PaginationParams = {
+      limit: 10,
+      offset: 0,
+    };
+    const pagination: Pagination = new Pagination(paginate);
+
+    it('should findAll Usuario', async () => {
+      jest.spyOn(repository, 'createQueryBuilder').mockReturnValue({
+        where: () => ({
+          limit: () => ({
+            offset: () => ({
+              orderBy: () => ({
+                getManyAndCount: jest
+                  .fn()
+                  .mockResolvedValueOnce([[usuario], 1]),
+              }),
+            }),
+          }),
+        }),
+      } as any);
+
+      const { data, count } = await service.findAll({}, ordering, pagination);
+      expect(count).toEqual(1);
+      expect((data as Usuario[])[0]).toEqual(usuario);
+    });
+  });
+});