Skip to main content

​
Pre-Production Testing Checklist

Before moving your BOOP integration to production, complete this comprehensive testing checklist using the dev environment at dev.app.boop.it.

​
🔧 Development Environment Setup

1

Obtain Dev Credentials

Get your development credentials from the BOOP team:
  • Vendor ID: ven_dev_your_id
  • API Key: sk_dev_your_key
  • WebSocket endpoint: wss://dev.app.boop.it/ws/vendor
2

Configure Base URL

Update your application to use the dev environment:
const BOOP_BASE_URL = 'https://dev.app.boop.it';
3

Test Health Check

Verify connectivity:
curl https://dev.app.boop.it/health

​
📋 Functional Testing

​
Authentication Flow Testing

Test Scenario: Basic user authentication without paymentSteps:
  1. Connect to vendor WebSocket
  2. Send authentication message with dev credentials
  3. Create authentication context for entrance/membership
  4. Request user attributes: ['pseudonym', 'email']
  5. Verify successful authentication response
Expected Result:
{
  "type": "auth_result",
  "context_id": "ctx_123",
  "result": {
    "success": true,
    "user_id": "usr_abc123",
    "attributes": {...}
  }
}
Test Scenario: Authentication with payment processingSteps:
  1. Create payment authentication context
  2. Set payment amount (e.g., 2500 cents = $25.00)
  3. Request payment-related attributes
  4. Verify both authentication and payment success
  5. Check transaction status via API
Expected Result:
  • Authentication successful
  • Payment processed
  • Transaction ID returned
  • Balance deducted correctly
Test Scenario: Age-restricted accessSteps:
  1. Request age-verify attribute (requires attestation)
  2. Test with verified and unverified users
  3. Handle attestation requirements
Expected Results:
  • Verified users: Access granted
  • Unverified users: Appropriate error message

​
Error Handling Testing

Test: Authentication with unregistered palmExpected: user-not-found error codeVerify: Graceful error handling in your UI
Test: Payment exceeding user balanceExpected: Payment failure with clear messageVerify: User prompted to add funds
Test: Request attributes user hasn’t providedExpected: user-missing-attributes with listVerify: User guided through attribute setup
Test: Handle connection drops and timeoutsExpected: Automatic reconnectionVerify: User experience remains smooth

​
🔄 Integration Testing

​
WebSocket Connection Testing

// Test WebSocket stability
const testWebSocketResilience = async () => {
  let reconnectCount = 0;

  const ws = new WebSocket('wss://dev.app.boop.it/ws/vendor');

  ws.onopen = () => {
    console.log('✅ WebSocket connected');
    // Send auth immediately
    ws.send(JSON.stringify({
      type: 'authenticate',
      vendor_id: 'ven_dev_your_id',
      api_key: 'sk_dev_your_key'
    }));
  };

  ws.onclose = () => {
    reconnectCount++;
    console.log(`🔄 WebSocket disconnected, attempt ${reconnectCount}`);

    if (reconnectCount < 5) {
      setTimeout(() => testWebSocketResilience(), 5000);
    }
  };

  ws.onerror = (error) => {
    console.error('❌ WebSocket error:', error);
  };
};

​
API Endpoint Testing

Test all API endpoints you’ll use in production: 
// Test user token balance retrieval
const testTokenBalance = async (userTokenShare) => {
  const userId = calculateUserId(userTokenShare);

  const response = await fetch(
    `https://dev.app.boop.it/api/v1/ledger/tokens/${userId}`,
    {
      headers: { 'X-API-Key': 'sk_dev_your_key' }
    }
  );

  const { balance } = await response.json();
  console.log(`✅ User balance: $${balance / 100}`);

  return balance;
};

​
📊 Performance Testing

​
Load Testing Checklist

Test with realistic load patterns to ensure your integration can handle production traffic.
  • Concurrent Users: Test with 10-50 simultaneous authentications
  • Peak Load: Simulate your expected peak usage
  • Response Times: Authentication should complete within 2-3 seconds
  • WebSocket Stability: Maintain connections under load
  • Error Rates: Should remain under 1% during normal operation

​
Performance Benchmarks

// Benchmark authentication performance
const benchmarkAuthentication = async () => {
  const startTime = Date.now();

  // Create authentication context
  const contextResult = await createAuthContext('payment', {
    amount: 1000,
    attributes: ['pseudonym', 'email']
  });

  const endTime = Date.now();
  const duration = endTime - startTime;

  console.log(`✅ Authentication completed in ${duration}ms`);

  // Performance targets:
  // - Authentication: < 2000ms
  // - Context creation: < 500ms
  // - WebSocket response: < 1000ms

  return {
    duration,
    success: duration < 2000,
    contextId: contextResult.context_id
  };
};

​
🔒 Security Testing

​
Credential Security

  • ✅ API Keys: Never exposed in client-side code
  • ✅ HTTPS Only: All API calls use HTTPS
  • ✅ Key Rotation: Test with rotated dev keys
  • ✅ Access Control: Verify unauthorized requests fail

​
Data Security

  • ✅ Attribute Encryption: User attributes properly encrypted
  • ✅ Payment Security: Transaction data secured
  • ✅ Logging: No sensitive data logged
  • ✅ Error Messages: No information leakage

​
📱 User Experience Testing

​
End-to-End User Flows

Test complete user journeys:
  1. First-Time User
    • Palm registration process
    • Attribute setup
    • First authentication
    • Payment setup
  2. Returning User
    • Quick authentication
    • Payment processing
    • Attribute updates
  3. Error Recovery
    • Failed authentication
    • Network issues
    • Payment failures

​
Device Testing

Test on various devices and browsers:
  • Mobile: iOS Safari, Android Chrome
  • Desktop: Chrome, Firefox, Safari, Edge
  • Network Conditions: WiFi, cellular, low bandwidth

​
✅ Production Readiness Checklist

Mark each item as complete before proceeding to production:
  • All functional tests passing
  • Error handling tested and working
  • Performance meets targets
  • Security review completed
  • User experience validated
  • Monitoring and logging implemented
  • Documentation updated
  • Team trained on production procedures
  • Rollback plan prepared
  • Production credentials obtained

​
🚀 Next Steps

Once all tests pass:
  1. Request Production Access: Contact BOOP team for production credentials
  2. Review Migration Guide: Follow the Migration Guide
  3. Set Up Monitoring: Implement production monitoring
  4. Plan Deployment: Schedule production deployment
  5. Prepare Support: Brief your support team on BOOP integration

Ready for Production?

When all checklist items are complete, you’re ready to move to production!Start Migration Process →