Merge remote-tracking branch 'origin/main'

Author: MartinBraquet

backend/api/tests/unit/ban-user.unit.test.ts

@@ -11,8 +11,7 @@ import { throwErrorIfNotMod } from "shared/helpers/auth";
 import * as constants from "common/envs/constants";
 import * as supabaseUsers from "shared/supabase/users";
 import * as sharedAnalytics from "shared/analytics";
-import {  } from "shared/helpers/auth";
-import { APIError, AuthedUser } from "api/helpers/endpoint"
+import { AuthedUser } from "api/helpers/endpoint"
 
 
 describe('banUser', () => {
@@ -24,13 +23,13 @@ describe('banUser', () => {
         (supabaseInit.createSupabaseDirectClient as jest.Mock)
             .mockReturnValue(mockPg);
     });
-    
     afterEach(() => {
         jest.restoreAllMocks();
     });
 
-    describe('should', () => {
-        it('ban a user successfully', async () => {
+
+    describe('when given valid input', () => {
+        it('should ban a user successfully', async () => {
             const mockUser = {
                 userId: '123',
                 unban: false
@@ -42,15 +41,25 @@ describe('banUser', () => {
 
             await banUser(mockUser, mockAuth, mockReq);
 
+            expect(throwErrorIfNotMod).toBeCalledTimes(1);
             expect(throwErrorIfNotMod).toBeCalledWith(mockAuth.uid);
+            expect(constants.isAdminId).toBeCalledTimes(1);
             expect(constants.isAdminId).toBeCalledWith(mockUser.userId);
-            expect(sharedAnalytics.trackPublicEvent)
-                .toBeCalledWith(mockAuth.uid, 'ban user', {userId: mockUser.userId});
-            expect(supabaseUsers.updateUser)
-                .toBeCalledWith(mockPg, mockUser.userId, {isBannedFromPosting: true});
+            expect(sharedAnalytics.trackPublicEvent).toBeCalledTimes(1);
+            expect(sharedAnalytics.trackPublicEvent).toBeCalledWith(
+                mockAuth.uid, 
+                'ban user',
+                {userId: mockUser.userId}
+            );
+            expect(supabaseUsers.updateUser).toBeCalledTimes(1);
+            expect(supabaseUsers.updateUser).toBeCalledWith(
+                mockPg,
+                mockUser.userId,
+                {isBannedFromPosting: true}
+            );
         });
 
-        it('unban a user successfully', async () => {
+        it('should unban a user successfully', async () => {
             const mockUser = {
                 userId: '123',
                 unban: true
@@ -64,13 +73,20 @@ describe('banUser', () => {
 
             expect(throwErrorIfNotMod).toBeCalledWith(mockAuth.uid);
             expect(constants.isAdminId).toBeCalledWith(mockUser.userId);
-            expect(sharedAnalytics.trackPublicEvent)
-                .toBeCalledWith(mockAuth.uid, 'ban user', {userId: mockUser.userId});
-            expect(supabaseUsers.updateUser)
-                .toBeCalledWith(mockPg, mockUser.userId, {isBannedFromPosting: false});
+            expect(sharedAnalytics.trackPublicEvent).toBeCalledWith(
+                mockAuth.uid,
+                'ban user',
+                {userId: mockUser.userId}
+            );
+            expect(supabaseUsers.updateUser).toBeCalledWith(
+                mockPg,
+                mockUser.userId,
+                {isBannedFromPosting: false}
+            );
         });
-
-        it('throw and error if the ban requester is not a mod or admin', async () => {
+    });
+    describe('when an error occurs', () => {
+        it('throw if the ban requester is not a mod or admin', async () => {
             const mockUser = {
                 userId: '123',
                 unban: false
@@ -79,21 +95,16 @@ describe('banUser', () => {
             const mockReq = {} as any;
 
             (throwErrorIfNotMod as jest.Mock).mockRejectedValue(
-                new APIError(
-                    403,
-                    `User ${mockAuth.uid} must be an admin or trusted to perform this action.`
-                )
+                new Error(`User ${mockAuth.uid} must be an admin or trusted to perform this action.`)
             );
 
             await expect(banUser(mockUser, mockAuth, mockReq))
                 .rejects
                 .toThrowError(`User ${mockAuth.uid} must be an admin or trusted to perform this action.`);
             expect(throwErrorIfNotMod).toBeCalledWith(mockAuth.uid);
-            expect(sharedAnalytics.trackPublicEvent).toBeCalledTimes(0);
-            expect(supabaseUsers.updateUser).toBeCalledTimes(0);
         });
 
-        it('throw an error if the ban target is an admin', async () => {
+        it('throw if the ban target is an admin', async () => {
             const mockUser = {
                 userId: '123',
                 unban: false
@@ -108,8 +119,6 @@ describe('banUser', () => {
                 .toThrowError('Cannot ban admin');
             expect(throwErrorIfNotMod).toBeCalledWith(mockAuth.uid);
             expect(constants.isAdminId).toBeCalledWith(mockUser.userId);
-            expect(sharedAnalytics.trackPublicEvent).toBeCalledTimes(0);
-            expect(supabaseUsers.updateUser).toBeCalledTimes(0);
         });
     });
 });

backend/api/tests/unit/block-user.unit.test.ts

@@ -23,50 +23,45 @@ describe('blockUser', () => {
         (supabaseInit.createSupabaseDirectClient as jest.Mock)
             .mockReturnValue(mockPg)
     });
-
     afterEach(() => {
         jest.restoreAllMocks();
     });
 
-    describe('should', () => {
+    describe('when given valid input', () => {
         it('block the user successfully', async () => {
             const mockParams = { id: '123' }
             const mockAuth = {uid: '321'} as AuthedUser;
             const mockReq = {} as any;
 
-            (supabaseUsers.updatePrivateUser as jest.Mock).mockResolvedValue(null);
-
             await blockUserModule.blockUser(mockParams, mockAuth, mockReq)
 
-            expect(mockPg.tx).toHaveBeenCalledTimes(1)
-
-            expect(supabaseUsers.updatePrivateUser)
-                .toHaveBeenCalledWith(
-                    expect.any(Object),
-                    mockAuth.uid,
-                    { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockParams.id)}
-                );
-            expect(supabaseUsers.updatePrivateUser)
-                .toHaveBeenCalledWith(
-                    expect.any(Object),
-                    mockParams.id,
-                    { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockAuth.uid)}
-                );
+            expect(mockPg.tx).toHaveBeenCalledTimes(1);
+            expect(supabaseUsers.updatePrivateUser).toBeCalledTimes(2);
+            expect(supabaseUsers.updatePrivateUser).toHaveBeenNthCalledWith(
+                1,
+                expect.any(Object),
+                mockAuth.uid,
+                { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockParams.id)}
+            );
+            expect(supabaseUsers.updatePrivateUser).toHaveBeenNthCalledWith(
+                2,
+                expect.any(Object),
+                mockParams.id,
+                { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockAuth.uid)}
+            );
         });
-
+    });
+    describe('when an error occurs', () => {
         it('throw an error if the user tries to block themselves', async () => {
             const mockParams = { id: '123' }
             const mockAuth = {uid: '123'} as AuthedUser;
             const mockReq = {} as any;
 
             expect(blockUserModule.blockUser(mockParams, mockAuth, mockReq))
                 .rejects
-                .toThrowError('You cannot block yourself')
-
-            expect(mockPg.tx).toHaveBeenCalledTimes(0)
+                .toThrowError('You cannot block yourself');
         });
     });
-
 });
 
 describe('unblockUser', () => {
@@ -84,35 +79,32 @@ describe('unblockUser', () => {
         (supabaseInit.createSupabaseDirectClient as jest.Mock)
             .mockReturnValue(mockPg)
     });
-
     afterEach(() => {
         jest.restoreAllMocks();
     });
 
-    describe('should', () => {
-        it('block the user successfully', async () => {
+    describe('when given valid input', () => {
+        it('should block the user successfully', async () => {
             const mockParams = { id: '123' }
             const mockAuth = {uid: '321'} as AuthedUser;
             const mockReq = {} as any;
 
-            (supabaseUsers.updatePrivateUser as jest.Mock).mockResolvedValue(null);
-
             await blockUserModule.unblockUser(mockParams, mockAuth, mockReq)
 
-            expect(mockPg.tx).toHaveBeenCalledTimes(1)
-
-            expect(supabaseUsers.updatePrivateUser)
-                .toHaveBeenCalledWith(
-                    expect.any(Object),
-                    mockAuth.uid,
-                    { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockParams.id)}
-                );
-            expect(supabaseUsers.updatePrivateUser)
-                .toHaveBeenCalledWith(
-                    expect.any(Object),
-                    mockParams.id,
-                    { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockAuth.uid)}
-                );
+            expect(mockPg.tx).toHaveBeenCalledTimes(1);
+            expect(supabaseUsers.updatePrivateUser).toBeCalledTimes(2);
+            expect(supabaseUsers.updatePrivateUser).toHaveBeenNthCalledWith(
+                1,
+                expect.any(Object),
+                mockAuth.uid,
+                { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockParams.id)}
+            );
+            expect(supabaseUsers.updatePrivateUser).toHaveBeenNthCalledWith(
+                2,
+                expect.any(Object),
+                mockParams.id,
+                { blockedByUserIds: supabaseUtils.FieldVal.arrayConcat(mockAuth.uid)}
+            );
         });
     });
 

backend/api/tests/unit/compatible-profiles.unit.test.ts

@@ -1,32 +1,41 @@
-import * as supabaseInit from "shared/supabase/init";
+jest.mock('shared/supabase/init');
+
 import {getCompatibleProfiles} from "api/compatible-profiles";
+import * as supabaseInit from "shared/supabase/init";
 
-jest.mock('shared/supabase/init')
 
 describe('getCompatibleProfiles', () => {
+  let mockPg = {} as any;
   beforeEach(() => {
     jest.resetAllMocks();
-    const mockPg = {
-      none: jest.fn().mockResolvedValue(null),
-      one: jest.fn().mockResolvedValue(null),
-      oneOrNone: jest.fn().mockResolvedValue(null),
-      any: jest.fn().mockResolvedValue([]),
-      map: jest.fn().mockResolvedValue([["abc", {score: 0.69}]]),
-    } as any;
+    mockPg = {
+      map: jest.fn().mockResolvedValue([]),
+    };
     (supabaseInit.createSupabaseDirectClient as jest.Mock)
       .mockReturnValue(mockPg);
   });
-
   afterEach(() => {
     jest.restoreAllMocks();
   });
 
-  describe('should', () => {
-    it('successfully get compatible profiles when supplied with a valid user Id', async () => {
-      const results = await getCompatibleProfiles("123");
+  describe('when given valid input', () => {
+    it('should successfully get compatible profiles', async () => {
+      const mockProps = '123';
+      const mockScores = ["abc", { score: 0.69 }];
+      const mockScoresFromEntries = {"abc": { score: 0.69 }};
+
+      (mockPg.map as jest.Mock).mockResolvedValue([mockScores]);
+
+      const results = await getCompatibleProfiles(mockProps);
+      const [sql, param, fn] = mockPg.map.mock.calls[0];
+      
       expect(results.status).toEqual('success');
-      expect(results.profileCompatibilityScores).toEqual({"abc": {score: 0.69}});
+      expect(results.profileCompatibilityScores).toEqual(mockScoresFromEntries);
+      expect(mockPg.map).toBeCalledTimes(1);
+      expect(sql).toContain('select *');
+      expect(sql).toContain('from compatibility_scores');
+      expect(param).toStrictEqual([mockProps]);
+      expect(fn).toEqual(expect.any(Function));
     });
-
   });
 });