[Misc] Adding more tests

.coderabbit.yaml

@@ -78,7 +78,7 @@ reviews:
         - Flag any hardcoded strings; they should be in the constants file.
         - Check for edge cases like null values or empty arrays.
         - Suggest performance optimizations where appropriate.
-
+        
         Mobile best practices:
         - Proper use of hooks (useRouter, useFonts, useAssets)
         - Accessibility: touch targets min 44x44, screen reader support
@@ -99,4 +99,22 @@ reviews:
         - Validate deep linking configurations
 
         Internationalization:
-        - User-visible strings should be externalized to resource files (useT())
+        - User-visible strings should be externalized to JSON resource files in common/messages via
+          ```
+          const t = useT()
+          const message = t('key', 'english string')
+          ```
+
+    - path: "tests/e2e/**/*.ts"
+      instructions: |
+        Playwright E2E test guidelines for this repo:
+        - Page objects live in `tests/e2e/web/pages/`. Each class wraps one page/route, holds only `private readonly` Locators, and exposes action methods.
+        - All tests must use the `app` fixture (type `App`) from `tests/e2e/web/fixtures/base.ts`. Never instantiate page objects directly in a test.
+        - Cross-page flows (actions spanning multiple pages) belong as methods on the `App` class, not as standalone helper functions.
+        - Action methods in page objects must assert `expect(locator).toBeVisible()` before interacting.
+        - Never use `page.waitForTimeout()`. Use Playwright's built-in auto-waiting or `waitForURL` / `waitForSelector`.
+        - No hardcoded credentials in spec files; use `SPEC_CONFIG.ts` or account fixtures.
+        - Test account cleanup must be done in fixture teardown (after `await use(...)`), not in `afterEach` hooks.
+        - File and class names must use PascalCase (e.g., `CompatibilityPage.ts` / `class CompatibilityPage`).
+        - No DB or Firebase calls inside page object classes; those belong in `tests/e2e/utils/`.
+        - Flag any new page object not yet registered in `App`.

.gitignore

@@ -102,3 +102,5 @@ test-results
 **/coverage
 
 *my-release-key.keystore
+
+.vscode/settings.json

docs/TESTING.md

@@ -348,6 +348,7 @@ jest.mock('path/to/module')
  * This creates an object containing all named exports from ./path/to/module
  */
 import * as mockModule from 'path/to/module'
+
 ;(mockModule.module as jest.Mock).mockResolvedValue(mockReturnValue)
 ```
 
@@ -705,6 +706,66 @@ Use this priority order for selecting elements in Playwright tests:
 
 This hierarchy mirrors how users actually interact with your application, making tests more reliable and meaningful.
 
+### Page Object Model (POM)
+
+Tests often receive multiple page objects as fixtures (e.g. `homePage`, `authPage`, `profilePage`). This is the **Page
+Object Model** pattern — a way to organize selectors and actions by the area of the app they belong to.
+
+**Page objects are not separate browser tabs.** They are all wrappers around the same underlying `page` instance. Each
+class simply encapsulates the selectors and actions relevant to one part of the UI:
+
+```typescript
+class ProfilePage {
+  constructor(private page: Page) {}
+
+  async verifyDisplayName(name: string) {
+    await expect(this.page.getByTestId('display-name')).toHaveText(name)
+  }
+}
+
+class SettingsPage {
+  constructor(private page: Page) {} // same page instance
+
+  async deleteAccount() {
+    await this.page.getByRole('button', {name: 'Delete account'}).click()
+  }
+}
+```
+
+**Why use POM instead of raw `page`?**
+
+Without it, tests are full of inline selectors that are brittle and hard to read. POM moves implementation details into
+dedicated classes so that the test itself reads like a plain-English description of user behavior. When a selector
+changes, you fix it in one place.
+
+```typescript
+// ❌ Without POM — noisy and brittle
+await page.locator('#email-input').fill(account.email)
+await page.locator('#submit-btn').click()
+await page.locator('[data-testid="skip-onboarding"]').click()
+// ...50 more lines of noise
+
+// ✅ With POM — readable and maintainable
+await registerWithEmail(homePage, authPage, fakerAccount)
+await skipOnboardingHeadToProfile(onboardingPage, signUpPage, profilePage, fakerAccount)
+await profilePage.verifyDisplayName(fakerAccount.display_name)
+```
+
+**What happens if you call a method on the "wrong" page object?**
+
+Nothing special — it still runs. Since all page objects share the same `page`, the method simply acts on whatever is
+currently rendered in the browser. Page objects do not track which screen you're on; that's your responsibility as the
+test author. If you call `profilePage.verifyDisplayName()` while the browser is showing the settings screen, the locator
+won't find its element and the test will **time out**.
+
+```typescript
+// ⚠️ This fails at runtime if navigation hasn't happened yet
+await settingsPage.deleteAccount() // navigates away from profile
+await profilePage.verifyDisplayName(name) // locator not found → timeout
+```
+
+Always ensure navigation has completed before calling methods that depend on a specific screen being visible.
+
 ### Setting up test data
 
 Since the tests run in parallel (i.e., at the same time) and share the same database and Firebase emulator, it can
@@ -802,7 +863,9 @@ These are seeded automatically by `yarn test:db:seed`:
 
 ## Troubleshooting
 
-For comprehensive troubleshooting guidance beyond testing-specific issues, see the [Troubleshooting Guide](TROUBLESHOOTING.md) which covers development environment setup, database and emulator issues, API problems, and more.
+For comprehensive troubleshooting guidance beyond testing-specific issues, see
+the [Troubleshooting Guide](TROUBLESHOOTING.md) which covers development environment setup, database and emulator
+issues, API problems, and more.
 
 ### Port already in use
 
@@ -885,4 +948,5 @@ To download the Playwright report from a failed CI run:
 3. Download `playwright-report`
 4. Open `index.html` in your browser
 
-For performance testing guidance and benchmarking strategies, see the [Performance Optimization Guide](PERFORMANCE_OPTIMIZATION.md).
+For performance testing guidance and benchmarking strategies, see
+the [Performance Optimization Guide](PERFORMANCE_OPTIMIZATION.md).

tests/e2e/backend/utils/userInformation.ts

@@ -12,8 +12,9 @@ import {
   SUBSTANCE_PREFERENCE_CHOICES,
 } from 'common/choices'
 
-class UserAccountInformation {
+class UserAccountInformationForSeeding {
   name = faker.person.fullName()
+  userName = faker.internet.displayName()
   email = faker.internet.email()
   user_id = faker.string.alpha(28)
   password = faker.internet.password()
@@ -54,4 +55,4 @@ class UserAccountInformation {
   }
 }
 
-export default UserAccountInformation
+export default UserAccountInformationForSeeding

tests/e2e/utils/databaseUtils.ts

@@ -6,7 +6,8 @@ export async function deleteFromDb(user_id: string) {
   const result = await db.query(deleteEntryById, [user_id])
 
   if (!result.length) {
-    throw new Error(`No user found with id: ${user_id}`)
+    console.debug(`No user found with id: ${user_id}`)
+    return
   }
 
   console.log('Deleted data: ', {
@@ -19,8 +20,8 @@ export async function deleteFromDb(user_id: string) {
 export async function userInformationFromDb(account: any) {
   const db = createSupabaseDirectClient()
   const queryUserById = `
-                SELECT p.*
-                FROM users AS p
+                SELECT *
+                FROM users
                 WHERE username = $1
             `
   const userResults = await db.query(queryUserById, [account.username])

tests/e2e/utils/firebaseUtils.ts

@@ -2,7 +2,10 @@ import axios from 'axios'
 
 import {config} from '../web/SPEC_CONFIG'
 
-export async function firebaseLogin(email: string, password: string) {
+export async function firebaseLoginEmailPassword(
+  email: string | undefined,
+  password: string | undefined,
+) {
   const login = await axios.post(
     `${config.FIREBASE_URL.BASE}${config.FIREBASE_URL.SIGN_IN_PASSWORD}`,
     {
@@ -13,15 +16,28 @@ export async function firebaseLogin(email: string, password: string) {
   )
   return login
 }
+
 export async function getUserId(email: string, password: string) {
   try {
-    const loginInfo = await firebaseLogin(email, password)
+    const loginInfo = await firebaseLoginEmailPassword(email, password)
     return loginInfo.data.localId
   } catch {
     return
   }
 }
 
+export async function findUser(idToken: string) {
+  const response = await axios.post(
+    `${config.FIREBASE_URL.BASE}${config.FIREBASE_URL.ACCOUNT_LOOKUP}`,
+    {
+      idToken,
+    },
+  )
+  if (response?.data?.users?.length > 0) {
+    return response.data.users[0]
+  }
+}
+
 export async function firebaseSignUp(email: string, password: string) {
   try {
     const response = await axios.post(`${config.FIREBASE_URL.BASE}${config.FIREBASE_URL.SIGNUP}`, {
@@ -46,8 +62,15 @@ export async function firebaseSignUp(email: string, password: string) {
   }
 }
 
-export async function deleteAccount(login: any) {
-  await axios.post(`${config.FIREBASE_URL.BASE}${config.FIREBASE_URL.DELETE}`, {
-    idToken: login.data.idToken,
-  })
+export async function deleteAccount(idToken: any) {
+  try {
+    await axios.post(`${config.FIREBASE_URL.BASE}${config.FIREBASE_URL.DELETE}`, {
+      idToken: idToken,
+    })
+  } catch (err: any) {
+    if (err.response?.data?.error?.message?.includes('USER_NOT_FOUND')) {
+      return
+    }
+    throw err
+  }
 }

tests/e2e/utils/seedDatabase.ts

@@ -7,7 +7,7 @@ import {createSupabaseDirectClient} from 'shared/supabase/init'
 import {insert} from 'shared/supabase/utils'
 import {getUser} from 'shared/utils'
 
-import UserAccountInformation from '../backend/utils/userInformation'
+import UserAccountInformationForSeeding from '../backend/utils/userInformation'
 import {firebaseSignUp} from './firebaseUtils'
 
 /**
@@ -16,7 +16,10 @@ import {firebaseSignUp} from './firebaseUtils'
  * @param userInfo - Class object containing information to create a user account generated by `fakerjs`.
  * @param profileType - Optional param used to signify how much information is used in the account generation.
  */
-export async function seedDbUser(userInfo: UserAccountInformation, profileType?: string) {
+export async function seedDbUser(
+  userInfo: UserAccountInformationForSeeding,
+  profileType?: string,
+): Promise<Boolean> {
   const pg = createSupabaseDirectClient()
   const userId = userInfo.user_id
   const deviceToken = randomString()
@@ -83,14 +86,14 @@ export async function seedDbUser(userInfo: UserAccountInformation, profileType?:
     blockedByUserIds: [],
   }
 
-  await pg.tx(async (tx: any) => {
+  return pg.tx(async (tx: any) => {
     const preexistingUser = await getUser(userId, tx)
-    if (preexistingUser) return
+    if (preexistingUser) return false
 
     await insert(tx, 'users', {
       id: userId,
       name: userInfo.name,
-      username: cleanUsername(userInfo.name),
+      username: cleanUsername(userInfo.userName),
       data: {},
     })
 
@@ -100,20 +103,25 @@ export async function seedDbUser(userInfo: UserAccountInformation, profileType?:
     })
 
     await insert(tx, 'profiles', profileData)
+    return true
   })
 }
 
 export async function seedUser(
   email?: string | undefined,
   password?: string | undefined,
   profileType?: string | undefined,
+  displayName?: string | undefined,
+  userName?: string | undefined,
 ) {
-  const userInfo = new UserAccountInformation()
+  const userInfo = new UserAccountInformationForSeeding()
   if (email) userInfo.email = email
   if (password) userInfo.password = password
+  if (displayName) userInfo.name = displayName
+  if (userName) userInfo.userName = userName
   userInfo.user_id = await firebaseSignUp(userInfo.email, userInfo.password)
   if (userInfo.user_id) {
-    await seedDbUser(userInfo, profileType ?? 'full')
+    const created = await seedDbUser(userInfo, profileType ?? 'full')
+    if (created) debug('User created in Firebase and Supabase:', userInfo.email)
   }
-  debug('User created in Firebase and Supabase:', userInfo.email)
 }

tests/e2e/web/SPEC_CONFIG.ts

@@ -4,6 +4,7 @@ export const config = {
     BASE: 'http://localhost:9099/identitytoolkit.googleapis.com/v1',
     SIGNUP: '/accounts:signUp?key=fake-api-key',
     SIGN_IN_PASSWORD: '/accounts:signInWithPassword?key=fake-api-key',
+    ACCOUNT_LOOKUP: '/accounts:lookup?key=fake-api-key',
     DELETE: '/accounts:delete?key=fake-api-key',
   },
   USERS: {

tests/e2e/web/fixtures/base.ts

@@ -4,40 +4,63 @@ import {AuthPage} from '../pages/AuthPage'
 import {ComatibilityPage} from '../pages/compatibilityPage'
 import {HomePage} from '../pages/homePage'
 import {OnboardingPage} from '../pages/onboardingPage'
+import {OrganizationPage} from '../pages/organizationPage'
 import {ProfilePage} from '../pages/profilePage'
+import {SettingsPage} from '../pages/settingsPage'
 import {SignUpPage} from '../pages/signUpPage'
+import {SocialPage} from '../pages/socialPage'
 import {testAccounts, UserAccountInformation} from '../utils/accountInformation'
 import {deleteUser} from '../utils/deleteUser'
+import {getAuthAccountInfo} from '../utils/networkUtils'
 
 export const test = base.extend<{
   homePage: HomePage
   onboardingPage: OnboardingPage
   signUpPage: SignUpPage
   profilePage: ProfilePage
   authPage: AuthPage
+  settingsPage: SettingsPage
+  socialPage: SocialPage
+  organizationPage: OrganizationPage
   compatabilityPage: ComatibilityPage
   cleanUpUsers: void
   onboardingAccount: UserAccountInformation
   fakerAccount: UserAccountInformation
   specAccount: UserAccountInformation
+  googleAccountOne: UserAccountInformation
+  googleAccountTwo: UserAccountInformation
 }>({
   onboardingAccount: async ({}, use) => {
-    const account = testAccounts.account_all_info() // email captured here
+    const account = testAccounts.email_account_all_info() // email captured here
     await use(account)
     console.log('Cleaning up onboarding 1 account...')
-    await deleteUser(account.email, account.password) // same account, guaranteed
+    await deleteUser('Email/Password', account) // same account, guaranteed
   },
   fakerAccount: async ({}, use) => {
-    const account = testAccounts.faker_account() // email captured here
+    const account = testAccounts.faker_account()
     await use(account)
     console.log('Cleaning up faker account...')
-    await deleteUser(account.email, account.password) // same account, guaranteed
+    await deleteUser('Email/Password', account)
+  },
+  googleAccountOne: async ({page}, use) => {
+    const account = testAccounts.google_account_one()
+    const getAuthObject = await getAuthAccountInfo(page)
+    await use(account)
+    console.log('Cleaning up google account...')
+    await deleteUser('Google', undefined, getAuthObject())
+  },
+  googleAccountTwo: async ({page}, use) => {
+    const account = testAccounts.google_account_two()
+    const getAuthObject = await getAuthAccountInfo(page)
+    await use(account)
+    console.log('Cleaning up google account...')
+    await deleteUser('Google', undefined, getAuthObject())
   },
   specAccount: async ({}, use) => {
     const account = testAccounts.spec_account()
     await use(account)
     console.log('Cleaning up spec account...')
-    await deleteUser(account.email, account.password)
+    await deleteUser('Email/Password', account)
   },
   onboardingPage: async ({page}, use) => {
     const onboardingPage = new OnboardingPage(page)
@@ -63,6 +86,18 @@ export const test = base.extend<{
     const compatibilityPage = new ComatibilityPage(page)
     await use(compatibilityPage)
   },
+  settingsPage: async ({page}, use) => {
+    const settingsPage = new SettingsPage(page)
+    await use(settingsPage)
+  },
+  socialPage: async ({page}, use) => {
+    const socialPage = new SocialPage(page)
+    await use(socialPage)
+  },
+  organizationPage: async ({page}, use) => {
+    const organizationPage = new OrganizationPage(page)
+    await use(organizationPage)
+  },
 })
 
 export {expect} from '@playwright/test'