Skip to content

Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.

9.6 KB
Raw Blame
import { createRoot } from "react-dom/client";
import { act } from "react-dom/test-utils";
import {
  createMemoryRouter,
  RouterProvider,
  useLoaderData,
} from "react-router-dom";
import { afterEach, beforeEach, expect, test, vi } from "vitest";
import { ResourceForm } from "./resource-form";
import { FetchBackedFormRequest } from "../../../scripts/fetch-backed-form-request";

beforeEach(() => vi.stubGlobal("XMLHttpRequest", FetchBackedFormRequest));

(
  globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;

afterEach(() => vi.unstubAllGlobals());

const success = {
  success: true,
  status: 200,
  results: [
    {
      resourceId: "resource",
      resourceName: "resource",
      status: 200,
      body: { saved: true },
    },
  ],
  errors: [],
};

test("managed submission refreshes mutable page data once without replaying POST", async () => {
  let currentValue = "before";
  const resourceGets = vi.fn(
    async (_request: Request) => new Response(currentValue)
  );
  const loader = vi.fn(async () => ({
    value: await (
      await fetch("https://resource.example/value", { cache: "no-store" })
    ).text(),
  }));
  const posts = vi.fn(async () => {
    currentValue = "after";
    return Response.json(success);
  });
  vi.stubGlobal("fetch", (input: RequestInfo | URL, init?: RequestInit) => {
    const request = new Request(input, init);
    return request.method === "GET" ? resourceGets(request) : posts();
  });
  const results: unknown[] = [];
  const Page = () => {
    const { value } = useLoaderData() as { value: string };
    return (
      <>
        <output>{value}</output>
        <ResourceForm
          data-ws-managed-form-id="form"
          action={[{ dataSourceId: "resource" }]}
          onResultChange={(result) => results.push(result)}
        >
          <button type="submit">Send</button>
        </ResourceForm>
      </>
    );
  };
  const router = createMemoryRouter([{ path: "/", loader, element: <Page /> }]);
  const container = document.createElement("div");
  document.body.append(container);
  const root = createRoot(container);
  try {
    await act(async () => root.render(<RouterProvider router={router} />));
    await vi.waitFor(() =>
      expect(container.querySelector("output")?.textContent).toBe("before")
    );
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() =>
      expect(container.querySelector("output")?.textContent).toBe("after")
    );
    expect(loader).toHaveBeenCalledTimes(2);
    expect(resourceGets).toHaveBeenCalledTimes(2);
    expect(resourceGets.mock.calls[0][0].cache).toBe("no-store");
    expect(posts).toHaveBeenCalledTimes(1);
    expect(results).toEqual([success]);
  } finally {
    await act(async () => root.unmount());
    container.remove();
  }
});

test("failed submissions skip refresh and a later successful submission refreshes", async () => {
  let currentValue = "before";
  const loader = vi.fn(async () => ({ value: currentValue }));
  const posts = vi
    .fn()
    .mockResolvedValueOnce(
      Response.json({
        success: false,
        status: 422,
        results: [],
        errors: [{ status: 422, body: null, message: "failed" }],
      })
    )
    .mockImplementation(async () => {
      currentValue = "after";
      return Response.json(success);
    });
  vi.stubGlobal("fetch", posts);
  const Page = () => {
    const { value } = useLoaderData() as { value: string };
    return (
      <>
        <output>{value}</output>
        <ResourceForm
          data-ws-managed-form-id="form"
          action={[{ dataSourceId: "resource" }]}
        >
          <button type="submit">Send</button>
        </ResourceForm>
      </>
    );
  };
  const router = createMemoryRouter([{ path: "/", loader, element: <Page /> }]);
  const container = document.createElement("div");
  document.body.append(container);
  const root = createRoot(container);
  try {
    await act(async () => root.render(<RouterProvider router={router} />));
    await vi.waitFor(() => expect(loader).toHaveBeenCalledTimes(1));
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() => expect(posts).toHaveBeenCalledTimes(1));
    await vi.waitFor(() =>
      expect(container.querySelector("form")?.hasAttribute("aria-busy")).toBe(
        false
      )
    );
    expect(loader).toHaveBeenCalledTimes(1);
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() =>
      expect(container.querySelector("output")?.textContent).toBe("after")
    );
    expect(loader).toHaveBeenCalledTimes(2);
    expect(posts).toHaveBeenCalledTimes(2);
  } finally {
    await act(async () => root.unmount());
    container.remove();
  }
});

test("a redirect skips refresh", async () => {
  const previousUrl = window.location.href;
  const loader = vi.fn(async () => ({ value: "before" }));
  const posts = vi.fn(async () => Response.json(success));
  vi.stubGlobal("fetch", posts);
  const router = createMemoryRouter([
    {
      path: "/",
      loader,
      element: (
        <ResourceForm
          data-ws-managed-form-id="form"
          action={[{ dataSourceId: "resource" }]}
          successRedirect="#done"
        >
          <button type="submit">Send</button>
        </ResourceForm>
      ),
    },
  ]);
  const container = document.createElement("div");
  document.body.append(container);
  const root = createRoot(container);
  try {
    await act(async () => root.render(<RouterProvider router={router} />));
    await vi.waitFor(() => expect(loader).toHaveBeenCalledTimes(1));
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() => expect(window.location.hash).toBe("#done"));
    expect(posts).toHaveBeenCalledTimes(1);
    expect(loader).toHaveBeenCalledTimes(1);
  } finally {
    await act(async () => root.unmount());
    container.remove();
    window.history.replaceState(null, "", previousUrl);
  }
});

test("navigation ignores an in-flight submission from the old page", async () => {
  let resolvePost: ((response: Response) => void) | undefined;
  const posts = vi.fn(
    () =>
      new Promise<Response>((resolve) => {
        resolvePost = resolve;
      })
  );
  vi.stubGlobal("fetch", posts);
  const results: unknown[] = [];
  const loader = vi.fn(async () => ({ value: "before" }));
  const router = createMemoryRouter([
    {
      path: "/",
      loader,
      element: (
        <ResourceForm
          data-ws-managed-form-id="form"
          action={[{ dataSourceId: "resource" }]}
          onResultChange={(result) => results.push(result)}
        >
          <button type="submit">Send</button>
        </ResourceForm>
      ),
    },
    { path: "/next", element: <output>Next page</output> },
  ]);
  const container = document.createElement("div");
  document.body.append(container);
  const root = createRoot(container);
  try {
    await act(async () => root.render(<RouterProvider router={router} />));
    await vi.waitFor(() => expect(loader).toHaveBeenCalledTimes(1));
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() => expect(posts).toHaveBeenCalledTimes(1));
    await act(async () => {
      await router.navigate("/next");
    });
    await act(async () => resolvePost?.(Response.json(success)));
    expect(container.querySelector("output")?.textContent).toBe("Next page");
    expect(results).toEqual([]);
    expect(loader).toHaveBeenCalledTimes(1);
    expect(posts).toHaveBeenCalledTimes(1);
  } finally {
    await act(async () => root.unmount());
    container.remove();
  }
});

test("refresh failure retains the completed success result and does not replay POST", async () => {
  let resourceCalls = 0;
  const loader = vi.fn(async () => {
    const response = await fetch("https://resource.example/value", {
      cache: "no-store",
    });
    return { value: response.ok ? await response.text() : "Unavailable" };
  });
  const posts = vi.fn(async () => Response.json(success));
  vi.stubGlobal("fetch", (input: RequestInfo | URL, init?: RequestInit) => {
    const request = new Request(input, init);
    if (request.method === "POST") {
      return posts();
    }
    resourceCalls++;
    return Promise.resolve(
      resourceCalls === 1
        ? new Response("before")
        : new Response("Resource down", { status: 503 })
    );
  });
  const results: unknown[] = [];
  const Page = () => {
    const { value } = useLoaderData() as { value: string };
    return (
      <>
        <output>{value}</output>
        <ResourceForm
          data-ws-managed-form-id="form"
          action={[{ dataSourceId: "resource" }]}
          onResultChange={(result) => results.push(result)}
        >
          <button type="submit">Send</button>
        </ResourceForm>
      </>
    );
  };
  const router = createMemoryRouter([
    {
      path: "/",
      loader,
      element: <Page />,
    },
  ]);
  const container = document.createElement("div");
  document.body.append(container);
  const root = createRoot(container);
  try {
    await act(async () => root.render(<RouterProvider router={router} />));
    await vi.waitFor(() => expect(loader).toHaveBeenCalledTimes(1));
    await act(async () => container.querySelector("button")?.click());
    await vi.waitFor(() => expect(loader).toHaveBeenCalledTimes(2));
    await vi.waitFor(() =>
      expect(container.querySelector("output")?.textContent).toBe("Unavailable")
    );
    expect(container.querySelector("form")?.getAttribute("data-state")).toBe(
      "success"
    );
    expect(results).toEqual([success]);
    expect(posts).toHaveBeenCalledTimes(1);
  } finally {
    await act(async () => root.unmount());
    container.remove();
  }
});