Add backend API unit tests

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

@@ -0,0 +1,143 @@
+import * as profilesModule from "api/get-profiles";
+import { Profile } from "common/profiles/profile";
+import { createSupabaseDirectClient } from "shared/supabase/init";
+import { renderSql } from "shared/supabase/sql-builder";
+
+jest.mock("shared/supabase/init")
+
+// describe.skip('getProfiles', () => {
+//     beforeEach(() => {
+//         jest.clearAllMocks();
+//     });
+
+//     describe('should fetch the user profiles', () => {
+//         it('successfully', async ()=> {            
+//             const mockProfiles = [
+//                 {
+//                 diet: ['Jonathon Hammon'],
+//                 has_kids: 0
+//                 },
+//                 {
+//                 diet: ['Joseph Hammon'],
+//                 has_kids: 1
+//                 },
+//                 {
+//                 diet: ['Jolene Hammon'],
+//                 has_kids: 2,
+//                 }
+//             ] as Profile [];
+
+//             jest.spyOn(profilesModule, 'loadProfiles').mockResolvedValue(mockProfiles);
+
+//             const props = {
+//                 limit: 2,
+//                 orderBy: "last_online_time" as const,
+//             };
+//             const mockReq = {} as any;
+//             const results = await profilesModule.getProfiles(props, mockReq, mockReq);
+
+//             if('continue' in results) {
+//                 throw new Error('Expected direct response')
+//             };
+
+//             expect(results.status).toEqual('success');
+//             expect(results.profiles).toEqual(mockProfiles);            
+//             expect(results.profiles[0]).toEqual(mockProfiles[0]);            
+//             expect(profilesModule.loadProfiles).toHaveBeenCalledWith(props);
+//             expect(profilesModule.loadProfiles).toHaveBeenCalledTimes(1);
+//         });
+
+//         it('unsucessfully', async () => {
+//             jest.spyOn(profilesModule, 'loadProfiles').mockRejectedValue(null);
+
+//             const props = {
+//                 limit: 2,
+//                 orderBy: "last_online_time" as const,
+//             };
+//             const mockReq = {} as any;
+//             const results = await profilesModule.getProfiles(props, mockReq, mockReq);
+
+//             if('continue' in results) {
+//                 throw new Error('Expected direct response')
+//             };
+
+//             expect(results.status).toEqual('fail');
+//             expect(results.profiles).toEqual([]);
+//             expect(profilesModule.loadProfiles).toHaveBeenCalledWith(props);
+//             expect(profilesModule.loadProfiles).toHaveBeenCalledTimes(1);
+//         });
+
+//     });
+// });
+
+describe('loadProfiles', () => {
+    let mockPg: any;
+
+    describe('should', () => {
+        beforeEach(() => {
+            mockPg = {
+                map: jest.fn().mockResolvedValue([]),
+            };
+
+            (createSupabaseDirectClient as jest.Mock).mockReturnValue(mockPg)
+            jest.clearAllMocks();
+        });
+        it('call pg.map with an SQL query', async () => {          
+            await profilesModule.loadProfiles({
+                limit: 10,
+                name: 'John',
+                is_smoker: true,
+            });
+
+            const sqlQuery = mockPg.map.mock.calls
+            console.log(sqlQuery);
+
+        });
+    });
+
+    // describe.skip('should', () => {
+    //     beforeEach(() => {
+    //         mockPg = {
+    //             map: jest.fn(),
+    //         };
+
+    //         (createSupabaseDirectClient as jest.Mock).mockReturnValue(mockPg)
+
+    //         jest.clearAllMocks();
+    //     });
+    //     it('return profiles from the database', async () => {
+    //         const mockProfiles = [
+    //             {
+    //             diet: ['Jonathon Hammon'],
+    //             is_smoker: true,
+    //             has_kids: 0
+    //             },
+    //             {
+    //             diet: ['Joseph Hammon'],
+    //             is_smoker: false,
+    //             has_kids: 1
+    //             },
+    //             {
+    //             diet: ['Jolene Hammon'],
+    //             is_smoker: true,
+    //             has_kids: 2,
+    //             }
+    //         ] as Profile [];
+
+    //         mockPg.map.mockResolvedValue(mockProfiles);
+    //         const props = {} as any;
+    //         const results = await profilesModule.loadProfiles(props);
+
+    //         expect(results).toEqual(mockProfiles);
+    //     });
+    // })
+})
+
+// const test = profilesModule.loadProfiles({
+//     limit: 10,
+//     name: 'Noah Boyer',
+//     // is_smoker: true,
+//     // orderBy: 'created_time'
+// });
+// test.then(res => {console.log(res);
+// })

backend/api/tests/unit/get-users.unit.test.ts

@@ -2,11 +2,13 @@ import { getUser } from "api/get-user";
 import { createSupabaseDirectClient } from "shared/supabase/init";
 import { toUserAPIResponse } from "common/api/user-types";
 import { convertUser } from "common/supabase/users";
-import { APIError } from "common/src/api/utils";
+import { APIError } from "common/api/utils";
 
 jest.mock("shared/supabase/init");
-jest.mock("common/supabase/users");
-jest.mock("common/api/utils");
+
+jest.spyOn(require("common/supabase/users"), 'convertUser')
+jest.spyOn(require("common/api/user-types"), 'toUserAPIResponse')
+
 describe('getUser', () =>{
     let mockPg: any;
 
@@ -19,41 +21,142 @@ describe('getUser', () =>{
         jest.clearAllMocks();
     });
 
-    it('should fetch user successfully by id', async () => {
-        const mockDbUser = {
-            created_time: '2025-11-11T16:42:05.188Z',
-            data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
-            id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
-            name: 'Franklin Buckridge',
-            name_username_vector: "'buckridg':2,4 'franklin':1,3",
-            username: 'Franky_Buck'
-        };
-        const mockConvertedUser = {
-            created_time: new Date(),
-            id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
-            name: 'Franklin Buckridge',
-            name_username_vector: "'buckridg':2,4 'franklin':1,3",
-            username: 'Franky_Buck'
+    describe('when fetching by id', () => {
+        it('should fetch user successfully by id', async () => {
+            const mockDbUser = {
+                created_time: '2025-11-11T16:42:05.188Z',
+                data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                name_username_vector: "'buckridg':2,4 'franklin':1,3",
+                username: 'Franky_Buck'
+            };
+            const mockConvertedUser = {
+                created_time: new Date(),
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                name_username_vector: "'buckridg':2,4 'franklin':1,3",
+                username: 'Franky_Buck'
+
+            };
+            const mockApiResponse = {
+                created_time: '2025-11-11T16:42:05.188Z',
+                data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                username: 'Franky_Buck'
+            };
+
+            mockPg.oneOrNone.mockImplementation((query: string, values: any[], cb: (value: any) => any) => {
+                const result = cb(mockDbUser);
+                return Promise.resolve(result);
+            });
+
+            (convertUser as jest.Mock).mockReturnValue(mockConvertedUser);
+            ( toUserAPIResponse as jest.Mock).mockReturnValue(mockApiResponse);
+
+            const result = await getUser({id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP'})
+
+            expect(mockPg.oneOrNone).toHaveBeenCalledWith(
+                expect.stringContaining('where id = $1'),
+                ['feUaIfcxVmJZHJOVVfawLTTPgZiP'],
+                expect.any(Function)
+            );
+
+            expect(convertUser).toHaveBeenCalledWith(mockDbUser);
+            expect(toUserAPIResponse).toHaveBeenCalledWith(mockConvertedUser);
+
+            expect(result).toEqual(mockApiResponse);
+
+        });
 
-        };
-        const mockApiResponse = {
-            created_time: '2025-11-11T16:42:05.188Z',
-            data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
-            id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
-            name: 'Franklin Buckridge',
-            username: 'Franky_Buck'
-        };
+        it('should throw 404 when user is not found by id', async () => {
+            mockPg.oneOrNone.mockImplementation((query: string, values: any[], cb: (value: any) => any) => {
+                return Promise.resolve(null);
+            });
 
-        // mockPg.oneOrNone.mockImplementation((query: any, params: any, callback: any) => {
-        //     return Promise.resolve(callback(mockDbUser))
-        // })
+            (convertUser as jest.Mock).mockReturnValue(null)
+
+            try {
+                await getUser({id: '3333'});
+                fail('Should have thrown');
+            } catch (error) {
+                const apiError = error as APIError;
+                expect(apiError.code).toBe(404)
+                expect(apiError.message).toBe('User not found')
+                expect(apiError.details).toBeUndefined()
+                expect(apiError.name).toBe('APIError')
+            }            
+        })
+
+    })
 
-        // (convertUser as jest.Mock).mockReturnValue(mockConvertedUser);
-        // ( toUserAPIResponse as jest.Mock).mockReturnValue(mockApiResponse);
+    describe('when fetching by username', () => {
+        it('should fetch user successfully by username', async () => {
+            const mockDbUser = {
+                created_time: '2025-11-11T16:42:05.188Z',
+                data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                name_username_vector: "'buckridg':2,4 'franklin':1,3",
+                username: 'Franky_Buck'
+            };
+            const mockConvertedUser = {
+                created_time: new Date(),
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                name_username_vector: "'buckridg':2,4 'franklin':1,3",
+                username: 'Franky_Buck'
+
+            };
+            const mockApiResponse = {
+                created_time: '2025-11-11T16:42:05.188Z',
+                data: { link: {}, avatarUrl: "", isBannedFromPosting: false },
+                id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP',
+                name: 'Franklin Buckridge',
+                username: 'Franky_Buck'
+            };
+
+            mockPg.oneOrNone.mockImplementation((query: string, values: any[], cb: (value: any) => any) => {
+                const result = cb(mockDbUser);
+                return Promise.resolve(result);
+            });
+
+            (convertUser as jest.Mock).mockReturnValue(mockConvertedUser);
+            (toUserAPIResponse as jest.Mock).mockReturnValue(mockApiResponse);
+
+            const result = await getUser({username: 'Franky_Buck'})
+
+            expect(mockPg.oneOrNone).toHaveBeenCalledWith(
+                expect.stringContaining('where username = $1'),
+                ['Franky_Buck'],
+                expect.any(Function)
+            );
+
+            expect(convertUser).toHaveBeenCalledWith(mockDbUser);
+            expect(toUserAPIResponse).toHaveBeenCalledWith(mockConvertedUser);
+
+            expect(result).toEqual(mockApiResponse);
+
+        });
 
-        // const result = await getUser({id: 'feUaIfcxVmJZHJOVVfawLTTPgZiP'})
+        it('should throw 404 when user is not found by id', async () => {
+            mockPg.oneOrNone.mockImplementation((query: string, values: any[], cb: (value: any) => any) => {
+                return Promise.resolve(null);
+            });
 
-        // console.log(result);
-
+            (convertUser as jest.Mock).mockReturnValue(null)
+
+            try {
+                await getUser({username: '3333'});
+                fail('Should have thrown');
+            } catch (error) {
+                const apiError = error as APIError;
+                expect(apiError.code).toBe(404)
+                expect(apiError.message).toBe('User not found')
+                expect(apiError.details).toBeUndefined()
+                expect(apiError.name).toBe('APIError')
+            }            
+        })
     })
 })