Add backend auth tests and rewrite the module to be a fit for tests.

Author: exil0867

backend/src/modules/auth/logic/login.test.ts

@@ -0,0 +1,79 @@
+import {mock, expect, describe, it, afterEach} from "bun:test"
+import {InvalidCredentials} from "./login.ts";
+import {login} from "./login.ts";
+
+const mockFindUserEmail = mock()
+const mockVerifyPassword = mock()
+const mockSignToken = mock()
+
+mock.module("../repo/user.repo.js", () => {
+  return {
+    findUserByEmail: mockFindUserEmail,
+  }
+})
+
+mock.module("../impl/password.js", () => {
+  return {
+    verifyPassword: mockVerifyPassword,
+  }
+})
+
+mock.module("../impl/jwt.js", () => {
+  return {
+    signToken: mockSignToken,
+  }
+})
+
+
+afterEach(() => {
+  mockFindUserEmail.mockReset()
+  mockVerifyPassword.mockReset()
+  mockSignToken.mockReset()
+})
+
+describe("Login function", () => {
+  const email = 'test@mail.com'
+  const password = '123456'
+  const userId = '123'
+  const token = 'fake.token'
+  const passwordHash = 'hashedpassword'
+  it("Throws if email does not exists", async () => {
+    mockFindUserEmail.mockResolvedValue({id: userId, password_hash: passwordHash})
+    mockVerifyPassword.mockResolvedValue(false)
+    mockSignToken.mockResolvedValue({sub: userId})
+    return expect(login({
+      email,
+      password
+    })).rejects.toBeInstanceOf(InvalidCredentials)
+  })
+
+  it("Throws if password is incorrect", async () => {
+    mockFindUserEmail.mockResolvedValue({id: userId, password_hash: passwordHash})
+    mockVerifyPassword.mockResolvedValue(false, )
+    mockSignToken.mockResolvedValue({sub: userId})
+    return expect(login({
+      email,
+      password
+    })).rejects.toBeInstanceOf(InvalidCredentials)
+  })
+
+  it("Resolves when email exists and password is correct", async () => {
+    mockFindUserEmail.mockResolvedValue({id: userId, password_hash: passwordHash})
+    mockVerifyPassword.mockResolvedValue(true)
+    mockSignToken.mockResolvedValue(token)
+    const user = await login({
+      email,
+      password
+    })
+    expect(mockFindUserEmail).toHaveBeenCalledTimes(1)
+    expect(mockFindUserEmail).toHaveBeenCalledWith(email)
+
+    expect(mockVerifyPassword).toHaveBeenCalledTimes(1)
+    expect(mockVerifyPassword).toHaveBeenCalledWith(password, passwordHash)
+
+    expect(mockSignToken).toHaveBeenCalledTimes(1)
+    expect(mockSignToken).toHaveBeenCalledWith({sub: userId})
+
+    expect(user).toBe(token)
+  })
+})

backend/src/modules/auth/logic/login.ts

@@ -6,6 +6,7 @@ export class InvalidCredentials extends Error {}
 
 export async function login({email, password}: {email: string, password: string}) {
   const user = await findUserByEmail(email)
+  if (!user) throw new InvalidCredentials("Email does not exist")
 
   const validPassword = await verifyPassword(password, user.password_hash)
   if (!validPassword) throw new InvalidCredentials('Invalid password')

backend/src/modules/auth/logic/signup.test.ts

@@ -1,4 +1,4 @@
-import {mock, expect, describe, it} from "bun:test"
+import {mock, expect, describe, it, afterEach} from "bun:test"
 import {signup} from "./signup.ts";
 import {InvalidCredentials} from "./signup.ts";
 
@@ -19,13 +19,45 @@ mock.module("../impl/password.js", () => {
   }
 })
 
-describe("signup function", () => {
+afterEach(() => {
+  mockFindUserEmail.mockReset()
+  mockCreateUser.mockReset()
+  mockHashPassword.mockReset()
+})
+
+describe("Signup function", () => {
+  const email = 'test@mail.com'
+  const username = 'test'
+  const password = '123456'
+  const passwordHash = 'hashedpassword'
+  const userId = '123'
   it("Throws if email already exists", async () => {
     mockFindUserEmail.mockResolvedValue({id: '123'})
-    expect(signup({
-      email: "test@mail.com",
-      username: "test",
-      password: "123456"
+    return expect(signup({
+      email,
+      username,
+      password
     })).rejects.toBeInstanceOf(InvalidCredentials)
   })
+
+  it("Resolves when the email does not exist", async () => {
+    mockFindUserEmail.mockResolvedValue(null)
+    mockHashPassword.mockResolvedValue(passwordHash)
+    mockCreateUser.mockResolvedValue( userId)
+    const user = await signup({
+      email,
+      username,
+      password
+    })
+    expect(mockFindUserEmail).toHaveBeenCalledTimes(1)
+    expect(mockFindUserEmail).toHaveBeenCalledWith(email)
+
+    expect(mockHashPassword).toHaveBeenCalledTimes(1)
+    expect(mockHashPassword).toHaveBeenCalledWith(password)
+
+    expect(mockCreateUser).toHaveBeenCalledTimes(1)
+    expect(mockCreateUser).toHaveBeenCalledWith({email, username, passwordHash})
+
+    expect(user).toBe(userId)
+  })
 })

backend/src/modules/auth/repo/user.repo.ts

@@ -16,27 +16,15 @@ export async function createUser({email, username, passwordHash}: {email: string
 
 export async function findUserByEmail(email: string) {
   const rows = await findUserByEmailRaw.run({email}, db)
-  const row = rows[0]
-  if (!row) {
-    throw new Error('FindUserByEmail returned no rows.');
-  }
-  return row
+  return rows[0]
 }
 
 export async function findUserByUsername(username: string) {
   const rows = await findUserByUsernameRaw.run({username}, db)
-  const row = rows[0]
-  if (!row) {
-    throw new Error('FindUserByUsername returned no rows.');
-  }
-  return row
+  return rows[0]
 }
 
 export async function findUserById(id: string) {
   const rows = await findUserByIdRaw.run({id}, db)
-  const row = rows[0]
-  if (!row) {
-    throw new Error('FindUserById returned no rows.');
-  }
-  return row
+  return rows[0]
 }