Testing

CheckoutDropInConfig(
    environment: .test,  // Use sandbox
    // ... rest of config
)

// Pseudocode example - adapt to your app's architecture
// Use your app's backend mock layer or dependency injection
// to simulate network failures in tests
class NetworkErrorTest: XCTestCase {
    func testNetworkError() async throws {
        // Configure your backend mock to return network errors
        // or use URLProtocol/URLSession mocks in your app
        
        // Verify error handling in your app
        // ... test implementation
    }
}

// Backend verification endpoint (Node.js/Express example)
app.post('/api/verify-payment', async (req, res) => {
  const { systemTransactionId, merchantTransactionId } = req.body;
  
  // Get expected amount from your database
  const order = await db.orders.findOne({ merchantTransactionId });
  
  // Guard against missing order
  if (!order) {
    return res.status(404).json({ success: false, error: 'Order not found' });
  }
  
  const expectedAmount = order.amount;
  
  // Query PXP API to verify transaction
  const transaction = await unityApi.getTransaction(systemTransactionId);
  
  // Verify transaction is successful
  if (transaction.state !== 'Authorised' && transaction.state !== 'Captured') {
    return res.json({ success: false, error: 'Transaction not authorised' });
  }
  
  // Verify amount matches
  const txnAmount = transaction.amounts?.transactionValue || transaction.amount;
  if (Math.abs(txnAmount - expectedAmount) > 0.01) {
    return res.json({ success: false, error: 'Amount mismatch' });
  }
  
  // Check for duplicate processing
  const alreadyProcessed = await db.transactions.findOne({ systemTransactionId });
  if (alreadyProcessed) {
    return res.json({ success: true, orderId: alreadyProcessed.orderId });
  }
  
  // Process order
  const orderId = await fulfillOrder(order);
  await db.transactions.create({ systemTransactionId, orderId });
  
  res.json({ success: true, orderId });
});

// Use SwiftUI Previews for different screen sizes
struct CheckoutView_Previews: PreviewProvider {
    static var previews: some View {
        Group {
            CheckoutView()
                .previewDevice(PreviewDevice(rawValue: "iPhone SE (3rd generation)"))
                .previewDisplayName("iPhone SE")
            
            CheckoutView()
                .previewDevice(PreviewDevice(rawValue: "iPhone 15 Pro"))
                .previewDisplayName("iPhone 15 Pro")
            
            CheckoutView()
                .previewDevice(PreviewDevice(rawValue: "iPad Pro (12.9-inch)"))
                .previewDisplayName("iPad Pro")
        }
    }
}

import XCTest
import PXPCheckoutSDK

class CheckoutConfigTests: XCTestCase {
    func testConfigCreation() {
        let config = CheckoutDropInConfig(
            environment: .test,
            session: mockSessionData(),
            transactionData: DropInTransactionData(
                amount: Decimal(string: "99.99") ?? 0,
                currency: "GBP",
                entryType: .ecom,
                intent: DropInTransactionIntentData(
                    card: .authorisation
                ),
                merchantTransactionId: "test-txn-123",
                merchantTransactionDate: { Date() }
            ),
            merchantShopperId: "shopper-123",
            ownerId: "MERCHANT-1"
        )
        
        XCTAssertEqual(config.environment, .test)
        XCTAssertEqual(config.ownerId, "MERCHANT-1")
        XCTAssertEqual(config.transactionData.currency, "GBP")
    }
    
    func testCallbackExecution() {
        var successCalled = false
        var errorCalled = false
        
        let config = CheckoutDropInConfig(
            environment: .test,
            session: mockSessionData(),
            transactionData: DropInTransactionData(
                amount: Decimal(string: "99.99") ?? 0,
                currency: "GBP",
                entryType: .ecom,
                intent: DropInTransactionIntentData(
                    card: .authorisation
                ),
                merchantTransactionId: "test-txn-callback-123",
                merchantTransactionDate: { Date() }
            ),
            merchantShopperId: "shopper-callback-123",
            ownerId: "MERCHANT-1",
            onSuccess: { result in
                Task { @MainActor in
                    successCalled = true
                }
            },
            onError: { paymentMethod, error in
                Task { @MainActor in
                    errorCalled = true
                }
            }
        )
        
        // Test callbacks
        config.onSuccess?(mockSuccessResult())
        XCTAssertTrue(successCalled)
        XCTAssertFalse(errorCalled)
    }
    
    func mockSessionData(includePaze: Bool = false) -> SessionData {
        return SessionData(
            sessionId: "test-session-id",
            hmacKey: "test-hmac-key",
            encryptionKey: "test-encryption-key",
            sessionExpiry: nil,
            allowedFundingTypes: AllowedFundingType(
                cardSchemes: ["Visa", "Mastercard"],
                cards: [],
                wallets: Wallets(
                    paypal: Paypal(
                        allowedFundingOptions: ["paypal"],
                        merchantId: "test-merchant-id"
                    ),
                    applePay: ApplePay(merchantId: "merchant.test.app"),
                    paze: includePaze
                        ? Paze(clientId: "test-paze-client-id", merchantCategoryCode: "5812")
                        : nil
                )
            ),
            restrictions: nil
        )
    }
    
    func testPazeConfigUsesUSD() {
        let config = CheckoutDropInConfig(
            environment: .test,
            session: mockSessionData(includePaze: true),
            transactionData: DropInTransactionData(
                amount: Decimal(string: "49.99") ?? 0,
                currency: "USD",
                entryType: .ecom,
                intent: DropInTransactionIntentData(card: .authorisation),
                merchantTransactionId: "test-paze-txn-123",
                merchantTransactionDate: { Date() }
            ),
            merchantShopperId: "shopper-123",
            ownerId: "MERCHANT-1",
            onSuccess: { _ in },
            onError: { _, _ in }
        )
        
        XCTAssertEqual(config.transactionData.currency, "USD")
        XCTAssertEqual(config.transactionData.entryType, .ecom)
    }
    
    func mockSuccessResult(paymentMethod: DropInPaymentMethod = .card) -> DropInSubmitResult {
        return DropInSubmitResult(
            systemTransactionId: "sys-txn-123",
            merchantTransactionId: "test-txn-123",
            paymentMethod: paymentMethod
            // paymentData is nil for card, PayPal, and Apple Pay; optional .paze for Paze
        )
    }
}

class AsyncDropInTests: XCTestCase {
    func testAsyncDropInCreation() async throws {
        let config = CheckoutDropInConfig(
            environment: .test,
            session: mockSessionData(),
            transactionData: DropInTransactionData(
                amount: Decimal(string: "49.99") ?? 0,
                currency: "GBP",
                entryType: .ecom,
                intent: DropInTransactionIntentData(
                    card: .authorisation
                ),
                merchantTransactionId: "test-async-txn-123",
                merchantTransactionDate: { Date() }
            ),
            merchantShopperId: "shopper-async-123",
            ownerId: "MERCHANT-1"
        )
        
        // Test async initialisation
        let dropIn = try CheckoutDropIn(config: config)
        await dropIn.create()
        
        // Verify Drop-in is ready
        XCTAssertNotNil(dropIn)
    }
}

import XCTest

class CheckoutFlowUITests: XCTestCase {
    var app: XCUIApplication!
    
    override func setUp() {
        super.setUp()
        continueAfterFailure = false
        app = XCUIApplication()
        app.launch()
    }
    
    func testCardPaymentFlow() {
        // Wait for Drop-in to render
        let cardButton = app.buttons["Card"]
        XCTAssertTrue(cardButton.waitForExistence(timeout: 5))
        
        // Verify payment methods are displayed
        XCTAssertTrue(app.buttons["Card"].exists)
        XCTAssertTrue(app.buttons["PayPal"].exists)
        // If Paze is enabled in your session:
        // XCTAssertTrue(app.buttons["Paze"].exists)
        
        // Select card payment
        cardButton.tap()
        
        // Verify card form is displayed
        XCTAssertTrue(app.textFields["Card number"].exists)
        XCTAssertTrue(app.textFields["Expiry date"].exists)
        XCTAssertTrue(app.textFields["CVV"].exists)
    }
    
    func testPaymentSubmission() {
        let cardButton = app.buttons["Card"]
        XCTAssertTrue(cardButton.waitForExistence(timeout: 5))
        
        // Fill card details and submit
        cardButton.tap()
        
        let cardNumberField = app.textFields["Card number"]
        cardNumberField.tap()
        cardNumberField.typeText("4111111111111111")
        
        let expiryField = app.textFields["Expiry date"]
        expiryField.tap()
        expiryField.typeText("1225")
        
        let cvvField = app.textFields["CVV"]
        cvvField.tap()
        cvvField.typeText("123")
        
        // Submit payment
        app.buttons["Pay"].tap()
        
        // Verify success screen appears
        let successMessage = app.staticTexts["Payment successful"]
        XCTAssertTrue(successMessage.waitForExistence(timeout: 10))
    }
}