31d3d70836
Blockchain Node: - Replace /blocks (pagination) with /blocks-range (height range query) - Add start/end height parameters with 1000-block max range validation - Return blocks in ascending height order instead of descending - Update metrics names (rpc_get_blocks_range_*) - Remove total count from response (return start/end/count instead) Coordinator API: - Add effective_url property to DatabaseConfig (SQLite/PostgreSQL defaults
362 lines
13 KiB
Python
362 lines
13 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Exchange End-to-End Test
|
|
Tests complete Bitcoin exchange workflow: rates → payment creation → monitoring → confirmation.
|
|
"""
|
|
|
|
import argparse
|
|
import sys
|
|
import time
|
|
from typing import Optional
|
|
|
|
import httpx
|
|
|
|
DEFAULT_COORDINATOR = "http://localhost:8000"
|
|
DEFAULT_API_KEY = "${CLIENT_API_KEY}"
|
|
DEFAULT_USER_ID = "e2e_test_user"
|
|
DEFAULT_AITBC_AMOUNT = 1000
|
|
DEFAULT_TIMEOUT = 300
|
|
POLL_INTERVAL = 10
|
|
|
|
|
|
def get_exchange_rates(client: httpx.Client, base_url: str) -> Optional[dict]:
|
|
"""Get current exchange rates"""
|
|
response = client.get(
|
|
f"{base_url}/v1/exchange/rates",
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to get exchange rates: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def create_payment(client: httpx.Client, base_url: str, user_id: str,
|
|
aitbc_amount: float, btc_amount: Optional[float] = None,
|
|
notes: Optional[str] = None) -> Optional[dict]:
|
|
"""Create a Bitcoin payment request"""
|
|
if not btc_amount:
|
|
# Get rates to calculate BTC amount
|
|
rates = get_exchange_rates(client, base_url)
|
|
if not rates:
|
|
return None
|
|
btc_amount = aitbc_amount / rates['btc_to_aitbc']
|
|
|
|
payload = {
|
|
"user_id": user_id,
|
|
"aitbc_amount": aitbc_amount,
|
|
"btc_amount": btc_amount
|
|
}
|
|
if notes:
|
|
payload["notes"] = notes
|
|
|
|
response = client.post(
|
|
f"{base_url}/v1/exchange/create-payment",
|
|
json=payload,
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to create payment: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def get_payment_status(client: httpx.Client, base_url: str, payment_id: str) -> Optional[dict]:
|
|
"""Get payment status"""
|
|
response = client.get(
|
|
f"{base_url}/v1/exchange/payment-status/{payment_id}",
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to get payment status: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def confirm_payment(client: httpx.Client, base_url: str, payment_id: str,
|
|
tx_hash: str) -> Optional[dict]:
|
|
"""Confirm payment (simulating blockchain confirmation)"""
|
|
response = client.post(
|
|
f"{base_url}/v1/exchange/confirm-payment/{payment_id}",
|
|
json={"tx_hash": tx_hash},
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to confirm payment: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def get_market_stats(client: httpx.Client, base_url: str) -> Optional[dict]:
|
|
"""Get market statistics"""
|
|
response = client.get(
|
|
f"{base_url}/v1/exchange/market-stats",
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to get market stats: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def get_wallet_balance(client: httpx.Client, base_url: str) -> Optional[dict]:
|
|
"""Get Bitcoin wallet balance"""
|
|
response = client.get(
|
|
f"{base_url}/v1/exchange/wallet/balance",
|
|
timeout=10,
|
|
)
|
|
if response.status_code != 200:
|
|
print(f"❌ Failed to get wallet balance: {response.status_code} {response.text}")
|
|
return None
|
|
return response.json()
|
|
|
|
|
|
def monitor_payment_confirmation(client: httpx.Client, base_url: str,
|
|
payment_id: str, timeout: int) -> Optional[str]:
|
|
"""Monitor payment until confirmed or timeout"""
|
|
deadline = time.time() + timeout
|
|
|
|
while time.time() < deadline:
|
|
status_data = get_payment_status(client, base_url, payment_id)
|
|
if not status_data:
|
|
return None
|
|
|
|
status = status_data.get("status")
|
|
print(f"⏳ Payment status: {status}")
|
|
|
|
if status == "confirmed":
|
|
return status
|
|
elif status == "expired":
|
|
print("❌ Payment expired")
|
|
return status
|
|
|
|
time.sleep(POLL_INTERVAL)
|
|
|
|
print("❌ Payment monitoring timed out")
|
|
return None
|
|
|
|
|
|
def test_basic_exchange_workflow(client: httpx.Client, base_url: str, user_id: str,
|
|
aitbc_amount: float) -> bool:
|
|
"""Test basic exchange workflow"""
|
|
print("🧪 Testing basic exchange workflow...")
|
|
|
|
# Step 1: Get exchange rates
|
|
print("💱 Getting exchange rates...")
|
|
rates = get_exchange_rates(client, base_url)
|
|
if not rates:
|
|
print("❌ Failed to get exchange rates")
|
|
return False
|
|
|
|
print(f"✅ Exchange rates: 1 BTC = {rates['btc_to_aitbc']:,} AITBC")
|
|
print(f" Fee: {rates['fee_percent']}%")
|
|
|
|
# Step 2: Create payment
|
|
print(f"💰 Creating payment for {aitbc_amount} AITBC...")
|
|
payment = create_payment(client, base_url, user_id, aitbc_amount,
|
|
notes="E2E test payment")
|
|
if not payment:
|
|
print("❌ Failed to create payment")
|
|
return False
|
|
|
|
print(f"✅ Payment created: {payment['payment_id']}")
|
|
print(f" Send {payment['btc_amount']:.8f} BTC to: {payment['payment_address']}")
|
|
print(f" Expires at: {payment['expires_at']}")
|
|
|
|
# Step 3: Check initial payment status
|
|
print("📋 Checking initial payment status...")
|
|
status = get_payment_status(client, base_url, payment['payment_id'])
|
|
if not status:
|
|
print("❌ Failed to get payment status")
|
|
return False
|
|
|
|
print(f"✅ Initial status: {status['status']}")
|
|
|
|
# Step 4: Simulate payment confirmation
|
|
print("🔗 Simulating blockchain confirmation...")
|
|
tx_hash = f"test_tx_{int(time.time())}"
|
|
confirmation = confirm_payment(client, base_url, payment['payment_id'], tx_hash)
|
|
if not confirmation:
|
|
print("❌ Failed to confirm payment")
|
|
return False
|
|
|
|
print(f"✅ Payment confirmed with transaction: {tx_hash}")
|
|
|
|
# Step 5: Verify final status
|
|
print("📄 Verifying final payment status...")
|
|
final_status = get_payment_status(client, base_url, payment['payment_id'])
|
|
if not final_status:
|
|
print("❌ Failed to get final payment status")
|
|
return False
|
|
|
|
if final_status['status'] != 'confirmed':
|
|
print(f"❌ Expected confirmed status, got: {final_status['status']}")
|
|
return False
|
|
|
|
print(f"✅ Payment confirmed! AITBC amount: {final_status['aitbc_amount']}")
|
|
|
|
return True
|
|
|
|
|
|
def test_market_statistics(client: httpx.Client, base_url: str) -> bool:
|
|
"""Test market statistics functionality"""
|
|
print("🧪 Testing market statistics...")
|
|
|
|
stats = get_market_stats(client, base_url)
|
|
if not stats:
|
|
print("❌ Failed to get market stats")
|
|
return False
|
|
|
|
print(f"📊 Market Statistics:")
|
|
print(f" Current price: ${stats['price']:.8f} per AITBC")
|
|
print(f" 24h change: {stats['price_change_24h']:+.2f}%")
|
|
print(f" Daily volume: {stats['daily_volume']:,} AITBC")
|
|
print(f" Daily volume (BTC): {stats['daily_volume_btc']:.8f} BTC")
|
|
print(f" Total payments: {stats['total_payments']}")
|
|
print(f" Pending payments: {stats['pending_payments']}")
|
|
|
|
return True
|
|
|
|
|
|
def test_wallet_operations(client: httpx.Client, base_url: str) -> bool:
|
|
"""Test wallet operations"""
|
|
print("🧪 Testing wallet operations...")
|
|
|
|
balance = get_wallet_balance(client, base_url)
|
|
if not balance:
|
|
print("❌ Failed to get wallet balance (service may be unavailable)")
|
|
return True # Don't fail test if wallet service is unavailable
|
|
|
|
print(f"💰 Wallet Balance:")
|
|
print(f" Address: {balance['address']}")
|
|
print(f" Balance: {balance['balance']:.8f} BTC")
|
|
print(f" Unconfirmed: {balance['unconfirmed_balance']:.8f} BTC")
|
|
print(f" Total received: {balance['total_received']:.8f} BTC")
|
|
print(f" Total sent: {balance['total_sent']:.8f} BTC")
|
|
|
|
return True
|
|
|
|
|
|
def test_multiple_payments_scenario(client: httpx.Client, base_url: str,
|
|
user_id: str) -> bool:
|
|
"""Test multiple payments scenario"""
|
|
print("🧪 Testing multiple payments scenario...")
|
|
|
|
# Create multiple payments
|
|
payment_amounts = [500, 1000, 1500]
|
|
payment_ids = []
|
|
|
|
for i, amount in enumerate(payment_amounts):
|
|
print(f"💰 Creating payment {i+1}: {amount} AITBC...")
|
|
payment = create_payment(client, base_url, f"{user_id}_{i}", amount,
|
|
notes=f"Multi-payment test {i+1}")
|
|
if not payment:
|
|
print(f"❌ Failed to create payment {i+1}")
|
|
return False
|
|
|
|
payment_ids.append(payment['payment_id'])
|
|
print(f"✅ Payment {i+1} created: {payment['payment_id']}")
|
|
time.sleep(1) # Small delay between payments
|
|
|
|
# Confirm all payments
|
|
for i, payment_id in enumerate(payment_ids):
|
|
print(f"🔗 Confirming payment {i+1}...")
|
|
tx_hash = f"multi_tx_{i}_{int(time.time())}"
|
|
confirmation = confirm_payment(client, base_url, payment_id, tx_hash)
|
|
if not confirmation:
|
|
print(f"❌ Failed to confirm payment {i+1}")
|
|
return False
|
|
print(f"✅ Payment {i+1} confirmed")
|
|
time.sleep(0.5)
|
|
|
|
# Check updated market stats
|
|
print("📊 Checking updated market statistics...")
|
|
final_stats = get_market_stats(client, base_url)
|
|
if final_stats:
|
|
print(f"✅ Final stats: {final_stats['total_payments']} total payments")
|
|
|
|
return True
|
|
|
|
|
|
def test_error_scenarios(client: httpx.Client, base_url: str) -> bool:
|
|
"""Test error handling scenarios"""
|
|
print("🧪 Testing error scenarios...")
|
|
|
|
# Test invalid payment creation
|
|
print("❌ Testing invalid payment creation...")
|
|
invalid_payment = create_payment(client, base_url, "test_user", -100)
|
|
if invalid_payment:
|
|
print("❌ Expected error for negative amount, but got success")
|
|
return False
|
|
print("✅ Correctly rejected negative amount")
|
|
|
|
# Test non-existent payment status
|
|
print("❌ Testing non-existent payment status...")
|
|
fake_status = get_payment_status(client, base_url, "fake_payment_id")
|
|
if fake_status:
|
|
print("❌ Expected error for fake payment ID, but got success")
|
|
return False
|
|
print("✅ Correctly rejected fake payment ID")
|
|
|
|
# Test invalid payment confirmation
|
|
print("❌ Testing invalid payment confirmation...")
|
|
fake_confirmation = confirm_payment(client, base_url, "fake_payment_id", "fake_tx")
|
|
if fake_confirmation:
|
|
print("❌ Expected error for fake payment confirmation, but got success")
|
|
return False
|
|
print("✅ Correctly rejected fake payment confirmation")
|
|
|
|
return True
|
|
|
|
|
|
def main() -> int:
|
|
parser = argparse.ArgumentParser(description="Exchange end-to-end test")
|
|
parser.add_argument("--url", default=DEFAULT_COORDINATOR, help="Coordinator base URL")
|
|
parser.add_argument("--api-key", default=DEFAULT_API_KEY, help="Client API key")
|
|
parser.add_argument("--user-id", default=DEFAULT_USER_ID, help="User ID for payments")
|
|
parser.add_argument("--aitbc-amount", type=float, default=DEFAULT_AITBC_AMOUNT, help="AITBC amount for test payment")
|
|
parser.add_argument("--timeout", type=int, default=DEFAULT_TIMEOUT, help="Timeout in seconds")
|
|
parser.add_argument("--test", choices=["basic", "stats", "wallet", "multi", "errors", "all"],
|
|
default="all", help="Test scenario to run")
|
|
args = parser.parse_args()
|
|
|
|
with httpx.Client() as client:
|
|
print("🚀 Starting Exchange end-to-end test...")
|
|
print(f"📍 Coordinator: {args.url}")
|
|
print(f"🆔 User ID: {args.user_id}")
|
|
print(f"💰 Test amount: {args.aitbc_amount} AITBC")
|
|
print()
|
|
|
|
success = True
|
|
|
|
if args.test in ["basic", "all"]:
|
|
success &= test_basic_exchange_workflow(client, args.url, args.user_id, args.aitbc_amount)
|
|
print()
|
|
|
|
if args.test in ["stats", "all"]:
|
|
success &= test_market_statistics(client, args.url)
|
|
print()
|
|
|
|
if args.test in ["wallet", "all"]:
|
|
success &= test_wallet_operations(client, args.url)
|
|
print()
|
|
|
|
if args.test in ["multi", "all"]:
|
|
success &= test_multiple_payments_scenario(client, args.url, args.user_id)
|
|
print()
|
|
|
|
if args.test in ["errors", "all"]:
|
|
success &= test_error_scenarios(client, args.url)
|
|
print()
|
|
|
|
if success:
|
|
print("✅ All exchange tests completed successfully!")
|
|
return 0
|
|
else:
|
|
print("❌ Some exchange tests failed!")
|
|
return 1
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|