diff --git a/src/auth/LoginPage.test.tsx b/src/auth/LoginPage.test.tsx new file mode 100644 index 000000000..0a24d3e22 --- /dev/null +++ b/src/auth/LoginPage.test.tsx @@ -0,0 +1,78 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, beforeEach, expect, test, vi } from "vitest"; +import { render, screen } from "@testing-library/react"; +import userEvent from "@testing-library/user-event"; +import { type FC } from "react"; +import { MemoryRouter, useLocation } from "react-router-dom"; +import { type MatrixClient } from "matrix-js-sdk"; + +import { LoginPage } from "./LoginPage"; +import { ClientManagerProvider } from "../ClientContext"; +import { type ClientManager } from "../state/ClientSession"; +import { Config } from "../config/Config"; + +beforeEach(() => { + vi.spyOn(Config, "defaultHomeserverUrl").mockReturnValue( + "https://hs.example.org", + ); +}); +afterEach(() => { + vi.restoreAllMocks(); + vi.clearAllMocks(); +}); + +test("signs in with the session's manager and goes home", async () => { + const manager = mockManager(); + vi.mocked(manager.login).mockResolvedValue({} as MatrixClient); + renderLogin(manager); + + await submit("alice", "hunter2"); + + expect(manager.login).toHaveBeenCalledWith( + "https://hs.example.org", + "alice", + "hunter2", + ); + expect(await screen.findByText("at /")).toBeVisible(); +}); + +test("shows why signing in failed", async () => { + const manager = mockManager(); + vi.mocked(manager.login).mockRejectedValue(new Error("Wrong password")); + renderLogin(manager); + + await submit("alice", "hunter2"); + + expect(await screen.findByText("Wrong password")).toBeVisible(); + expect(screen.getByText("at /login")).toBeVisible(); +}); + +async function submit(username: string, password: string): Promise { + const user = userEvent.setup(); + await user.type(screen.getByTestId("login_username"), username); + await user.type(screen.getByTestId("login_password"), password); + await user.click(screen.getByTestId("login_login")); +} + +function mockManager(): ClientManager { + return { login: vi.fn(), register: vi.fn(), logout: vi.fn() }; +} + +const WhereAmI: FC = () => at {useLocation().pathname}; + +function renderLogin(manager: ClientManager): void { + render( + + + + + + , + ); +} diff --git a/src/auth/RegisterPage.test.tsx b/src/auth/RegisterPage.test.tsx new file mode 100644 index 000000000..54479b03f --- /dev/null +++ b/src/auth/RegisterPage.test.tsx @@ -0,0 +1,133 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, expect, test, vi } from "vitest"; +import { render, screen } from "@testing-library/react"; +import userEvent from "@testing-library/user-event"; +import { type FC } from "react"; +import { MemoryRouter, useLocation } from "react-router-dom"; +import { type MatrixClient } from "matrix-js-sdk"; +import { BehaviorSubject } from "rxjs"; + +import { RegisterPage } from "./RegisterPage"; +import { ClientContextProvider, ClientManagerProvider } from "../ClientContext"; +import { + type ClientManager, + type ClientSessionState, +} from "../state/ClientSession"; + +vi.mock("./useRecaptcha", () => ({ + useRecaptcha: () => ({ + execute: vi.fn().mockResolvedValue("captcha-response"), + reset, + recaptchaId: "recaptcha", + }), +})); +vi.mock("./useRegistrationTerms", () => ({ + useRegistrationTerms: () => ({ recaptchaKey: "site-key" }), +})); + +const reset = vi.fn(); + +afterEach(() => vi.clearAllMocks()); + +test("waits for the session to be restored", () => { + renderRegister({ state: "loading" }, mockManager()); + expect(screen.getByRole("heading", { name: "Loading…" })).toBeVisible(); +}); + +test("registers an account, signs in and goes home", async () => { + const manager = mockManager(); + const setSignedIn = vi.fn(); + vi.mocked(manager.register).mockResolvedValue({ + client: {} as MatrixClient, + setSignedIn, + }); + renderRegister({ state: "signedOut" }, manager); + + await submit("alice", "hunter2"); + + expect(manager.register).toHaveBeenCalledWith( + "alice", + "hunter2", + "alice", + "captcha-response", + false, + ); + expect(setSignedIn).toHaveBeenCalled(); + expect(await screen.findByText("at /")).toBeVisible(); +}); + +test("upgrades a passwordless user to a full account", async () => { + const manager = mockManager(); + vi.mocked(manager.register).mockResolvedValue({ + client: {} as MatrixClient, + setSignedIn: vi.fn(), + }); + renderRegister( + { + state: "signedIn", + client: { getUserId: () => "@guest:example.org" } as MatrixClient, + passwordlessUser: true, + }, + manager, + ); + + await submit("alice", "hunter2"); + + expect(manager.register).toHaveBeenCalledWith( + "alice", + "hunter2", + "alice", + "captcha-response", + true, + ); +}); + +test("shows why registering failed and resets the captcha", async () => { + const manager = mockManager(); + vi.mocked(manager.register).mockRejectedValue(new Error("Name taken")); + renderRegister({ state: "signedOut" }, manager); + + await submit("alice", "hunter2"); + + expect(await screen.findByText("Name taken")).toBeVisible(); + expect(reset).toHaveBeenCalled(); + expect(screen.getByText("at /register")).toBeVisible(); +}); + +async function submit(username: string, password: string): Promise { + const user = userEvent.setup(); + await user.type(screen.getByTestId("register_username"), username); + await user.type(screen.getByTestId("register_password"), password); + await user.type(screen.getByTestId("register_confirm_password"), password); + await user.click(screen.getByTestId("register_register")); +} + +function mockManager(): ClientManager { + return { login: vi.fn(), register: vi.fn(), logout: vi.fn() }; +} + +const WhereAmI: FC = () => at {useLocation().pathname}; + +function renderRegister( + state: ClientSessionState, + manager: ClientManager, +): void { + render( + + (state) }} + > + + + + + + , + ); +} diff --git a/src/auth/useRegisterPasswordlessUser.test.tsx b/src/auth/useRegisterPasswordlessUser.test.tsx new file mode 100644 index 000000000..e46c9442e --- /dev/null +++ b/src/auth/useRegisterPasswordlessUser.test.tsx @@ -0,0 +1,116 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, expect, test, vi } from "vitest"; +import { renderHook } from "@testing-library/react"; +import { type FC, type PropsWithChildren } from "react"; +import { type MatrixClient } from "matrix-js-sdk"; + +import { useRegisterPasswordlessUser } from "./useRegisterPasswordlessUser"; +import { ClientManagerProvider } from "../ClientContext"; +import { type ClientManager } from "../state/ClientSession"; +import { computeUrlParams, UrlParamsProvider } from "../UrlParams"; + +vi.mock("./useRecaptcha", () => ({ + useRecaptcha: () => ({ + execute: vi.fn().mockResolvedValue("captcha-response"), + reset, + recaptchaId: "recaptcha", + }), +})); +vi.mock("./useRegistrationTerms", () => ({ + useRegistrationTerms: () => ({ + privacyPolicyUrl: "https://hs.example.org/privacy", + recaptchaKey: "site-key", + }), +})); +vi.mock("./generateRandomName", () => ({ + generateRandomName: () => "Random Name", +})); + +const reset = vi.fn(); + +afterEach(() => vi.clearAllMocks()); + +test("registers a user under a random name and signs them in", async () => { + const setSignedIn = vi.fn(); + const manager = mockManager(); + vi.mocked(manager.register).mockResolvedValue({ + client: {} as MatrixClient, + setSignedIn, + }); + + const { result } = renderHook(() => useRegisterPasswordlessUser(), { + wrapper: wrapper(manager, false), + }); + await result.current.registerPasswordlessUser("Alice"); + + expect(manager.register).toHaveBeenCalledWith( + "Random Name", + expect.stringMatching(/^.{16}$/), + "Alice", + "captcha-response", + true, + ); + expect(setSignedIn).toHaveBeenCalled(); + expect(result.current.privacyPolicyUrl).toBe( + "https://hs.example.org/privacy", + ); + expect(result.current.recaptchaId).toBe("recaptcha"); +}); + +test("resets the captcha when registration fails", async () => { + const manager = mockManager(); + vi.mocked(manager.register).mockRejectedValue(new Error("Nope")); + + const { result } = renderHook(() => useRegisterPasswordlessUser(), { + wrapper: wrapper(manager, false), + }); + + await expect( + result.current.registerPasswordlessUser("Alice"), + ).rejects.toThrow("Nope"); + expect(reset).toHaveBeenCalled(); +}); + +test("cannot register on a session that is not ours", async () => { + const { result } = renderHook(() => useRegisterPasswordlessUser(), { + wrapper: wrapper(null, false), + }); + + await expect( + result.current.registerPasswordlessUser("Alice"), + ).rejects.toThrow("This session cannot register"); +}); + +test("never registers as a widget", async () => { + const manager = mockManager(); + const { result } = renderHook(() => useRegisterPasswordlessUser(), { + wrapper: wrapper(manager, true), + }); + + await expect( + result.current.registerPasswordlessUser("Alice"), + ).rejects.toThrow(/embedded mode/); + expect(manager.register).not.toHaveBeenCalled(); +}); + +function mockManager(): ClientManager { + return { login: vi.fn(), register: vi.fn(), logout: vi.fn() }; +} + +function wrapper( + manager: ClientManager | null, + isWidget: boolean, +): FC { + const params = { ...computeUrlParams(), isWidget }; + return ({ children }) => ( + + {children} + + ); +} diff --git a/src/auth/useRegistrationTerms.test.tsx b/src/auth/useRegistrationTerms.test.tsx new file mode 100644 index 000000000..86d29d3cc --- /dev/null +++ b/src/auth/useRegistrationTerms.test.tsx @@ -0,0 +1,98 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, beforeEach, expect, test, vi } from "vitest"; +import { renderHook, waitFor } from "@testing-library/react"; +import type * as MatrixJsSdk from "matrix-js-sdk"; +import { createClient, type MatrixClient } from "matrix-js-sdk"; +import { type FC, type PropsWithChildren } from "react"; + +import { useRegistrationTerms } from "./useRegistrationTerms"; +import { computeUrlParams, UrlParamsProvider } from "../UrlParams"; +import { Config } from "../config/Config"; + +vi.mock("matrix-js-sdk", async (importOriginal) => ({ + ...(await importOriginal()), + createClient: vi.fn(), +})); + +const registerRequest = vi.fn(); + +beforeEach(() => { + vi.spyOn(Config, "defaultHomeserverUrl").mockReturnValue( + "https://hs.example.org", + ); + vi.mocked(createClient).mockReturnValue({ + registerRequest, + } as Partial as MatrixClient); +}); +afterEach(() => { + vi.restoreAllMocks(); + vi.clearAllMocks(); +}); + +test("reads the terms the homeserver asks for from a registration attempt", async () => { + registerRequest.mockRejectedValue({ + data: { + params: { + "m.login.terms": { + policies: { + privacy_policy: { en: { url: "https://hs.example.org/privacy" } }, + }, + }, + "m.login.recaptcha": { public_key: "site-key" }, + }, + }, + }); + + const { result } = renderHook(() => useRegistrationTerms(), { + wrapper: wrapper(false), + }); + + expect(createClient).toHaveBeenCalledWith({ + baseUrl: "https://hs.example.org", + }); + await waitFor(() => + expect(result.current).toEqual({ + privacyPolicyUrl: "https://hs.example.org/privacy", + recaptchaKey: "site-key", + }), + ); +}); + +test("has nothing to agree to where the homeserver asks for nothing", async () => { + registerRequest.mockRejectedValue({ data: { params: {} } }); + + const { result } = renderHook(() => useRegistrationTerms(), { + wrapper: wrapper(false), + }); + + await waitFor(() => expect(registerRequest).toHaveBeenCalled()); + expect(result.current).toEqual({ + privacyPolicyUrl: undefined, + recaptchaKey: undefined, + }); +}); + +test("asks the homeserver nothing as a widget", () => { + const { result } = renderHook(() => useRegistrationTerms(), { + wrapper: wrapper(true), + }); + + expect(createClient).not.toHaveBeenCalled(); + expect(result.current).toEqual({ + privacyPolicyUrl: undefined, + recaptchaKey: undefined, + }); +}); + +function wrapper(isWidget: boolean): FC { + const params = { ...computeUrlParams(), isWidget }; + return ({ children }) => ( + {children} + ); +} diff --git a/src/home/HomePage.test.tsx b/src/home/HomePage.test.tsx new file mode 100644 index 000000000..d5e2f83f0 --- /dev/null +++ b/src/home/HomePage.test.tsx @@ -0,0 +1,62 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { expect, test, vi } from "vitest"; +import { render, screen } from "@testing-library/react"; +import { BrowserRouter } from "react-router-dom"; +import { type MatrixClient } from "matrix-js-sdk"; +import { BehaviorSubject } from "rxjs"; + +import { HomePage } from "./HomePage"; +import { ClientContextProvider } from "../ClientContext"; +import { type ClientSessionState } from "../state/ClientSession"; + +vi.mock("./RegisteredView", () => ({ + RegisteredView: ({ client }: { client: MatrixClient }) => ( + registered as {client.getUserId()} + ), +})); +vi.mock("./UnauthenticatedView", () => ({ + UnauthenticatedView: () => unauthenticated, +})); + +test("waits for the session to be restored", () => { + renderHome({ state: "loading" }); + expect(screen.getByRole("heading", { name: "Loading…" })).toBeVisible(); +}); + +test("shows the session's error", () => { + vi.spyOn(console, "error").mockImplementation(() => {}); + renderHome({ state: "error", error: new Error("Opened elsewhere") }); + expect(screen.getByText("Something went wrong")).toBeVisible(); +}); + +test("welcomes a signed-in user", () => { + renderHome({ + state: "signedIn", + client: { getUserId: () => "@alice:example.org" } as MatrixClient, + passwordlessUser: false, + }); + expect(screen.getByText("registered as @alice:example.org")).toBeVisible(); +}); + +test("invites a signed-out user to start a call", () => { + renderHome({ state: "signedOut" }); + expect(screen.getByText("unauthenticated")).toBeVisible(); +}); + +function renderHome(state: ClientSessionState): void { + render( + + (state) }} + > + + + , + ); +} diff --git a/src/home/UnauthenticatedView.test.tsx b/src/home/UnauthenticatedView.test.tsx new file mode 100644 index 000000000..b959be32e --- /dev/null +++ b/src/home/UnauthenticatedView.test.tsx @@ -0,0 +1,136 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, expect, test, vi } from "vitest"; +import { render, screen } from "@testing-library/react"; +import userEvent from "@testing-library/user-event"; +import { type FC } from "react"; +import { MemoryRouter, useLocation } from "react-router-dom"; +import { type MatrixClient } from "matrix-js-sdk"; + +import { UnauthenticatedView } from "./UnauthenticatedView"; +import { ClientManagerProvider } from "../ClientContext"; +import { type ClientManager } from "../state/ClientSession"; +import { computeUrlParams, UrlParamsProvider } from "../UrlParams"; +import type * as matrixUtils from "../utils/matrix"; +import { createRoom, getRelativeRoomUrl } from "../utils/matrix"; +import { E2eeType } from "../e2ee/e2eeType"; + +vi.mock("../auth/useRecaptcha", () => ({ + useRecaptcha: () => ({ + execute: vi.fn().mockResolvedValue("captcha-response"), + reset, + recaptchaId: "recaptcha", + }), +})); +vi.mock("../auth/useRegistrationTerms", () => ({ + useRegistrationTerms: () => ({ recaptchaKey: "site-key" }), +})); +vi.mock("../auth/generateRandomName", () => ({ + generateRandomName: () => "Random Name", +})); +vi.mock("../utils/matrix", async (importOriginal) => ({ + ...(await importOriginal()), + createRoom: vi.fn(), +})); +vi.mock("../UserMenuContainer", () => ({ UserMenuContainer: () => null })); + +const reset = vi.fn(); +const client = {} as MatrixClient; + +afterEach(() => vi.clearAllMocks()); + +test("registers a guest, creates their call and signs them in", async () => { + const manager = mockManager(); + const setSignedIn = vi.fn(); + vi.mocked(manager.register).mockResolvedValue({ client, setSignedIn }); + vi.mocked(createRoom).mockResolvedValue({ + roomId: "!call:example.org", + alias: "#my-call:example.org", + password: "secret", + }); + renderView(manager); + + await submit("My Call", "Alice"); + + expect(manager.register).toHaveBeenCalledWith( + "Random Name", + expect.stringMatching(/^.{16}$/), + "Alice", + "captcha-response", + true, + ); + expect(createRoom).toHaveBeenCalledWith( + client, + "My Call", + E2eeType.SHARED_KEY, + ); + expect(setSignedIn).toHaveBeenCalled(); + const url = getRelativeRoomUrl( + "!call:example.org", + { kind: E2eeType.SHARED_KEY, secret: "secret" }, + "My Call", + ); + expect(await screen.findByText(`at ${url}`)).toBeVisible(); +}); + +test("signs in only once the user chooses to join a call that exists", async () => { + const manager = mockManager(); + const setSignedIn = vi.fn(); + vi.mocked(manager.register).mockResolvedValue({ client, setSignedIn }); + vi.mocked(createRoom).mockRejectedValue({ errcode: "M_ROOM_IN_USE" }); + renderView(manager); + + await submit("My Call", "Alice"); + + const join = await screen.findByRole("button", { name: "Yes, join call" }); + expect(setSignedIn).not.toHaveBeenCalled(); + await userEvent.click(join); + expect(setSignedIn).toHaveBeenCalled(); + expect(await screen.findByText("at /my-call")).toBeVisible(); +}); + +test("shows why registering failed and resets the captcha", async () => { + const manager = mockManager(); + vi.mocked(manager.register).mockRejectedValue(new Error("Rate limited")); + renderView(manager); + + await submit("My Call", "Alice"); + + expect(await screen.findByText("Rate limited")).toBeVisible(); + expect(reset).toHaveBeenCalled(); + expect(createRoom).not.toHaveBeenCalled(); +}); + +async function submit(callName: string, displayName: string): Promise { + const user = userEvent.setup(); + await user.type(screen.getByTestId("home_callName"), callName); + await user.type(screen.getByTestId("home_displayName"), displayName); + await user.click(screen.getByTestId("home_go")); +} + +function mockManager(): ClientManager { + return { login: vi.fn(), register: vi.fn(), logout: vi.fn() }; +} + +const WhereAmI: FC = () => { + const { pathname, search, hash } = useLocation(); + return {`at ${pathname}${search}${hash}`}; +}; + +function renderView(manager: ClientManager): void { + render( + + + + + + + + , + ); +} diff --git a/src/home/UnauthenticatedView.tsx b/src/home/UnauthenticatedView.tsx index 37a68fc64..0d8cbc241 100644 --- a/src/home/UnauthenticatedView.tsx +++ b/src/home/UnauthenticatedView.tsx @@ -88,7 +88,8 @@ export const UnauthenticatedView: FC = () => { // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-ignore if (error.errcode === "M_ROOM_IN_USE") { - setOnFinished(() => { + // Wrapped once more, as a bare function would be taken for an updater + setOnFinished(() => () => { setSignedIn(); const aliasLocalpart = roomAliasLocalpartFromRoomName(roomName); navigate(`/${aliasLocalpart}`)?.catch((error) => { diff --git a/src/room/RoomPage.test.tsx b/src/room/RoomPage.test.tsx new file mode 100644 index 000000000..8c5444787 --- /dev/null +++ b/src/room/RoomPage.test.tsx @@ -0,0 +1,101 @@ +/* +Copyright 2026 Element Creations Ltd. + +SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial +Please see LICENSE in the repository root for full details. +*/ + +import { afterEach, expect, test, vi } from "vitest"; +import { render, screen } from "@testing-library/react"; +import { MemoryRouter } from "react-router-dom"; +import { type MatrixClient } from "matrix-js-sdk"; +import { BehaviorSubject } from "rxjs"; + +import { RoomPage } from "./RoomPage"; +import { ClientContextProvider } from "../ClientContext"; +import { type ClientSessionState } from "../state/ClientSession"; +import { computeUrlParams, UrlParamsProvider } from "../UrlParams"; +import { useLoadGroupCall } from "./useLoadGroupCall"; + +vi.mock("./useLoadGroupCall", () => ({ + useLoadGroupCall: vi.fn(() => ({ kind: "loading" })), + CallTerminatedMessage: class extends Error {}, +})); +vi.mock("./useRoomName", () => ({ useRoomName: () => null })); +vi.mock("../profile/useProfile", () => ({ useProfile: () => ({}) })); +vi.mock("../auth/useRegisterPasswordlessUser", () => ({ + useRegisterPasswordlessUser: () => ({ registerPasswordlessUser }), +})); +vi.mock("./RoomAuthView", () => ({ + RoomAuthView: () => room auth view, +})); +vi.mock("../home/HomePage", () => ({ + HomePage: () => home page, +})); +vi.mock("./CallView", () => ({ + CallView: ({ isPasswordlessUser }: { isPasswordlessUser: boolean }) => ( + call view, passwordless: {String(isPasswordlessUser)} + ), +})); +vi.mock("./KnockLobbyView", () => ({ KnockLobbyView: () => null })); + +const registerPasswordlessUser = vi.fn().mockResolvedValue(undefined); + +afterEach(() => vi.clearAllMocks()); + +test("waits for the session to be restored", () => { + renderRoom({ state: "loading" }, "/call"); + expect(screen.getByRole("heading", { name: "Loading…" })).toBeVisible(); +}); + +test("asks a signed-out user to join as a guest", () => { + renderRoom({ state: "signedOut" }, "/call"); + expect(screen.getByText("room auth view")).toBeVisible(); + expect(registerPasswordlessUser).not.toHaveBeenCalled(); +}); + +test("registers a passwordless user when the URL names one", () => { + renderRoom({ state: "signedOut" }, "/call", "Alice"); + expect(registerPasswordlessUser).toHaveBeenCalledWith("Alice"); +}); + +test("falls back to the home page without a room", () => { + renderRoom(signedIn(false), "/"); + expect(screen.getByText("home page")).toBeVisible(); +}); + +test("tells the call whether its user is passwordless", () => { + vi.mocked(useLoadGroupCall).mockReturnValue({ + kind: "loaded", + rtcSession: { room: {} }, + } as unknown as ReturnType); + + renderRoom(signedIn(true), "/call"); + expect(screen.getByText("call view, passwordless: true")).toBeVisible(); +}); + +function signedIn(passwordlessUser: boolean): ClientSessionState { + return { + state: "signedIn", + client: { getUserId: () => "@alice:example.org" } as MatrixClient, + passwordlessUser, + }; +} + +function renderRoom( + state: ClientSessionState, + path: string, + displayName: string | null = null, +): void { + render( + + + (state) }} + > + + + + , + ); +}