music-collection/backend/src/album/album.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { getRepositoryToken } from '@nestjs/typeorm';
import { AlbumController } from './album.controller';
import { AlbumService } from './album.service';
import { Album } from './album.entity';
import { CreateAlbumDto } from './dto/create-album.dto';
import { UpdateAlbumDto } from './dto/update-album.dto';
import { DeleteResult, Repository } from 'typeorm';

const mockAlbum = new Album();
const mockCreateAlbumDto = new CreateAlbumDto();
const mockUpdateAlbumDto = new UpdateAlbumDto();
const mockDeleteResult = new DeleteResult();

describe('AlbumController', () => {
  let controller: AlbumController;
  let service: AlbumService;
  let repository: Repository<Album>;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [AlbumController],
      providers: [
        AlbumService,
        {
          provide: getRepositoryToken(Album),
          useValue: {
            find: jest.fn().mockResolvedValue([mockAlbum]),
            findOne: jest.fn().mockResolvedValue(mockAlbum),
            findOneBy: jest.fn().mockResolvedValue({ id: 1, title: 'some album', artist: 'some artist', genre: 'some genre' }),
            create: jest.fn().mockResolvedValue(mockAlbum),
            save: jest.fn().mockResolvedValue({ id: 1, title: 'some album', artist: 'some artist', genre: 'some genre' }),
            update: jest.fn().mockResolvedValue(mockAlbum),
            delete: jest.fn().mockResolvedValue(mockDeleteResult),
          },
        },
      ]
    }).compile();

    controller = module.get<AlbumController>(AlbumController);
    service = module.get<AlbumService>(AlbumService);
    repository = module.get<Repository<Album>>(getRepositoryToken(Album));
  });

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

  describe('findAll', () => {
    it('should return an array of Albums', async () => {
      expect(await controller.findAll()).toStrictEqual([mockAlbum]);
    })
  })

  describe('findOneById', () => {
    it('should return an Album', async () => {
      expect(await controller.findOneById(1)).toStrictEqual(mockAlbum);
    })
  })

  describe('create', () => {
    it('should return the Album ID', async () => {
      expect(await controller.create(mockCreateAlbumDto)).toStrictEqual(mockAlbum);
    })
  })

  describe('update', () => {
    it('should return the success message', async () => {
      mockUpdateAlbumDto.id = 1;
      expect(await controller.update(1, mockUpdateAlbumDto)).toStrictEqual(mockAlbum);
    })
  })

  describe('remove', () => {
    it('should return a DeleteResult', async () => {
      expect(await controller.remove(1)).toStrictEqual(mockDeleteResult);
    })
  })
});