DEV Community

Gabriel de Luca
Gabriel de Luca

Posted on

AluraChallenges #2 ( Semana 2)

#nestjs #typescript #jest #typeorm

No post anterior, nós fizemos todas as implementações que tínhamos da semana 1, deixando nossa API de vídeos pronta para consumo.

Só que ainda temos desafios pela frente e nessa semana faremos a inserção de categorias, para classificarmos os nossos vídeos.
A história dessa semana é a seguinte:

Depois de alguns testes com usuários, foi definido que a próxima feature a ser desenvolvida nesse projeto é a divisão dos vídeos por categoria, para melhorar a experiência de organização da lista de vídeos pelo usuário.

Então, faremos nesse post as seguintes implementações :

  • Adicionar categorias e seus campos na base de dados;
  • Rotas CRUD para /categorias;
  • Incluir campo categoriaId no modelo video;
  • Escrever os testes unitários.

Vamos começar fazendo os dois primeiros pontos, e novamente usaremos o generate do Nest, para criamos o recurso Categorias.

nest generate resource categorias
Enter fullscreen mode Exit fullscreen mode

Após a criação, faremos a definição da nossa classe CreateCategoriaDto:

// src/categorias/dto/create-categoria.dto.ts

import { Video } from '../../videos/entities/video.entity';

export class CreateCategoriaDto {
  id: number;
  titulo: string;
  cor: string;
  videos: Video[];
}
Enter fullscreen mode Exit fullscreen mode

e alteraremos o nosso CreateVideoDto, adicionando a categoria:

// src/videos/dto/create-video.dto.ts

import { Categoria } from '../../categorias/entities/categoria.entity';

export class CreateVideoDto {
...

categoria: Categoria;
}
Enter fullscreen mode Exit fullscreen mode

Agora vamos na nossa "entity" e precisaremos fazer um pouco diferente.
Como será necessário ligar as tabelas de videos e categorias, utilizaremos o decorator @OneToMany(), que significa que teremos 1 categoria para vários vídeos:

// src/categorias/entities/categoria.entity.ts

import { IsNotEmpty, IsString } from 'class-validator';
import { Video } from '../../videos/entities/video.entity';
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Categoria {
  @PrimaryGeneratedColumn()
  id: number;

  @IsNotEmpty()
  @IsString()
  @Column()
  titulo: string;

  @IsNotEmpty()
  @IsString()
  @Column()
  cor: string;

  @OneToMany(() => Video, (video) => video.categoria)
  videos: Video[];
}
Enter fullscreen mode Exit fullscreen mode

Será necessário alterar nossa "entity" Video também, informando que teremos varios vídeos para cada categoria. Utilizaremos o decorator @ManyToOne() após todos os atributos que já temos:

// src/videos/entities/video.entity.ts

import { PrimaryGeneratedColumn, Column, Entity, ManyToOne } from 'typeorm';
import { IsNotEmpty, IsString, IsUrl } from 'class-validator';
import { Categoria } from '../../categorias/entities/categoria.entity';

@Entity()
export class Video {
  ...
  @ManyToOne(() => Categoria, (categoria) => categoria.id, { nullable: false })
  categoria: Categoria;
}
Enter fullscreen mode Exit fullscreen mode

Entidades ajustadas, vamos para o nosso "categoria.service" para implementar as funcionalidades dela.
A diferença nela está no findAll, que passamos o parâmetro indicando a relação (relations: ['videos']) e já pedindo para trazer os dados dessa relação (loadEagerRelations: true):

// src/categorias/categorias.service.ts

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { CreateCategoriaDto } from './dto/create-categoria.dto';
import { UpdateCategoriaDto } from './dto/update-categoria.dto';
import { Categoria } from './entities/categoria.entity';

@Injectable()
export class CategoriasService {
  @InjectRepository(Categoria)
  private categoriaRepository: Repository<Categoria>;

  create(createCategoriaDto: CreateCategoriaDto) {
    return this.categoriaRepository.save(createCategoriaDto);
  }

  findAll() {
    return this.categoriaRepository.find({
      relations: ['videos'],
      loadEagerRelations: true,
    });
  }

  findOne(id: number) {
    return this.categoriaRepository.findOne(id);
  }

  update(id: number, updateCategoriaDto: UpdateCategoriaDto) {
    return this.categoriaRepository.update(id, updateCategoriaDto);
  }

  async remove(id: number) {
    const categoria = await this.findOne(id);
    return this.categoriaRepository.remove(categoria);
  }
}
Enter fullscreen mode Exit fullscreen mode

Novamente, temos que ajustar nosso "video.service" também, que no caso, só terá alteração no método "findAll()":

// src/videos/videos.service.ts

...
findAll() {
    return this.videoRepository.find({
      relations: ['categoria'],
      loadEagerRelations: true,
    });
  }
...
Enter fullscreen mode Exit fullscreen mode

Agora, para que a tabela de categorias seja criada no banco e identificada pelo Nest, precisamos ir no categorias.module e importar o TypeOrmModule passando a Categoria como parâmetro:

// src/categorias/categorias.module.ts

import { Module } from '@nestjs/common';
import { CategoriasService } from './categorias.service';
import { CategoriasController } from './categorias.controller';
import { Categoria } from './entities/categoria.entity';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [TypeOrmModule.forFeature([Categoria])],
  controllers: [CategoriasController],
  providers: [CategoriasService],
})
export class CategoriasModule {}
Enter fullscreen mode Exit fullscreen mode

Maravilha, implementamos a categoria para os nossos videos, porém, temos um card que pede para que ao acessar a rota "/categorias/:id/videos" retorne os vídeos de uma determinada categoria:
videos_por_categoria

Para que isso seja possível, vamos precisar de uma nova rota no nosso controller de categorias.
A nova rota vai ficar assim:

// src/categorias/categorias.controller.ts
...

@Get(':id/videos')
  findVideosByCategoryId(@Param('id') id: string) {
    return this.categoriasService.findVideoByCategory(+id);
  }

...
Enter fullscreen mode Exit fullscreen mode

Mas espera aí, nós não temos esse método "categoriasService.findVideoByCategory()".
Precisamos criar esse método lá no nosso serviço "categorias.service":

// src/categorias/categorias.service.ts

...

async findVideoByCategory(id: number): Promise<Video[]> {
    const categoria = await this.findOne(id);
    return categoria.videos;
  }

...
Enter fullscreen mode Exit fullscreen mode

Mas se tentarmos acessar a rota, veremos uma tela branca, sem retorno de nenhum dado. --'
Para que seja retornado, precisamos alterar também o nosso método findOne, passando um objeto de configuração, informando que queremos que ele faça o carregamento dos dados relacionados à essa tabela.
O método ficará assim:

// src/categorias/categorias.service.ts
...

findOne(id: number) {
    return this.categoriaRepository.findOne(id, {
      relations: ['videos'],
      loadEagerRelations: true,
    });
  }

...
Enter fullscreen mode Exit fullscreen mode

Agora sim, ao acessar nossa rota ".../categorias/1/videos", teremos nossos vídeos referentes à essa categoria.

O próximo card, tem a seguinte descrição:
videos_query_params

Para atender a esse requisito, precisaremos alterar nosso controller e nosso service de videos:

// src/videos/videos.controller.ts

...

@Get()
  findAll(@Query() query) {
    return this.videosService.findAll(query.search);
  }

...
Enter fullscreen mode Exit fullscreen mode 
// src/videos/videos.service.ts

...

findAll(search = '') {
    return this.videoRepository.find({
      where: { titulo: ILike(`%${search}%`) },
      relations: ['categoria'],
    });
  }

...
Enter fullscreen mode Exit fullscreen mode

Próximo card:
categ_livre

Como já criamos uma categoria anteriormente, vamos enviar uma requisição de update para a categoria de ID 1, alterando o título para LIVRE
insomnia_patch
E após isso, vamos no videos.service e alteraremos a lógica do método create:

// src/videos/videos.service.ts
...

create(createVideoDto: CreateVideoDto) {
    if (!createVideoDto.categoria)
      return this.videoRepository.save({
        ...createVideoDto,
        categoria: { id: 1 },
      });
    return this.videoRepository.save(createVideoDto);
  }

...
Enter fullscreen mode Exit fullscreen mode

Pronto, requisito atendido!

(Faça uma requisição criando um vídeo sem informar a categoria e veja se está tudo funcionando como o esperado, o retorno deve ser o vídeo criado e com a "categoria":{"id": 1})

O próximo requisito é para que se crie os testes automatizados e aí que o negócio começa a ficar legal.

Implementando testes automatizados

Para facilitar nossos mocks, vamos inserir um construtor para as nossas entidades, deixando elas assim:

// src/categorias/entities/categoria.entity.ts

...

constructor(private categoria?: Partial<Categoria>) {}
Enter fullscreen mode Exit fullscreen mode 
// src/categorias/entities/categoria.entity.ts

...

constructor(private video?: Partial<Categoria>) {}
Enter fullscreen mode Exit fullscreen mode

Vamos criar também uma pasta common dentro de src e nela criar uma pasta test, que ficarão os arquivos necessário e comum à todos os testes. Por agora, teremos dois stubs:
videos.stub.ts (crie esse arquivo)

// src/common/test/videos.stub.ts

import { Categoria } from '../../categorias/entities/categoria.entity';
import { Video } from '../../videos/entities/video.entity';
import { categoriasStub } from './categorias.stub';

export const videosStub: Video[] = [
  new Video({
    id: 1,
    titulo: 'título qualquer',
    descricao: 'descrição qualquer',
    url: 'http://url_qualquer.com',
    categoria: new Categoria({ id: 1, titulo: 'LIVRE', cor: 'verde' }),
  }),
  new Video({
    id: 2,
    titulo: 'outro título qualquer',
    descricao: 'outra descrição qualquer',
    url: 'http://outra_url_qualquer.com',
    categoria: categoriasStub[1],
  }),
  new Video({
    id: 3,
    titulo: 'titulo qualquer',
    descricao: 'descrição qualquer',
    url: 'http://url_qualquer.com',
    categoria: categoriasStub[1],
  }),
];
Enter fullscreen mode Exit fullscreen mode

e categorias.stub.ts (crie também)

// src/common/test/categorias.stub.ts

import { Categoria } from '../../categorias/entities/categoria.entity';

export const categoriasStub: Categoria[] = [
  new Categoria({ id: 1, titulo: 'LIVRE', cor: 'verde' }),
  new Categoria({ id: 2, titulo: 'Programação', cor: 'azul' }),
];
Enter fullscreen mode Exit fullscreen mode

Testando os controllers

Vamos rodas os testes e ver no que vai dar.

npm run test
Enter fullscreen mode Exit fullscreen mode

Que delícia, nenhum teste passou!
Isso acontece pois alteramos e implementamos tudo sem criar nenhum teste o que não é muito legal, mas enfim, vamos começar a ajustar as coisa...

Testando nosso categorias.controller

O Nestjs já deixa uma estrutura pré-montada, então, vamos até o nosso arquivo categorias.controller.spec.ts para trabalhar nele.
Nosso controller tem como dependência o service e para que ele seja disponibilizado no teste precisamos prover ele.
Faremos dessa forma:

// src/categorias/categorias.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { categoriasStub } from '../common/test/categorias.stub';
import { CategoriasController } from './categorias.controller';
import { CategoriasService } from './categorias.service';
import { videosStub } from '../common/test/videos.stub';

describe('CategoriasController', () => {
  let controller: CategoriasController;
  let service: CategoriasService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [CategoriasController],
      providers: [
        CategoriasService,
        {
          provide: CategoriasService,
          useValue: {
            create: jest.fn().mockResolvedValue(categoriasStub[0]),
            findAll: jest.fn().mockResolvedValue(categoriasStub),
            findOne: jest.fn().mockResolvedValue(categoriasStub[0]),
            findVideoByCategory: jest.fn().mockResolvedValue(videosStub),
            update: jest.fn().mockResolvedValue(categoriasStub[0]),
            remove: jest.fn().mockResolvedValue(categoriasStub[0]),
          },
        },
      ],
    }).compile();

    controller = module.get<CategoriasController>(CategoriasController);
    service = module.get<CategoriasService>(CategoriasService);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
    expect(service).toBeDefined();
  }); 
});
Enter fullscreen mode Exit fullscreen mode

repare que nós criamos um mock para cada função que temos no serviço e definimos o retorno delas com nosso stub da categoria.

com isso, podemos rodar novamente o comando de testes do npm, só que agora, deixaremos ele em modo watch para que ele fique observando as alterações, enquanto implementamos os testes, mas faremos somente para o arquivo que estamos trabalhando no momento:

npm run test:watch -t /home/gabriel/Documentos/alura-challenges-2/src/categorias/categorias.controller.spec.ts

# substitua essa parte '/home/gabriel/Documentos' pelo caminho do seu computador, é claro.
Enter fullscreen mode Exit fullscreen mode

Feito isso, o teste vai rodar e faremos a implementação do restante.
No final, esse arquivo ficará assim:

// src/categorias/categorias.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { categoriasStub } from '../common/test/categorias.stub';
import { CategoriasController } from './categorias.controller';
import { CategoriasService } from './categorias.service';
import { videosStub } from '../common/test/videos.stub';

describe('CategoriasController', () => {
  let controller: CategoriasController;
  let service: CategoriasService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [CategoriasController],
      providers: [
        CategoriasService,
        {
          provide: CategoriasService,
          useValue: {
            create: jest.fn().mockResolvedValue(categoriasStub[0]),
            findAll: jest.fn().mockResolvedValue(categoriasStub),
            findOne: jest.fn().mockResolvedValue(categoriasStub[0]),
            findVideoByCategory: jest.fn().mockResolvedValue(videosStub),
            update: jest.fn().mockResolvedValue(categoriasStub[0]),
            remove: jest.fn().mockResolvedValue(categoriasStub[0]),
          },
        },
      ],
    }).compile();

    controller = module.get<CategoriasController>(CategoriasController);
    service = module.get<CategoriasService>(CategoriasService);
  });

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

  describe('create', () => {
    it('should create a category', async () => {
      const result = await service.create(categoriasStub[0]);
      expect(result).toEqual(categoriasStub[0]);
      expect(service.create).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'create').mockRejectedValueOnce(new Error());
      expect(service.create(categoriasStub[0])).rejects.toThrowError();
      expect(service.create).toHaveBeenCalledTimes(1);
    });
  });

  describe('findAll', () => {
    it('should return a category list', async () => {
      const result = await service.findAll();
      expect(result).toEqual(categoriasStub);
      expect(service.findAll).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'findAll').mockRejectedValueOnce(new Error());
      expect(service.findAll()).rejects.toThrowError();
      expect(service.findAll).toHaveBeenCalledTimes(1);
    });
  });

  describe('findOne', () => {
    it('should return a category', async () => {
      const result = await service.findOne(categoriasStub[0].id);
      expect(result).toEqual(categoriasStub[0]);
      expect(service.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'findOne').mockRejectedValueOnce(new Error());
      expect(service.findOne(1)).rejects.toThrowError();
      expect(service.findOne).toHaveBeenCalledTimes(1);
    });
  });

  describe('findVideosByCategoryId', () => {
    it('should return videos from a category', async () => {
      const result = await service.findVideoByCategory(categoriasStub[0].id);
      expect(result).toEqual(videosStub);
      expect(service.findVideoByCategory).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest
        .spyOn(service, 'findVideoByCategory')
        .mockRejectedValueOnce(new Error());
      expect(service.findVideoByCategory(1)).rejects.toThrowError();
      expect(service.findVideoByCategory).toHaveBeenCalledTimes(1);
    });
  });

  describe('update', () => {
    it('should return a updated category', async () => {
      const result = await service.update(
        categoriasStub[0].id,
        categoriasStub[0],
      );
      expect(result).toEqual(categoriasStub[0]);
      expect(service.update).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'update').mockRejectedValueOnce(new Error());
      expect(service.update(1, categoriasStub[0])).rejects.toThrowError();
      expect(service.update).toHaveBeenCalledTimes(1);
    });
  });

  describe('remove', () => {
    it('should return a removed category', async () => {
      const result = await service.remove(categoriasStub[0].id);
      expect(result).toEqual(categoriasStub[0]);
      expect(service.remove).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'remove').mockRejectedValueOnce(new Error());
      expect(service.remove(1)).rejects.toThrowError();
      expect(service.remove).toHaveBeenCalledTimes(1);
    });
  });
});
Enter fullscreen mode Exit fullscreen mode

Passou todos os testes? vamos para o próximo!

Testando nosso videos.controller 

npm run test:watch -t /home/gabriel/Documentos/alura-challenges-2/src/videos/videos.controller.spec.ts

# substitua essa parte '/home/gabriel/Documentos' pelo caminho do seu computador, é claro.
Enter fullscreen mode Exit fullscreen mode

A ideia é a mesma para cá, então, esse arquivo fica assim:

// src/videos/videos.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { VideosController } from './videos.controller';
import { VideosService } from './videos.service';
import { videosStub } from '../common/test/videos.stub';

describe('VideosController', () => {
  let controller: VideosController;
  let service: VideosService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [VideosController],
      providers: [
        VideosService,
        {
          provide: VideosService,
          useValue: {
            create: jest.fn().mockResolvedValue(videosStub[0]),
            findAll: jest.fn().mockResolvedValue(videosStub),
            findOne: jest.fn().mockResolvedValue(videosStub[0]),
            update: jest.fn().mockResolvedValue(videosStub[0]),
            remove: jest.fn().mockResolvedValue(videosStub[0]),
          },
        },
      ],
    }).compile();

    controller = module.get<VideosController>(VideosController);
    service = module.get<VideosService>(VideosService);
  });

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

  describe('create', () => {
    it('should create a video', async () => {
      const result = await service.create(videosStub[0]);
      expect(result).toEqual(videosStub[0]);
      expect(service.create).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'create').mockRejectedValueOnce(new Error());
      expect(service.create(videosStub[0])).rejects.toThrowError();
      expect(service.create).toHaveBeenCalledTimes(1);
    });
  });

  describe('findAll', () => {
    it('should return a video list', async () => {
      const result = await service.findAll();
      expect(result).toEqual(videosStub);
      expect(service.findAll).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'findAll').mockRejectedValueOnce(new Error());
      expect(service.findAll()).rejects.toThrowError();
      expect(service.findAll).toHaveBeenCalledTimes(1);
    });
  });

  describe('findOne', () => {
    it('should return a video', async () => {
      const result = await service.findOne(videosStub[0].id);
      expect(result).toEqual(videosStub[0]);
      expect(service.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'findOne').mockRejectedValueOnce(new Error());
      expect(service.findOne(1)).rejects.toThrowError();
      expect(service.findOne).toHaveBeenCalledTimes(1);
    });
  });

  describe('update', () => {
    it('should return a updated video', async () => {
      const result = await service.update(videosStub[0].id, videosStub[0]);
      expect(result).toEqual(videosStub[0]);
      expect(service.update).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'update').mockRejectedValueOnce(new Error());
      expect(service.update(1, videosStub[0])).rejects.toThrowError();
      expect(service.update).toHaveBeenCalledTimes(1);
    });
  });

  describe('remove', () => {
    it('should return a removed video', async () => {
      const result = await service.remove(videosStub[0].id);
      expect(result).toEqual(videosStub[0]);
      expect(service.remove).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(service, 'remove').mockRejectedValueOnce(new Error());
      expect(service.remove(1)).rejects.toThrowError();
      expect(service.remove).toHaveBeenCalledTimes(1);
    });
  });
});
Enter fullscreen mode Exit fullscreen mode

Testes dos controllers ok, vamos para os services.

Testando os services

Sem muitas mudanças para cá também, faremos o mesmo que nos controllers, exceto pelo fato de que a dependência deixa de ser o serviço (óbvio, pois estamos no serviço rs) e passa a ser o nosso repository.
Trecho para prestar atenção:

// src/categorias/categorias.service.spec.ts

...

beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        CategoriasService,
        {
          provide: getRepositoryToken(Categoria),
          useValue: {
            save: jest.fn().mockResolvedValue(categoriasStub[0]),
            find: jest.fn().mockResolvedValue(categoriasStub),
            findOne: jest.fn().mockResolvedValue(categoriasStub[0]),
            update: jest.fn().mockResolvedValue(categoriasStub[0]),
            remove: jest.fn().mockResolvedValue(categoriasStub[0]),
          },
        },
      ],
    }).compile();

    service = module.get<CategoriasService>(CategoriasService);
    repository = module.get(getRepositoryToken(Categoria));
  });

...
Enter fullscreen mode Exit fullscreen mode

Dada a devida atenção para o que muda dos controllers, vamos para as implementações dos services.

Testando nosso categorias.service 

npm run test:watch -t /home/gabriel/Documentos/alura-challenges-2/src/categorias/categorias.service.spec.ts

# substitua essa parte '/home/gabriel/Documentos' pelo caminho do seu computador, é claro.
Enter fullscreen mode Exit fullscreen mode

O código para testar nosso service de categorias ficará assim:

// src/categorias/categorias.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { CategoriasService } from './categorias.service';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Categoria } from './entities/categoria.entity';
import { categoriasStub } from '../common/test/categorias.stub';
import { Repository } from 'typeorm';

describe('CategoriasService', () => {
  let service: CategoriasService;
  let repository: Repository<Categoria>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        CategoriasService,
        {
          provide: getRepositoryToken(Categoria),
          useValue: {
            save: jest.fn().mockResolvedValue(categoriasStub[0]),
            find: jest.fn().mockResolvedValue(categoriasStub),
            findOne: jest.fn().mockResolvedValue(categoriasStub[0]),
            update: jest.fn().mockResolvedValue(categoriasStub[0]),
            remove: jest.fn().mockResolvedValue(categoriasStub[0]),
          },
        },
      ],
    }).compile();

    service = module.get<CategoriasService>(CategoriasService);
    repository = module.get(getRepositoryToken(Categoria));
  });

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

  describe('save', () => {
    it('should create a category', async () => {
      const newCategory: Omit<Categoria, 'id'> = categoriasStub[0];

      const result = await service.create(newCategory);

      expect(result).toEqual(categoriasStub[0]);
      expect(repository.save).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'save').mockRejectedValueOnce(new Error());
      expect(service.create(categoriasStub[0])).rejects.toThrowError();
      expect(repository.save).toHaveBeenCalledTimes(1);
    });
  });

  describe('findAll', () => {
    it('should return a categories list', async () => {
      const result = await service.findAll();
      expect(result).toEqual(categoriasStub);
      expect(repository.find).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'find').mockRejectedValueOnce(new Error());
      expect(service.findAll()).rejects.toThrowError();
      expect(repository.find).toHaveBeenCalledTimes(1);
    });
  });

  describe('findOne', () => {
    it('should return a category', async () => {
      const result = await service.findOne(categoriasStub[0].id);
      expect(result).toEqual(categoriasStub[0]);
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'findOne').mockRejectedValueOnce(new Error());
      expect(service.findOne(1)).rejects.toThrowError();
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });
  });

  describe('update', () => {
    it('should return a updated category', async () => {
      const result = await service.update(
        categoriasStub[0].id,
        categoriasStub[0],
      );
      expect(result).toEqual(categoriasStub[0]);
      expect(repository.update).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'update').mockRejectedValueOnce(new Error());
      expect(service.update(1, categoriasStub[0])).rejects.toThrowError();
      expect(repository.update).toHaveBeenCalledTimes(1);
    });
  });

  describe('remove', () => {
    it('should return a removed category', async () => {
      const result = await service.remove(categoriasStub[0].id);
      expect(result).toEqual(categoriasStub[0]);
      expect(repository.remove).toHaveBeenCalledTimes(1);
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'remove').mockRejectedValueOnce(new Error());
      expect(service.remove(1)).rejects.toThrowError();
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });
  });
});
Enter fullscreen mode Exit fullscreen mode

Testando nosso videos.service

E para o nossos testes do service de videos:

npm run test:watch -t /home/gabriel/Documentos/alura-challenges-2/src/videos/videos.service.spec.ts

# substitua essa parte '/home/gabriel/Documentos' pelo caminho do seu computador, é claro.
Enter fullscreen mode Exit fullscreen mode 
// src/videos/videos.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { videosStub } from '../common/test/videos.stub';
import { Video } from './entities/video.entity';
import { VideosService } from './videos.service';

describe('VideosService', () => {
  let service: VideosService;
  let repository: Repository<Video>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        VideosService,
        {
          provide: getRepositoryToken(Video),
          useValue: {
            save: jest.fn().mockResolvedValue(videosStub[0]),
            find: jest.fn().mockResolvedValue(videosStub),
            findOne: jest.fn().mockResolvedValue(videosStub[0]),
            update: jest.fn().mockResolvedValue(videosStub[0]),
            remove: jest.fn().mockResolvedValue(videosStub[0]),
          },
        },
      ],
    }).compile();

    service = module.get<VideosService>(VideosService);
    repository = module.get(getRepositoryToken(Video));
  });

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

  describe('save', () => {
    const newVideo: Omit<Video, 'id'> = videosStub[0];

    it('should create a video', async () => {
      const result = await service.create(newVideo);
      expect(result).toEqual(videosStub[0]);
      expect(repository.save).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'save').mockRejectedValueOnce(new Error());
      expect(service.create(videosStub[0])).rejects.toThrowError();
      expect(repository.save).toHaveBeenCalledTimes(1);
    });
  });

  describe('findAll', () => {
    it('should return a videos list if search is not informed', async () => {
      const result = await service.findAll();
      expect(result).toEqual(videosStub);
      expect(repository.find).toHaveBeenCalledTimes(1);
    });

    it('should return a videos list if search is informed', async () => {
      //Arrange
      const expectedResult = videosStub.filter((video) =>
        video.titulo?.includes('teste'),
      );
      jest.spyOn(repository, 'find').mockResolvedValue(expectedResult);

      //Act
      const result = await service.findAll('teste');

      //Assert
      expect(result).toEqual([]);
      expect(repository.find).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'find').mockRejectedValueOnce(new Error());
      expect(service.findAll()).rejects.toThrowError();
      expect(repository.find).toHaveBeenCalledTimes(1);
    });
  });

  describe('findOne', () => {
    it('should return a video', async () => {
      const result = await service.findOne(videosStub[0].id);
      expect(result).toEqual(videosStub[0]);
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'findOne').mockRejectedValueOnce(new Error());
      expect(service.findOne(1)).rejects.toThrowError();
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });
  });

  describe('update', () => {
    it('should return a updated video', async () => {
      const result = await service.update(videosStub[0].id, videosStub[0]);
      expect(result).toEqual(videosStub[0]);
      expect(repository.update).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'update').mockRejectedValueOnce(new Error());
      expect(service.update(1, videosStub[0])).rejects.toThrowError();
      expect(repository.update).toHaveBeenCalledTimes(1);
    });
  });

  describe('remove', () => {
    it('should return a removed video', async () => {
      const result = await service.remove(videosStub[0].id);
      expect(result).toEqual(videosStub[0]);
      expect(repository.remove).toHaveBeenCalledTimes(1);
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });

    it('should throw an exception', () => {
      jest.spyOn(repository, 'remove').mockRejectedValueOnce(new Error());
      expect(service.remove(1)).rejects.toThrowError();
      expect(repository.findOne).toHaveBeenCalledTimes(1);
    });
  });
});
Enter fullscreen mode Exit fullscreen mode

E com isso, fechamos as implementações da segunda semana.

Aaaah, estou fazendo meus commits conforme vou implementando as coisas... (Padronizadinho, conforme configuramos no início)
Está lá no meu Github.

Abraços e até a próxima semana!

Top comments (0)

Read next

aelassas profile image

Functional Programming in TypeScript

aelassas -

naveedahmed profile image

Incremental Hydration in Angular 19: Take Your App’s Performance to the Next Level

Naveed Ahmed -

nlea profile image

Handling Asynchronous Tasks in Cloudflare Workers – Part 1: Essentials for a Single Worker

Nele Lea -

turingvangisms profile image

property 'target' does not exist on type 'HTMLInputElement'

Turing -