mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
432ec4ae68
Use Go 1.27.4 in CI and Docker for the standard library security fixes. Wait for a memo's queued updates to settle before a Space change refreshes all memo queries, so older reads cannot replace newer optimistic edits. Cover successful and failed queued updates and unrelated pending memos.
544 lines
26 KiB
TypeScript
544 lines
26 KiB
TypeScript
import { create } from "@bufbuild/protobuf";
|
|
import { focusManager, QueryClient, QueryClientProvider } from "@tanstack/react-query";
|
|
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
import type { ReactNode } from "react";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { attachmentKeys } from "@/hooks/useAttachmentQueries";
|
|
import {
|
|
findMemoInCollectionQueries,
|
|
memoKeys,
|
|
useCreateMemo,
|
|
useMemo,
|
|
useMemoByName,
|
|
useMemoRecord,
|
|
useMemos,
|
|
useUpdateMemo,
|
|
} from "@/hooks/useMemoQueries";
|
|
import { memoShareKeys } from "@/hooks/useMemoShareQueries";
|
|
import { userKeys } from "@/hooks/useUserQueries";
|
|
import { ListMemoCommentsResponseSchema, ListMemosResponseSchema, type Memo, MemoSchema } from "@/types/proto/api/memo_service_pb";
|
|
|
|
const api = vi.hoisted(() => ({
|
|
getMemo: vi.fn(),
|
|
listMemos: vi.fn(),
|
|
updateMemo: vi.fn(),
|
|
createMemo: vi.fn(),
|
|
createMemoComment: vi.fn(),
|
|
}));
|
|
vi.mock("@/connect", () => ({ memoServiceClient: api }));
|
|
|
|
const setup = () => {
|
|
const client = new QueryClient({ defaultOptions: { queries: { retry: false, retryDelay: 0 }, mutations: { retry: false } } });
|
|
const wrapper = ({ children }: { children: ReactNode }) => <QueryClientProvider client={client}>{children}</QueryClientProvider>;
|
|
return { client, wrapper };
|
|
};
|
|
|
|
const memo = (name: string, content = name): Memo => create(MemoSchema, { name, content });
|
|
|
|
describe("useMemoRecord", () => {
|
|
beforeEach(() => vi.resetAllMocks());
|
|
|
|
it("reads a memo from an infinite list page without a request", () => {
|
|
const { client, wrapper } = setup();
|
|
const listed = memo("memos/listed");
|
|
client.setQueryData(memoKeys.list({}), { pages: [create(ListMemosResponseSchema, { memos: [listed] })], pageParams: [""] });
|
|
|
|
const { result } = renderHook(() => useMemoRecord(listed.name), { wrapper });
|
|
|
|
expect(result.current).toBe(listed);
|
|
expect(api.getMemo).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("reads a memo from comment pages, the calendar month and a shared memo", () => {
|
|
const { client, wrapper } = setup();
|
|
const comment = memo("memos/comment");
|
|
const monthly = memo("memos/monthly");
|
|
const shared = memo("memos/shared");
|
|
client.setQueryData([...memoKeys.comments("memos/parent"), "infinite", 50], {
|
|
pages: [create(ListMemoCommentsResponseSchema, { comments: [comment] })],
|
|
pageParams: [""],
|
|
});
|
|
client.setQueryData([...memoKeys.lists(), "calendar-month", { filter: "", orderBy: "" }], [monthly]);
|
|
client.setQueryData(memoShareKeys.byShare("token"), shared);
|
|
|
|
const { result } = renderHook(
|
|
() => [useMemoRecord(comment.name), useMemoRecord(monthly.name), useMemoRecord(shared.name), useMemoRecord("memos/none")],
|
|
{ wrapper },
|
|
);
|
|
|
|
expect(result.current).toEqual([comment, monthly, shared, undefined]);
|
|
});
|
|
|
|
it("prefers the copy fetched most recently", () => {
|
|
const { client, wrapper } = setup();
|
|
const stale = memo("memos/x", "old");
|
|
const fresh = memo("memos/x", "new");
|
|
client.setQueryData(memoKeys.detail(stale.name), stale, { updatedAt: 1_000 });
|
|
client.setQueryData(memoKeys.list({}), create(ListMemosResponseSchema, { memos: [fresh] }), { updatedAt: 2_000 });
|
|
|
|
const { result } = renderHook(() => useMemoRecord(stale.name), { wrapper });
|
|
|
|
expect(result.current).toBe(fresh);
|
|
});
|
|
|
|
it("follows the list's refetch and a mutation's optimistic patch", async () => {
|
|
const { client, wrapper } = setup();
|
|
const before = memo("memos/x", "before");
|
|
client.setQueryData(memoKeys.list({}), create(ListMemosResponseSchema, { memos: [before] }));
|
|
let resolve!: (memo: Memo) => void;
|
|
api.updateMemo.mockImplementation(
|
|
() =>
|
|
new Promise<Memo>((done) => {
|
|
resolve = done;
|
|
}),
|
|
);
|
|
|
|
const { result } = renderHook(() => ({ record: useMemoRecord(before.name), update: useUpdateMemo(before.name) }), { wrapper });
|
|
expect(result.current.record?.content).toBe("before");
|
|
|
|
act(() => {
|
|
client.setQueryData(memoKeys.list({}), create(ListMemosResponseSchema, { memos: [memo("memos/x", "refetched")] }));
|
|
});
|
|
expect(result.current.record?.content).toBe("refetched");
|
|
|
|
act(() => result.current.update.mutate({ update: { name: before.name, content: "edited" }, updateMask: ["content"] }));
|
|
// The optimistic patch, before the server answers.
|
|
await waitFor(() => expect(result.current.record?.content).toBe("edited"));
|
|
expect(result.current.update.isSuccess).toBe(false);
|
|
await act(async () => resolve(memo("memos/x", "edited")));
|
|
await waitFor(() => expect(result.current.update.isSuccess).toBe(true));
|
|
expect(result.current.record?.content).toBe("edited");
|
|
});
|
|
|
|
it("patches an edited comment inside its comment page", async () => {
|
|
const { client, wrapper } = setup();
|
|
const comment = create(MemoSchema, { name: "memos/c", parent: "memos/p", content: "before" });
|
|
const key = [...memoKeys.comments("memos/p"), 0];
|
|
client.setQueryData(key, create(ListMemoCommentsResponseSchema, { comments: [comment] }));
|
|
api.updateMemo.mockImplementation(async ({ memo: update }: { memo: Memo }) => ({ ...comment, ...update }));
|
|
|
|
const { result } = renderHook(() => useUpdateMemo(comment.name), { wrapper });
|
|
act(() => result.current.mutate({ update: { name: comment.name, content: "after" }, updateMask: ["content"] }));
|
|
await waitFor(() => expect(client.getQueryData<{ comments: Memo[] }>(key)?.comments[0].content).toBe("after"));
|
|
await waitFor(() => expect(result.current.isSuccess).toBe(true));
|
|
expect(findMemoInCollectionQueries(client, comment.name)?.content).toBe("after");
|
|
});
|
|
|
|
it("reports a memo recorded as unavailable", () => {
|
|
const { client, wrapper } = setup();
|
|
client.setQueryData(memoKeys.detail("memos/gone"), null);
|
|
client.setQueryData(memoKeys.list({}), create(ListMemosResponseSchema, { memos: [memo("memos/gone")] }));
|
|
|
|
const { result } = renderHook(() => useMemoRecord("memos/gone"), { wrapper });
|
|
|
|
expect(result.current).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe("useMemoByName", () => {
|
|
beforeEach(() => vi.resetAllMocks());
|
|
|
|
it("fetches the detail once when no query holds the memo, then reads the cache", async () => {
|
|
const { client, wrapper } = setup();
|
|
const fetched = memo("memos/deep");
|
|
api.getMemo.mockResolvedValue(fetched);
|
|
|
|
const { result } = renderHook(() => useMemoByName(fetched.name), { wrapper });
|
|
expect(result.current.isLoading).toBe(true);
|
|
await waitFor(() => expect(result.current.data).toEqual(fetched));
|
|
|
|
expect(api.getMemo).toHaveBeenCalledOnce();
|
|
expect(client.getQueryData(memoKeys.detail(fetched.name))).toEqual(fetched);
|
|
await act(async () => {
|
|
await client.invalidateQueries({ queryKey: memoKeys.all, refetchType: "active" });
|
|
});
|
|
expect(api.getMemo).toHaveBeenCalledOnce();
|
|
});
|
|
|
|
it("costs no request when a list already holds the memo", () => {
|
|
const { client, wrapper } = setup();
|
|
const listed = memo("memos/listed");
|
|
client.setQueryData(memoKeys.list({}), create(ListMemosResponseSchema, { memos: [listed] }));
|
|
|
|
const { result } = renderHook(() => useMemoByName(listed.name), { wrapper });
|
|
|
|
expect(result.current.data).toBe(listed);
|
|
expect(result.current.isLoading).toBe(false);
|
|
expect(api.getMemo).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe("useCreateMemo", () => {
|
|
beforeEach(() => vi.resetAllMocks());
|
|
|
|
it("creates a comment through the parent and refreshes the parent's comments", async () => {
|
|
const { client, wrapper } = setup();
|
|
const created = create(MemoSchema, { name: "memos/new", parent: "memos/p", content: "hi" });
|
|
api.createMemoComment.mockResolvedValue(created);
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
|
|
const { result } = renderHook(() => useCreateMemo(), { wrapper });
|
|
await act(async () => {
|
|
await result.current.mutateAsync({ memo: memo("", "hi"), parent: "memos/p" });
|
|
});
|
|
|
|
expect(api.createMemoComment).toHaveBeenCalledWith({ parent: "memos/p", comment: expect.objectContaining({ content: "hi" }) });
|
|
expect(api.createMemo).not.toHaveBeenCalled();
|
|
expect(client.getQueryData(memoKeys.detail(created.name))).toEqual(created);
|
|
const keys = invalidate.mock.calls.map(([filters]) => filters?.queryKey);
|
|
expect(keys).toContainEqual(memoKeys.comments("memos/p"));
|
|
expect(keys).toContainEqual(memoKeys.detail("memos/p"));
|
|
});
|
|
|
|
it("creates a top-level memo without touching any comment query", async () => {
|
|
const { client, wrapper } = setup();
|
|
const created = memo("memos/new", "hi");
|
|
api.createMemo.mockResolvedValue(created);
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
|
|
const { result } = renderHook(() => useCreateMemo(), { wrapper });
|
|
await act(async () => {
|
|
await result.current.mutateAsync({ memo: memo("", "hi") });
|
|
});
|
|
|
|
expect(api.createMemo).toHaveBeenCalledWith({ memo: expect.objectContaining({ content: "hi" }) });
|
|
expect(invalidate.mock.calls.map(([filters]) => filters?.queryKey?.[1])).not.toContain("comments");
|
|
});
|
|
});
|
|
|
|
describe("useUpdateMemo", () => {
|
|
beforeEach(() => vi.resetAllMocks());
|
|
|
|
// Pin, then unpin before the first reply: two updates of one memo in flight, as a quick second click makes them.
|
|
const pinThenUnpin = () => {
|
|
const { client, wrapper } = setup();
|
|
const target = memo("memos/x");
|
|
client.setQueryData(memoKeys.detail(target.name), target);
|
|
const replies: Array<() => void> = [];
|
|
api.updateMemo.mockImplementation(
|
|
({ memo: update }: { memo: Memo }) =>
|
|
new Promise<Memo>((done) => replies.push(() => done(create(MemoSchema, { ...target, pinned: update.pinned })))),
|
|
);
|
|
const { result } = renderHook(() => ({ record: useMemoRecord(target.name), update: useUpdateMemo(target.name) }), { wrapper });
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: target.name, pinned: true }, updateMask: ["pinned"] });
|
|
result.current.update.mutate({ update: { name: target.name, pinned: false }, updateMask: ["pinned"] });
|
|
});
|
|
// Answers one waiting request: the newest (pop) or the oldest (shift), once every request that can be sent is.
|
|
const answer = async (pick: "newest" | "oldest") => {
|
|
await act(async () => {
|
|
await new Promise((done) => setTimeout(done, 0));
|
|
});
|
|
await waitFor(() => expect(replies.length).toBeGreaterThan(0));
|
|
await act(async () => (pick === "newest" ? replies.pop() : replies.shift())?.());
|
|
};
|
|
return { client, target, result, answer };
|
|
};
|
|
|
|
it("keeps the newer change when the older reply arrives last", async () => {
|
|
const { client, target, result, answer } = pinThenUnpin();
|
|
await waitFor(() => expect(result.current.record?.pinned).toBe(false));
|
|
|
|
await answer("newest");
|
|
await answer("newest");
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
|
|
expect(api.updateMemo.mock.calls.map(([request]) => request.memo.pinned)).toEqual([true, false]);
|
|
expect(client.getQueryData<Memo>(memoKeys.detail(target.name))?.pinned).toBe(false);
|
|
expect(result.current.record?.pinned).toBe(false);
|
|
});
|
|
|
|
it("does not show the older reply while the newer update is still saving", async () => {
|
|
const { client, result, answer } = pinThenUnpin();
|
|
await waitFor(() => expect(result.current.record?.pinned).toBe(false));
|
|
|
|
await answer("oldest");
|
|
expect(result.current.record?.pinned).toBe(false);
|
|
|
|
await answer("oldest");
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
expect(result.current.record?.pinned).toBe(false);
|
|
});
|
|
|
|
it("sends the queued update when the older reply lands while the page is hidden", async () => {
|
|
const { client, result, answer } = pinThenUnpin();
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(1));
|
|
|
|
// The tab is left right after the second click: the unpin must not wait for the return.
|
|
focusManager.setFocused(false);
|
|
try {
|
|
await answer("oldest");
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
await answer("oldest");
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
} finally {
|
|
focusManager.setFocused(undefined);
|
|
}
|
|
expect(result.current.record?.pinned).toBe(false);
|
|
});
|
|
|
|
it("sends a memo's updates in the order they were made, whatever each does before it is sent", async () => {
|
|
const { client, wrapper } = setup();
|
|
const target = memo("memos/x");
|
|
client.setQueryData(memoKeys.detail(target.name), target);
|
|
const replies: Array<() => void> = [];
|
|
api.updateMemo.mockImplementation(
|
|
({ memo: update }: { memo: Memo }) =>
|
|
new Promise<Memo>((done) => replies.push(() => done(create(MemoSchema, { ...target, ...update })))),
|
|
);
|
|
const { result } = renderHook(() => useUpdateMemo(target.name), { wrapper });
|
|
|
|
// A move patches nothing before it is sent, so it is ready to send before the pin made ahead of it.
|
|
act(() => {
|
|
result.current.mutate({ update: { name: target.name, pinned: true }, updateMask: ["pinned"] });
|
|
result.current.mutate({ update: { name: target.name, space: "spaces/b" }, updateMask: ["space"] });
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(1));
|
|
await act(async () => replies[0]());
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
await act(async () => replies[1]());
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
|
|
expect(api.updateMemo.mock.calls.map(([request]) => request.updateMask.paths)).toEqual([["pinned"], ["space"]]);
|
|
});
|
|
|
|
// A detail page and a list on screen, and a fake server that answers both from what it has saved.
|
|
const onScreen = async (before: Memo) => {
|
|
const { client, wrapper } = setup();
|
|
const server = { memo: before };
|
|
api.getMemo.mockImplementation(async () => server.memo);
|
|
api.listMemos.mockImplementation(async () => create(ListMemosResponseSchema, { memos: [server.memo] }));
|
|
client.setQueryData(memoKeys.detail(before.name), before);
|
|
const rendered = renderHook(() => ({ detail: useMemo(before.name), list: useMemos(), update: useUpdateMemo(before.name) }), {
|
|
wrapper,
|
|
});
|
|
await waitFor(() => expect(rendered.result.current.list.data?.memos).toHaveLength(1));
|
|
return { client, server, result: rendered.result };
|
|
};
|
|
|
|
it.each(["succeeds", "fails"])("defers a Space refresh until the last queued update %s", async (outcome) => {
|
|
const before = create(MemoSchema, { name: "memos/x", content: "before", space: "spaces/a" });
|
|
const moved = create(MemoSchema, { ...before, space: "spaces/b" });
|
|
const edited = create(MemoSchema, { ...moved, content: "edited" });
|
|
const { client, server, result } = await onScreen(before);
|
|
const commentsKey = memoKeys.comments(before.name);
|
|
client.setQueryData(commentsKey, create(ListMemoCommentsResponseSchema, { comments: [] }));
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
const replies: Array<{ resolve: (memo: Memo) => void; reject: (error: Error) => void }> = [];
|
|
api.updateMemo.mockImplementation(() => new Promise<Memo>((resolve, reject) => replies.push({ resolve, reject })));
|
|
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: before.name, space: moved.space }, updateMask: ["space"] });
|
|
result.current.update.mutate({ update: { name: before.name, content: edited.content }, updateMask: ["content"] });
|
|
result.current.update.mutate({ update: { name: before.name, pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(1));
|
|
await waitFor(() => expect(result.current.detail.data).toMatchObject({ content: edited.content, pinned: true }));
|
|
|
|
await act(async () => {
|
|
server.memo = moved;
|
|
replies[0].resolve(moved);
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
await waitFor(() => expect(client.isFetching()).toBe(0));
|
|
expect(result.current.detail.data).toMatchObject({ content: edited.content, pinned: true });
|
|
expect(invalidate.mock.calls.map(([filters]) => filters?.queryKey)).not.toContainEqual(memoKeys.all);
|
|
|
|
await act(async () => {
|
|
server.memo = edited;
|
|
replies[1].resolve(edited);
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(3));
|
|
expect(invalidate.mock.calls.map(([filters]) => filters?.queryKey)).not.toContainEqual(memoKeys.all);
|
|
expect(client.getQueryState(commentsKey)?.isInvalidated).toBe(false);
|
|
|
|
await act(async () => {
|
|
if (outcome === "succeeds") {
|
|
server.memo = create(MemoSchema, { ...edited, pinned: true });
|
|
replies[2].resolve(server.memo);
|
|
} else {
|
|
replies[2].reject(new Error("pin failed"));
|
|
}
|
|
});
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
await waitFor(() => expect(client.isFetching()).toBe(0));
|
|
expect(result.current.detail.data).toMatchObject({ space: moved.space, content: edited.content, pinned: outcome === "succeeds" });
|
|
expect(result.current.list.data?.memos[0]).toMatchObject({ content: edited.content, pinned: outcome === "succeeds" });
|
|
expect(invalidate.mock.calls.map(([filters]) => filters?.queryKey)).toContainEqual(memoKeys.all);
|
|
expect(client.getQueryState(commentsKey)?.isInvalidated).toBe(true);
|
|
});
|
|
|
|
it("refreshes a Space change without waiting for an unrelated memo's update", async () => {
|
|
const before = create(MemoSchema, { name: "memos/x", space: "spaces/a" });
|
|
const { client, server, result } = await onScreen(before);
|
|
// Both hooks must use the same client, as they do on a page with multiple memos.
|
|
const { result: other } = renderHook(() => useUpdateMemo("memos/other"), {
|
|
wrapper: ({ children }: { children: ReactNode }) => <QueryClientProvider client={client}>{children}</QueryClientProvider>,
|
|
});
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
api.updateMemo.mockImplementation(({ memo: update }: { memo: Memo }) => {
|
|
if (update.name !== before.name) return new Promise<Memo>(() => {});
|
|
server.memo = create(MemoSchema, { ...before, space: "spaces/b" });
|
|
return Promise.resolve(server.memo);
|
|
});
|
|
act(() => {
|
|
other.current.mutate({ update: { name: "memos/other", pinned: true }, updateMask: ["pinned"] });
|
|
result.current.update.mutate({ update: { name: before.name, space: "spaces/b" }, updateMask: ["space"] });
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
await waitFor(() => expect(result.current.update.isPending).toBe(false));
|
|
expect(client.isMutating()).toBe(1);
|
|
expect(invalidate.mock.calls.map(([filters]) => filters?.queryKey)).toContainEqual(memoKeys.all);
|
|
});
|
|
|
|
it("ends on the server's state when the queued update fails after the older one saved", async () => {
|
|
const before = create(MemoSchema, { name: "memos/x", content: "- [ ] a", snippet: "[ ] a", property: { hasIncompleteTasks: true } });
|
|
// The server derives the snippet and the property from the content, so only its replies carry them.
|
|
const saved = create(MemoSchema, { name: before.name, content: "- [x] a", snippet: "[x] a", property: { hasIncompleteTasks: false } });
|
|
const { client, server, result } = await onScreen(before);
|
|
api.updateMemo
|
|
.mockImplementationOnce(async () => {
|
|
server.memo = saved;
|
|
return saved;
|
|
})
|
|
.mockRejectedValueOnce(new Error("pin failed"));
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: before.name, content: saved.content }, updateMask: ["content"] });
|
|
result.current.update.mutate({ update: { name: before.name, pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
|
|
await waitFor(() => expect(result.current.detail.data?.snippet).toBe(saved.snippet));
|
|
expect(result.current.detail.data?.property?.hasIncompleteTasks).toBe(false);
|
|
expect(result.current.detail.data?.pinned).toBe(false);
|
|
await waitFor(() => expect(result.current.list.data?.memos[0].snippet).toBe(saved.snippet));
|
|
expect(result.current.list.data?.memos[0].property?.hasIncompleteTasks).toBe(false);
|
|
// The saved update refreshes what holds no memo itself, whatever the update behind it does.
|
|
const keys = invalidate.mock.calls.map(([filters]) => filters?.queryKey);
|
|
expect(keys).toContainEqual(userKeys.stats());
|
|
expect(keys).toContainEqual(attachmentKeys.lists());
|
|
});
|
|
|
|
it("sends no refetch that could answer after the newer reply when the older update fails", async () => {
|
|
const before = memo("memos/x");
|
|
const { client, server, result } = await onScreen(before);
|
|
// A refetch answers with what the server held when it was asked, however late.
|
|
const refetches: Array<() => void> = [];
|
|
api.getMemo.mockImplementation(() => {
|
|
const held = server.memo;
|
|
return new Promise<Memo>((done) => refetches.push(() => done(held)));
|
|
});
|
|
api.updateMemo.mockRejectedValueOnce(new Error("edit failed")).mockImplementationOnce(async () => {
|
|
server.memo = create(MemoSchema, { ...before, pinned: true });
|
|
return server.memo;
|
|
});
|
|
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: before.name, content: "edited" }, updateMask: ["content"] });
|
|
result.current.update.mutate({ update: { name: before.name, pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
await act(async () => {
|
|
refetches.forEach((answer) => answer());
|
|
await new Promise((done) => setTimeout(done, 0));
|
|
});
|
|
|
|
expect(client.getQueryData<Memo>(memoKeys.detail(before.name))?.pinned).toBe(true);
|
|
expect(result.current.detail.data?.pinned).toBe(true);
|
|
});
|
|
|
|
it("keeps a queued update's optimistic patch when the older update fails and rolls back", async () => {
|
|
const before = memo("memos/x");
|
|
const { client, result } = await onScreen(before);
|
|
const pinReply: Array<() => void> = [];
|
|
api.updateMemo
|
|
.mockRejectedValueOnce(new Error("edit failed"))
|
|
.mockImplementationOnce(
|
|
() => new Promise<Memo>((done) => pinReply.push(() => done(create(MemoSchema, { ...before, pinned: true })))),
|
|
);
|
|
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: before.name, content: "edited" }, updateMask: ["content"] });
|
|
result.current.update.mutate({ update: { name: before.name, pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
// The edit has failed and rolled back; the pin's reply has not come.
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
await act(async () => {
|
|
await new Promise((done) => setTimeout(done, 0));
|
|
});
|
|
|
|
expect(result.current.detail.data).toMatchObject({ content: before.content, pinned: true });
|
|
expect(result.current.list.data?.memos[0]).toMatchObject({ content: before.content, pinned: true });
|
|
|
|
await act(async () => pinReply[0]());
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
expect(result.current.detail.data).toMatchObject({ content: before.content, pinned: true });
|
|
});
|
|
|
|
it("rolls back to the memo as it was when two updates in a row fail and the refetch fails too", async () => {
|
|
const before = memo("memos/x");
|
|
const { client, result } = await onScreen(before);
|
|
api.updateMemo.mockRejectedValue(new Error("down"));
|
|
api.getMemo.mockRejectedValue(new Error("down"));
|
|
api.listMemos.mockRejectedValue(new Error("down"));
|
|
const invalidate = vi.spyOn(client, "invalidateQueries");
|
|
|
|
// The second update's snapshot is taken over the first one's optimistic patch.
|
|
act(() => {
|
|
result.current.update.mutate({ update: { name: before.name, content: "edited" }, updateMask: ["content"] });
|
|
result.current.update.mutate({
|
|
update: { name: before.name, content: "edited again", pinned: true },
|
|
updateMask: ["content", "pinned"],
|
|
});
|
|
});
|
|
await waitFor(() => expect(client.isMutating()).toBe(0));
|
|
await waitFor(() => expect(client.isFetching()).toBe(0));
|
|
|
|
expect(result.current.detail.data).toMatchObject({ content: before.content, pinned: false });
|
|
expect(result.current.list.data?.memos[0]).toMatchObject({ content: before.content, pinned: false });
|
|
// A failed update refetches the memo and what lists it, not every query under the memo root.
|
|
const keys = invalidate.mock.calls.map(([filters]) => filters?.queryKey);
|
|
expect(keys).toContainEqual(memoKeys.detail(before.name));
|
|
expect(keys).toContainEqual(memoKeys.lists());
|
|
expect(keys).not.toContainEqual(memoKeys.all);
|
|
});
|
|
|
|
it("sends an update of another memo while one memo's update is unanswered", async () => {
|
|
const { wrapper } = setup();
|
|
api.updateMemo.mockImplementation(() => new Promise<Memo>(() => {}));
|
|
const { result } = renderHook(() => ({ a: useUpdateMemo("memos/a"), b: useUpdateMemo("memos/b") }), { wrapper });
|
|
|
|
act(() => {
|
|
result.current.a.mutate({ update: { name: "memos/a", pinned: true }, updateMask: ["pinned"] });
|
|
result.current.b.mutate({ update: { name: "memos/b", pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
});
|
|
|
|
it("sends a queued update when the hook of the update in front of it moves to another memo", async () => {
|
|
const { wrapper } = setup();
|
|
const replies: Array<() => void> = [];
|
|
api.updateMemo.mockImplementation(
|
|
({ memo: update }: { memo: Memo }) =>
|
|
new Promise<Memo>((done) => replies.push(() => done(create(MemoSchema, { name: update.name })))),
|
|
);
|
|
const { result, rerender } = renderHook(({ name }) => ({ moving: useUpdateMemo(name), staying: useUpdateMemo("memos/a") }), {
|
|
wrapper,
|
|
initialProps: { name: "memos/a" },
|
|
});
|
|
act(() => {
|
|
result.current.moving.mutate({ update: { name: "memos/a", content: "edited" }, updateMask: ["content"] });
|
|
result.current.staying.mutate({ update: { name: "memos/a", pinned: true }, updateMask: ["pinned"] });
|
|
});
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(1));
|
|
|
|
rerender({ name: "memos/b" });
|
|
await act(async () => replies[0]());
|
|
|
|
await waitFor(() => expect(api.updateMemo).toHaveBeenCalledTimes(2));
|
|
});
|
|
});
|