@tribe-nest/forge 3.29.0 → 3.34.0

package/src/ui/media/_tests/bookingSession.spec.tsx

@@ -0,0 +1,227 @@
+// @vitest-environment jsdom
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { MediaError } from "@tribe-nest/media-protocol";
+
+import {
+  BOOKING_CALL_CLOSES_MINUTES_AFTER,
+  BOOKING_CALL_OPENS_MINUTES_BEFORE,
+  bookingCallWindow,
+  useBookingSessionCredentials,
+  type BookingCallSubject,
+} from "../bookingSession";
+
+/**
+ * The Forge context, stubbed at the seam the hook actually reads.
+ *
+ * `ForgeClientProvider` builds its Axios instance from an `apiUrl`, so there is
+ * no way to hand it a fake transport from outside; mocking `useForge` is the
+ * only join where a spec can see the request the hook makes.
+ */
+const { post, forgeContext } = vi.hoisted(() => {
+  const post = vi.fn();
+  // ONE object across renders, like the real provider's memoized client. A
+  // fresh one per render would change the hook's dependency and make the
+  // identity assertion below fail against a correct implementation.
+  return { post, forgeContext: { client: { post }, profileId: "11111111-1111-4111-8111-111111111111" } };
+});
+
+vi.mock("../../../provider/ForgeProvider", () => ({ useForge: () => forgeContext }));
+
+/**
+ * The booking half of the media barrel.
+ *
+ * Two things are worth testing here and nothing else is. `bookingCallWindow` is
+ * a total function that decides whether a Join control is drawn at all, and
+ * getting it wrong shows a client a button that 409s or hides one from a
+ * session that has started. `useBookingSessionCredentials` is a transport, and
+ * the property that matters is that it posts to the credential endpoint with
+ * NO body: the endpoint's schema is `.strict()`, so a field added here in a
+ * moment of helpfulness would 400 every call in production.
+ */
+
+const MINUTE = 60_000;
+const HOUR = 60 * MINUTE;
+
+const booking = (overrides: Partial<BookingCallSubject> = {}): BookingCallSubject => ({
+  status: "confirmed",
+  sessionStartTime: new Date("2026-08-20T10:00:00.000Z").toISOString(),
+  sessionEndTime: new Date("2026-08-20T11:00:00.000Z").toISOString(),
+  location: { type: "video" },
+  ...overrides,
+});
+
+const at = (iso: string) => new Date(iso);
+
+describe("the join window, as literal numbers", () => {
+  /**
+   * The one place in this file that does NOT compute its expectation from the
+   * constants.
+   *
+   * Everything below asserts `opensAt` against
+   * `BOOKING_CALL_OPENS_MINUTES_BEFORE`, which is correct for what those tests
+   * are about (the arithmetic) and completely blind to the value: changing 15 to
+   * 60 leaves the whole suite green. The server carries its OWN pair of literals
+   * in `apps/backend/src/services/public/coaching/commands/bookingSession.ts`
+   * (`SESSION_JOIN_OPENS_MINUTES_BEFORE` / `SESSION_JOIN_CLOSES_MINUTES_AFTER`),
+   * whose spec had exactly the same self-referential shape, so a change on
+   * either side was invisible to both suites.
+   *
+   * The server's answer is the one that counts. When these two disagree the
+   * visible result is a Join button drawn 45 minutes before the server will mint
+   * a ticket (a client clicks and gets a bare 409), or a button hidden while the
+   * room is open. So both sides pin the value, and moving it means editing two
+   * specs that name each other.
+   */
+  it("mirrors the server: 15 minutes before, 120 minutes after", () => {
+    expect(BOOKING_CALL_OPENS_MINUTES_BEFORE).toBe(15);
+    expect(BOOKING_CALL_CLOSES_MINUTES_AFTER).toBe(120);
+  });
+});
+
+describe("bookingCallWindow", () => {
+  it("opens exactly the stated number of minutes before the session", () => {
+    const subject = booking();
+    const opensAt = new Date(new Date(subject.sessionStartTime).getTime() - BOOKING_CALL_OPENS_MINUTES_BEFORE * MINUTE);
+
+    expect(bookingCallWindow(subject).opensAt.toISOString()).toBe(opensAt.toISOString());
+    // One millisecond either side of the boundary, so an off-by-one in the
+    // comparison cannot pass: a client refreshing at the advertised minute must
+    // get in, and one refreshing a moment earlier must not.
+    expect(bookingCallWindow(subject, new Date(opensAt.getTime() - 1)).isOpen).toBe(false);
+    expect(bookingCallWindow(subject, opensAt).isOpen).toBe(true);
+  });
+
+  it("stays open after the hour ends, then shuts", () => {
+    const subject = booking();
+    const closesAt = new Date(new Date(subject.sessionEndTime).getTime() + BOOKING_CALL_CLOSES_MINUTES_AFTER * MINUTE);
+
+    expect(bookingCallWindow(subject).closesAt.toISOString()).toBe(closesAt.toISOString());
+    // A session that runs over must not be cut off, which is what the window
+    // after the end is for.
+    expect(bookingCallWindow(subject, at("2026-08-20T11:30:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, closesAt).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, new Date(closesAt.getTime() + 1)).isOpen).toBe(false);
+  });
+
+  it("is not a video call when the location is anything else", () => {
+    const midSession = at("2026-08-20T10:30:00.000Z");
+
+    for (const location of [{ type: "online" }, { type: "in_person" }, null, undefined]) {
+      const window = bookingCallWindow(booking({ location }), midSession);
+      expect(window.isVideo).toBe(false);
+      // Never open, however good the timing is: there is no room to enter.
+      expect(window.isOpen).toBe(false);
+    }
+  });
+
+  it("is not a video call when the booking is not confirmed", () => {
+    const midSession = at("2026-08-20T10:30:00.000Z");
+    // A cancelled session has no room. The server withholds `location`
+    // entirely for one, so this is belt and braces against a cached row.
+    const window = bookingCallWindow(booking({ status: "canceled" }), midSession);
+    expect(window.isVideo).toBe(false);
+    expect(window.isOpen).toBe(false);
+  });
+
+  it("holds for a session whose window straddles a day boundary", () => {
+    const subject = booking({
+      sessionStartTime: "2026-08-20T23:50:00.000Z",
+      sessionEndTime: "2026-08-21T00:50:00.000Z",
+    });
+    expect(bookingCallWindow(subject, at("2026-08-20T23:40:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, at("2026-08-20T23:34:00.000Z")).isOpen).toBe(false);
+    expect(bookingCallWindow(subject, at("2026-08-21T02:49:00.000Z")).isOpen).toBe(true);
+    expect(bookingCallWindow(subject, at("2026-08-21T02:51:00.000Z")).isOpen).toBe(false);
+  });
+});
+
+describe("useBookingSessionCredentials", () => {
+  beforeEach(() => {
+    post.mockReset();
+    post.mockResolvedValue({
+      data: {
+        mediaUrl: "wss://media.test",
+        token: "tok",
+        expiresAt: "2026-08-20T10:10:00.000Z",
+        identity: "guest-acc-1",
+        roomId: "booking-booking-1",
+        grants: { canPublish: true, canSubscribe: true, canPublishData: true },
+        role: "guest",
+        roomOpensAt: "2026-08-20T09:45:00.000Z",
+        roomClosesAt: "2026-08-20T13:00:00.000Z",
+      },
+    });
+  });
+
+  it("posts an EMPTY body to this booking's credential endpoint", async () => {
+    const getCredentials = renderHook(() => useBookingSessionCredentials("booking-1")).result.current;
+
+    const credentials = await getCredentials();
+
+    expect(post).toHaveBeenCalledTimes(1);
+    expect(post).toHaveBeenCalledWith("/public/coaching/bookings/booking-1/session/join", {});
+    // The endpoint's schema is `.strict()` and declares no fields at all, so a
+    // `profileId` added here in a moment of helpfulness would 400 every call.
+    // Asserting the exact second argument is what catches that.
+    expect(credentials.roomId).toBe("booking-booking-1");
+    expect(credentials.role).toBe("guest");
+  });
+
+  /**
+   * The server's refusal must reach the screen as the server's SENTENCE. Left
+   * as an axios error, the SDK read it as a dropped socket and the screen said
+   * "Connection lost" about a call the person was never in.
+   */
+  it("turns the server's refusal into a MediaError carrying its message", async () => {
+    post.mockRejectedValueOnce({
+      response: { status: 409, data: { message: "The room opens 15 minutes before the session." } },
+    });
+    const getCredentials = renderHook(() => useBookingSessionCredentials("booking-1")).result.current;
+
+    const error: unknown = await getCredentials().then(
+      () => undefined,
+      (e: unknown) => e,
+    );
+
+    expect(error).toBeInstanceOf(MediaError);
+    expect((error as MediaError).message).toBe("The room opens 15 minutes before the session.");
+    expect((error as MediaError).code).toBe("bad_request");
+    expect((error as MediaError).retryable).toBe(false);
+  });
+
+  it("maps a 401 and a 404 to the SDK's own codes, and a 5xx to a retryable internal", async () => {
+    const getCredentials = renderHook(() => useBookingSessionCredentials("booking-1")).result.current;
+    const refusal = async (status: number) => {
+      post.mockRejectedValueOnce({ response: { status, data: { message: `status ${status}` } } });
+      return getCredentials().then(
+        () => undefined,
+        (e: unknown) => e as MediaError,
+      );
+    };
+
+    expect((await refusal(401))?.code).toBe("unauthorized");
+    expect((await refusal(404))?.code).toBe("no_such_room");
+    const internal = await refusal(503);
+    expect(internal?.code).toBe("internal");
+    expect(internal?.retryable).toBe(true);
+  });
+
+  it("leaves a network failure alone, because that one really is a connection problem", async () => {
+    const network = new Error("Network Error");
+    post.mockRejectedValueOnce(network);
+    const getCredentials = renderHook(() => useBookingSessionCredentials("booking-1")).result.current;
+
+    await expect(getCredentials()).rejects.toBe(network);
+  });
+
+  it("keeps ONE callback identity per booking", () => {
+    const { result, rerender } = renderHook(() => useBookingSessionCredentials("booking-1"));
+    const first = result.current;
+    rerender();
+    // `<MediaRoomProvider>` holds its options in a ref because an inline arrow
+    // would be a new function every render; a callback that changed identity on
+    // every parent render would defeat that and reconnect a live call.
+    expect(result.current).toBe(first);
+  });
+});