Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

Use named errors for Space friendships

Manav Rathif0968aaed332
diff --git a/rust/bindings/wasm/space/src/space.rs b/rust/bindings/wasm/space/src/space.rs
index 3c93394b5d..25efd6f00b 100644
--- a/rust/bindings/wasm/space/src/space.rs
+++ b/rust/bindings/wasm/space/src/space.rs
@@ -31,6 +31,14 @@ impl Error {
Self::Space(ente_space::Error::InvalidSpaceSlug) => Some("invalid_space_slug"),
Self::Space(ente_space::Error::PostLimitReached) => Some("post_limit_reached"),
Self::Space(ente_space::Error::FriendLimitReached) => Some("friend_limit_reached"),
+ Self::Space(ente_space::Error::ProfileNotFound) => Some("profile_not_found"),
+ Self::Space(ente_space::Error::SelfFriendship) => Some("self_friendship"),
+ Self::Space(ente_space::Error::FriendRequestLimitReached) => {
+ Some("friend_request_limit_reached")
+ }
+ Self::Space(ente_space::Error::FriendRequestUnavailable) => {
+ Some("friend_request_unavailable")
+ }
Self::Space(ente_space::Error::SessionUnauthorized) => Some("session_unauthorized"),
Self::Space(ente_space::Error::PermissionDenied) => Some("permission_denied"),
_ => None,
diff --git a/rust/crates/space/src/client/friends.rs b/rust/crates/space/src/client/friends.rs
index 03fed66284..301e543761 100644
--- a/rust/crates/space/src/client/friends.rs
+++ b/rust/crates/space/src/client/friends.rs
@@ -11,9 +11,13 @@ use ente_core::http;
fn map_friend_mutation_error(error: http::Error) -> Error {
match &error {
- http::Error::Api { code, .. } if code == "SPACE_FRIEND_LIMIT_REACHED" => {
- Error::FriendLimitReached
- }
+ http::Error::Api { code, .. } => match code.as_str() {
+ "SPACE_FRIEND_LIMIT_REACHED" => Error::FriendLimitReached,
+ "SPACE_SELF_FRIENDSHIP" => Error::SelfFriendship,
+ "SPACE_FRIEND_REQUEST_LIMIT_REACHED" => Error::FriendRequestLimitReached,
+ "SPACE_FRIEND_REQUEST_UNAVAILABLE" => Error::FriendRequestUnavailable,
+ _ => error.into(),
+ },
_ => error.into(),
}
}
@@ -112,7 +116,7 @@ impl AccountSpaceCtx {
.await?
.into_iter()
.find(|value| value.request_id == request_id)
- .ok_or_else(|| Error::InvalidInput("friend request is not available".into()))?;
+ .ok_or(Error::FriendRequestUnavailable)?;
if request.requester.public_key.trim().is_empty() {
return Err(Error::InvalidInput(
"requester public key is required".into(),
@@ -149,7 +153,13 @@ impl AccountSpaceCtx {
return Err(Error::InvalidInput("friend request id is required".into()));
}
let path = format!("/spaces/{space_id}/friends/requests/{request_id}");
- self.api().delete(&path).send().await?.error_for_status()?;
+ self.api()
+ .delete(&path)
+ .send()
+ .await?
+ .error_for_code()
+ .await
+ .map_err(map_friend_mutation_error)?;
Ok(())
}
diff --git a/rust/crates/space/src/client/mod.rs b/rust/crates/space/src/client/mod.rs
index 14b76444cf..5db4dd60a1 100644
--- a/rust/crates/space/src/client/mod.rs
+++ b/rust/crates/space/src/client/mod.rs
@@ -373,7 +373,11 @@ impl AccountSpaceCtx {
.get(&path)
.send()
.await?
- .error_for_status()?
+ .error_for_status()
+ .map_err(|error| match error.status_code() {
+ Some(404) => Error::ProfileNotFound,
+ _ => error.into(),
+ })?
.json()
.await?)
}
diff --git a/rust/crates/space/src/error.rs b/rust/crates/space/src/error.rs
index 59cfd4536f..55a0bdd880 100644
--- a/rust/crates/space/src/error.rs
+++ b/rust/crates/space/src/error.rs
@@ -42,6 +42,18 @@ pub enum Error {
#[error("space friend limit reached")]
FriendLimitReached,
+ #[error("space profile not found")]
+ ProfileNotFound,
+
+ #[error("cannot add yourself as a friend")]
+ SelfFriendship,
+
+ #[error("space friend request limit reached")]
+ FriendRequestLimitReached,
+
+ #[error("friend request is no longer available")]
+ FriendRequestUnavailable,
+
#[error("space session is unauthorized")]
SessionUnauthorized,
diff --git a/server/space/controller/friends.go b/server/space/controller/friends.go
index e7688d218a..498822c674 100644
--- a/server/space/controller/friends.go
+++ b/server/space/controller/friends.go
@@ -27,6 +27,14 @@ func newSpaceFriendLimitReachedError() *ente.ApiError {
}
}
+func newSpaceFriendRequestUnavailableError(status int) *ente.ApiError {
+ return &ente.ApiError{
+ Code: ente.ErrorCode("SPACE_FRIEND_REQUEST_UNAVAILABLE"),
+ Message: "friend request is no longer available",
+ HttpStatusCode: status,
+ }
+}
+
func (c *FriendsController) Add(ctx context.Context, requesterSpace *repo.SpaceRecord, req models.AddFriendPayload) (*models.FriendStatusResponse, error) {
if (strings.TrimSpace(req.TargetSpaceID) == "" && strings.TrimSpace(req.TargetUsername) == "") ||
strings.TrimSpace(req.RequesterFriendSealedSpaceKey) == "" ||
@@ -57,7 +65,11 @@ func (c *FriendsController) Add(ctx context.Context, requesterSpace *repo.SpaceR
)
if err != nil {
if errors.Is(stacktrace.RootCause(err), repo.ErrSelfFriendship) {
- return nil, ente.NewBadRequestWithMessage("cannot add yourself as a friend")
+ return nil, &ente.ApiError{
+ Code: ente.ErrorCode("SPACE_SELF_FRIENDSHIP"),
+ Message: "cannot add yourself as a friend",
+ HttpStatusCode: http.StatusBadRequest,
+ }
}
if errors.Is(stacktrace.RootCause(err), repo.ErrAlreadyFriends) {
return &models.FriendStatusResponse{Status: "friend"}, nil
@@ -69,7 +81,11 @@ func (c *FriendsController) Add(ctx context.Context, requesterSpace *repo.SpaceR
return nil, ente.NewBadRequestWithMessage("space key version is stale")
}
if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceFriendRequestLimitReached) {
- return nil, ente.NewConflictError("space friend request limit reached")
+ return nil, &ente.ApiError{
+ Code: ente.ErrorCode("SPACE_FRIEND_REQUEST_LIMIT_REACHED"),
+ Message: "space friend request limit reached",
+ HttpStatusCode: http.StatusConflict,
+ }
}
return nil, err
}
@@ -135,7 +151,10 @@ func (c *FriendsController) ConfirmRequest(ctx context.Context, targetSpace *rep
return nil, newSpaceFriendLimitReachedError()
}
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
- return nil, ente.NewBadRequestWithMessage("friend request is stale or no longer available")
+ return nil, newSpaceFriendRequestUnavailableError(http.StatusBadRequest)
+ }
+ if errors.Is(stacktrace.RootCause(err), repo.ErrSpaceFriendRequestStale) {
+ return nil, ente.NewBadRequestWithMessage("space key version is stale")
}
return nil, err
}
@@ -148,7 +167,7 @@ func (c *FriendsController) ConfirmRequest(ctx context.Context, targetSpace *rep
func (c *FriendsController) DeleteRequest(ctx context.Context, space *repo.SpaceRecord, requestID int64) error {
if err := c.FriendsRepo.DeleteFriendRequest(ctx, space.SpaceID, requestID); err != nil {
if errors.Is(stacktrace.RootCause(err), sql.ErrNoRows) {
- return ente.ErrNotFound
+ return newSpaceFriendRequestUnavailableError(http.StatusNotFound)
}
return err
}
diff --git a/server/space/controller/friends_test.go b/server/space/controller/friends_test.go
index cc6a2024de..e7ca54041f 100644
--- a/server/space/controller/friends_test.go
+++ b/server/space/controller/friends_test.go
@@ -3,8 +3,10 @@ package controller
import (
"context"
"encoding/base64"
+ "net/http"
"testing"
+ "github.com/ente/museum/ente"
"github.com/ente/museum/space/models"
spacerepo "github.com/ente/museum/space/repo"
"github.com/stretchr/testify/require"
@@ -99,8 +101,54 @@ func TestAddFriendRejectsOwnSpace(t *testing.T) {
})
require.Nil(t, resp)
- require.Error(t, err)
- require.Contains(t, err.Error(), "cannot add yourself as a friend")
+ var apiErr *ente.ApiError
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, ente.ErrorCode("SPACE_SELF_FRIENDSHIP"), apiErr.Code)
+ require.Equal(t, http.StatusBadRequest, apiErr.HttpStatusCode)
+}
+
+func TestFriendRequestUnavailableDoesNotIncludeStaleKeys(t *testing.T) {
+ friends, repos, ctx := setupFriendsControllerTest(t)
+ aliceID := insertSpaceControllerUser(t, repos, "[email protected]", "alice-public")
+ bobID := insertSpaceControllerUser(t, repos, "[email protected]", "bob-public")
+ alice, err := testCreateSpace(ctx, repos, aliceID, "alice_request_state", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ bob, err := testCreateSpace(ctx, repos, bobID, "bob_request_state", "root", "public", "secret", "nonce", "profile")
+ require.NoError(t, err)
+ request, _, _, err := repos.Friends.CreateFriendRequest(ctx, aliceID, alice.SpaceID, bob.SpaceID, []byte("requester-key"), alice.CurrentVersion)
+ require.NoError(t, err)
+ confirm := models.ConfirmFriendRequestPayload{
+ TargetFriendSealedSpaceKey: base64.StdEncoding.EncodeToString([]byte("target-key")),
+ TargetKeyVersion: bob.CurrentVersion,
+ }
+
+ staleTarget := confirm
+ staleTarget.TargetKeyVersion++
+ _, err = friends.ConfirmRequest(ctx, bob, request.RequestID, staleTarget)
+ var apiErr *ente.ApiError
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, ente.ErrorCode("BAD_REQUEST"), apiErr.Code)
+ require.Equal(t, "space key version is stale", apiErr.Message)
+
+ _, err = testRotateKey(ctx, repos, aliceID, alice.SpaceID, alice.CurrentVersion, "new-root", "wrapped-previous-key", "new-profile")
+ require.NoError(t, err)
+ _, err = friends.ConfirmRequest(ctx, bob, request.RequestID, confirm)
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, ente.ErrorCode("BAD_REQUEST"), apiErr.Code)
+ require.Equal(t, "space key version is stale", apiErr.Message)
+ requests, err := friends.ListRequests(ctx, bob)
+ require.NoError(t, err)
+ require.Len(t, requests, 1)
+
+ require.NoError(t, friends.DeleteRequest(ctx, alice, request.RequestID))
+ _, err = friends.ConfirmRequest(ctx, bob, request.RequestID, confirm)
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, ente.ErrorCode("SPACE_FRIEND_REQUEST_UNAVAILABLE"), apiErr.Code)
+ require.Equal(t, http.StatusBadRequest, apiErr.HttpStatusCode)
+ err = friends.DeleteRequest(ctx, bob, request.RequestID)
+ require.ErrorAs(t, err, &apiErr)
+ require.Equal(t, ente.ErrorCode("SPACE_FRIEND_REQUEST_UNAVAILABLE"), apiErr.Code)
+ require.Equal(t, http.StatusNotFound, apiErr.HttpStatusCode)
}
func TestUnfriendBySpaceIDRemovesReciprocalShares(t *testing.T) {
diff --git a/server/space/repo/friends.go b/server/space/repo/friends.go
index c1a7dbcad4..009fc74872 100644
--- a/server/space/repo/friends.go
+++ b/server/space/repo/friends.go
@@ -16,6 +16,7 @@ var (
ErrSelfFriendship = errors.New("space users cannot friend themselves")
ErrSpaceFriendLimitReached = errors.New("space friend limit reached")
ErrSpaceFriendRequestLimitReached = errors.New("space friend request limit reached")
+ ErrSpaceFriendRequestStale = errors.New("space friend request keys are stale")
)
const (
@@ -383,7 +384,7 @@ func (r *FriendsRepository) ConfirmFriendRequest(ctx context.Context, targetSpac
return 0, false, stacktrace.Propagate(err, "")
}
if targetCurrentVersion != targetKeyVersion || requesterCurrentVersion != requesterKeyVersion {
- return 0, false, sql.ErrNoRows
+ return 0, false, ErrSpaceFriendRequestStale
}
alreadyFriends, err := areMutualFriendsTx(ctx, tx, requesterSpaceID, targetSpaceID)
diff --git a/server/space/repo/module_test.go b/server/space/repo/module_test.go
index c54962f19e..784df83ca2 100644
--- a/server/space/repo/module_test.go
+++ b/server/space/repo/module_test.go
@@ -2060,7 +2060,7 @@ func TestAddFriendRejectsStaleKeyVersion(t *testing.T) {
require.NoError(t, err)
err = testAddFriend(ctx, module, bobID, bobSpace.SpaceID, aliceSpace.SpaceID, "stale-share-key", aliceSpace.CurrentVersion, "bob-share-key", bobSpace.CurrentVersion)
- require.ErrorIs(t, err, sql.ErrNoRows)
+ require.ErrorIs(t, err, ErrSpaceFriendRequestStale)
_, err = module.Friends.GetShareForFriendAndSpace(ctx, bobSpace.SpaceID, aliceSpace.SpaceID)
require.ErrorIs(t, err, sql.ErrNoRows)
diff --git a/web/apps/space/package.json b/web/apps/space/package.json
index 44039297c5..7f6ce180f8 100644
--- a/web/apps/space/package.json
+++ b/web/apps/space/package.json
@@ -3,7 +3,8 @@
"version": "0.0.0",
"private": true,
"scripts": {
- "build:post": "rm -f out/404.html"
+ "build:post": "rm -f out/404.html",
+ "test": "vitest --run"
},
"dependencies": {
"@fontsource-variable/inter": "5.2.8",
@@ -20,6 +21,8 @@
"thumbhash": "0.1.1"
},
"devDependencies": {
- "ente-build-config": "*"
+ "ente-build-config": "*",
+ "vite-plugin-wasm": "3.6.0",
+ "vitest": "4.1.8"
}
}
diff --git a/web/apps/space/src/components/MessagesPage.tsx b/web/apps/space/src/components/MessagesPage.tsx
index ece27c6ec9..cfe50a13c0 100644
--- a/web/apps/space/src/components/MessagesPage.tsx
+++ b/web/apps/space/src/components/MessagesPage.tsx
@@ -11,8 +11,6 @@ import {
confirmCurrentFriendRequest,
deleteCurrentFriendRequest,
deleteCurrentMessage,
- isFriendRequestCanceledError,
- isSpaceFriendLimitError,
loadCurrentMessageActivityPostPreview,
loadCurrentMessageConversationAvatar,
loadCurrentMessageConversations,
@@ -29,6 +27,10 @@ import {
} from "services/space";
import { useSpaceAppState } from "state/app-state";
import { spaceAppBackgroundColor } from "styles/colors";
+import {
+ isFriendRequestCanceledError,
+ isSpaceFriendLimitError,
+} from "utils/friend-errors";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
diff --git a/web/apps/space/src/pages/app/friends/index.tsx b/web/apps/space/src/pages/app/friends/index.tsx
index 38b85c2bfb..b43f1a6244 100644
--- a/web/apps/space/src/pages/app/friends/index.tsx
+++ b/web/apps/space/src/pages/app/friends/index.tsx
@@ -11,8 +11,6 @@ import {
clearSpaceFriendsCache,
confirmCurrentFriendRequest,
deleteCurrentFriendRequest,
- isFriendRequestCanceledError,
- isSpaceFriendLimitError,
loadCurrentFriendAvatarURL,
loadCurrentFriendRequests,
loadCurrentSpaceFriends,
@@ -22,6 +20,10 @@ import {
} from "services/space";
import { useSpaceAppState } from "state/app-state";
import { spaceAppBackgroundColor } from "styles/colors";
+import {
+ isFriendRequestCanceledError,
+ isSpaceFriendLimitError,
+} from "utils/friend-errors";
import { maximumSpaceFriendCount } from "utils/friend-limits";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
diff --git a/web/apps/space/src/pages/app/index.tsx b/web/apps/space/src/pages/app/index.tsx
index b92325b0cc..49b26aa52e 100644
--- a/web/apps/space/src/pages/app/index.tsx
+++ b/web/apps/space/src/pages/app/index.tsx
@@ -20,8 +20,6 @@ import {
clearSpaceFriendsCache,
confirmCurrentFriendRequest,
deleteCurrentFriendRequest,
- isFriendRequestCanceledError,
- isSpaceFriendLimitError,
loadCurrentFriendAvatarURL,
loadCurrentFriendRequests,
loadCurrentSpaceFriends,
@@ -35,6 +33,10 @@ import {
} from "services/space";
import { useSpaceAppState } from "state/app-state";
import { spaceAppBackgroundColor } from "styles/colors";
+import {
+ isFriendRequestCanceledError,
+ isSpaceFriendLimitError,
+} from "utils/friend-errors";
import { maximumSpaceFriendCount } from "utils/friend-limits";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
diff --git a/web/apps/space/src/pages/index.tsx b/web/apps/space/src/pages/index.tsx
index 0facecebbd..d32c593407 100644
--- a/web/apps/space/src/pages/index.tsx
+++ b/web/apps/space/src/pages/index.tsx
@@ -26,7 +26,6 @@ import {
type SpaceInviteRoute,
} from "services/invite";
import {
- isSpaceFriendLimitError,
loadCurrentSpaceRelationship,
loadPublicSpaceIdentity,
openPublicSpaceLink,
@@ -37,6 +36,7 @@ import {
} from "services/space";
import { useSpaceAppState, type OnboardingEntrySource } from "state/app-state";
import { spaceAppBackgroundColor } from "styles/colors";
+import { isSpaceFriendLimitError } from "utils/friend-errors";
import { profilePostItemsFromPosts } from "utils/post-display";
import { useSpaceRouter } from "utils/route-transitions";
import { spaceRoutes } from "utils/routes";
diff --git a/web/apps/space/src/screens/FriendsScreen.tsx b/web/apps/space/src/screens/FriendsScreen.tsx
index 18bef63251..2cd50520ca 100644
--- a/web/apps/space/src/screens/FriendsScreen.tsx
+++ b/web/apps/space/src/screens/FriendsScreen.tsx
@@ -32,10 +32,7 @@ import {
normalizeSpaceUsername,
spaceUsernameValidationError,
} from "services/profile";
-import {
- isSpaceFriendLimitError,
- type SpaceFriendRequest,
-} from "services/space";
+import type { SpaceFriendRequest } from "services/space";
import {
spaceAppBackground,
spaceDialogBackground,
@@ -45,6 +42,10 @@ import {
spaceTextMuted,
} from "styles/colors";
import { spaceTouchTargetSize } from "styles/touch-targets";
+import {
+ friendRequestErrorMessage,
+ isSpaceFriendLimitError,
+} from "utils/friend-errors";
import {
maximumSpaceFriendCount,
spaceFriendLimitMessage,
@@ -630,30 +631,6 @@ interface AddFriendSheetProps {
username: string;
}
-const friendRequestErrorMessage = (error: unknown, username: string) => {
- if (isSpaceFriendLimitError(error)) return spaceFriendLimitMessage;
- if (!error || typeof error != "object") {
- return "Couldn't send the friend request. Please try again.";
- }
-
- const { message, status } = error as {
- message?: unknown;
- status?: unknown;
- };
- if (status == 404) return `No Space profile found for @${username}.`;
- if (
- status == 400 &&
- typeof message == "string" &&
- message.includes("cannot add yourself")
- ) {
- return "You can't add yourself as a friend.";
- }
- if (status == 409) {
- return `@${username} can't receive more friend requests right now.`;
- }
- return "Couldn't send the friend request. Please try again.";
-};
-
const AddFriendSheet: React.FC<AddFriendSheetProps> = ({
friendRequests,
friends,
diff --git a/web/apps/space/src/services/space.ts b/web/apps/space/src/services/space.ts
index 6cf55d6060..c0590111d6 100644
--- a/web/apps/space/src/services/space.ts
+++ b/web/apps/space/src/services/space.ts
@@ -28,6 +28,7 @@ import {
parseSpaceProfilePayload,
spaceProfileTextField,
} from "services/profile-payload";
+import { isFriendRequestCanceledError } from "utils/friend-errors";
import { normalizeSpaceMessageText } from "utils/message-limits";
export { clearSpaceMediaURLCache } from "services/media-cache";
@@ -382,9 +383,6 @@ interface SpaceConversationsContext {
export const isSpaceContentError = (error: unknown) =>
isNamedError(error, "content_unavailable");
-export const isSpaceFriendLimitError = (error: unknown) =>
- isNamedError(error, "friend_limit_reached");
-
const timestampMsFromSpaceDate = (value: string) => {
const parsed = Date.parse(value);
if (!Number.isFinite(parsed)) {
@@ -1642,23 +1640,6 @@ export const confirmCurrentFriendRequest = async (
}
};
-export const isFriendRequestCanceledError = (error: unknown) => {
- if (!error || typeof error != "object") return false;
-
- const { code, message, status } = error as {
- code?: unknown;
- message?: unknown;
- status?: unknown;
- };
- return (
- status == 400 ||
- status == 404 ||
- (code == "invalid_input" &&
- typeof message == "string" &&
- message.includes("friend request is not available"))
- );
-};
-
export const deleteCurrentFriendRequest = async (
spaceId: string,
requestId: number,
diff --git a/web/apps/space/src/utils/friend-errors.ts b/web/apps/space/src/utils/friend-errors.ts
new file mode 100644
index 0000000000..02e79ec7b1
--- /dev/null
+++ b/web/apps/space/src/utils/friend-errors.ts
@@ -0,0 +1,22 @@
+import { isNamedError } from "ente-base/error";
+import { spaceFriendLimitMessage } from "./friend-limits";
+
+export const isSpaceFriendLimitError = (error: unknown) =>
+ isNamedError(error, "friend_limit_reached");
+
+export const isFriendRequestCanceledError = (error: unknown) =>
+ isNamedError(error, "friend_request_unavailable");
+
+export const friendRequestErrorMessage = (error: unknown, username: string) => {
+ if (isSpaceFriendLimitError(error)) return spaceFriendLimitMessage;
+ if (isNamedError(error, "profile_not_found")) {
+ return `No Space profile found for @${username}.`;
+ }
+ if (isNamedError(error, "self_friendship")) {
+ return "You can't add yourself as a friend.";
+ }
+ if (isNamedError(error, "friend_request_limit_reached")) {
+ return `@${username} can't receive more friend requests right now.`;
+ }
+ return "Couldn't send the friend request. Please try again.";
+};
diff --git a/web/apps/space/tests/friend-errors.test.ts b/web/apps/space/tests/friend-errors.test.ts
new file mode 100644
index 0000000000..e33bd69db7
--- /dev/null
+++ b/web/apps/space/tests/friend-errors.test.ts
@@ -0,0 +1,149 @@
+import {
+ encryptSpaceRootEntityKey,
+ openSpaceAccountContext,
+ type SpaceAccountCtxHandle,
+} from "ente-space-wasm";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import {
+ friendRequestErrorMessage,
+ isFriendRequestCanceledError,
+} from "../src/utils/friend-errors";
+import { spaceFriendLimitMessage } from "../src/utils/friend-limits";
+
+let ctx: SpaceAccountCtxHandle;
+const publicKey = Buffer.from([9, ...new Array<number>(31).fill(0)]).toString(
+ "base64",
+);
+
+beforeEach(async () => {
+ const key = Buffer.alloc(32, 1).toString("base64");
+ ctx = await openSpaceAccountContext({
+ baseUrl: "http://localhost",
+ clientPackage: "io.ente.space.web",
+ spaceRootKeyB64: key,
+ spaceSessionToken: "test-token",
+ ownedSpaces: [
+ {
+ spaceId: "self",
+ spaceSlug: "self",
+ keyVersion: 1,
+ rootWrappedSpaceKey: await encryptSpaceRootEntityKey(key, key),
+ },
+ ],
+ });
+});
+
+afterEach(() => {
+ ctx.free();
+ vi.unstubAllGlobals();
+});
+
+test("an absent request reaches the cancellation handler", async () => {
+ mockFetch(() => Response.json([]));
+ const error: unknown = await ctx
+ .confirmFriendRequest("self", 1n)
+ .catch((e: unknown) => e);
+ expect(error).toBeInstanceOf(Error);
+ expect(isFriendRequestCanceledError(error)).toBe(true);
+});
+
+test.each(["confirm", "delete"] as const)(
+ "%s recognizes a request removed on Museum",
+ async (operation) => {
+ mockAPI(
+ "SPACE_FRIEND_REQUEST_UNAVAILABLE",
+ operation == "confirm" ? 400 : 404,
+ );
+ const error: unknown = await (
+ operation == "confirm"
+ ? ctx.confirmFriendRequest("self", 1n)
+ : ctx.deleteFriendRequest("self", 1n)
+ ).catch((e: unknown) => e);
+ expect(error).toBeInstanceOf(Error);
+ expect(isFriendRequestCanceledError(error)).toBe(true);
+ },
+);
+
+test.each([400, 404, 409, 500])(
+ "HTTP %i without the unavailable code stays an error",
+ async (status) => {
+ mockAPI("BAD_REQUEST", status);
+ for (const operation of [
+ () => ctx.confirmFriendRequest("self", 1n),
+ () => ctx.deleteFriendRequest("self", 1n),
+ ]) {
+ const error: unknown = await operation().catch((e: unknown) => e);
+ expect(error).toBeInstanceOf(Error);
+ expect(isFriendRequestCanceledError(error)).toBe(false);
+ }
+ },
+);
+
+test("a missing profile reaches the add-friend message", async () => {
+ mockFetch(() => new Response(null, { status: 404 }));
+ const error: unknown = await ctx
+ .requestFriendByUsername("self", "missing")
+ .catch((e: unknown) => e);
+ expect(error).toBeInstanceOf(Error);
+ expect(friendRequestErrorMessage(error, "missing")).toBe(
+ "No Space profile found for @missing.",
+ );
+});
+
+test.each([
+ ["SPACE_SELF_FRIENDSHIP", 400, "You can't add yourself as a friend."],
+ [
+ "SPACE_FRIEND_REQUEST_LIMIT_REACHED",
+ 409,
+ "@friend can't receive more friend requests right now.",
+ ],
+ ["SPACE_FRIEND_LIMIT_REACHED", 409, spaceFriendLimitMessage],
+ ["CONFLICT", 409, "Couldn't send the friend request. Please try again."],
+] as const)(
+ "%s reaches the add-friend message",
+ async (code, status, message) => {
+ mockAPI(code, status);
+ const error: unknown = await ctx
+ .requestFriendByUsername("self", "friend")
+ .catch((e: unknown) => e);
+ expect(error).toBeInstanceOf(Error);
+ expect(friendRequestErrorMessage(error, "friend")).toBe(message);
+ },
+);
+
+const mockAPI = (code: string, status: number) =>
+ mockFetch((request) => {
+ const path = new URL(request.url).pathname;
+ if (path == "/space/public/by-slug/friend") {
+ return Response.json({
+ spaceId: "friend",
+ spaceSlug: "friend",
+ owner: "friend",
+ publicKey,
+ });
+ }
+ if (
+ request.method == "GET" &&
+ path == "/spaces/self/friends/requests"
+ ) {
+ return Response.json([
+ {
+ requestId: 1,
+ requester: {
+ spaceId: "friend",
+ spaceSlug: "friend",
+ publicKey,
+ },
+ createdAt: "2026-09-07T00:00:00Z",
+ },
+ ]);
+ }
+ return Response.json({ code }, { status });
+ });
+
+const mockFetch = (respond: (request: Request) => Response) =>
+ vi.stubGlobal("fetch", (request: Request) => {
+ const response = respond(request);
+ Object.defineProperty(response, "url", { value: request.url });
+ return Promise.resolve(response);
+ });
diff --git a/web/apps/space/tsconfig.json b/web/apps/space/tsconfig.json
index dae6dd4afe..f60ef372f3 100644
--- a/web/apps/space/tsconfig.json
+++ b/web/apps/space/tsconfig.json
@@ -3,6 +3,8 @@
"compilerOptions": { "baseUrl": "./src", "ignoreDeprecations": "6.0" },
"include": [
"src",
+ "tests",
+ "vitest.config.ts",
"next-env.d.ts",
"../../packages/base/global-electron.d.ts",
"../../packages/base/global-css.d.ts",
diff --git a/web/apps/space/vitest.config.ts b/web/apps/space/vitest.config.ts
new file mode 100644
index 0000000000..0b2f1a1c24
--- /dev/null
+++ b/web/apps/space/vitest.config.ts
@@ -0,0 +1,5 @@
+import type { PluginOption } from "vite";
+import wasm from "vite-plugin-wasm";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({ plugins: [wasm() as PluginOption] });
diff --git a/web/package-lock.json b/web/package-lock.json
index 7fcfe6e312..f2d47c2adc 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -354,7 +354,9 @@
"thumbhash": "0.1.1"
},
"devDependencies": {
- "ente-build-config": "*"
+ "ente-build-config": "*",
+ "vite-plugin-wasm": "3.6.0",
+ "vitest": "4.1.8"
}
},
"apps/space/node_modules/@hugeicons/react": {
diff --git a/web/package.json b/web/package.json
index 690a0bf569..f082ee49d2 100644
--- a/web/package.json
+++ b/web/package.json
@@ -52,7 +52,7 @@
"dev:twoof3": "npm exec --workspace twoof3 -- next dev --webpack -p 3012",
"lint": "concurrently --names 'prettier,eslint,tsc,wasm-imports' \"prettier --check --log-level warn .\" \"npm exec --workspaces -- eslint --max-warnings 0\" \"npm exec --workspaces -- tsc\" \"npm run check:wasm-imports\"",
"lint:fix": "concurrently --names 'prettier,eslint,tsc' \"prettier --write --log-level warn .\" \"npm exec --workspaces -- eslint --fix --max-warnings 0\" \"npm exec --workspaces -- tsc\"",
- "test": "npm run test --workspace ente-prelogin-wasm && npm run test --workspace ente-locker-wasm && npm run test --workspace ente-paste-wasm && npm run test --workspace ente-contacts && npm run test --workspace locker && npm run test --workspace photos"
+ "test": "npm run test --workspace ente-prelogin-wasm && npm run test --workspace ente-locker-wasm && npm run test --workspace ente-paste-wasm && npm run test --workspace ente-contacts && npm run test --workspace locker && npm run test --workspace photos && npm run test --workspace space"
},
"overrides": {
"@types/react": "19.2.17",