Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

7.8 KB
Raw Blame
// @vitest-environment jsdom
import React from "react";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { NextIntlClientProvider } from "next-intl";

import messages from "../../../../src/i18n/messages/en.json";

const cleanupCallbacks: Array<() => void> = [];

function makeContainer(): HTMLElement {
  const container = document.createElement("div");
  document.body.appendChild(container);
  cleanupCallbacks.push(() => {
    container.remove();
  });
  return container;
}

describe("DistributeProxiesButton", () => {
  beforeEach(() => {
    (
      globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean }
    ).IS_REACT_ACT_ENVIRONMENT = true;
    vi.useFakeTimers({ shouldAdvanceTime: true });
  });

  afterEach(() => {
    while (cleanupCallbacks.length > 0) {
      cleanupCallbacks.pop()?.();
    }
    document.body.innerHTML = "";
    vi.useRealTimers();
    vi.clearAllMocks();
  });

  async function renderButton(
    props: Partial<
      React.ComponentProps<typeof import("@/shared/components/DistributeProxiesButton").default>
    > = {}
  ) {
    const { default: DistributeProxiesButton } =
      await import("@/shared/components/DistributeProxiesButton");
    const container = makeContainer();
    const root = createRoot(container);
    cleanupCallbacks.push(() => act(() => root.unmount()));
    await act(async () => {
      root.render(
        <NextIntlClientProvider
          locale="en"
          messages={{ common: messages.common, sharedComponents: messages.sharedComponents }}
        >
          <DistributeProxiesButton
            onDistribute={props.onDistribute ?? vi.fn().mockResolvedValue(undefined)}
            {...props}
          />
        </NextIntlClientProvider>
      );
    });
    return { container, root };
  }

  async function confirmDistribution(container: HTMLElement) {
    const trigger = container.querySelector("button") as HTMLButtonElement;
    await act(async () => trigger.click());
    const confirm = Array.from(container.querySelectorAll("button")).find(
      (button) => button.textContent?.trim() === "Distribute proxies"
    );
    expect(confirm).toBeTruthy();
    await act(async () => confirm!.click());
  }

  it("renders with default label", async () => {
    const { container } = await renderButton();
    const button = container.querySelector("button");
    expect(button).not.toBeNull();
    expect(button?.textContent).toContain("Distribute Proxies");
  });

  it("renders with custom label", async () => {
    const { container } = await renderButton({ label: "Custom Label" });
    const button = container.querySelector("button");
    expect(button?.textContent).toContain("Custom Label");
  });

  it("shows swap_horiz icon in idle state", async () => {
    const { container } = await renderButton();
    const icon = container.querySelector(".material-symbols-outlined");
    expect(icon?.textContent).toBe("swap_horiz");
  });

  it("disables button when disabled prop is true", async () => {
    const { container } = await renderButton({ disabled: true });
    const button = container.querySelector("button") as HTMLButtonElement;
    expect(button.disabled).toBe(true);
  });

  it("calls onDistribute after confirmation", async () => {
    const onDistribute = vi.fn().mockResolvedValue(undefined);
    const { container } = await renderButton({ onDistribute });
    await confirmDistribution(container);

    expect(onDistribute).toHaveBeenCalledTimes(1);
  });

  it("enters distributing state after confirmation", async () => {
    let resolveDistribute: () => void;
    const onDistribute = vi.fn().mockImplementation(
      () =>
        new Promise<void>((resolve) => {
          resolveDistribute = resolve;
        })
    );
    const { container } = await renderButton({ onDistribute });
    const button = container.querySelector("button") as HTMLButtonElement;
    await confirmDistribution(container);

    // Should show distributing state
    expect(button.textContent).toContain("Distributing...");
    expect(button.disabled).toBe(true);
    const icon = container.querySelector(".material-symbols-outlined");
    expect(icon?.textContent).toBe("sync");

    // Resolve the promise
    await act(async () => {
      resolveDistribute!();
    });
  });

  it("enters complete state after successful distribution", async () => {
    vi.useFakeTimers({ shouldAdvanceTime: true });
    const onDistribute = vi.fn().mockResolvedValue(undefined);
    const { container } = await renderButton({ onDistribute });
    const button = container.querySelector("button") as HTMLButtonElement;
    await confirmDistribution(container);

    // Wait for distributing to complete
    await act(async () => {
      await vi.advanceTimersByTimeAsync(100);
    });

    expect(button.textContent).toContain("Complete");
    const icon = container.querySelector(".material-symbols-outlined");
    expect(icon?.textContent).toBe("check");
  });

  it("returns to idle state after complete timeout", async () => {
    vi.useFakeTimers({ shouldAdvanceTime: true });
    const onDistribute = vi.fn().mockResolvedValue(undefined);
    const { container } = await renderButton({ onDistribute });
    const button = container.querySelector("button") as HTMLButtonElement;
    await confirmDistribution(container);

    // Wait for distributing to complete
    await act(async () => {
      await vi.advanceTimersByTimeAsync(100);
    });

    expect(button.textContent).toContain("Complete");

    // Wait for the 1.5s timeout
    await act(async () => {
      await vi.advanceTimersByTimeAsync(1600);
    });

    expect(button.textContent).toContain("Distribute Proxies");
    const icon = container.querySelector(".material-symbols-outlined");
    expect(icon?.textContent).toBe("swap_horiz");
  });

  it("returns to idle state on error", async () => {
    const onDistribute = vi.fn().mockRejectedValue(new Error("fail"));
    const { container } = await renderButton({ onDistribute });
    const button = container.querySelector("button") as HTMLButtonElement;
    await confirmDistribution(container);

    // Wait for error handling
    await act(async () => {
      await vi.advanceTimersByTimeAsync(100);
    });

    expect(button.textContent).toContain("Distribute Proxies");
    expect(button.disabled).toBe(false);
  });

  it("does not click when disabled", async () => {
    const onDistribute = vi.fn().mockResolvedValue(undefined);
    const { container } = await renderButton({ onDistribute, disabled: true });
    const button = container.querySelector("button") as HTMLButtonElement;

    await act(async () => {
      button.click();
    });

    expect(onDistribute).not.toHaveBeenCalled();
  });

  it("applies sm size classes", async () => {
    const { container } = await renderButton({ size: "sm" });
    const button = container.querySelector("button") as HTMLButtonElement;
    expect(button.className).toContain("px-2");
    expect(button.className).toContain("py-1");
    expect(button.className).toContain("text-[11px]");
  });

  it("applies md size classes by default", async () => {
    const { container } = await renderButton();
    const button = container.querySelector("button") as HTMLButtonElement;
    expect(button.className).toContain("px-3");
    expect(button.className).toContain("py-1.5");
    expect(button.className).toContain("text-xs");
  });

  it("sets aria-label to the current label", async () => {
    const { container } = await renderButton();
    const button = container.querySelector("button") as HTMLButtonElement;
    expect(button.getAttribute("aria-label")).toBe("Distribute Proxies");
  });

  it("sets title to the current label", async () => {
    const { container } = await renderButton();
    const button = container.querySelector("button") as HTMLButtonElement;
    expect(button.getAttribute("title")).toBe("Distribute Proxies");
  });
});