Stripe Testing: Simulating Payments with Test Mode and Cards

import stripe
import os

# Switch between test and live mode
def get_stripe_client(use_test=True):
    if use_test:
        stripe.api_key = "sk_test_51Mq..."  # Test secret key
    else:
        stripe.api_key = os.environ["STRIPE_SECRET_KEY"]  # Live key
    return stripe

# Verify test mode
client = get_stripe_client(True)
account = stripe.Account.retrieve()
print(f"Account: {account.id}")
print(f"Test mode: {not account.charges_enabled}")  # Charges disabled in test
# Expected output:
# Account: acct_TestAccount123
# Test mode: True

# List test products
products = stripe.Product.list(limit=3)
for p in products:
    print(f"  {p.id}: {p.name} ({'active' if p.active else 'archived'})")

# Common test cards for different scenarios
test_cards = {
    "success_visa": "4242424242424242",
    "success_visa_debit": "4000056655665556",
    "sca_required": "4000002500003155",
    "decline_insufficient_funds": "4000000000009995",
    "decline_expired_card": "4000000000000069",
    "decline_stolen_card": "4000000000004954",
    "decline_processing_error": "4000000000000119",
    "dispute_chargeback": "4000000000000259"
}

def simulate_payment(card_number, amount=2999):
    """Create and confirm a PaymentIntent with a test card."""
    stripe.api_key = "sk_test_..."
    intent = stripe.PaymentIntent.create(
        amount=amount,
        currency="usd",
        payment_method_data={
            "type": "card",
            "card": {"number": card_number, "exp_month": 12, "exp_year": 2030, "cvc": "123"}
        },
        confirm=True
    )
    print(f"Card: {card_number[:4]}...{card_number[-4:]}")
    print(f"Status: {intent.status}")
    if intent.status == "requires_action":
        print("3D Secure authentication required")
    elif intent.status == "succeeded":
        print(f"Payment succeeded: ${intent.amount/100:.2f}")
    elif intent.status == "requires_payment_method":
        error = intent.last_payment_error
        print(f"Declined: {error.decline_code} ({error.message})")
    return intent

# Test success
result = simulate_payment("4242424242424242")
# Expected output:
# Card: 4242...4242
# Status: succeeded
# Payment succeeded: $29.99

# Test insufficient funds
result = simulate_payment("4000000000009995")
# Expected output:
# Card: 4000...9995
# Status: requires_payment_method
# Declined: insufficient_funds (Your card has insufficient funds.)

# Start webhook forwarding (run in terminal)
# stripe listen --forward-to localhost:8000/webhook/stripe

# The CLI provides a signing secret:
# > Ready! Your webhook signing secret is whsec_...

# Verify webhook signature (Python)
import hashlib
import hmac

def verify_webhook_signature(payload, sig_header, secret):
    try:
        event = stripe.Webhook.construct_event(
            payload, sig_header, secret
        )
        print(f"Verified event: {event.type}")
        return event
    except ValueError:
        print("Invalid payload")
    except stripe.error.SignatureVerificationError:
        print("Invalid signature")
    return None

def handle_test_webhook():
    """Simulate receiving a webhook event."""
    # In test mode, Stripe sends real webhooks
    # Use stripe trigger to simulate events:
    # stripe trigger payment_intent.succeeded

    print("Listening for events...")
    print("Use: stripe trigger payment_intent.succeeded")
    print("Use: stripe trigger checkout.session.completed")
    print("Use: stripe trigger customer.subscription.updated")

# Expected terminal output when running stripe trigger:
# 2024-06-28 12:00:00  --> payment_intent.succeeded [evt_test_...]

def create_test_dispute():
    """Use a dispute-trigger card to simulate a chargeback."""
    intent = stripe.PaymentIntent.create(
        amount=5000,
        currency="usd",
        payment_method_data={
            "type": "card",
            "card": {"number": "4000000000000259", "exp_month": 12, "exp_year": 2030, "cvc": "123"}
        },
        confirm=True
    )
    print(f"Dispute payment: {intent.id} ({intent.status})")
    # Stripe automatically creates a dispute for this card
    return intent

def test_refund_flow(payment_intent_id):
    """Test full and partial refunds."""
    # Full refund
    refund = stripe.Refund.create(
        payment_intent=payment_intent_id
    )
    print(f"Full refund: {refund.id} (${refund.amount/100:.2f})")
    print(f"Status: {refund.status}")

    # Partial refund (if full refund above failed)
    try:
        partial = stripe.Refund.create(
            payment_intent=payment_intent_id,
            amount=1000
        )
        print(f"Partial refund: {partial.id} ($10.00)")
    except stripe.error.InvalidRequestError as e:
        print(f"Cannot partial refund after full refund: {e}")

# test_refund_flow("pi_TestPaymentIntentABC")
# Expected output:
# Full refund: re_1FullRefundABC ($50.00)
# Status: succeeded
# Cannot partial refund after full refund: This PaymentIntent has already been refunded.