describe('Payment Integration Tests', () => {
  const finfusion = new FinFusion({
    apiKey: process.env.TEST_API_KEY,
    environment: 'sandbox'
  });

  test('complete payment flow', async () => {
    // Create payment intent
    const intent = await finfusion.payments.createIntent({
      amount: 1000,
      currency: 'USD',
      paymentMethod: 'card',
      metadata: { orderId: 'test_123' }
    });

    expect(intent.status).toBe('requires_payment_method');

    // Attach test card
    const paymentMethod = await finfusion.paymentMethods.create({
      type: 'card',
      card: {
        number: '4242424242424242',
        expMonth: 12,
        expYear: 2024,
        cvc: '123'
      }
    });

    // Confirm payment
    const payment = await finfusion.payments.confirm(intent.id, {
      paymentMethod: paymentMethod.id
    });

    expect(payment.status).toBe('succeeded');
    expect(payment.amount).toBe(1000);
  });
});
        

describe('Payment Error Scenarios', () => {
  test('handles insufficient funds', async () => {
    const intent = await finfusion.payments.createIntent({
      amount: 1000,
      currency: 'USD',
      paymentMethod: 'card'
    });

    // Use test card that triggers insufficient funds
    const error = await finfusion.payments.confirm(intent.id, {
      paymentMethod: {
        card: {
          number: '4000000000009995',  // Test card for insufficient funds
          expMonth: 12,
          expYear: 2024,
          cvc: '123'
        }
      }
    }).catch(e => e);

    expect(error.code).toBe('card_declined');
    expect(error.decline_code).toBe('insufficient_funds');
  });
});
        

import { check } from 'k6';
import http from 'k6/http';

export const options = {
  stages: [
    { duration: '2m', target: 100 }, // Ramp up to 100 users
    { duration: '5m', target: 100 }, // Stay at 100 users
    { duration: '2m', target: 0 }    // Ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'], // 95% of requests must complete below 500ms
    http_req_failed: ['rate<0.01']    // Error rate must be below 1%
  }
};

export default function() {
  const payload = JSON.stringify({
    amount: 1000,
    currency: 'USD',
    paymentMethod: 'card'
  });

  const params = {
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${__ENV.API_KEY}`
    }
  };

  const res = http.post(
    'https://api.finfusion.cloud/v1/payments',
    payload,
    params
  );

  check(res, {
    'is status 200': (r) => r.status === 200,
    'response time < 500ms': (r) => r.timings.duration < 500
  });
}
        

describe('Security Tests', () => {
  test('rejects invalid API keys', async () => {
    const invalidClient = new FinFusion({
      apiKey: 'invalid_key',
      environment: 'sandbox'
    });

    const error = await invalidClient.payments.create({
      amount: 1000,
      currency: 'USD'
    }).catch(e => e);

    expect(error.code).toBe('authentication_failed');
  });

  test('validates webhook signatures', async () => {
    const payload = {
      type: 'payment.succeeded',
      data: { id: 'pmt_123' }
    };

    const invalidSignature = 'invalid_signature';
    
    expect(() => {
      webhookHandler.verifySignature(payload, invalidSignature)
    }).toThrow('Invalid webhook signature');
  });
});