Reworking api responses

backend/src/album/album.controller.spec.ts

@@ -30,7 +30,7 @@ describe('AlbumController', () => {
             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"),
+            update: jest.fn().mockResolvedValue(mockAlbum),
             delete: jest.fn().mockResolvedValue(mockDeleteResult),
           },
         },
@@ -60,14 +60,14 @@ describe('AlbumController', () => {
 
   describe('create', () => {
     it('should return the Album ID', async () => {
-      expect(await controller.create(mockCreateAlbumDto)).toStrictEqual(1);
+      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("Album updated successfully");
+      expect(await controller.update(1, mockUpdateAlbumDto)).toStrictEqual(mockAlbum);
     })
   })
 

backend/src/album/album.controller.ts

@@ -22,13 +22,13 @@ export class AlbumController {
 
   @Post()
   @UsePipes(new ValidationPipe({ transform: true }))
-  async create(@Body() createAlbumDto: CreateAlbumDto): Promise<number> {
+  async create(@Body() createAlbumDto: CreateAlbumDto): Promise<Album | null> {
     return this.albumService.create(createAlbumDto);
   }
 
   @Put(':id')
   @UsePipes(new ValidationPipe({ transform: true }))
-  async update(@Param('id') id: number, @Body() updateAlbumDto: UpdateAlbumDto): Promise<string> {
+  async update(@Param('id') id: number, @Body() updateAlbumDto: UpdateAlbumDto): Promise<Album | null> {
     return this.albumService.update(id, updateAlbumDto);
   }
 

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

@@ -27,7 +27,7 @@ describe('AlbumService', () => {
             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"),
+            update: jest.fn().mockResolvedValue(mockAlbum),
             delete: jest.fn().mockResolvedValue(mockDeleteResult),
           },
         },
@@ -56,14 +56,14 @@ describe('AlbumService', () => {
 
   describe('create', () => {
     it('should return the Album ID', async () => {
-      expect(await service.create(mockCreateAlbumDto)).toStrictEqual(1);
+      expect(await service.create(mockCreateAlbumDto)).toStrictEqual(mockAlbum);
     })
   })
 
   describe('update', () => {
     it('should return the success message', async () => {
       mockUpdateAlbumDto.id = 1;
-      expect(await service.update(1, mockUpdateAlbumDto)).toStrictEqual("Album updated successfully");
+      expect(await service.update(1, mockUpdateAlbumDto)).toStrictEqual(mockAlbum);
     })
   })
 

backend/src/album/album.service.ts

@@ -32,30 +32,30 @@ export class AlbumService {
     });
   }
 
-  async create(createAlbumDto: CreateAlbumDto): Promise<number> {
+  async create(createAlbumDto: CreateAlbumDto): Promise<Album | null> {
     const album = this.albumRepository.create({
       title: createAlbumDto.title,
       artist: createAlbumDto.artist,
       genre: createAlbumDto.genre
     });
     const savedAlbum = await this.albumRepository.save(album);
-    return savedAlbum.id;
+    return savedAlbum;
   }
 
-  async update(id: number, updateAlbumDto: UpdateAlbumDto): Promise<string> {
+  async update(id: number, updateAlbumDto: UpdateAlbumDto): Promise<Album | null> {
     if (id === updateAlbumDto.id) {
       const album = this.albumRepository.findOneBy({ id: updateAlbumDto.id });
       if (!album)
-        return "Album not found";
+        return null;
 
-      await this.albumRepository.update({ id: updateAlbumDto.id }, {
+      const savedAlbum = await this.albumRepository.update({ id: updateAlbumDto.id }, {
         title: updateAlbumDto.title,
         artist: updateAlbumDto.artist,
         genre: updateAlbumDto.genre
       });
-      return "Album updated successfully";
+      return savedAlbum;
     } else {
-      return "Album ID does not match posted data";
+      return null;
     }
   }
 

backend/src/song/song.controller.spec.ts

@@ -4,9 +4,15 @@ import { SongController } from './song.controller';
 import { SongService } from './song.service';
 import { Song } from './song.entity';
 import { Album } from '../album/album.entity';
+import { CreateSongDto } from './dto/create-song.dto';
+import { UpdateSongDto } from './dto/update-song.dto';
+import { DeleteResult, Repository } from 'typeorm';
 
 const mockSong = new Song();
 const mockAlbum = new Album();
+const mockCreateSongDto = new CreateSongDto();
+const mockUpdateSongDto = new UpdateSongDto();
+const mockDeleteResult = new DeleteResult();
 
 describe('SongController', () => {
   let controller: SongController;
@@ -19,21 +25,25 @@ describe('SongController', () => {
         {
           provide: getRepositoryToken(Song),
           useValue: {
-            findAll: jest.fn().mockResolvedValue([mockSong]),
-            findOneById: jest.fn().mockResolvedValue(mockSong),
-            create: jest.fn().mockResolvedValue(1),
-            update: jest.fn().mockResolvedValue("Song updated successfully"),
-            remove: jest.fn().mockResolvedValue(null),
+            find: jest.fn().mockResolvedValue([mockSong]),
+            findOne: jest.fn().mockResolvedValue(mockSong),
+            findOneBy: jest.fn().mockResolvedValue({ id: 3, title: 'some song', duration: 300, trackNumber: 2, album: mockAlbum }),
+            create: jest.fn().mockResolvedValue(mockAlbum),
+            save: jest.fn().mockResolvedValue({ id: 3, title: 'some song', duration: 300, trackNumber: 2, album: mockAlbum }),
+            update: jest.fn().mockResolvedValue(mockDSong),
+            delete: jest.fn().mockResolvedValue(mockDeleteResult),
           },
         },
         {
           provide: getRepositoryToken(Album),
           useValue: {
-            findAll: jest.fn().mockResolvedValue([mockAlbum]),
-            findOneById: jest.fn().mockResolvedValue(mockAlbum),
-            create: jest.fn().mockResolvedValue(1),
-            update: jest.fn().mockResolvedValue("Album updated successfully"),
-            remove: jest.fn().mockResolvedValue(null),
+            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),
           },
         },
       ]

frontend/src/app/album/page.tsx

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