如何在Laravel中使用PHPUnit模拟PayPal交易及订单确认？

Hey there! Let's walk through how to mock PayPal transaction confirmation for your checkout flow testing—since you've got basic testing experience but are new to mocking, I'll keep this practical and step-by-step.

一、Where to Run These Tests #

You have a few solid options depending on what part of the flow you want to validate:

• Frontend UI Test Layer: If you want to simulate the full user-facing checkout experience (like clicking PayPal buttons, seeing confirmation messages), use tools like Cypress or Playwright. Here you'll intercept PayPal API calls or simulate the PayPal popup flow to avoid leaving your app. Great for validating UI interactions and end-to-end user journeys.
• Backend Service Test Layer: If your focus is on order-processing logic (e.g., marking orders as paid, updating inventory after payment), mock the PayPal client directly in your unit/integration tests. This lets you isolate and validate your business logic without relying on the real PayPal API.
• Mock Server for E2E Testing: For near-real-world E2E tests without using a real PayPal account, spin up a mock server (like WireMock) to mimic PayPal's API behavior. Point your app to this mock server instead of the real PayPal endpoint.

二、How to Replace Business Code with Mock Implementations #

Let's break this down by common testing scenarios:

1. Backend Unit/Integration Tests (Example with Java & Mockito) #

First, make sure your business code relies on an abstraction (not a concrete class) for PayPal interactions—this makes mocking trivial.

Suppose you have a real PayPal client:

// Real PayPal client that calls the live API
public class PayPalClient {
    public PaymentConfirmation confirmPayment(String paymentId) {
        // Logic to call real PayPal API
        return realPayPalApiCall(paymentId);
    }
}

// Your checkout service that uses the PayPal client
public class CheckoutService {
    private final PayPalClient payPalClient;

    public CheckoutService(PayPalClient payPalClient) {
        this.payPalClient = payPalClient;
    }

    public Order completeCheckout(String paymentId, Order order) {
        PaymentConfirmation confirmation = payPalClient.confirmPayment(paymentId);
        if (confirmation.isSuccess()) {
            order.setStatus(OrderStatus.PAID);
            return orderRepository.save(order);
        } else {
            throw new PaymentFailedException(confirmation.getErrorMessage());
        }
    }
}

Now use Mockito to replace the real PayPalClient with a mock:

import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.*;

@ExtendWith(MockitoExtension.class)
public class CheckoutServiceTest {
    @Mock
    private PayPalClient mockPayPalClient; // Mock the PayPal client

    private CheckoutService checkoutService = new CheckoutService(mockPayPalClient);

    @Test
    public void completeCheckout_PaymentSucceeds_UpdatesOrderStatus() {
        // Set up mock to return a successful payment confirmation
        PaymentConfirmation mockSuccess = new PaymentConfirmation(true, null);
        when(mockPayPalClient.confirmPayment("test-payment-123")).thenReturn(mockSuccess);

        // Run the checkout logic
        Order testOrder = new Order();
        Order result = checkoutService.completeCheckout("test-payment-123", testOrder);

        // Verify the order was marked as paid
        assertEquals(OrderStatus.PAID, result.getStatus());
    }

    @Test
    public void completeCheckout_PaymentFails_ThrowsException() {
        // Set up mock to return a failed payment confirmation
        PaymentConfirmation mockFailure = new PaymentConfirmation(false, "Insufficient funds");
        when(mockPayPalClient.confirmPayment("test-payment-456")).thenReturn(mockFailure);

        // Verify the expected exception is thrown
        assertThrows(PaymentFailedException.class, () -> {
            checkoutService.completeCheckout("test-payment-456", new Order());
        });
    }
}

The key here is dependency injection: by passing the PayPal client into your checkout service, you can swap the real implementation with a mock during tests—no changes to your production code needed.

2. Frontend UI Tests (Example with Cypress) #

If your frontend uses PayPal's JS SDK or redirects to PayPal, you can intercept and mock the API calls directly in your UI tests:

describe('Checkout Flow', () => {
  it('completes checkout with successful PayPal payment', () => {
    // Navigate to your checkout page
    cy.visit('/checkout');

    // Fill out shipping/payment details
    cy.get('#shipping-address').type('123 Test Street');
    cy.get('#email').type('test@example.com');

    // Click the PayPal payment button
    cy.get('#pay-with-paypal').click();

    // Intercept PayPal's payment confirmation API call and mock a success response
    cy.intercept('POST', 'https://api.paypal.com/v1/payments/payment/*/execute', {
      statusCode: 200,
      body: {
        state: 'approved',
        id: 'mock-payment-789'
      }
    }).as('payPalConfirm');

    // Wait for the mock response, then verify the success page loads
    cy.wait('@payPalConfirm');
    cy.get('#order-success-message').should('be.visible');
  });
});

This lets you simulate the entire user flow without ever leaving your app or using a real PayPal account.

3. Mock Server for Full Integration Tests #

For tests that need to mimic the full PayPal service behavior (e.g., testing webhook handling), use a tool like WireMock:

1. Start the WireMock server and configure it to respond to PayPal API endpoints (e.g., POST /v1/payments/payment/{id}/execute with success/failure responses).
2. Update your app's configuration to point to the WireMock server instead of the real PayPal API.
3. Run your tests—your app will interact with the mock server just like it would with real PayPal, allowing you to validate end-to-end flows safely.

三、Key Tips to Avoid Pitfalls #

• Keep mocks realistic: Make sure your mock responses match the real PayPal API's structure as closely as possible—this prevents tests from passing in mock scenarios but failing in production.
• Test edge cases: Don't just test successful payments—mock failed payments, timeouts, and invalid responses to ensure your code handles errors gracefully.
• Don't over-mock: In E2E tests, only mock external services like PayPal. Avoid mocking your own app's core logic, as this can hide real bugs.

内容的提问来源于stack exchange，提问作者Harry Bosh