backend_test.py

#!/usr/bin/env python3

import requests
import sys
import json
from datetime import datetime

class LezzetAPITester:
    def __init__(self, base_url="https://food-delivery-app-152.preview.emergentagent.com/api"):
        self.base_url = base_url
        self.token = None
        self.user_id = None
        self.tests_run = 0
        self.tests_passed = 0
        self.test_results = []

    def log_test_result(self, name, success, details=""):
        """Log test result for reporting"""
        self.test_results.append({
            "name": name,
            "success": success,
            "details": details,
            "timestamp": datetime.now().isoformat()
        })

    def run_test(self, name, method, endpoint, expected_status, data=None, auth_required=False):
        """Run a single API test"""
        url = f"{self.base_url}/{endpoint}"
        headers = {'Content-Type': 'application/json'}
        if auth_required and self.token:
            headers['Authorization'] = f'Bearer {self.token}'

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

            success = response.status_code == expected_status
            
            if success:
                self.tests_passed += 1
                print(f"✅ Passed - Status: {response.status_code}")
                try:
                    response_data = response.json() if response.text else {}
                    self.log_test_result(name, True, f"Status: {response.status_code}")
                    return True, response_data
                except:
                    self.log_test_result(name, True, f"Status: {response.status_code} (no JSON)")
                    return True, {}
            else:
                print(f"❌ Failed - Expected {expected_status}, got {response.status_code}")
                try:
                    error_details = response.json() if response.text else {"error": "No response body"}
                    print(f"   Response: {error_details}")
                    self.log_test_result(name, False, f"Expected {expected_status}, got {response.status_code}: {error_details}")
                except:
                    self.log_test_result(name, False, f"Expected {expected_status}, got {response.status_code}")
                return False, {}

        except requests.exceptions.RequestException as e:
            print(f"❌ Failed - Network Error: {str(e)}")
            self.log_test_result(name, False, f"Network Error: {str(e)}")
            return False, {}
        except Exception as e:
            print(f"❌ Failed - Error: {str(e)}")
            self.log_test_result(name, False, f"Error: {str(e)}")
            return False, {}

    def test_health_check(self):
        """Test basic API health"""
        success, response = self.run_test("API Health Check", "GET", "", 200)
        return success

    def test_seed_data(self):
        """Seed demo data if needed"""
        print("\n📦 Seeding demo data...")
        success, response = self.run_test("Seed Demo Data", "POST", "seed", 200)
        return success

    def test_user_registration(self):
        """Test user registration"""
        timestamp = datetime.now().strftime('%H%M%S')
        test_user = {
            "email": f"test_user_{timestamp}@lezzet.com",
            "password": "TestPass123!",
            "name": f"Test User {timestamp}",
            "phone": f"+90555{timestamp}",
            "role": "customer"
        }
        
        success, response = self.run_test(
            "User Registration", 
            "POST", 
            "auth/register", 
            200, 
            test_user
        )
        
        if success and 'access_token' in response:
            self.token = response['access_token']
            self.user_id = response['user']['user_id']
            print(f"   ✅ Token obtained: {self.token[:20]}...")
            return True
        return False

    def test_user_login(self):
        """Test user login with existing credentials"""
        if not self.token:  # Only test login if we don't have a token from registration
            login_data = {
                "email": "admin@lezzet.com",
                "password": "admin123"
            }
            success, response = self.run_test(
                "User Login", 
                "POST", 
                "auth/login", 
                200, 
                login_data
            )
            
            if success and 'access_token' in response:
                self.token = response['access_token']
                self.user_id = response['user']['user_id']
                print(f"   ✅ Login token obtained: {self.token[:20]}...")
                return True
            return False
        return True

    def test_get_current_user(self):
        """Test getting current user info"""
        if not self.token:
            print("   ⚠️ Skipping - No authentication token")
            return False
            
        success, response = self.run_test(
            "Get Current User",
            "GET", 
            "auth/me", 
            200,
            auth_required=True
        )
        return success

    def test_get_restaurants(self):
        """Test fetching restaurants"""
        success, response = self.run_test(
            "Get Restaurants", 
            "GET", 
            "restaurants", 
            200
        )
        
        if success and isinstance(response, list) and len(response) > 0:
            print(f"   ✅ Found {len(response)} restaurants")
            self.test_restaurant_id = response[0].get('restaurant_id')
            return True
        elif success and isinstance(response, list) and len(response) == 0:
            print("   ⚠️ No restaurants found, may need to seed data")
            return True
        return success

    def test_get_restaurant_detail(self):
        """Test fetching specific restaurant details"""
        if not hasattr(self, 'test_restaurant_id') or not self.test_restaurant_id:
            # Try to get restaurants first to find an ID
            restaurants_success, restaurants = self.run_test("Get Restaurants for Detail Test", "GET", "restaurants", 200)
            if not restaurants_success or not restaurants or len(restaurants) == 0:
                print("   ⚠️ Skipping - No restaurants available for detail test")
                return False
            self.test_restaurant_id = restaurants[0].get('restaurant_id')
        
        success, response = self.run_test(
            "Get Restaurant Detail",
            "GET",
            f"restaurants/{self.test_restaurant_id}",
            200
        )
        
        if success:
            print(f"   ✅ Restaurant details loaded for: {response.get('name', 'Unknown')}")
        return success

    def test_favorites_functionality(self):
        """Test adding and removing favorites"""
        if not self.token:
            print("   ⚠️ Skipping - No authentication token")
            return False
            
        if not hasattr(self, 'test_restaurant_id') or not self.test_restaurant_id:
            print("   ⚠️ Skipping - No restaurant ID available for favorites test")
            return False

        # Add to favorites
        add_success, _ = self.run_test(
            "Add Restaurant to Favorites",
            "POST",
            f"users/favorites/{self.test_restaurant_id}",
            200,
            auth_required=True
        )

        # Get favorites list
        get_success, favorites = self.run_test(
            "Get User Favorites",
            "GET",
            "users/favorites",
            200,
            auth_required=True
        )

        # Remove from favorites
        remove_success, _ = self.run_test(
            "Remove Restaurant from Favorites",
            "DELETE",
            f"users/favorites/{self.test_restaurant_id}",
            200,
            auth_required=True
        )

        return add_success and get_success and remove_success

    def test_order_creation(self):
        """Test creating an order"""
        if not self.token:
            print("   ⚠️ Skipping - No authentication token")
            return False
            
        if not hasattr(self, 'test_restaurant_id'):
            print("   ⚠️ Skipping - No restaurant ID available for order test")
            return False

        # Get restaurant details to find menu items
        success, restaurant = self.run_test(
            "Get Restaurant for Order Test",
            "GET",
            f"restaurants/{self.test_restaurant_id}",
            200
        )

        if not success or not restaurant.get('menu') or len(restaurant['menu']) == 0:
            print("   ⚠️ Skipping - No menu items available for order test")
            return False

        # Create order with first menu item
        menu_item = restaurant['menu'][0]
        order_data = {
            "restaurant_id": self.test_restaurant_id,
            "items": [{
                "item_id": menu_item['item_id'],
                "name": menu_item['name'],
                "quantity": 1,
                "price": menu_item['price']
            }],
            "delivery_address": {
                "street": "Test Street 123",
                "city": "Istanbul",
                "district": "Kadikoy"
            },
            "payment_method": "cash",
            "notes": "Test order"
        }

        success, response = self.run_test(
            "Create Order",
            "POST",
            "orders",
            200,
            order_data,
            auth_required=True
        )

        if success:
            print(f"   ✅ Order created with ID: {response.get('order_id', 'Unknown')}")

        return success

    def test_get_user_orders(self):
        """Test fetching user orders"""
        if not self.token:
            print("   ⚠️ Skipping - No authentication token")
            return False

        success, response = self.run_test(
            "Get User Orders",
            "GET",
            "orders",
            200,
            auth_required=True
        )

        if success:
            order_count = len(response) if isinstance(response, list) else 0
            print(f"   ✅ Found {order_count} orders for user")

        return success

    def test_admin_login(self):
        """Test admin login with Muhammed1974 password"""
        admin_data = {
            "password": "Muhammed1974"
        }
        
        success, response = self.run_test(
            "Admin Login", 
            "POST", 
            "auth/admin/login", 
            200, 
            admin_data
        )
        
        if success and 'access_token' in response:
            self.admin_token = response['access_token']
            self.admin_user = response['user']
            print(f"   ✅ Admin token obtained: {self.admin_token[:20]}...")
            print(f"   ✅ Admin role: {self.admin_user.get('role', 'Unknown')}")
            return True
        return False

    def test_admin_dashboard(self):
        """Test admin dashboard statistics"""
        if not hasattr(self, 'admin_token') or not self.admin_token:
            print("   ⚠️ Skipping - No admin token")
            return False
            
        success, response = self.run_test(
            "Get Admin Dashboard",
            "GET",
            "superadmin/dashboard",
            200,
            auth_required=False  # We'll manually add auth header
        )
        
        # Override the auth for admin token
        url = f"{self.base_url}/superadmin/dashboard"
        headers = {'Authorization': f'Bearer {self.admin_token}'}
        
        try:
            response_req = requests.get(url, headers=headers, timeout=30)
            if response_req.status_code == 200:
                data = response_req.json()
                print(f"   ✅ Dashboard loaded with stats:")
                stats = data.get('stats', {})
                print(f"       Total Users: {stats.get('total_users', 0)}")
                print(f"       Total Restaurants: {stats.get('total_restaurants', 0)}")
                print(f"       Orders Today: {stats.get('orders_today', 0)}")
                print(f"       Revenue Today: {stats.get('revenue_today', 0)}")
                return True
            else:
                print(f"   ❌ Dashboard failed: {response_req.status_code}")
                return False
        except Exception as e:
            print(f"   ❌ Dashboard error: {str(e)}")
            return False

    def test_admin_restaurant_management(self):
        """Test admin restaurant creation and deletion"""
        if not hasattr(self, 'admin_token') or not self.admin_token:
            print("   ⚠️ Skipping - No admin token")
            return False

        # Test creating restaurant
        restaurant_data = {
            "name": "Test Admin Restaurant",
            "name_ar": "مطعم اختبار الادمن",
            "description": "Test restaurant created by admin",
            "description_ar": "مطعم تجريبي تم إنشاؤه من قبل الإدارة",
            "address": "Test Address Damascus",
            "phone": "+963911123456",
            "email": "test@restaurant.com",
            "cuisine_types": ["Syrian", "Traditional"],
            "delivery_fee": 15.0,
            "min_order": 50.0
        }

        url = f"{self.base_url}/superadmin/restaurants"
        headers = {
            'Authorization': f'Bearer {self.admin_token}',
            'Content-Type': 'application/json'
        }

        try:
            # Create restaurant
            response = requests.post(url, json=restaurant_data, headers=headers, timeout=30)
            if response.status_code == 200:
                result = response.json()
                restaurant_id = result.get('restaurant_id')
                print(f"   ✅ Restaurant created with ID: {restaurant_id}")
                
                # Test deleting the created restaurant
                delete_url = f"{self.base_url}/superadmin/restaurants/{restaurant_id}"
                delete_response = requests.delete(delete_url, headers=headers, timeout=30)
                
                if delete_response.status_code == 200:
                    print(f"   ✅ Restaurant deleted successfully")
                    return True
                else:
                    print(f"   ❌ Failed to delete restaurant: {delete_response.status_code}")
                    return False
            else:
                print(f"   ❌ Restaurant creation failed: {response.status_code}")
                try:
                    error_data = response.json()
                    print(f"       Error: {error_data}")
                except:
                    print(f"       Raw response: {response.text}")
                return False
                
        except Exception as e:
            print(f"   ❌ Restaurant management error: {str(e)}")
            return False

    def test_email_verification_system(self):
        """Test email verification system"""
        # Create a user that needs verification
        timestamp = datetime.now().strftime('%H%M%S%f')[:10]  # More unique timestamp
        test_user = {
            "email": f"verify_test_{timestamp}@example.com",
            "password": "TestPass123!",
            "name": f"Verify Test User {timestamp}",
            "phone": f"+90555{timestamp}",
            "role": "customer"
        }
        
        success, response = self.run_test(
            "User Registration with Verification", 
            "POST", 
            "auth/register", 
            200, 
            test_user
        )
        
        if success and response.get('requires_verification'):
            verification_code = response.get('verification_code')
            print(f"   ✅ Registration requires verification, code: {verification_code}")
            
            # Test email verification
            verify_data = {
                "email": test_user["email"],
                "code": verification_code
            }
            
            verify_success, verify_response = self.run_test(
                "Email Verification",
                "POST",
                "auth/verify-email",
                200,
                verify_data
            )
            
            if verify_success:
                print(f"   ✅ Email verification successful")
                return True
            else:
                print(f"   ❌ Email verification failed")
                return False
        else:
            print(f"   ❌ Registration should require verification")
            return False

    def test_app_settings(self):
        """Test app settings (app_name changing)"""
        if not hasattr(self, 'admin_token') or not self.admin_token:
            print("   ⚠️ Skipping - No admin token")
            return False

        headers = {'Authorization': f'Bearer {self.admin_token}'}

        # Get current settings
        get_url = f"{self.base_url}/superadmin/settings"
        try:
            get_response = requests.get(get_url, headers=headers, timeout=30)
            if get_response.status_code == 200:
                current_settings = get_response.json()
                original_app_name = current_settings.get('app_name', 'Lezzet')
                print(f"   ✅ Current app name: {original_app_name}")
                
                # Test changing app name
                new_settings = {
                    "app_name": "مطعم لذيذ",  # Arabic name
                    "default_currency": "SYP",
                    "default_country": "syria"
                }
                
                put_response = requests.put(get_url, json=new_settings, headers=headers, timeout=30)
                if put_response.status_code == 200:
                    print(f"   ✅ App settings updated successfully")
                    
                    # Verify the change
                    verify_response = requests.get(get_url, headers=headers, timeout=30)
                    if verify_response.status_code == 200:
                        updated_settings = verify_response.json()
                        if updated_settings.get('app_name') == "مطعم لذيذ":
                            print(f"   ✅ App name change verified: {updated_settings.get('app_name')}")
                            
                            # Restore original name
                            restore_settings = {"app_name": original_app_name}
                            requests.put(get_url, json=restore_settings, headers=headers, timeout=30)
                            return True
                    return False
                else:
                    print(f"   ❌ Settings update failed: {put_response.status_code}")
                    return False
            else:
                print(f"   ❌ Failed to get settings: {get_response.status_code}")
                return False
        except Exception as e:
            print(f"   ❌ Settings test error: {str(e)}")
            return False

    def test_panel_management(self):
        """Test panel hiding/showing functionality"""
        if not hasattr(self, 'admin_token') or not self.admin_token:
            print("   ⚠️ Skipping - No admin token")
            return False

        headers = {'Authorization': f'Bearer {self.admin_token}'}

        # Get panels list
        panels_url = f"{self.base_url}/superadmin/panels"
        try:
            get_response = requests.get(panels_url, headers=headers, timeout=30)
            if get_response.status_code == 200:
                panels = get_response.json()
                print(f"   ✅ Found {len(panels)} panels")
                
                if panels:
                    # Test toggling the first panel
                    first_panel = panels[0]
                    panel_id = first_panel['id']
                    original_hidden = first_panel['hidden']
                    
                    # Toggle panel
                    toggle_url = f"{self.base_url}/superadmin/panels/{panel_id}/toggle"
                    toggle_response = requests.put(toggle_url, headers=headers, timeout=30)
                    
                    if toggle_response.status_code == 200:
                        print(f"   ✅ Panel {panel_id} toggled successfully")
                        
                        # Verify toggle worked
                        verify_response = requests.get(panels_url, headers=headers, timeout=30)
                        if verify_response.status_code == 200:
                            updated_panels = verify_response.json()
                            updated_panel = next((p for p in updated_panels if p['id'] == panel_id), None)
                            
                            if updated_panel and updated_panel['hidden'] != original_hidden:
                                print(f"   ✅ Panel visibility changed: {not original_hidden} -> {updated_panel['hidden']}")
                                
                                # Toggle back to original state
                                requests.put(toggle_url, headers=headers, timeout=30)
                                return True
                        return False
                    else:
                        print(f"   ❌ Panel toggle failed: {toggle_response.status_code}")
                        return False
                else:
                    print(f"   ⚠️ No panels found to test")
                    return True
            else:
                print(f"   ❌ Failed to get panels: {get_response.status_code}")
                return False
        except Exception as e:
            print(f"   ❌ Panel management error: {str(e)}")
            return False

    def run_all_tests(self):
        """Run all tests in sequence"""
        print("🚀 Starting Lezzet API Tests...")
        print(f"🔗 Base URL: {self.base_url}")
        
        # Test sequence
        tests = [
            ("API Health Check", self.test_health_check),
            ("Seed Demo Data", self.test_seed_data),
            ("User Registration", self.test_user_registration),
            ("Get Current User", self.test_get_current_user),
            ("Get Restaurants", self.test_get_restaurants),
            ("Get Restaurant Detail", self.test_get_restaurant_detail),
            ("Favorites Functionality", self.test_favorites_functionality),
            ("Create Order", self.test_order_creation),
            ("Get User Orders", self.test_get_user_orders),
            # New admin features tests
            ("Admin Login", self.test_admin_login),
            ("Admin Dashboard", self.test_admin_dashboard),
            ("Admin Restaurant Management", self.test_admin_restaurant_management),
            ("Email Verification System", self.test_email_verification_system),
            ("App Settings Management", self.test_app_settings),
            ("Panel Management", self.test_panel_management),
        ]

        for test_name, test_func in tests:
            try:
                test_func()
            except Exception as e:
                print(f"❌ {test_name} failed with exception: {str(e)}")
                self.log_test_result(test_name, False, f"Exception: {str(e)}")

        # Print final results
        success_rate = (self.tests_passed / self.tests_run * 100) if self.tests_run > 0 else 0
        print(f"\n📊 Test Results:")
        print(f"   Total Tests: {self.tests_run}")
        print(f"   Passed: {self.tests_passed}")
        print(f"   Failed: {self.tests_run - self.tests_passed}")
        print(f"   Success Rate: {success_rate:.1f}%")

        # Determine overall result
        if success_rate >= 80:
            print("🎉 Overall Result: PASS")
            return 0
        elif success_rate >= 50:
            print("⚠️  Overall Result: PARTIAL")
            return 1
        else:
            print("❌ Overall Result: FAIL")
            return 2

def main():
    tester = LezzetAPITester()
    return tester.run_all_tests()

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