Testando Integração com Stripe

# .env.test
STRIPE_SECRET_KEY=sk_test_...
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_...
STRIPE_WEBHOOK_SECRET=whsec_test_...

// __mocks__/stripe.ts
import { vi } from "vitest";
 
const mockStripe = {
  checkout: {
    sessions: {
      create: vi.fn(),
      retrieve: vi.fn(),
    },
  },
  paymentIntents: {
    create: vi.fn(),
    retrieve: vi.fn(),
  },
  subscriptions: {
    create: vi.fn(),
    retrieve: vi.fn(),
    update: vi.fn(),
    cancel: vi.fn(),
  },
  customers: {
    create: vi.fn(),
    retrieve: vi.fn(),
  },
  billingPortal: {
    sessions: {
      create: vi.fn(),
    },
  },
  webhooks: {
    constructEvent: vi.fn(),
  },
};
 
export default vi.fn(() => mockStripe);
export { mockStripe };

// lib/__mocks__/stripe.ts
import { mockStripe } from "../../__mocks__/stripe";
export const stripe = mockStripe;

// __tests__/actions/checkout.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";
import { mockStripe } from "../../__mocks__/stripe";
 
// Simula o módulo stripe
vi.mock("@/lib/stripe", () => ({
  stripe: mockStripe,
}));
 
// Simula next/navigation
const mockRedirect = vi.fn();
vi.mock("next/navigation", () => ({
  redirect: mockRedirect,
}));
 
describe("createCheckoutSession", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    process.env.NEXT_PUBLIC_APP_URL = "http://localhost:3000";
  });
 
  it("cria uma sessão de checkout e redireciona", async () => {
    mockStripe.checkout.sessions.create.mockResolvedValue({
      id: "cs_test_123",
      url: "https://checkout.stripe.com/pay/cs_test_123",
    });
 
    // Importa após as simulações serem configuradas
    const { createCheckoutSession } = await import(
      "@/app/actions/checkout"
    );
 
    await createCheckoutSession("price_test_123");
 
    expect(mockStripe.checkout.sessions.create).toHaveBeenCalledWith(
      expect.objectContaining({
        mode: "payment",
        line_items: [{ price: "price_test_123", quantity: 1 }],
        success_url: expect.stringContaining("/success"),
        cancel_url: expect.stringContaining("/pricing"),
      })
    );
 
    expect(mockRedirect).toHaveBeenCalledWith(
      "https://checkout.stripe.com/pay/cs_test_123"
    );
  });
 
  it("lida com erros do Stripe graciosamente", async () => {
    mockStripe.checkout.sessions.create.mockRejectedValue(
      new Error("No such price: 'price_invalid'")
    );
 
    const { createCheckoutSession } = await import(
      "@/app/actions/checkout"
    );
 
    await expect(
      createCheckoutSession("price_invalid")
    ).rejects.toThrow();
  });
});

// __tests__/actions/payment-intent.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";
import { mockStripe } from "../../__mocks__/stripe";
 
vi.mock("@/lib/stripe", () => ({
  stripe: mockStripe,
}));
 
describe("createPaymentIntent", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });
 
  it("cria um payment intent com o valor correto", async () => {
    mockStripe.paymentIntents.create.mockResolvedValue({
      id: "pi_test_123",
      client_secret: "pi_test_123_secret_456",
      amount: 2999,
      currency: "usd",
      status: "requires_payment_method",
    });
 
    const { createPaymentIntent } = await import(
      "@/app/actions/payment"
    );
    const result = await createPaymentIntent(2999);
 
    expect(result.clientSecret).toBe("pi_test_123_secret_456");
    expect(mockStripe.paymentIntents.create).toHaveBeenCalledWith(
      expect.objectContaining({
        amount: 2999,
        currency: "usd",
        automatic_payment_methods: { enabled: true },
      })
    );
  });
});

// __tests__/api/webhook.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";
import { mockStripe } from "../../__mocks__/stripe";
 
vi.mock("@/lib/stripe", () => ({
  stripe: mockStripe,
}));
 
const mockDb = {
  user: {
    update: vi.fn(),
    updateMany: vi.fn(),
  },
  purchase: {
    create: vi.fn(),
  },
};
 
vi.mock("@/lib/db", () => ({
  db: mockDb,
}));
 
describe("Stripe webhook handler", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    process.env.STRIPE_WEBHOOK_SECRET = "whsec_test";
  });
 
  it("lida com checkout.session.completed", async () => {
    const event = {
      id: "evt_test_123",
      type: "checkout.session.completed",
      data: {
        object: {
          id: "cs_test_123",
          mode: "subscription",
          customer: "cus_test_123",
          subscription: "sub_test_123",
          metadata: { userId: "user_123" },
          amount_total: 2900,
        },
      },
    };
 
    mockStripe.webhooks.constructEvent.mockReturnValue(event);
 
    const { POST } = await import(
      "@/app/api/webhooks/stripe/route"
    );
 
    const request = new Request("http://localhost:3000/api/webhooks/stripe", {
      method: "POST",
      body: JSON.stringify(event),
      headers: { "stripe-signature": "test_sig" },
    });
 
    const response = await POST(request);
    expect(response.status).toBe(200);
 
    const json = await response.json();
    expect(json.received).toBe(true);
  });
 
  it("rejeita assinaturas inválidas", async () => {
    mockStripe.webhooks.constructEvent.mockImplementation(() => {
      throw new Error("Invalid signature");
    });
 
    const { POST } = await import(
      "@/app/api/webhooks/stripe/route"
    );
 
    const request = new Request("http://localhost:3000/api/webhooks/stripe", {
      method: "POST",
      body: "{}",
      headers: { "stripe-signature": "invalid" },
    });
 
    const response = await POST(request);
    expect(response.status).toBe(400);
  });
});

// e2e/checkout.spec.ts
import { test, expect } from "@playwright/test";
 
test.describe("Fluxo de Checkout", () => {
  test("completa uma compra com cartão de teste", async ({ page }) => {
    await page.goto("/shop");
    await page.click('button:has-text("Buy Now")');
 
    // Aguarda o redirecionamento do Stripe Checkout
    await page.waitForURL(/checkout\.stripe\.com/);
 
    // Preenche os detalhes do cartão de teste no Stripe Checkout
    const emailInput = page.locator("#email");
    await emailInput.fill("test@example.com");
 
    const cardFrame = page.frameLocator("iframe[name*='card']").first();
 
    await cardFrame
      .locator('[placeholder="1234 1234 1234 1234"]')
      .fill("4242424242424242");
    await cardFrame
      .locator('[placeholder="MM / YY"]')
      .fill("12/34");
    await cardFrame
      .locator('[placeholder="CVC"]')
      .fill("123");
 
    // Preenche o nome de faturamento
    const nameInput = page.locator('#billingName');
    await nameInput.fill("Test User");
 
    // Submete o pagamento
    await page.click('button:has-text("Pay")');
 
    // Aguarda o redirecionamento de volta para a página de sucesso
    await page.waitForURL(/\/success/);
    await expect(page.locator("h1")).toContainText("Payment Successful");
  });
 
  test("lida com cartão recusado", async ({ page }) => {
    await page.goto("/checkout");
 
    // Aguarda o carregamento do PaymentElement
    const stripeFrame = page.frameLocator(
      "iframe[name*='__privateStripeFrame']"
    ).first();
 
    await stripeFrame
      .locator('[placeholder="1234 1234 1234 1234"]')
      .fill("4000000000000002"); // Cartão de recusa genérico
 
    await stripeFrame
      .locator('[placeholder="MM / YY"]')
      .fill("12/34");
    await stripeFrame
      .locator('[placeholder="CVC"]')
      .fill("123");
 
    await page.click('button:has-text("Pay")');
 
    // Espera a mensagem de erro
    await expect(page.locator('[role="alert"]')).toContainText("declined");
  });
});

# Dispara um evento específico
stripe trigger checkout.session.completed
 
# Dispara com dados personalizados
stripe trigger payment_intent.succeeded \
  --add payment_intent:metadata.userId=user_123
 
# Escuta e encaminha para um endpoint específico
stripe listen --forward-to localhost:3000/api/webhooks/stripe \
  --events checkout.session.completed,invoice.paid
 
# Reexecuta um evento específico do seu Dashboard
stripe events resend evt_xxx

describe("Ciclo de vida da assinatura", () => {
  it("lida com o cancelamento da assinatura", async () => {
    const mockUser = {
      id: "user_123",
      stripeSubscriptionId: "sub_test_123",
    };
 
    mockStripe.subscriptions.update.mockResolvedValue({
      id: "sub_test_123",
      cancel_at_period_end: true,
      status: "active",
    });
 
    vi.mock("@/lib/auth", () => ({
      auth: vi.fn().mockResolvedValue({
        user: { id: "user_123" },
      }),
    }));
 
    vi.mock("@/lib/db", () => ({
      db: {
        user: {
          findUnique: vi.fn().mockResolvedValue(mockUser),
        },
      },
    }));
 
    const { cancelSubscriptionAction } = await import(
      "@/app/actions/subscription"
    );
    const result = await cancelSubscriptionAction();
 
    expect(result).toEqual({ success: true });
    expect(mockStripe.subscriptions.update).toHaveBeenCalledWith(
      "sub_test_123",
      { cancel_at_period_end: true }
    );
  });
});

import type Stripe from "stripe";
 
function createMockEvent(
  type: string,
  data: Record<string, unknown>
): Stripe.Event {
  return {
    id: `evt_test_${Date.now()}`,
    type,
    data: { object: data },
    object: "event",
    api_version: "2024-12-18.acacia",
    created: Math.floor(Date.now() / 1000),
    livemode: false,
    pending_webhooks: 0,
    request: null,
  } as unknown as Stripe.Event;
}