More tests, more debugging

backend/src/album/album.service.spec.ts

@@ -2,11 +2,18 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { getRepositoryToken } from '@nestjs/typeorm';
 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('AlbumService', () => {
   let service: AlbumService;
+  let repository: Repository<Album>;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
@@ -15,20 +22,54 @@ describe('AlbumService', () => {
         {
           provide: getRepositoryToken(Album),
           useValue: {
-            findAll: jest.fn().mockResolvedValue([mockAlbum]),
+            find: jest.fn().mockResolvedValue([mockAlbum]),
-            findOneById: jest.fn().mockResolvedValue(mockAlbum),
+            findOne: jest.fn().mockResolvedValue(mockAlbum),
-            create: jest.fn().mockResolvedValue(1),
+            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("Album updated successfully"),
-            remove: jest.fn().mockResolvedValue(null),
+            delete: jest.fn().mockResolvedValue(mockDeleteResult),
           },
         },
       ]
     }).compile();
 
     service = module.get<AlbumService>(AlbumService);
+    repository = module.get<Repository<Album>>(getRepositoryToken(Album));
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
+
+  describe('findAll', () => {
+    it('should return an array of Albums', async () => {
+      expect(await service.findAll()).toStrictEqual([mockAlbum]);
+    })
+  })
+
+  describe('findOneById', () => {
+    it('should return an Album', async () => {
+      expect(await service.findOneById(1)).toStrictEqual(mockAlbum);
+    })
+  })
+
+  describe('create', () => {
+    it('should return the Album ID', async () => {
+      expect(await service.create(mockCreateAlbumDto)).toStrictEqual(1);
+    })
+  })
+
+  describe('update', () => {
+    it('should return the success message', async () => {
+      mockUpdateAlbumDto.id = 1;
+      expect(await service.update(1, mockUpdateAlbumDto)).toStrictEqual("Album updated successfully");
+    })
+  })
+
+  describe('remove', () => {
+    it('should return a DeleteResult', async () => {
+      expect(await service.remove(1)).toStrictEqual(mockDeleteResult);
+    })
+  })
 });

frontend/src/app/album/page.tsx

@@ -42,10 +42,10 @@ export default function Page() {
       console.log(formData);
       if (formData.get('id') === "") {
         const data = await createAlbum(formData);
-        console.log(data);
+        console.log("Created Album", data);
       } else {
         const data = await updateAlbum(formData);
-        console.log(data);
+        console.log("Updated Album", data);
       }
     } catch (error) {
       console.error("Error creating Album: ", error);