xiaoxia-saas/apps/web/e2e/subscription.spec.ts

/**
 * 订阅管理 E2E 测试
 *
 * 覆盖：路由守卫、订阅降级、过期处理、订阅状态检查
 */
import { expect, test, type APIRequestContext } from "@playwright/test";

const PASSWORD = "Test123456!";
const apiBase = process.env.E2E_API_BASE || "/api/v1";

function uniqueEmail(prefix: string): string {
  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}@example.com`;
}

function uniqueUsername(prefix: string): string {
  return `${prefix}_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
}

/** 登录操作，遇到 429 限流自动等待重试 */
async function loginWithRetry(
  request: APIRequestContext,
  email: string,
  password: string,
  maxRetries = 2,
) {
  for (let i = 0; i <= maxRetries; i++) {
    const response = await request.post(`${apiBase}/auth/login`, {
      data: { email, password },
    });
    if (response.status() !== 429) return response;
    console.log(`[login] 触发限流，等待 65s 后重试 (${i + 1}/${maxRetries})`);
    await new Promise((r) => setTimeout(r, 65000));
  }
  return request.post(`${apiBase}/auth/login`, {
    data: { email, password },
  });
}

/** 注册并登录，返回 { headers, email, username, userId } */
async function createAuthedUser(request: APIRequestContext, label: string) {
  const email = uniqueEmail(label);
  const username = uniqueUsername(label);

  const reg = await request.post(`${apiBase}/auth/register`, {
    data: { email, password: PASSWORD, username, display_name: `E2E ${label}` },
  });
  expect(reg.ok(), `注册应成功: ${await reg.text()}`).toBeTruthy();

  const login = await loginWithRetry(request, email, PASSWORD);
  expect(login.ok(), `登录应成功: ${await login.text()}`).toBeTruthy();
  const loginData = await login.json();

  return {
    headers: { Authorization: `Bearer ${loginData.access_token}` },
    email,
    username,
  };
}

test.describe("Subscription route guard", () => {
  test.describe.configure({ timeout: 120_000 });
  test("redirects anonymous users to login", async ({ page }) => {
    await page.goto("/app/subscription");
    await expect(page).toHaveURL(/\/login/);
  });
});

test.describe("订阅信息查看", () => {
  test.describe.configure({ timeout: 120_000 });
  test("获取当前订阅信息 - 正向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-info");

    const response = await request.get(`${apiBase}/subscription/current`, {
      headers,
    });

    expect(
      response.ok(),
      `获取订阅信息应返回 2xx，实际: ${response.status()} ${await response.text()}`,
    ).toBeTruthy();

    const data = await response.json();
    expect(data.plan_id, "应返回 plan_id").toBeTruthy();
    expect(data.status, "应返回 status").toBeTruthy();
  });

  test("未登录获取订阅信息 - 反向", async ({ request }) => {
    const response = await request.get(`${apiBase}/subscription/current`);
    expect([401, 403]).toContain(response.status());
  });
});

test.describe("订阅降级", () => {
  test.describe.configure({ timeout: 120_000 });
  test("Pro 用户降级到 Standard - 正向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-downgrade");

    // 先升级到 Pro
    const upgrade = await request.post(`${apiBase}/subscription/change-plan`, {
      headers,
      data: {
        target_plan_id: "pro",
        billing_cycle: "monthly",
      },
    });
    expect(
      upgrade.ok(),
      `升级到 Pro 应成功: ${await upgrade.text()}`,
    ).toBeTruthy();

    // 降级到 Standard
    const downgrade = await request.post(
      `${apiBase}/subscription/change-plan`,
      {
        headers,
        data: {
          target_plan_id: "standard",
          billing_cycle: "monthly",
        },
      },
    );

    // 降级应成功或返回提示信息（某些业务可能限制降级）
    expect(downgrade.status(), "降级请求应返回 2xx 或 4xx").toBeLessThan(500);

    const data = await downgrade.json();
    // 成功或失败都应有明确响应
    expect(data).toBeTruthy();
  });

  test("降级到相同套餐 - 反向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-same");

    // 用户默认为 free，再次选择 free
    const response = await request.post(`${apiBase}/subscription/change-plan`, {
      headers,
      data: {
        target_plan_id: "free",
        billing_cycle: "monthly",
      },
    });

    // 相同套餐应返回 200 + success=false，或者 400
    if (response.ok()) {
      const data = await response.json();
      expect(data.success).toBe(false);
    } else {
      expect([400, 422]).toContain(response.status());
    }
  });

  test("降级到无效套餐 - 反向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-badplan");

    const response = await request.post(`${apiBase}/subscription/change-plan`, {
      headers,
      data: {
        target_plan_id: "nonexistent_plan",
        billing_cycle: "monthly",
      },
    });

    expect(response.status(), "无效套餐应返回 4xx").toBeGreaterThanOrEqual(400);
    expect(response.status()).toBeLessThan(500);
  });
});

test.describe("订阅过期处理", () => {
  test.describe.configure({ timeout: 120_000 });
  test("取消订阅 - 反向（免费用户）", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-cancel");

    // 免费用户取消订阅应返回错误
    const response = await request.post(`${apiBase}/subscription/cancel`, {
      headers,
    });

    // 免费用户可能不需要取消，返回 400 或类似错误
    if (!response.ok()) {
      const data = await response.json();
      expect(
        data.error?.message || data.detail || data.message,
        "应返回错误信息",
      ).toBeTruthy();
    }
  });

  test("未登录取消订阅 - 反向", async ({ request }) => {
    const response = await request.post(`${apiBase}/subscription/cancel`);
    expect([401, 403]).toContain(response.status());
  });

  test("切换自动续费 - 正向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-autorenew");

    // 关闭自动续费
    const disableResp = await request.post(
      `${apiBase}/subscription/toggle-auto-renew`,
      {
        headers,
        data: { enabled: false },
      },
    );
    expect(
      disableResp.ok(),
      `关闭自动续费应成功: ${await disableResp.text()}`,
    ).toBeTruthy();

    // 重新开启自动续费
    const enableResp = await request.post(
      `${apiBase}/subscription/toggle-auto-renew`,
      {
        headers,
        data: { enabled: true },
      },
    );
    expect(
      enableResp.ok(),
      `开启自动续费应成功: ${await enableResp.text()}`,
    ).toBeTruthy();
  });

  test("无效参数切换自动续费 - 反向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-autoren-bad");

    // 缺少 enabled 字段
    const response = await request.post(
      `${apiBase}/subscription/toggle-auto-renew`,
      {
        headers,
        data: {},
      },
    );

    expect([400, 422]).toContain(response.status());
  });
});

test.describe("账单记录", () => {
  test.describe.configure({ timeout: 120_000 });
  test("获取账单记录 - 正向", async ({ request }) => {
    const { headers } = await createAuthedUser(request, "sub-bills");

    const response = await request.get(
      `${apiBase}/subscription/billing-records`,
      { headers },
    );

    expect(
      response.ok(),
      `获取账单记录应返回 2xx，实际: ${response.status()}`,
    ).toBeTruthy();

    const data = await response.json();
    expect(Array.isArray(data), "账单记录应为数组").toBeTruthy();
  });

  test("未登录获取账单记录 - 反向", async ({ request }) => {
    const response = await request.get(
      `${apiBase}/subscription/billing-records`,
    );
    expect([401, 403]).toContain(response.status());
  });
});