Authentication favorites

src/auth/casl/casl-ability.factory.ts

@@ -9,13 +9,13 @@ import { Injectable } from '@nestjs/common';
 import { Permission } from '../enums/permission.enum';
 import { User } from '../../users/entities/user.entity';
 import { FlatClass } from '../types/flat-class.type';
+import { Favorite } from '../../favorites/entities/favorite.entity';
 import { History } from '../../history/models/history.entity';
 import { Cart } from '../../cart/entities/cart.entity';
 import { CustomMessage } from '../../custom-messages/entities/custom-messages.entity';
 import { Item } from '../../items/entities/items.entity';
-
 // TODO: add classes to InferSubjects -> InferSubjects<typeof Item | typeof Review ...>
-type Subjects = InferSubjects<typeof Item | typeof Cart | typeof CustomMessage | typeof History> | 'all';
+type Subjects = InferSubjects<typeof Item | typeof Cart | typeof CustomMessage | typeof History | typeof Favorite> | 'all';
 
 export type AppAbility = Ability<[Permission, Subjects]>;
 
@@ -38,6 +38,14 @@ export class CaslAbilityFactory {
       'user.id': user.id,
     });
 
+    can<FlatClass<Favorite>>([
+      Permission.Read, 
+      Permission.Create, 
+      Permission.Delete
+    ], Favorite, {
+      'user.id': user.id,
+    });
+
     can<FlatClass<CustomMessage>>(
       [Permission.Read, Permission.Delete, Permission.Update],
       CustomMessage,

src/favorites/controllers/favorites.controller.spec.ts

@@ -1,25 +1,57 @@
+import {
+  ForbiddenException,
+  NotFoundException,
+} from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
+import { plainToClass } from 'class-transformer';
+import { CaslModule } from '../../auth/casl/casl.module';
+import STATUS from '../../statusCodes/statusCodes';
+import { User } from '../../users/entities/user.entity';
+import { CreateFavoriteDto } from '../dto/create-favorite.dto';
+import { Favorite } from '../entities/favorite.entity';
 import { FavoritesService } from '../services/favorites.service';
 import { FavoritesController } from './favorites.controller';
 
 describe('FavoritesController', () => {
   let controller: FavoritesController;
 
+  const user: User = new User();
+  user.id = 1;
+
   const mockFavoriteService = {
-    paginate: jest.fn(),
-    create: jest.fn(dto => {
-      return {
-        ...dto,
-        user_id: 24
-      }
+    paginate: jest.fn().mockResolvedValue([
+      {
+        id: 1,
+        user: 1,
+        item_id: 1,
+        createdAt: new Date(),
+      },
+    ]),
+    create: jest.fn((user: User, body: CreateFavoriteDto) => {
+      Promise.resolve({
+        item_id: 1,
+      });
     }),
-    delete: jest.fn()
-  }
+    delete: jest.fn(),
+    findFavorite: jest.fn().mockImplementation((id) =>
+      Promise.resolve(
+        plainToClass(Favorite, {
+          user: user,
+          id: id,
+        }),
+      ),
+    ),
+  };
+
+  const response: any = {
+    user: new User(),
+  };
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [FavoritesController],
-      providers: [FavoritesService]
+      providers: [FavoritesService],
+      imports: [CaslModule],
     })
       .overrideProvider(FavoritesService)
       .useValue(mockFavoriteService)
@@ -32,28 +64,77 @@ describe('FavoritesController', () => {
     expect(controller).toBeDefined();
   });
 
-  it('should get 10 favorites records.', () => {
-    const page = 1
-    const limit = 10
-    const token = 1
-    expect(controller.paginate(token, page, limit)).not.toBeUndefined()
-    expect(mockFavoriteService.paginate).toHaveBeenCalled()
-  })
-
-  it('should create a favorite.', () => {
-    const data = { item_id: 61 }
-    const token = 1
-    expect(controller.create(token, data)).toEqual({
-      "message": "Created",
-      "statusCode": 201,
+  describe('paginate', () => {
+    it('should get 10 favorites records.', async () => {
+      const page = 1;
+      const limit = 10;
+      const route = '/favorites';
+
+      const user: User = new User();
+      user.id = 1;
+
+      await expect(controller.paginate(response, page, limit)).resolves.toEqual(
+        [
+          {
+            id: 1,
+            user: 1,
+            item_id: 1,
+            createdAt: expect.any(Date),
+          },
+        ],
+      );
+
+      expect(mockFavoriteService.paginate).toHaveBeenCalledWith(
+        { page, limit, route },
+        response.user,
+      );
+    });
+  });
+
+  describe('create', () => {
+    it('should create a favorite.', async () => {
+      const mockUser = new User();
+      mockUser.id = 1;
+
+      const request: any = {
+        user: mockUser,
+      };
+      request.user.id = 1;
+
+      const dto: CreateFavoriteDto = {
+        itemId: 1,
+      };
+
+      expect(await controller.create(request, dto)).toEqual(STATUS.CREATED);
+
+      expect(mockFavoriteService.create).toHaveBeenCalledWith(
+        dto,
+        request.user,
+      );
     });
-    expect(mockFavoriteService.create).toHaveBeenCalledWith(data, token)
   });
 
-  it('should delete a favorite.', () => {
-    const okResponse = { "message": "Ok", "statusCode": 200}
-    const favoriteId = 1
-    expect(controller.delete(favoriteId)).toStrictEqual(okResponse)
-    expect(mockFavoriteService.delete).toHaveBeenCalledWith(favoriteId)
-  })
+  describe('delete', () => {
+    it('should delete a favorite.', async () => {
+      const request: any = {
+        user: user,
+      };
+
+      expect(await controller.delete(request, 1)).toEqual(STATUS.DELETED);
+    });
+
+    it('should return a ForbiddenException', async () => {
+      await expect(controller.delete(response, 1)).rejects.toThrowError(
+        ForbiddenException,
+      );
+    });
+
+    it('should return a NotFoundException', async () => {
+      mockFavoriteService.findFavorite.mockRejectedValueOnce(new NotFoundException());
+
+      await expect(controller.delete(response, 1)).rejects.toThrowError(
+        NotFoundException,
+      );
+    });
+  });
 });