backend_test.py

#!/usr/bin/env python3

import requests
import sys
import json
import time
from datetime import datetime
from typing import Dict, Any

class NexusBuyAPITester:
    def __init__(self, base_url: str = "https://nexus-buy.preview.emergentagent.com"):
        self.base_url = base_url.rstrip('/')
        self.buyer_token = None
        self.seller_token = None
        self.buyer_data = None
        self.seller_data = None
        self.tests_run = 0
        self.tests_passed = 0
        self.failed_tests = []

    def run_test(self, name: str, method: str, endpoint: str, expected_status: int, 
                 data: Dict = None, token: str = None, params: Dict = None) -> tuple:
        """Run a single API test"""
        url = f"{self.base_url}/api/{endpoint}" if not endpoint.startswith('/') else f"{self.base_url}{endpoint}"
        headers = {'Content-Type': 'application/json'}
        if token:
            headers['Authorization'] = f'Bearer {token}'

        self.tests_run += 1
        print(f"\n🔍 Testing {name}...")
        print(f"   {method} {url}")
        
        try:
            if method == 'GET':
                response = requests.get(url, headers=headers, params=params, timeout=10)
            elif method == 'POST':
                response = requests.post(url, json=data, headers=headers, timeout=10)
            elif method == 'PUT':
                response = requests.put(url, json=data, headers=headers, timeout=10)
            elif method == 'DELETE':
                response = requests.delete(url, headers=headers, timeout=10)

            success = response.status_code == expected_status
            
            if success:
                self.tests_passed += 1
                print(f"   ✅ PASSED - Status: {response.status_code}")
                try:
                    response_data = response.json()
                    print(f"   📋 Response keys: {list(response_data.keys()) if isinstance(response_data, dict) else type(response_data)}")
                    return True, response_data
                except:
                    return True, {}
            else:
                print(f"   ❌ FAILED - Expected {expected_status}, got {response.status_code}")
                try:
                    error_data = response.json()
                    print(f"   📋 Error: {error_data}")
                except:
                    print(f"   📋 Raw response: {response.text}")
                self.failed_tests.append(f"{name}: Expected {expected_status}, got {response.status_code}")
                return False, {}

        except requests.exceptions.RequestException as e:
            print(f"   ❌ NETWORK ERROR: {str(e)}")
            self.failed_tests.append(f"{name}: Network error - {str(e)}")
            return False, {}
        except Exception as e:
            print(f"   ❌ ERROR: {str(e)}")
            self.failed_tests.append(f"{name}: {str(e)}")
            return False, {}

    def test_auth_flow(self):
        """Test complete authentication flow"""
        print("\n" + "="*50)
        print("🔐 TESTING AUTHENTICATION")
        print("="*50)
        
        # Test buyer registration
        buyer_data = {
            "name": "Test Buyer",
            "email": "buyer@test.com", 
            "password": "test123",
            "role": "buyer"
        }
        success, response = self.run_test("Buyer Registration", "POST", "auth/register", 200, buyer_data)
        if success and response.get('token'):
            self.buyer_token = response['token']
            self.buyer_data = response.get('user', {})
            print(f"   🎯 Buyer ID: {self.buyer_data.get('id', 'N/A')}")
        
        # Test seller registration  
        seller_data = {
            "name": "Test Seller",
            "email": "seller@test.com",
            "password": "test123", 
            "role": "seller"
        }
        success, response = self.run_test("Seller Registration", "POST", "auth/register", 200, seller_data)
        if success and response.get('token'):
            self.seller_token = response['token']
            self.seller_data = response.get('user', {})
            print(f"   🎯 Seller ID: {self.seller_data.get('id', 'N/A')}")
        
        # Test buyer login
        login_data = {"email": "buyer@test.com", "password": "test123"}
        success, response = self.run_test("Buyer Login", "POST", "auth/login", 200, login_data)
        if success and response.get('token'):
            self.buyer_token = response['token']
            self.buyer_data = response.get('user', {})
            print(f"   🎯 Buyer ID from login: {self.buyer_data.get('id', 'N/A')}")
        
        # Test seller login
        seller_login = {"email": "seller@test.com", "password": "test123"}  
        success, response = self.run_test("Seller Login", "POST", "auth/login", 200, seller_login)
        if success and response.get('token'):
            self.seller_token = response['token']
            self.seller_data = response.get('user', {})
            print(f"   🎯 Seller ID from login: {self.seller_data.get('id', 'N/A')}")
        
        # Test profile retrieval
        if self.buyer_token:
            self.run_test("Buyer Profile", "GET", "auth/me", 200, token=self.buyer_token)
        if self.seller_token:
            self.run_test("Seller Profile", "GET", "auth/me", 200, token=self.seller_token)

    def test_products_api(self):
        """Test product-related endpoints"""
        print("\n" + "="*50) 
        print("📦 TESTING PRODUCTS API")
        print("="*50)
        
        # Test getting all products
        success, products = self.run_test("Get All Products", "GET", "products", 200)
        if success and isinstance(products, list):
            print(f"   📊 Found {len(products)} products")
            if len(products) > 0:
                sample_product = products[0]
                product_id = sample_product.get('id')
                print(f"   🎯 Sample product: {sample_product.get('name', 'N/A')}")
                
                # Test getting single product
                if product_id:
                    self.run_test("Get Single Product", "GET", f"products/{product_id}", 200)
                    
                    # Test product recommendations
                    self.run_test("Product Recommendations", "GET", f"recommendations/{product_id}", 200)
        
        # Test categories
        self.run_test("Get Categories", "GET", "categories", 200)
        
        # Test product search
        self.run_test("Search Products", "GET", "products", 200, params={"search": "pasta"})
        
        # Test category filter
        self.run_test("Filter by Category", "GET", "products", 200, params={"category": "Pantry"})
        
        # Test seller product creation (if seller token available)
        if self.seller_token:
            product_data = {
                "name": "Test Product", 
                "description": "A test product",
                "price": 99.99,
                "category": "Test Category",
                "image_url": "https://via.placeholder.com/400",
                "barcode": "1234567890123",
                "stock": 50,
                "tags": ["test", "sample"]
            }
            success, new_product = self.run_test("Create Product", "POST", "products", 200, product_data, self.seller_token)
            
            if success and new_product.get('id'):
                product_id = new_product['id']
                print(f"   🎯 Created product ID: {product_id}")
                
                # Test product update
                update_data = {**product_data, "price": 89.99}
                self.run_test("Update Product", "PUT", f"products/{product_id}", 200, update_data, self.seller_token)
                
                # Test product delete
                self.run_test("Delete Product", "DELETE", f"products/{product_id}", 200, token=self.seller_token)

    def test_cart_api(self):
        """Test cart functionality"""
        print("\n" + "="*50)
        print("🛒 TESTING CART API") 
        print("="*50)
        
        if not self.buyer_token:
            print("   ⚠️ Skipping cart tests - no buyer token")
            return
            
        # Get products to add to cart
        success, products = self.run_test("Get Products for Cart", "GET", "products", 200)
        if not success or not products:
            print("   ⚠️ Skipping cart tests - no products available")
            return
            
        product_id = products[0].get('id')
        if not product_id:
            print("   ⚠️ Skipping cart tests - no valid product ID")
            return
            
        print(f"   🎯 Using product: {products[0].get('name', 'N/A')}")
        
        # Test empty cart
        self.run_test("Get Empty Cart", "GET", "cart", 200, token=self.buyer_token)
        
        # Test add to cart
        cart_item = {"product_id": product_id, "quantity": 2}
        self.run_test("Add to Cart", "POST", "cart/add", 200, cart_item, self.buyer_token)
        
        # Test get cart with items
        success, cart = self.run_test("Get Cart with Items", "GET", "cart", 200, token=self.buyer_token)
        if success and cart:
            print(f"   📊 Cart has {len(cart)} items")
        
        # Test update cart quantity
        update_item = {"product_id": product_id, "quantity": 3}
        self.run_test("Update Cart Quantity", "PUT", "cart/update", 200, update_item, self.buyer_token)
        
        # Test remove from cart
        self.run_test("Remove from Cart", "DELETE", f"cart/remove/{product_id}", 200, token=self.buyer_token)
        
        # Test clear cart
        self.run_test("Clear Cart", "DELETE", "cart/clear", 200, token=self.buyer_token)

    def test_ai_features(self):
        """Test AI-related endpoints"""
        print("\n" + "="*50)
        print("🤖 TESTING AI FEATURES")
        print("="*50)
        
        if not self.buyer_token:
            print("   ⚠️ Skipping AI tests - no buyer token")
            return
            
        # Test AI chat
        chat_data = {"message": "I want to cook pasta for 4 people", "session_id": "test123"}
        success, response = self.run_test("AI Chat", "POST", "ai/chat", 200, chat_data, self.buyer_token)
        if success:
            print(f"   🎯 AI Response: {response.get('response', 'N/A')[:100]}...")
            suggestions = response.get('suggestions', [])
            print(f"   📊 AI provided {len(suggestions)} suggestions")
        
        # Test intent search
        intent_data = {"query": "cold remedy"}
        success, response = self.run_test("Intent Search", "POST", "ai/intent-search", 200, intent_data)
        if success:
            suggestions = response.get('suggestions', [])
            print(f"   📊 Intent search found {len(suggestions)} suggestions")

    def test_payment_flow(self):
        """Test payment endpoints (mocked)"""
        print("\n" + "="*50)
        print("💳 TESTING PAYMENT FLOW (MOCKED)")
        print("="*50)
        
        if not self.buyer_token:
            print("   ⚠️ Skipping payment tests - no buyer token")
            return
            
        # Test create payment order
        payment_data = {"amount": 10000}  # Rs. 100.00
        success, order = self.run_test("Create Payment Order", "POST", "payments/create-order", 200, payment_data, self.buyer_token)
        
        if success and order.get('id'):
            order_id = order['id']
            print(f"   🎯 Payment order ID: {order_id}")
            
            # Test verify payment
            verify_data = {"order_id": order_id}
            self.run_test("Verify Payment", "POST", "payments/verify", 200, verify_data, self.buyer_token)

    def test_order_flow(self):
        """Test complete order creation flow"""
        print("\n" + "="*50)
        print("📋 TESTING ORDER FLOW")
        print("="*50)
        
        if not self.buyer_token:
            print("   ⚠️ Skipping order tests - no buyer token")
            return
            
        # Get a product for order
        success, products = self.run_test("Get Products for Order", "GET", "products", 200)
        if not success or not products:
            print("   ⚠️ Skipping order tests - no products available")
            return
            
        product = products[0]
        
        # Create order
        order_data = {
            "items": [{"product_id": product['id'], "name": product['name'], "price": product['price'], "quantity": 2}],
            "total": product['price'] * 2,
            "delivery_address": "123 Test Street, Test City, 12345"
        }
        success, order = self.run_test("Create Order", "POST", "orders", 200, order_data, self.buyer_token)
        
        if success:
            print(f"   🎯 Order ID: {order.get('id', 'N/A')}")
        
        # Get orders
        self.run_test("Get User Orders", "GET", "orders", 200, token=self.buyer_token)

    def test_seller_features(self):
        """Test seller-specific features"""
        print("\n" + "="*50)
        print("🏪 TESTING SELLER FEATURES")
        print("="*50)
        
        if not self.seller_token:
            print("   ⚠️ Skipping seller tests - no seller token")
            return
            
        # Test seller analytics
        self.run_test("Seller Analytics", "GET", "analytics/seller", 200, token=self.seller_token)
        
        # Test barcode lookup
        barcode_data = {"barcode": "8901234567001"}
        self.run_test("Barcode Lookup", "POST", "inventory/barcode-lookup", 200, barcode_data, self.seller_token)
        
        # Test admin analytics (general endpoint)
        self.run_test("Admin Analytics", "GET", "analytics/overview", 200)

    def test_misc_endpoints(self):
        """Test miscellaneous endpoints"""
        print("\n" + "="*50)
        print("🔧 TESTING MISC ENDPOINTS")
        print("="*50)
        
        # Test stores
        self.run_test("Get Stores", "GET", "stores", 200)
        
        # Test seed endpoint
        self.run_test("Seed Data", "POST", "seed", 200)

    def run_all_tests(self):
        """Run comprehensive API test suite"""
        print("🚀 Starting NexusBuy API Test Suite")
        print(f"🌐 Backend URL: {self.base_url}")
        print(f"⏰ Test started at: {datetime.now()}")
        
        try:
            self.test_auth_flow()
            self.test_products_api()
            self.test_cart_api()
            self.test_ai_features()
            self.test_payment_flow()
            self.test_order_flow()
            self.test_seller_features()
            self.test_misc_endpoints()
        except KeyboardInterrupt:
            print("\n⚠️ Tests interrupted by user")
        except Exception as e:
            print(f"\n💥 Unexpected error during testing: {str(e)}")
        
        self.print_summary()

    def print_summary(self):
        """Print test results summary"""
        print("\n" + "="*60)
        print("📊 TEST RESULTS SUMMARY")
        print("="*60)
        
        success_rate = (self.tests_passed / self.tests_run * 100) if self.tests_run > 0 else 0
        
        print(f"✅ Tests Passed: {self.tests_passed}/{self.tests_run} ({success_rate:.1f}%)")
        
        if self.failed_tests:
            print(f"\n❌ Failed Tests ({len(self.failed_tests)}):")
            for i, failure in enumerate(self.failed_tests, 1):
                print(f"   {i}. {failure}")
        
        print(f"\n🎯 Authentication Status:")
        print(f"   Buyer Token: {'✅ Valid' if self.buyer_token else '❌ Missing'}")
        print(f"   Seller Token: {'✅ Valid' if self.seller_token else '❌ Missing'}")
        
        if success_rate >= 80:
            print(f"\n🎉 OVERALL STATUS: ✅ GOOD (Backend appears functional)")
            return 0
        elif success_rate >= 50:
            print(f"\n⚠️ OVERALL STATUS: 🟡 PARTIAL (Some issues detected)")
            return 1
        else:
            print(f"\n💥 OVERALL STATUS: ❌ POOR (Major issues detected)")
            return 2

def main():
    """Main function"""
    backend_url = "https://nexus-buy.preview.emergentagent.com"
    
    print("NexusBuy API Tester")
    print("==================")
    
    tester = NexusBuyAPITester(backend_url)
    return tester.run_all_tests()

if __name__ == "__main__":
    sys.exit(main())