Add backend API unit tests

.vscode/launch.json

@@ -0,0 +1,32 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+        "name": "Debug Jest Tests",
+        "type": "node",
+        "request": "launch",
+        "runtimeArgs": [
+            "--inspect-brk",
+            "${workspaceRoot}/node_modules/.bin/jest",
+            "--runInBand"
+        ],
+        "console": "integratedTerminal",
+        "internalConsoleOptions": "neverOpen"
+        }
+        // {
+        //     "type": "node",
+        //     "request": "launch",
+        //     "name": "Launch Program",
+        //     "skipFiles": [
+        //         "<node_internals>/**"
+        //     ],
+        //     "program": "${workspaceFolder}/backend/api/tests/unit/get-profiles.unit.test.ts",
+        //     "outFiles": [
+        //         "${workspaceFolder}/**/*.js"
+        //     ]
+        // }
+    ]
+}

backend/api/.eslintrc.js

@@ -13,7 +13,7 @@ module.exports = {
       parser: '@typescript-eslint/parser',
       parserOptions: {
         tsconfigRootDir: __dirname,
-        project: ['./tsconfig.json'],
+        project: ['./tsconfig.json', './tsconfig.test.json'],
       },
       rules: {
         '@typescript-eslint/ban-types': [

backend/api/README.md

@@ -168,3 +168,6 @@ docker rmi -f $(docker images -aq)
 ### Documentation
 
 The API doc is available at https://api.compassmeet.com. It's dynamically prepared in [app.ts](src/app.ts).
+
+### Todo (Tests)
+- [ ] Finish get-supabase-token unit test when endpoint is implemented

backend/api/src/get-profiles.ts

@@ -10,26 +10,26 @@ export type profileQueryType = {
   after?: string | undefined,
   // Search and filter parameters
   name?: string | undefined,
-  genders?: String[] | undefined,
-  education_levels?: String[] | undefined,
-  pref_gender?: String[] | undefined,
+  genders?: string[] | undefined,
+  education_levels?: string[] | undefined,
+  pref_gender?: string[] | undefined,
   pref_age_min?: number | undefined,
   pref_age_max?: number | undefined,
   drinks_min?: number | undefined,
   drinks_max?: number | undefined,
-  pref_relation_styles?: String[] | undefined,
-  pref_romantic_styles?: String[] | undefined,
-  diet?: String[] | undefined,
-  political_beliefs?: String[] | undefined,
-  mbti?: String[] | undefined,
-  relationship_status?: String[] | undefined,
-  languages?: String[] | undefined,
-  religion?: String[] | undefined,
+  pref_relation_styles?: string[] | undefined,
+  pref_romantic_styles?: string[] | undefined,
+  diet?: string[] | undefined,
+  political_beliefs?: string[] | undefined,
+  mbti?: string[] | undefined,
+  relationship_status?: string[] | undefined,
+  languages?: string[] | undefined,
+  religion?: string[] | undefined,
   wants_kids_strength?: number | undefined,
   has_kids?: number | undefined,
   is_smoker?: boolean | undefined,
   shortBio?: boolean | undefined,
-  geodbCityIds?: String[] | undefined,
+  geodbCityIds?: string[] | undefined,
   lat?: number | undefined,
   lon?: number | undefined,
   radius?: number | undefined,

backend/api/src/get-user.ts

@@ -1,8 +1,7 @@
 import { toUserAPIResponse } from 'common/api/user-types'
-import { convertUser, displayUserColumns } from 'common/supabase/users'
+import { convertUser } from 'common/supabase/users'
 import { createSupabaseDirectClient } from 'shared/supabase/init'
 import { APIError } from 'common/api/utils'
-import { removeNullOrUndefinedProps } from 'common/util/object'
 
 export const getUser = async (props: { id: string } | { username: string }) => {
   const pg = createSupabaseDirectClient()

backend/api/src/report.ts

@@ -52,7 +52,7 @@ export const report: APIHandler<'report'> = async (body, auth) => {
         console.error('Failed to get reported user for report', userError)
         return
       }
-      let message: string = `
+      const message: string = `
       🚨 **New Report** 🚨
       **Type:** ${contentType}
       **Content ID:** ${contentId}

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

@@ -0,0 +1,115 @@
+jest.mock('shared/supabase/init')
+jest.mock('shared/helpers/auth')
+jest.mock('common/envs/constants')
+jest.mock('shared/supabase/users')
+jest.mock('shared/analytics')
+jest.mock('shared/utils')
+
+import { banUser } from "api/ban-user";
+import * as supabaseInit from "shared/supabase/init";
+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"
+
+
+describe('banUser', () => {
+    const mockPg = {} as any;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+
+        (supabaseInit.createSupabaseDirectClient as jest.Mock)
+            .mockReturnValue(mockPg);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('should', () => {
+        it('ban a user successfully', async () => {
+            const mockUser = {
+                userId: '123',
+                unban: false
+            };
+            const mockAuth = {uid: '321'} as AuthedUser;
+            const mockReq = {} as any;
+
+            (constants.isAdminId as jest.Mock).mockReturnValue(false);
+
+            await banUser(mockUser, mockAuth, mockReq);
+
+            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: true});
+        });
+
+        it('unban a user successfully', async () => {
+            const mockUser = {
+                userId: '123',
+                unban: true
+            };
+            const mockAuth = {uid: '321'} as AuthedUser;
+            const mockReq = {} as any;
+
+            (constants.isAdminId as jest.Mock).mockReturnValue(false);
+
+            await banUser(mockUser, mockAuth, mockReq);
+
+            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});
+        });
+
+        it('throw and error if the ban requester is not a mod or admin', async () => {
+            const mockUser = {
+                userId: '123',
+                unban: false
+            };
+            const mockAuth = {uid: '321'} as AuthedUser;
+            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.`
+                )
+            );
+
+            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 () => {
+            const mockUser = {
+                userId: '123',
+                unban: false
+            };
+            const mockAuth = {uid: '321'} as AuthedUser;
+            const mockReq = {} as any;
+
+            (constants.isAdminId as jest.Mock).mockReturnValue(true);
+
+            await expect(banUser(mockUser, mockAuth, mockReq))
+                .rejects
+                .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

@@ -0,0 +1,119 @@
+jest.mock('shared/supabase/init')
+jest.mock('shared/supabase/users')
+jest.mock('shared/supabase/utils')
+
+import * as blockUserModule from "api/block-user";
+import { AuthedUser } from "api/helpers/endpoint";
+import * as supabaseInit from "shared/supabase/init";
+import * as supabaseUsers from "shared/supabase/users";
+import * as supabaseUtils from "shared/supabase/utils";
+
+describe('blockUser', () => {
+    let mockPg: any;
+
+    beforeEach(() => {
+        jest.resetAllMocks()
+        mockPg = {
+            tx: jest.fn(async (cb) => {
+                const mockTx = {};
+                await cb(mockTx);
+            }),
+        };
+
+        (supabaseInit.createSupabaseDirectClient as jest.Mock)
+            .mockReturnValue(mockPg)
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('should', () => {
+        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)}
+                );
+        });
+
+        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)
+        });
+    });
+
+});
+
+describe('unblockUser', () => {
+    let mockPg: any;
+
+    beforeEach(() => {
+        jest.resetAllMocks()
+        mockPg = {
+            tx: jest.fn(async (cb) => {
+                const mockTx = {};
+                await cb(mockTx);
+            }),
+        };
+
+        (supabaseInit.createSupabaseDirectClient as jest.Mock)
+            .mockReturnValue(mockPg)
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    describe('should', () => {
+        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.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)}
+                );
+        });
+    });
+
+});

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

@@ -0,0 +1,32 @@
+import * as supabaseInit from "shared/supabase/init";
+import {getCompatibleProfiles} from "api/compatible-profiles";
+
+jest.mock('shared/supabase/init')
+
+describe('getCompatibleProfiles', () => {
+  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;
+    (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");
+      expect(results.status).toEqual('success');
+      expect(results.profileCompatibilityScores).toEqual({"abc": {score: 0.69}});
+    });
+
+  });
+});