@12-apps/payments-frontend 1.4.0 → 1.4.2

package/src/components/checkout/__tests__/chain-instruments.test.tsx

@@ -1,244 +0,0 @@
-// @vitest-environment jsdom
-/**
- * FUT-563 — "o comprador digita o cartão UMA vez e a compra sobrevive ao
- * primeiro provedor falhar": the browser half of it.
- *
- * A card instrument is bound to the provider that minted it, so a chain the
- * checkout tokenized for only ONCE is a chain the gateway can attempt only
- * once — it skips the rest rather than send a blob they cannot read. What is
- * pinned here is that the same validated card produces one instrument per
- * chain entry and they all travel on ONE charge, with nothing re-typed.
- *
- * The browser journey (the `cadeia-de-provedores` Gherkin feature)
- * covers the happy path end to end; these are the halves it cannot stage — a
- * tail provider whose tokenization fails while the head's works, and a store
- * whose host published no chain at all.
- */
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { JSX } from "react";
-
-const client = vi.hoisted(() => ({
-  chargeCard: vi.fn(),
-  listSavedCards: vi.fn(),
-  refreshCardPublicKey: vi.fn(),
-  pollOrderStatus: vi.fn(),
-  fetchCheckoutConfig: vi.fn(),
-}));
-
-vi.mock("../client", () => client);
-
-import type { CardTokenizationConfig } from "../../../card";
-import type { CardChainLink } from "../method-capability";
-import type { CheckoutOrder } from "../types";
-import { useCardCheckout } from "../use-card-checkout";
-
-const ORDER: CheckoutOrder = {
-  orderId: "o1",
-  status: "AWAITING_PAYMENT",
-  method: "CARD",
-  totalCents: 1250,
-  subtotalCents: 1250,
-  discountTotalCents: 0,
-  appliedDiscounts: [],
-  totalLabel: "R$ 12,50",
-};
-
-/** Stub-mode entries: the mock tokenizer mints without a real key or network. */
-const HEAD: CardChainLink = {
-  provider: "pagbank",
-  publicKey: null,
-  mockTokenization: true,
-  mintable: true,
-};
-const TAIL: CardChainLink = {
-  provider: "stone",
-  publicKey: null,
-  mockTokenization: true,
-  mintable: true,
-};
-/**
- * Declares an in-browser scheme, but this browser has none for it: no
- * tokenizer, no key, no mock grant. The mint FAILS — a different thing from
- * an entry that asks for no instrument.
- */
-const UNMINTABLE: CardChainLink = {
-  provider: "unknown-vendor",
-  publicKey: null,
-  mockTokenization: false,
-  mintable: true,
-};
-/** A hosted page: its own site takes the card, so nothing is minted for it. */
-const HOSTED: CardChainLink = {
-  provider: "infinitepay",
-  publicKey: null,
-  mockTokenization: false,
-  mintable: false,
-};
-/**
- * The ACTIVE provider of a hosted-headed store, as the config's head triple:
- * no scheme, no key, no stub grant. Nothing this browser can mint against.
- */
-const HOSTED_HEAD: CardTokenizationConfig = {
-  provider: "infinitepay",
-  publicKey: null,
-  mockTokenization: false,
-};
-
-const CARD = { number: "4111111111111111", holder: "VERA CADEIA", expiry: "12/34", cvv: "123" };
-
-/**
- * Filling and paying are two BUTTONS, not one handler: `handlePay` closes over
- * the card in state, so a submit fired in the same tick as `setCard` validates
- * the empty form and never reaches the tokenizer.
- */
-function Harness({
-  chain,
-  config = HEAD,
-}: {
-  chain: CardChainLink[];
-  config?: CardTokenizationConfig;
-}): JSX.Element {
-  const cc = useCardCheckout(ORDER, {}, config, vi.fn(), 10, undefined, chain);
-  return (
-    <div>
-      <button type="button" data-testid="fill" onClick={() => cc.setCard(CARD)}>
-        Preencher
-      </button>
-      <button type="button" data-testid="pay" onClick={() => void cc.handlePay()}>
-        Pagar
-      </button>
-      {cc.error ? <p data-testid="pay-error">{cc.error}</p> : null}
-    </div>
-  );
-}
-
-/** The `tokensByProvider` of the single charge submitted. */
-function sentInstruments(): Record<string, string> | undefined {
-  const input = client.chargeCard.mock.calls[0]?.[0] as
-    | { tokensByProvider?: Record<string, string> }
-    | undefined;
-  return input?.tokensByProvider;
-}
-
-async function payWith(chain: CardChainLink[], config?: CardTokenizationConfig): Promise<void> {
-  render(<Harness chain={chain} config={config} />);
-  await waitFor(() => {
-    expect(client.listSavedCards).toHaveBeenCalled();
-  });
-  fireEvent.click(screen.getByTestId("fill"));
-  fireEvent.click(screen.getByTestId("pay"));
-  await waitFor(() => {
-    expect(client.chargeCard).toHaveBeenCalled();
-  });
-}
-
-/** Fill + tap Pagar, then prove the submit never reached the charge route. */
-async function expectNoCharge(
-  chain: CardChainLink[],
-  config?: CardTokenizationConfig,
-): Promise<void> {
-  render(<Harness chain={chain} config={config} />);
-  await waitFor(() => {
-    expect(client.listSavedCards).toHaveBeenCalled();
-  });
-  fireEvent.click(screen.getByTestId("fill"));
-  fireEvent.click(screen.getByTestId("pay"));
-  // The refusal is what ends the submit, so waiting for it is what proves the
-  // charge was skipped rather than merely still in flight.
-  await waitFor(() => {
-    expect(screen.getByTestId("pay-error").textContent).toMatch(/indisponível nesta loja/i);
-  });
-  expect(client.chargeCard).not.toHaveBeenCalled();
-}
-
-beforeEach(() => {
-  vi.clearAllMocks();
-  client.listSavedCards.mockResolvedValue([]);
-  // The head is PagBank with no key, so the hook's on-demand key refresh runs
-  // on mount (FUT-174). It finds none here — stub mode is what mints the token.
-  client.refreshCardPublicKey.mockResolvedValue({ ok: true, data: { publicKey: null } });
-  client.pollOrderStatus.mockResolvedValue({ ok: true, data: "AWAITING_PAYMENT" });
-  client.chargeCard.mockResolvedValue({ ok: true, data: { status: "AWAITING_PAYMENT" } });
-});
-
-afterEach(() => {
-  cleanup();
-});
-
-describe("one instrument per provider (FUT-563)", () => {
-  it("mints for EVERY entry of the chain from one typed card", async () => {
-    await payWith([HEAD, TAIL]);
-
-    const minted = sentInstruments();
-    expect(Object.keys(minted ?? {}).sort()).toEqual(["pagbank", "stone"]);
-    // Distinct instruments: one blob reused across providers is the exact
-    // thing the gateway refuses to send.
-    expect(minted?.["pagbank"]).not.toBe(minted?.["stone"]);
-    // The buyer typed once.
-    expect(client.chargeCard).toHaveBeenCalledTimes(1);
-  });
-
-  it("keeps the head's own token as the bare `token`", async () => {
-    await payWith([HEAD, TAIL]);
-
-    const input = client.chargeCard.mock.calls[0]?.[0] as { token: string };
-    expect(sentInstruments()?.["pagbank"]).toBe(input.token);
-  });
-
-  it("still pays when a TAIL provider cannot be tokenized for", async () => {
-    // That provider is one the walk will skip — strictly better than failing
-    // the whole payment because the second acquirer's key was missing. The map
-    // still travels, naming who DID mint: the server then skips the tail by
-    // name instead of reading the bare token as the head's and skipping
-    // everyone else.
-    await payWith([HEAD, UNMINTABLE]);
-
-    expect(sentInstruments()).toEqual({ pagbank: expect.any(String) });
-    expect(client.chargeCard).toHaveBeenCalledTimes(1);
-  });
-
-  it("sends the map when the TAIL is a provider that needs NO instrument", async () => {
-    // The two-provider shape this feature exists for: a card acquirer plus a
-    // hosted-page fallback. Nothing is minted for the hosted entry — its own
-    // site takes the card — so a map counted by minted keys would be dropped,
-    // the bare token read as the head's, and the fallback refused for
-    // "holding someone else's instrument". The chain has TWO entries, so the
-    // map goes.
-    await payWith([HEAD, HOSTED]);
-
-    expect(sentInstruments()).toEqual({ pagbank: expect.any(String) });
-    // And never a mocked one for the hosted provider.
-    expect(sentInstruments()).not.toHaveProperty("infinitepay");
-  });
-
-  it("mints against the first MINTABLE entry when the HEAD is a hosted page", async () => {
-    // The store this feature creates by simply enabling a second provider:
-    // InfinitePay (REDIRECT) first, an acquirer behind it. The server asks the
-    // WHOLE chain whether anybody tokenizes in the browser, so it shows our
-    // card form — and the submit must mint against the entry the form is being
-    // shown FOR. Minting against the head refused the payment outright, with a
-    // full PAN already typed and no provider ever asked.
-    await payWith([HOSTED, HEAD], HOSTED_HEAD);
-
-    expect(client.chargeCard).toHaveBeenCalledTimes(1);
-    expect(sentInstruments()).toEqual({ pagbank: expect.any(String) });
-    // The bare token is the one that was actually minted, not the head's.
-    const input = client.chargeCard.mock.calls[0]?.[0] as { token: string };
-    expect(input.token).toBe(sentInstruments()?.["pagbank"]);
-  });
-
-  it("still refuses when NO entry of the chain can be minted for", async () => {
-    // Nothing to fall back to — the buyer is told so before any charge, which
-    // is the honest answer and the one FUT-697 wrote.
-    await expectNoCharge([HOSTED, UNMINTABLE], HOSTED_HEAD);
-  });
-
-  it("sends no map at all for a single-provider store", async () => {
-    // The pre-FUT-563 wire shape, unchanged: one token, no map.
-    await payWith([HEAD]);
-
-    expect(sentInstruments()).toBeUndefined();
-  });
-});

package/src/components/checkout/__tests__/clear-cart-on-paid.test.tsx

@@ -1,64 +0,0 @@
-// @vitest-environment jsdom
-/**
- * A buyer who paid must not be handed their cart back.
- *
- * FUT-601 fixed the SERVER half: the cart is emptied inside the confirmation
- * transaction, for the delivery that won the claim. Nothing told the SPA — its
- * cart provider survives every checkout route change and kept the snapshot it
- * seeded on mount, so the buyer pressed "Voltar ao cardápio" and found the
- * badge still counting the items they had just bought.
- *
- * Since FUT-564 the flow lives in this package and the cart lives in the host,
- * so the client half of that fix is a PORT: `onPaid` fires when — and only
- * when — the order settles PAID. The host re-reads its server-emptied cart
- * there; a payment that did not go through fires nothing, because that shopper
- * still has a basket to retry with.
- */
-import { act, renderHook, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { useCheckoutController, type CheckoutHostPorts } from "../use-checkout-controller";
-
-/** One test's own port set — every callback a fresh spy. */
-function makePorts(): CheckoutHostPorts & { onPaid: ReturnType<typeof vi.fn> } {
-  return {
-    createOrder: vi.fn(),
-    saveBuyerContact: vi.fn(),
-    onExitToMenu: vi.fn(),
-    onPaid: vi.fn(),
-  };
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-describe("the host's onPaid port after a checkout settles", () => {
-  it("fires once the order is PAID", async () => {
-    const ports = makePorts();
-    const { result } = renderHook(() => useCheckoutController(ports));
-
-    act(() => {
-      result.current.handleResolved("PAID");
-    });
-
-    await waitFor(() => {
-      expect(ports.onPaid).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  it("stays silent when the payment failed", async () => {
-    const ports = makePorts();
-    const { result } = renderHook(() => useCheckoutController(ports));
-
-    act(() => {
-      result.current.handleResolved("FAILED");
-    });
-
-    // The step advanced, so the effect has had its chance to run.
-    await waitFor(() => {
-      expect(result.current.finalStatus).toBe("FAILED");
-    });
-    expect(ports.onPaid).not.toHaveBeenCalled();
-  });
-});

package/src/components/checkout/__tests__/hosted-return.test.ts

@@ -1,109 +0,0 @@
-// @vitest-environment jsdom
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { rememberHostedOrder, takeHostedOrder } from "../hosted-return";
-import type { CheckoutOrder } from "../types";
-
-/**
- * FUT-556 — surviving the trip to a hosted checkout.
- *
- * A redirect provider tears the SPA down. These pin the two rules that keep the
- * return from landing on a blank payment step, and keep an ABANDONED payment
- * from resurfacing as if it had happened: the parked order is handed back only
- * on a return trip, and only once.
- */
-
-const ORDER: CheckoutOrder = {
-  orderId: "o1",
-  status: "AWAITING_PAYMENT",
-  method: "PIX",
-  totalCents: 550,
-  subtotalCents: 550,
-  discountTotalCents: 0,
-  appliedDiscounts: [],
-  totalLabel: "R$ 5,50",
-};
-
-/** Put the tab on `search`, the way the provider's redirect leaves it. */
-function land(search: string): void {
-  window.history.replaceState({}, "", `/future-drink/menu/checkout${search}`);
-}
-
-describe("hosted-return", () => {
-  beforeEach(() => {
-    window.sessionStorage.clear();
-    land("");
-  });
-  afterEach(() => {
-    window.sessionStorage.clear();
-  });
-
-  it("hands the order back when the provider sent the buyer home", () => {
-    rememberHostedOrder(ORDER);
-    land("?transaction_nsu=123&slug=abc");
-
-    expect(takeHostedOrder()).toEqual(ORDER);
-  });
-
-  it("recognises a return that carries only one of the markers", () => {
-    rememberHostedOrder(ORDER);
-    land("?slug=abc");
-
-    expect(takeHostedOrder()?.orderId).toBe("o1");
-  });
-
-  it("recognises a buyer coming back from a Stripe 3DS challenge (FUT-698)", () => {
-    // What Stripe appends to the card confirm's `return_url` after the issuer
-    // page: the intent id, its client secret and the redirect verdict.
-    rememberHostedOrder(ORDER);
-    land("?payment_intent=pi_1&payment_intent_client_secret=pi_1_secret&redirect_status=succeeded");
-
-    expect(takeHostedOrder()?.orderId).toBe("o1");
-  });
-
-  it("still recognises the hosted-store return exactly as before (FUT-556)", () => {
-    // The InfinitePay handoff must keep working with the Stripe markers added:
-    // "loja hospedada continua com o hand-off e retorno de hoje".
-    rememberHostedOrder(ORDER);
-    land("?transaction_nsu=123&slug=abc&order_nsu=o1");
-
-    expect(takeHostedOrder()?.orderId).toBe("o1");
-  });
-
-  it("ignores a parked order when this is not a return trip", () => {
-    rememberHostedOrder(ORDER);
-    land("");
-
-    // A buyer who abandoned the provider's page and came back to checkout later
-    // must start a fresh order, not resume one they never paid.
-    expect(takeHostedOrder()).toBeNull();
-  });
-
-  it("hands the order back exactly once", () => {
-    rememberHostedOrder(ORDER);
-    land("?transaction_nsu=123");
-
-    expect(takeHostedOrder()).not.toBeNull();
-    expect(takeHostedOrder()).toBeNull();
-  });
-
-  it("answers null for a value that is not an order", () => {
-    window.sessionStorage.setItem("futurepay.checkout.hostedOrder", '{"nonsense":true}');
-    land("?transaction_nsu=123");
-
-    expect(takeHostedOrder()).toBeNull();
-  });
-
-  it("answers null for unparseable storage rather than throwing", () => {
-    window.sessionStorage.setItem("futurepay.checkout.hostedOrder", "{not json");
-    land("?transaction_nsu=123");
-
-    expect(takeHostedOrder()).toBeNull();
-  });
-
-  it("answers null when nothing was parked", () => {
-    land("?transaction_nsu=123");
-
-    expect(takeHostedOrder()).toBeNull();
-  });
-});

package/src/components/checkout/__tests__/method-capability.test.tsx

@@ -1,120 +0,0 @@
-// @vitest-environment jsdom
-/**
- * FUT-698 — the method picker derives its options from the chain's declared
- * capabilities (`capabilities.methods`, surfaced by `GET /api/checkout/config`).
- *
- * These are the browser-unreachable halves of the ticket's "método sem suporte
- * na cadeia não aparece no picker" scenario: every adapter shipped today
- * declares PIX and CARD, so the missing-method case only exists synthetically.
- * Test names keep the scenario's Given/When/Then. Rendered with NO slot
- * provider on purpose (raw-MUI defaults carry the load-bearing test ids);
- * jest-dom is not a dependency here — DOM properties are asserted directly.
- */
-import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { PaymentStep } from "../checkout-steps";
-import { MethodPicker } from "../method-picker";
-import type { CheckoutProviderConfig } from "../types";
-
-afterEach(() => {
-  cleanup();
-});
-
-function config(methods: CheckoutProviderConfig["methods"]): CheckoutProviderConfig {
-  return {
-    provider: "stone",
-    tokenization: "PUBLIC_KEY",
-    publicKey: "pk_stone",
-    mockTokenization: false,
-    methods,
-  };
-}
-
-/** Render the Pagamento step with no order raised — just the picker. */
-function renderPaymentStep(providerConfig: CheckoutProviderConfig | null): void {
-  render(
-    <PaymentStep
-      method={null}
-      onMethodChange={vi.fn()}
-      order={null}
-      buyer={{}}
-      creating={false}
-      createError={null}
-      errorField={null}
-      onGenerate={vi.fn()}
-      onUseEmail={vi.fn()}
-      providerConfig={providerConfig}
-      onResolved={vi.fn()}
-    />,
-  );
-}
-
-/** The offered methods, read off the rendered radiogroup's testids. */
-function offeredTestIds(): string[] {
-  return Array.from(
-    screen.getByTestId("checkout-method").querySelectorAll("[data-testid^='checkout-method-']"),
-  ).map((option) => option.getAttribute("data-testid") ?? "");
-}
-
-describe("MethodPicker — method by capability (FUT-698)", () => {
-  it("given the chain cannot PIX, when the picker renders, then PIX is not offered", () => {
-    render(<MethodPicker value={null} onChange={vi.fn()} offered={["CARD"]} />);
-
-    expect(offeredTestIds()).toEqual(["checkout-method-CARD"]);
-  });
-
-  it("given the chain cannot CARD, when the picker renders, then CARD is not offered", () => {
-    render(<MethodPicker value={null} onChange={vi.fn()} offered={["PIX"]} />);
-
-    expect(offeredTestIds()).toEqual(["checkout-method-PIX"]);
-  });
-
-  it("given the config has not answered yet, then every method renders (fail open)", () => {
-    render(<MethodPicker value={null} onChange={vi.fn()} offered={null} />);
-
-    expect(offeredTestIds()).toEqual(["checkout-method-PIX", "checkout-method-CARD"]);
-  });
-
-  it("card-path gating still wins over a chain that declares CARD", () => {
-    // The chain CAN charge cards, but this browser has no way to mint one
-    // (no scheme/key/stub) — the tile stays visible but DISABLED with a caption
-    // (FUT-697 review): a removed tile would leave an unexplained one-option
-    // "choice", while a disabled one says why.
-    render(
-      <MethodPicker value={null} onChange={vi.fn()} offered={["PIX", "CARD"]} cardUnavailable />,
-    );
-
-    expect(offeredTestIds()).toEqual(["checkout-method-PIX", "checkout-method-CARD"]);
-    const cardTile = screen.getByTestId("checkout-method-CARD") as HTMLButtonElement;
-    expect(cardTile.disabled).toBe(true);
-    expect(screen.getByText("Indisponível nesta loja")).toBeTruthy();
-  });
-});
-
-describe("PaymentStep — the config's methods reach the picker (FUT-698)", () => {
-  it("given a chain that only PIXes, when Pagamento renders, then card is never offered", () => {
-    renderPaymentStep(config(["PIX"]));
-
-    expect(offeredTestIds()).toEqual(["checkout-method-PIX"]);
-  });
-
-  it("given a chain that declares BOLETO, then only methods the checkout can drive appear", () => {
-    renderPaymentStep(config(["PIX", "CARD", "BOLETO"]));
-
-    // Stone/Stripe declare BOLETO server-side (true), but this checkout has no
-    // boleto UI yet (phase 2) — the picker offers only what it can honour.
-    expect(screen.getByTestId("checkout-method-PIX")).toBeTruthy();
-    expect(screen.getByTestId("checkout-method-CARD")).toBeTruthy();
-    expect(screen.getByTestId("checkout-method").querySelectorAll("[role='radio']")).toHaveLength(
-      2,
-    );
-  });
-
-  it("given no config yet, then Pagamento offers both methods as before", () => {
-    renderPaymentStep(null);
-
-    expect(screen.getByTestId("checkout-method-PIX")).toBeTruthy();
-    expect(screen.getByTestId("checkout-method-CARD")).toBeTruthy();
-  });
-});

package/src/components/checkout/__tests__/mint-deadline.test.ts

@@ -1,99 +0,0 @@
-// @vitest-environment jsdom
-/**
- * FUT-563 — a BACKUP acquirer nobody can reach must not hold the payment.
- *
- * Minting one instrument per chain entry puts the buyer's Pagar button behind
- * every acquirer in the chain, and a tokenizer is a cross-origin POST with no
- * deadline of its own — browser `fetch` has none either. A middlebox that
- * accepts the socket and never answers therefore left "Pagar R$ …" spinning
- * and disabled for as long as the OS kept the connection: the failover feature
- * blocking on the provider it exists to fall back TO, with the head's own
- * token already minted and nothing wrong with it.
- *
- * These are the halves the browser journey cannot stage — it has no way to
- * make an acquirer stop answering.
- */
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { resolveNewCardToken } from "../card-instruments";
-import type { CardChainLink } from "../method-capability";
-
-vi.mock("../client", () => ({ refreshCardPublicKey: vi.fn() }));
-
-const CARD = { number: "4111111111111111", holder: "VERA CADEIA", expiry: "12/34", cvv: "123" };
-
-/** Stub mode: the head mints locally, with no network and no key. */
-const HEAD: CardChainLink = {
-  provider: "pagbank",
-  publicKey: null,
-  mockTokenization: true,
-  mintable: true,
-};
-/** A real Pagar.me tokenizer — this one goes to the network. */
-const STONE: CardChainLink = {
-  provider: "stone",
-  publicKey: "pk_stone",
-  mockTokenization: false,
-  mintable: true,
-};
-/** A real Stripe tokenizer — likewise. */
-const STRIPE: CardChainLink = {
-  provider: "stripe",
-  publicKey: "pk_stripe",
-  mockTokenization: false,
-  mintable: true,
-};
-
-/** A tokenizer endpoint that accepts the request and never answers. */
-function blackHole(): ReturnType<typeof vi.fn> {
-  const fetchMock = vi.fn(() => new Promise<Response>(() => undefined));
-  vi.stubGlobal("fetch", fetchMock);
-  return fetchMock;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("minting the chain is bounded and concurrent", () => {
-  it("charges on the head when a TAIL acquirer never answers", async () => {
-    const fetchMock = blackHole();
-
-    const resolved = await resolveNewCardToken(CARD, HEAD, "o1", vi.fn(), false, [HEAD, STONE], 20);
-
-    // The degradation this module already documents: the provider we could not
-    // mint for is one the walk will skip. The payment still goes out.
-    expect(resolved.ok).toBe(true);
-    const instruments = resolved.ok ? resolved.data : null;
-    expect(instruments?.tokensByProvider).toEqual({ pagbank: expect.any(String) });
-    // And the abandoned request is ABORTED, not merely ignored — a token that
-    // arrives after we gave up on it is one nothing will ever charge.
-    const init = fetchMock.mock.calls[0]?.[1] as RequestInit | undefined;
-    expect(init?.signal?.aborted).toBe(true);
-  });
-
-  it("asks every tail at ONCE, not one after the other", async () => {
-    // Sequentially, two unreachable backups cost the buyer two full deadlines
-    // before a charge they could have had immediately.
-    const fetchMock = blackHole();
-    const deadlineMs = 400;
-
-    const minting = resolveNewCardToken(
-      CARD,
-      HEAD,
-      "o1",
-      vi.fn(),
-      false,
-      [HEAD, STONE, STRIPE],
-      deadlineMs,
-    );
-    // Both requests are in flight well inside ONE deadline — which they could
-    // not be if the second waited for the first to time out.
-    await vi.waitFor(() => {
-      expect(fetchMock).toHaveBeenCalledTimes(2);
-    });
-
-    const resolved = await minting;
-    expect(resolved.ok).toBe(true);
-  });
-});

package/src/components/checkout/__tests__/payments-unavailable.test.tsx

@@ -1,53 +0,0 @@
-// @vitest-environment jsdom
-import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { PaymentsUnavailable } from "../payments-unavailable";
-
-/**
- * A store with no active payment provider used to render the full payment step
- * — PIX and Cartão — and fail only at order creation, telling the shopper
- * "tente novamente em instantes": retry advice for a condition retrying never
- * fixes. These pin the two honest answers instead.
- *
- * Rendered with NO slot provider on purpose: outside a
- * `CheckoutComponentsProvider` the component falls back to the raw-MUI
- * defaults, so this suite also pins that the default slots carry the
- * load-bearing test ids. jest-dom is not a dependency here — DOM properties
- * are asserted directly.
- */
-
-afterEach(cleanup);
-
-describe("checkout — store cannot charge online", () => {
-  it("offers the waiter when the shopper has a mesa", async () => {
-    const onCallWaiter = vi.fn();
-    render(<PaymentsUnavailable waiterAvailable onCallWaiter={onCallWaiter} />);
-
-    expect(screen.getByTestId("checkout-call-waiter")).toBeTruthy();
-    fireEvent.click(screen.getByTestId("checkout-call-waiter-button"));
-    expect(onCallWaiter).toHaveBeenCalledTimes(1);
-
-    // Never the dead end: the shopper is not told to retry.
-    await waitFor(() => expect(screen.queryByText(/tente novamente/i)).toBeNull());
-  });
-
-  it("says plainly that the store does not charge online with no waiter to call", async () => {
-    render(<PaymentsUnavailable waiterAvailable={false} />);
-
-    expect(screen.getByTestId("checkout-payments-disabled")).toBeTruthy();
-    // No waiter reachable — offering one would be a dead button.
-    await waitFor(() => expect(screen.queryByTestId("checkout-call-waiter-button")).toBeNull());
-  });
-
-  it("renders no waiter button when the host supplies no handler", async () => {
-    render(<PaymentsUnavailable waiterAvailable />);
-    await waitFor(() => expect(screen.queryByTestId("checkout-call-waiter-button")).toBeNull());
-  });
-
-  it("disables the waiter button while the request is in flight", () => {
-    render(<PaymentsUnavailable waiterAvailable onCallWaiter={vi.fn()} calling />);
-    const button = screen.getByTestId("checkout-call-waiter-button") as HTMLButtonElement;
-    expect(button.disabled).toBe(true);
-  });
-});