init projectmycelium

tests/tests_archive/ux_suite/flows/authentication.rs

@@ -0,0 +1,359 @@
+//! Authentication Flow Tests
+//! 
+//! Tests for user authentication functionality:
+//! - User registration at /register
+//! - Login and logout functionality
+//! - Cart migration during login
+//! - Session management
+//! - GitEa OAuth integration (conditional)
+
+use crate::utils::*;
+use crate::environment::*;
+use tokio_test;
+
+/// Test user registration flow
+#[tokio::test]
+#[serial_test::serial]
+async fn test_user_registration_flow() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing user registration flow");
+
+    // Get test persona
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    
+    // Navigate to registration page
+    helper.browser.navigate_to("/register").await?;
+    helper.assert_page_loaded("Register").await?;
+    
+    // Verify registration form elements exist
+    assert!(helper.browser.element_exists("input[name='email'], input[type='email']").await);
+    assert!(helper.browser.element_exists("input[name='password'], input[type='password']").await);
+    assert!(helper.browser.element_exists("input[name='name'], input[name='full_name']").await);
+    
+    helper.take_screenshot("registration_form").await?;
+    
+    // Fill registration form
+    helper.browser.type_text("input[name='email'], input[type='email']", &persona.email).await?;
+    helper.browser.type_text("input[name='password'], input[type='password']", &persona.password).await?;
+    helper.browser.type_text("input[name='name'], input[name='full_name']", &persona.name).await?;
+    
+    // Fill additional fields if they exist
+    if helper.browser.element_exists("input[name='confirm_password']").await {
+        helper.browser.type_text("input[name='confirm_password']", &persona.password).await?;
+    }
+    
+    helper.take_screenshot("registration_form_filled").await?;
+    
+    // Submit registration
+    helper.browser.click("button[type='submit'], .register-btn, .signup-btn").await?;
+    
+    // Wait for success response or redirect
+    helper.browser.wait_for_element(".success, .dashboard, .registration-success, .alert-success").await?;
+    
+    helper.take_screenshot("registration_success").await?;
+    
+    // Verify user is now authenticated (should be on dashboard or logged in)
+    if helper.browser.get_current_url().await?.contains("dashboard") {
+        helper.assert_user_is_authenticated().await?;
+    }
+
+    log::info!("User registration flow test completed successfully");
+    Ok(())
+}
+
+/// Test user login flow
+#[tokio::test]
+#[serial_test::serial]
+async fn test_user_login_flow() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing user login flow");
+
+    // Get test persona (should already exist from registration or test data)
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    
+    // Navigate to login page
+    helper.browser.navigate_to("/login").await?;
+    helper.assert_page_loaded("Login").await?;
+    
+    // Verify login form elements exist
+    assert!(helper.browser.element_exists("input[name='email'], input[type='email']").await);
+    assert!(helper.browser.element_exists("input[name='password'], input[type='password']").await);
+    assert!(helper.browser.element_exists("button[type='submit'], .login-btn").await);
+    
+    helper.take_screenshot("login_form").await?;
+    
+    // Test login with valid credentials
+    helper.login_as(persona).await?;
+    
+    // Verify successful login
+    helper.assert_user_is_authenticated().await?;
+    
+    // Verify redirect to dashboard or appropriate page
+    let current_url = helper.browser.get_current_url().await?;
+    assert!(current_url.contains("dashboard") || current_url.contains("marketplace"));
+    
+    helper.take_screenshot("login_success").await?;
+
+    log::info!("User login flow test completed successfully");
+    Ok(())
+}
+
+/// Test user logout flow
+#[tokio::test]
+#[serial_test::serial]
+async fn test_user_logout_flow() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing user logout flow");
+
+    // First login
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    helper.assert_user_is_authenticated().await?;
+    
+    // Test logout
+    helper.logout().await?;
+    
+    // Verify logout success
+    let current_url = helper.browser.get_current_url().await?;
+    assert!(!current_url.contains("dashboard"));
+    
+    // Verify user menu/authentication indicators are gone
+    assert!(!helper.browser.element_exists(".user-menu, .logout-btn").await);
+    
+    // Try to access protected page and verify redirect
+    helper.browser.navigate_to("/dashboard").await?;
+    
+    // Should redirect to login or show unauthorized
+    let final_url = helper.browser.get_current_url().await?;
+    assert!(final_url.contains("login") || final_url.contains("unauthorized") || !final_url.contains("dashboard"));
+    
+    helper.take_screenshot("logout_success").await?;
+
+    log::info!("User logout flow test completed successfully");
+    Ok(())
+}
+
+/// Test cart migration during login
+#[tokio::test]
+#[serial_test::serial]
+async fn test_cart_migration_during_login() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing cart migration during login");
+
+    // Step 1: Add items to cart as anonymous user
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Try to add item to anonymous cart
+    if helper.browser.element_exists(".add-to-cart, .product-card").await {
+        helper.browser.click(".add-to-cart, .product-card .btn").await?;
+        helper.browser.wait_for_element(".cart-updated, .notification").await.ok();
+    }
+    
+    // Navigate to anonymous cart and verify items
+    helper.navigate_to_cart().await?;
+    let anonymous_cart_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+    
+    helper.take_screenshot("anonymous_cart_with_items").await?;
+    
+    // Step 2: Login and verify cart migration
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Navigate to authenticated user cart
+    helper.navigate_to_cart().await?;
+    
+    // Verify cart items were migrated
+    let authenticated_cart_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+    
+    // Cart should have same or more items (if user already had items)
+    assert!(authenticated_cart_items >= anonymous_cart_items, 
+           "Cart migration failed: anonymous had {}, authenticated has {}", 
+           anonymous_cart_items, authenticated_cart_items);
+    
+    helper.take_screenshot("authenticated_cart_after_migration").await?;
+
+    log::info!("Cart migration during login test completed successfully");
+    Ok(())
+}
+
+/// Test session management and persistence
+#[tokio::test]
+#[serial_test::serial]
+async fn test_session_management() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing session management and persistence");
+
+    // Login
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    helper.assert_user_is_authenticated().await?;
+    
+    // Navigate to different pages and verify session persists
+    let test_pages = vec![
+        "/dashboard",
+        "/dashboard/wallet",
+        "/marketplace",
+        "/dashboard/settings",
+    ];
+    
+    for page in test_pages {
+        helper.browser.navigate_to(page).await?;
+        
+        // Verify still authenticated on each page
+        if page.contains("dashboard") {
+            // For dashboard pages, check for dashboard elements
+            helper.browser.wait_for_element(".dashboard, .user-content").await.ok();
+        }
+        
+        // Check that we're not redirected to login
+        let current_url = helper.browser.get_current_url().await?;
+        assert!(!current_url.contains("login"), "Session expired on page {}", page);
+        
+        helper.take_screenshot(&format!("session_check_{}", page.replace("/", "_"))).await?;
+    }
+    
+    // Test API authentication status
+    let auth_status = helper.api_client.validate_auth_status().await?;
+    assert!(auth_status.authenticated, "API reports user not authenticated");
+    assert_eq!(auth_status.user_email, Some(persona.email.clone()));
+
+    log::info!("Session management test completed successfully");
+    Ok(())
+}
+
+/// Test login error handling
+#[tokio::test]
+#[serial_test::serial]
+async fn test_login_error_handling() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing login error handling");
+
+    // Navigate to login page
+    helper.browser.navigate_to("/login").await?;
+    
+    // Test invalid credentials
+    helper.browser.type_text("input[name='email'], input[type='email']", "invalid@example.com").await?;
+    helper.browser.type_text("input[name='password'], input[type='password']", "wrongpassword").await?;
+    
+    helper.take_screenshot("login_invalid_credentials").await?;
+    
+    // Submit login
+    helper.browser.click("button[type='submit'], .login-btn").await?;
+    
+    // Should show error message
+    helper.browser.wait_for_element(".error, .alert-danger, .login-error").await?;
+    
+    // Verify error message is displayed
+    assert!(helper.browser.element_exists(".error, .alert-danger, .login-error").await);
+    
+    // Verify user is not authenticated
+    assert!(!helper.browser.element_exists(".user-menu, .dashboard-link").await);
+    
+    helper.take_screenshot("login_error_displayed").await?;
+    
+    // Test empty form submission
+    helper.browser.navigate_to("/login").await?;
+    helper.browser.click("button[type='submit'], .login-btn").await?;
+    
+    // Should show validation errors
+    helper.browser.wait_for_element(".validation-error, .required-field").await.ok();
+    helper.take_screenshot("login_validation_errors").await?;
+
+    log::info!("Login error handling test completed successfully");
+    Ok(())
+}
+
+/// Test GitEa OAuth integration (conditional on environment)
+#[tokio::test]
+#[serial_test::serial]
+async fn test_gitea_oauth_integration() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment).await?;
+
+    log::info!("Testing GitEa OAuth integration");
+
+    // Check if GitEa OAuth is enabled
+    if std::env::var("GITEA_CLIENT_ID").is_ok() {
+        // Navigate to login page
+        helper.browser.navigate_to("/login").await?;
+        
+        // Look for GitEa OAuth button
+        if helper.browser.element_exists(".oauth-gitea, .gitea-login, a[href*='auth/gitea']").await {
+            helper.take_screenshot("login_with_gitea_option").await?;
+            
+            // Click GitEa OAuth (don't complete the flow in tests)
+            // Just verify the redirect starts
+            helper.browser.click(".oauth-gitea, .gitea-login, a[href*='auth/gitea']").await?;
+            
+            // Should redirect to GitEa or show OAuth flow
+            let current_url = helper.browser.get_current_url().await?;
+            assert!(current_url.contains("gitea") || current_url.contains("oauth") || current_url.contains("auth"));
+            
+            helper.take_screenshot("gitea_oauth_redirect").await?;
+            
+            log::info!("GitEa OAuth integration verified");
+        } else {
+            log::info!("GitEa OAuth button not found - may not be enabled");
+        }
+    } else {
+        log::info!("GitEa OAuth not configured - skipping integration test");
+    }
+
+    Ok(())
+}
+
+/// Test registration validation
+#[tokio::test]
+#[serial_test::serial]
+async fn test_registration_validation() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment).await?;
+
+    log::info!("Testing registration validation");
+
+    // Navigate to registration page
+    helper.browser.navigate_to("/register").await?;
+    
+    // Test empty form submission
+    helper.browser.click("button[type='submit'], .register-btn").await?;
+    
+    // Should show validation errors
+    helper.browser.wait_for_element(".validation-error, .required-field, .error").await.ok();
+    helper.take_screenshot("registration_validation_errors").await?;
+    
+    // Test invalid email format
+    helper.browser.type_text("input[name='email'], input[type='email']", "invalid-email").await?;
+    helper.browser.type_text("input[name='password'], input[type='password']", "short").await?;
+    helper.browser.click("button[type='submit'], .register-btn").await?;
+    
+    // Should show format validation errors
+    helper.browser.wait_for_element(".validation-error, .email-error").await.ok();
+    helper.take_screenshot("registration_format_errors").await?;
+    
+    // Test duplicate email (if validation exists)
+    let existing_persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.browser.navigate_to("/register").await?;
+    helper.browser.type_text("input[name='email'], input[type='email']", &existing_persona.email).await?;
+    helper.browser.type_text("input[name='password'], input[type='password']", "validpassword123").await?;
+    helper.browser.type_text("input[name='name'], input[name='full_name']", "Test User").await?;
+    helper.browser.click("button[type='submit'], .register-btn").await?;
+    
+    // May show duplicate email error
+    helper.browser.wait_for_element(".error, .duplicate-email").await.ok();
+    helper.take_screenshot("registration_duplicate_email").await?;
+
+    log::info!("Registration validation test completed successfully");
+    Ok(())
+}

tests/tests_archive/ux_suite/flows/mod.rs

@@ -0,0 +1,17 @@
+//! UX Test Flows
+//! 
+//! Complete end-to-end user flow tests organized by category
+
+pub mod public_access;
+pub mod authentication;
+pub mod shopping;
+pub mod dashboard;
+pub mod provider_workflows;
+pub mod settings;
+
+pub use public_access::*;
+pub use authentication::*;
+pub use shopping::*;
+pub use dashboard::*;
+pub use provider_workflows::*;
+pub use settings::*;

tests/tests_archive/ux_suite/flows/public_access.rs

@@ -0,0 +1,317 @@
+//! Public Access Tests
+//! 
+//! Tests for functionality available without authentication:
+//! - Information pages (/docs, /privacy, /terms, /about, /contact)
+//! - Anonymous marketplace browsing
+//! - Anonymous cart functionality
+//! - Search and filtering
+
+use crate::utils::*;
+use crate::environment::*;
+use tokio_test;
+
+/// Test all public information pages are accessible
+#[tokio::test]
+#[serial_test::serial]
+async fn test_public_information_pages() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing public information pages");
+
+    // Test each information page
+    let pages = vec![
+        ("/docs", "Documentation"),
+        ("/privacy", "Privacy"),
+        ("/terms", "Terms"),
+        ("/about", "About"),
+        ("/contact", "Contact"),
+    ];
+
+    for (url, expected_title_part) in pages {
+        log::info!("Testing page: {}", url);
+        
+        // Navigate to page
+        helper.browser.navigate_to(url).await?;
+        
+        // Assert page loads successfully
+        helper.assert_page_loaded(expected_title_part).await?;
+        
+        // Take screenshot
+        let page_name = url.trim_start_matches('/');
+        helper.take_screenshot(&format!("public_page_{}", page_name)).await?;
+        
+        // Verify page contains expected content indicators
+        match url {
+            "/docs" => {
+                assert!(helper.browser.element_exists(".documentation, .docs-content, h1").await);
+            }
+            "/privacy" => {
+                assert!(helper.browser.element_exists(".privacy-policy, .legal-content, h1").await);
+            }
+            "/terms" => {
+                assert!(helper.browser.element_exists(".terms-conditions, .legal-content, h1").await);
+            }
+            "/about" => {
+                assert!(helper.browser.element_exists(".about-content, .marketplace-info, h1").await);
+            }
+            "/contact" => {
+                assert!(helper.browser.element_exists(".contact-info, .contact-form, h1").await);
+            }
+            _ => {}
+        }
+    }
+
+    log::info!("All public information pages test completed successfully");
+    Ok(())
+}
+
+/// Test anonymous marketplace browsing
+#[tokio::test]
+#[serial_test::serial]
+async fn test_anonymous_marketplace_browsing() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing anonymous marketplace browsing");
+
+    // Test main marketplace page
+    helper.browser.navigate_to("/marketplace").await?;
+    helper.assert_page_loaded("Marketplace").await?;
+    
+    // Verify marketplace loads without authentication
+    assert!(helper.browser.element_exists(".marketplace, .product-grid, .category-nav").await);
+    helper.take_screenshot("marketplace_anonymous").await?;
+
+    // Test each marketplace category
+    let categories = vec![
+        ("/marketplace/compute", "compute resources"),
+        ("/marketplace/3nodes", "3nodes"),
+        ("/marketplace/gateways", "gateways"),
+        ("/marketplace/applications", "applications"),
+        ("/marketplace/services", "services"),
+    ];
+
+    for (url, category_name) in categories {
+        log::info!("Testing marketplace category: {}", category_name);
+        
+        helper.browser.navigate_to(url).await?;
+        
+        // Wait for category content to load
+        helper.browser.wait_for_element(".category-content, .product-list, .marketplace").await?;
+        
+        // Verify category-specific elements exist
+        match url {
+            "/marketplace/compute" => {
+                // Should show VM/slice options
+                helper.browser.wait_for_element(".compute-resources, .vm-options, .slice-list").await.ok();
+            }
+            "/marketplace/3nodes" => {
+                // Should show node listings
+                helper.browser.wait_for_element(".node-listings, .server-list, .3node-grid").await.ok();
+            }
+            "/marketplace/gateways" => {
+                // Should show gateway services
+                helper.browser.wait_for_element(".gateway-services, .mycelium-gateways").await.ok();
+            }
+            "/marketplace/applications" => {
+                // Should show app listings
+                helper.browser.wait_for_element(".app-grid, .application-list, .published-apps").await.ok();
+            }
+            "/marketplace/services" => {
+                // Should show service listings
+                helper.browser.wait_for_element(".service-list, .professional-services").await.ok();
+            }
+            _ => {}
+        }
+        
+        let category_clean = category_name.replace(" ", "_");
+        helper.take_screenshot(&format!("marketplace_{}", category_clean)).await?;
+    }
+
+    log::info!("Anonymous marketplace browsing test completed successfully");
+    Ok(())
+}
+
+/// Test anonymous cart functionality
+#[tokio::test]
+#[serial_test::serial]
+async fn test_anonymous_cart_functionality() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing anonymous cart functionality");
+
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Try to add item to cart (if products are available)
+    if helper.browser.element_exists(".add-to-cart, .product-card").await {
+        // Click first add to cart button found
+        helper.browser.click(".add-to-cart, .product-card .btn-primary").await?;
+        
+        // Should show some indication of cart update
+        helper.browser.wait_for_element(".cart-updated, .notification, .alert").await.ok();
+    }
+    
+    // Navigate to anonymous cart
+    helper.navigate_to_cart().await?;
+    helper.assert_page_loaded("Cart").await?;
+    
+    // Verify cart page shows for non-authenticated users
+    assert!(helper.browser.element_exists(".cart, .cart-content, .shopping-cart").await);
+    helper.take_screenshot("anonymous_cart").await?;
+    
+    // Check for login prompt when trying to checkout
+    if helper.browser.element_exists(".checkout-btn, .proceed-checkout").await {
+        helper.browser.click(".checkout-btn, .proceed-checkout").await?;
+        
+        // Should redirect to login or show login prompt
+        helper.browser.wait_for_element(".login-form, .auth-required, .login-prompt").await.ok();
+        helper.take_screenshot("checkout_login_prompt").await?;
+    }
+
+    log::info!("Anonymous cart functionality test completed successfully");
+    Ok(())
+}
+
+/// Test marketplace search and filtering
+#[tokio::test]
+#[serial_test::serial]
+async fn test_marketplace_search_and_filtering() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing marketplace search and filtering");
+
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Test search functionality
+    if helper.browser.element_exists(".search-input, input[type='search']").await {
+        helper.browser.type_text(".search-input, input[type='search']", "test").await?;
+        
+        // Submit search or wait for auto-search
+        if helper.browser.element_exists(".search-btn, .search-submit").await {
+            helper.browser.click(".search-btn, .search-submit").await?;
+        }
+        
+        // Wait for search results
+        helper.browser.wait_for_element(".search-results, .product-grid, .filtered-results").await.ok();
+        helper.take_screenshot("marketplace_search_results").await?;
+    }
+    
+    // Test category filtering
+    if helper.browser.element_exists(".category-filter, .filter-category").await {
+        let filters = helper.browser.find_elements(".category-filter option, .filter-btn").await.ok();
+        
+        if let Some(filters) = filters {
+            if filters.len() > 1 {
+                // Click first filter option
+                filters[1].click().await.ok();
+                
+                // Wait for filtered results
+                helper.browser.wait_for_element(".filtered-results, .category-products").await.ok();
+                helper.take_screenshot("marketplace_filtered_results").await?;
+            }
+        }
+    }
+    
+    // Test price filtering if available
+    if helper.browser.element_exists(".price-filter, .price-range").await {
+        helper.take_screenshot("marketplace_price_filter").await?;
+    }
+
+    log::info!("Marketplace search and filtering test completed successfully");
+    Ok(())
+}
+
+/// Test product details pages
+#[tokio::test]
+#[serial_test::serial]
+async fn test_product_details_pages() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing product details pages");
+
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Find and click on a product (if available)
+    if helper.browser.element_exists(".product-card, .product-item").await {
+        helper.browser.click(".product-card, .product-item").await?;
+        
+        // Wait for product details page
+        helper.browser.wait_for_element(".product-details, .product-info, .item-details").await.ok();
+        
+        // Verify product details elements
+        let expected_elements = vec![
+            ".product-name, .item-title",
+            ".product-price, .price-info",
+            ".product-description, .item-description",
+        ];
+        
+        for element in expected_elements {
+            if helper.browser.element_exists(element).await {
+                log::info!("Found product detail element: {}", element);
+            }
+        }
+        
+        helper.take_screenshot("product_details_page").await?;
+        
+        // Test product action buttons (without authentication)
+        if helper.browser.element_exists(".add-to-cart").await {
+            log::info!("Add to cart button available on product details");
+        }
+        
+        if helper.browser.element_exists(".buy-now").await {
+            log::info!("Buy now button available on product details");
+        }
+    }
+
+    log::info!("Product details pages test completed successfully");
+    Ok(())
+}
+
+/// Test marketplace accessibility and responsiveness
+#[tokio::test]
+#[serial_test::serial]
+async fn test_marketplace_accessibility() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing marketplace accessibility and responsiveness");
+
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Test different viewport sizes
+    let viewport_sizes = vec![
+        (1920, 1080), // Desktop
+        (768, 1024),  // Tablet
+        (375, 667),   // Mobile
+    ];
+    
+    for (width, height) in viewport_sizes {
+        log::info!("Testing viewport size: {}x{}", width, height);
+        
+        // Set viewport size
+        helper.browser.driver.set_window_size(width, height).await?;
+        
+        // Wait for layout to adjust
+        helper.wait(std::time::Duration::from_millis(500)).await;
+        
+        // Take screenshot for visual verification
+        helper.take_screenshot(&format!("marketplace_{}x{}", width, height)).await?;
+        
+        // Verify key elements are still accessible
+        assert!(helper.browser.element_exists("body").await);
+    }
+    
+    // Reset to default size
+    helper.browser.driver.set_window_size(1920, 1080).await?;
+
+    log::info!("Marketplace accessibility test completed successfully");
+    Ok(())
+}

tests/tests_archive/ux_suite/flows/shopping.rs

@@ -0,0 +1,445 @@
+//! Shopping Workflow Tests
+//! 
+//! Tests for complete shopping experience:
+//! - Buy Now functionality
+//! - Add to Cart workflow
+//! - Checkout process
+//! - Order confirmation
+//! - Cart management (add, remove, edit quantities)
+
+use crate::utils::*;
+use crate::environment::*;
+use tokio_test;
+
+/// Test Buy Now complete workflow
+#[tokio::test]
+#[serial_test::serial]
+async fn test_buy_now_complete_workflow() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing Buy Now complete workflow");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Look for products with Buy Now option
+    if helper.browser.element_exists(".product-card, .product-item").await {
+        // Get initial wallet balance
+        let initial_balance = helper.api_client.get_wallet_balance().await.ok();
+        
+        // Click on first product to get details
+        helper.browser.click(".product-card, .product-item").await?;
+        helper.browser.wait_for_element(".product-details, .buy-now").await.ok();
+        
+        helper.take_screenshot("product_page_buy_now").await?;
+        
+        // Click Buy Now button
+        if helper.browser.element_exists(".buy-now, button[data-action='buy-now']").await {
+            helper.browser.click(".buy-now, button[data-action='buy-now']").await?;
+            
+            // Complete checkout flow
+            let order_id = helper.complete_checkout_flow().await?;
+            
+            // Verify order confirmation
+            assert!(!order_id.is_empty());
+            helper.assert_element_contains_text(".order-confirmation, .success", "success").await.ok();
+            
+            // Check if wallet balance was deducted (if we got initial balance)
+            if let Some(initial) = initial_balance {
+                let final_balance = helper.api_client.get_wallet_balance().await?;
+                assert!(final_balance.balance <= initial.balance, "Wallet balance should be deducted");
+            }
+            
+            helper.take_screenshot("buy_now_success").await?;
+        }
+    }
+
+    log::info!("Buy Now complete workflow test completed successfully");
+    Ok(())
+}
+
+/// Test Add to Cart workflow
+#[tokio::test]
+#[serial_test::serial]
+async fn test_add_to_cart_workflow() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing Add to Cart workflow");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Navigate to marketplace
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Initial cart should be empty or have known state
+    helper.navigate_to_cart().await?;
+    let initial_cart_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+    
+    // Go back to marketplace and add items
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Add first product to cart
+    if helper.browser.element_exists(".add-to-cart, .product-card").await {
+        helper.browser.click(".add-to-cart, .product-card .btn:not(.buy-now)").await?;
+        
+        // Wait for cart update notification
+        helper.browser.wait_for_element(".cart-updated, .notification, .alert-success").await.ok();
+        helper.take_screenshot("item_added_to_cart").await?;
+        
+        // Verify cart badge updated
+        if helper.browser.element_exists(".cart-badge, .cart-count").await {
+            let badge_text = helper.browser.get_text(".cart-badge, .cart-count").await?;
+            let cart_count = badge_text.parse::<usize>().unwrap_or(0);
+            assert!(cart_count > initial_cart_items, "Cart count should increase");
+        }
+    }
+    
+    // Navigate to cart and verify item
+    helper.navigate_to_cart().await?;
+    let final_cart_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+    assert!(final_cart_items > initial_cart_items, "Cart should have more items");
+    
+    helper.take_screenshot("cart_with_added_items").await?;
+
+    log::info!("Add to Cart workflow test completed successfully");
+    Ok(())
+}
+
+/// Test cart management (edit quantities, remove items)
+#[tokio::test]
+#[serial_test::serial]
+async fn test_cart_management() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing cart management");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Add items to cart first
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Add multiple items if possible
+    let add_to_cart_buttons = helper.browser.find_elements(".add-to-cart, .product-card .btn").await.unwrap_or_default();
+    for (i, button) in add_to_cart_buttons.iter().take(2).enumerate() {
+        button.click().await.ok();
+        helper.wait(std::time::Duration::from_millis(500)).await;
+        log::info!("Added item {} to cart", i + 1);
+    }
+    
+    // Navigate to cart
+    helper.navigate_to_cart().await?;
+    
+    // Test quantity editing (if available)
+    if helper.browser.element_exists(".quantity-input, input[name='quantity']").await {
+        helper.browser.type_text(".quantity-input, input[name='quantity']", "3").await?;
+        
+        // Click update quantity button if exists
+        if helper.browser.element_exists(".update-quantity, .quantity-update").await {
+            helper.browser.click(".update-quantity, .quantity-update").await?;
+            helper.browser.wait_for_element(".cart-updated, .notification").await.ok();
+        }
+        
+        helper.take_screenshot("cart_quantity_updated").await?;
+    }
+    
+    // Test increase/decrease quantity buttons
+    if helper.browser.element_exists(".quantity-increase, .btn-plus").await {
+        helper.browser.click(".quantity-increase, .btn-plus").await?;
+        helper.wait(std::time::Duration::from_millis(500)).await;
+        helper.take_screenshot("cart_quantity_increased").await?;
+    }
+    
+    if helper.browser.element_exists(".quantity-decrease, .btn-minus").await {
+        helper.browser.click(".quantity-decrease, .btn-minus").await?;
+        helper.wait(std::time::Duration::from_millis(500)).await;
+        helper.take_screenshot("cart_quantity_decreased").await?;
+    }
+    
+    // Test remove item from cart
+    let initial_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+    
+    if helper.browser.element_exists(".remove-item, .delete-item, .btn-remove").await {
+        helper.browser.click(".remove-item, .delete-item, .btn-remove").await?;
+        
+        // Wait for item removal
+        helper.browser.wait_for_element(".item-removed, .notification").await.ok();
+        
+        // Verify item count decreased
+        let final_items = helper.browser.find_elements(".cart-item, .product-item").await.unwrap_or_default().len();
+        assert!(final_items < initial_items, "Cart items should decrease after removal");
+        
+        helper.take_screenshot("cart_item_removed").await?;
+    }
+    
+    // Test clear cart functionality
+    if helper.browser.element_exists(".clear-cart, .empty-cart").await {
+        helper.browser.click(".clear-cart, .empty-cart").await?;
+        
+        // Handle confirmation if present
+        if helper.browser.element_exists(".confirm-clear, .confirm-yes").await {
+            helper.browser.click(".confirm-clear, .confirm-yes").await?;
+        }
+        
+        // Verify cart is empty
+        helper.browser.wait_for_element(".cart-empty, .empty-state").await.ok();
+        helper.take_screenshot("cart_cleared").await?;
+    }
+
+    log::info!("Cart management test completed successfully");
+    Ok(())
+}
+
+/// Test complete checkout process
+#[tokio::test]
+#[serial_test::serial]
+async fn test_complete_checkout_process() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment);
+
+    log::info!("Testing complete checkout process");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Add items to cart
+    helper.browser.navigate_to("/marketplace").await?;
+    if helper.browser.element_exists(".add-to-cart, .product-card").await {
+        helper.browser.click(".add-to-cart, .product-card .btn").await?;
+        helper.browser.wait_for_element(".cart-updated, .notification").await.ok();
+    }
+    
+    // Navigate to cart
+    helper.navigate_to_cart().await?;
+    helper.take_screenshot("cart_before_checkout").await?;
+    
+    // Get initial wallet balance for verification
+    let initial_balance = helper.api_client.get_wallet_balance().await.ok();
+    
+    // Proceed to checkout
+    if helper.browser.element_exists(".checkout-btn, .proceed-checkout").await {
+        helper.browser.click(".checkout-btn, .proceed-checkout").await?;
+        
+        // Wait for checkout page/modal
+        helper.browser.wait_for_element(".checkout, .checkout-form, .payment-form").await?;
+        helper.take_screenshot("checkout_page").await?;
+        
+        // Fill checkout form if required
+        if helper.browser.element_exists("input[name='billing_address']").await {
+            helper.browser.type_text("input[name='billing_address']", "123 Test Street").await?;
+        }
+        
+        if helper.browser.element_exists("input[name='city']").await {
+            helper.browser.type_text("input[name='city']", "Test City").await?;
+        }
+        
+        // Confirm purchase
+        if helper.browser.element_exists(".confirm-purchase, .place-order").await {
+            helper.browser.click(".confirm-purchase, .place-order").await?;
+            
+            // Wait for order processing
+            helper.browser.wait_for_element(".processing, .order-confirmation, .success").await?;
+            helper.take_screenshot("order_processing").await?;
+            
+            // Wait for final confirmation
+            helper.browser.wait_for_element(".order-success, .purchase-complete").await?;
+            
+            // Verify order details are displayed
+            if helper.browser.element_exists(".order-id, .order-number").await {
+                let order_id = helper.browser.get_text(".order-id, .order-number").await?;
+                assert!(!order_id.is_empty(), "Order ID should be displayed");
+                log::info!("Order completed with ID: {}", order_id);
+            }
+            
+            helper.take_screenshot("checkout_success").await?;
+            
+            // Verify wallet balance was deducted
+            if let Some(initial) = initial_balance {
+                let final_balance = helper.api_client.get_wallet_balance().await?;
+                assert!(final_balance.balance < initial.balance, "Wallet balance should be deducted");
+                log::info!("Wallet balance: {} -> {}", initial.balance, final_balance.balance);
+            }
+        }
+    }
+
+    log::info!("Complete checkout process test completed successfully");
+    Ok(())
+}
+
+/// Test checkout with insufficient funds
+#[tokio::test]
+#[serial_test::serial]
+async fn test_checkout_insufficient_funds() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment).await?;
+
+    log::info!("Testing checkout with insufficient funds");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Check current wallet balance
+    let balance = helper.api_client.get_wallet_balance().await?;
+    
+    // If balance is sufficient, we can't test insufficient funds scenario easily
+    // This test would need a way to set balance to insufficient amount
+    log::info!("Current balance: {} {}", balance.balance, balance.currency);
+    
+    // Add expensive item to cart (if available) or multiple items
+    helper.browser.navigate_to("/marketplace").await?;
+    
+    // Add items to cart until we might exceed balance
+    let products = helper.browser.find_elements(".product-card, .add-to-cart").await.unwrap_or_default();
+    for product in products.iter().take(5) {
+        product.click().await.ok();
+        helper.wait(std::time::Duration::from_millis(300)).await;
+    }
+    
+    // Navigate to cart and try checkout
+    helper.navigate_to_cart().await?;
+    
+    if helper.browser.element_exists(".checkout-btn").await {
+        helper.browser.click(".checkout-btn").await?;
+        
+        // Look for insufficient funds error
+        helper.browser.wait_for_element(".insufficient-funds, .payment-error, .error").await.ok();
+        
+        if helper.browser.element_exists(".insufficient-funds, .payment-error").await {
+            helper.take_screenshot("insufficient_funds_error").await?;
+            log::info!("Insufficient funds error properly displayed");
+        } else {
+            log::info!("No insufficient funds scenario encountered");
+        }
+    }
+
+    Ok(())
+}
+
+/// Test order history and tracking
+#[tokio::test]
+#[serial_test::serial]
+async fn test_order_history_and_tracking() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment).await?;
+
+    log::info!("Testing order history and tracking");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Navigate to order history
+    helper.navigate_to_dashboard_section("orders").await?;
+    
+    // Verify orders page elements
+    assert!(helper.browser.element_exists(".orders, .order-history, .order-list").await);
+    helper.take_screenshot("order_history_page").await?;
+    
+    // Check if orders exist
+    if helper.browser.element_exists(".order-item, .order-row").await {
+        // Click on first order for details
+        helper.browser.click(".order-item, .order-row").await?;
+        
+        // Wait for order details
+        helper.browser.wait_for_element(".order-details, .order-info").await.ok();
+        helper.take_screenshot("order_details_page").await?;
+        
+        // Verify order details elements
+        let expected_elements = vec![
+            ".order-id, .order-number",
+            ".order-date, .purchase-date",
+            ".order-status, .status",
+            ".order-total, .total-amount",
+        ];
+        
+        for element in expected_elements {
+            if helper.browser.element_exists(element).await {
+                log::info!("Found order detail element: {}", element);
+            }
+        }
+        
+        // Test invoice download if available
+        if helper.browser.element_exists(".download-invoice, .invoice-link").await {
+            helper.browser.click(".download-invoice, .invoice-link").await?;
+            helper.take_screenshot("invoice_download").await?;
+        }
+    } else {
+        log::info!("No orders found in history - this is expected for new test environment");
+    }
+
+    log::info!("Order history and tracking test completed successfully");
+    Ok(())
+}
+
+/// Test different product categories checkout
+#[tokio::test]
+#[serial_test::serial]
+async fn test_different_product_categories_checkout() -> Result<(), Box<dyn std::error::Error>> {
+    let environment = TestFixtures::setup_test_environment().await?;
+    let mut helper = UXTestHelper::new(&environment).await?;
+
+    log::info!("Testing different product categories checkout");
+
+    // Login as consumer
+    let persona = helper.data_manager.get_persona(&UserRole::Consumer).unwrap();
+    helper.login_as(persona).await?;
+    
+    // Test different marketplace categories
+    let categories = vec![
+        "/marketplace/compute",
+        "/marketplace/applications", 
+        "/marketplace/services",
+    ];
+    
+    for category_url in categories {
+        log::info!("Testing checkout for category: {}", category_url);
+        
+        helper.browser.navigate_to(category_url).await?;
+        
+        // Look for products in this category
+        if helper.browser.element_exists(".product-card, .service-item, .app-item").await {
+            // Try to add item to cart
+            helper.browser.click(".add-to-cart, .buy-now").await.ok();
+            
+            // Handle any category-specific checkout flows
+            match category_url {
+                "/marketplace/compute" => {
+                    // VM/Compute might have configuration options
+                    if helper.browser.element_exists(".vm-config, .compute-options").await {
+                        helper.take_screenshot("compute_configuration").await?;
+                    }
+                }
+                "/marketplace/applications" => {
+                    // Apps might have deployment options
+                    if helper.browser.element_exists(".app-config, .deployment-options").await {
+                        helper.take_screenshot("app_configuration").await?;
+                    }
+                }
+                "/marketplace/services" => {
+                    // Services might have booking/scheduling
+                    if helper.browser.element_exists(".service-booking, .schedule-options").await {
+                        helper.take_screenshot("service_booking").await?;
+                    }
+                }
+                _ => {}
+            }
+            
+            helper.wait(std::time::Duration::from_millis(500)).await;
+        }
+    }
+
+    log::info!("Different product categories checkout test completed successfully");
+    Ok(())
+}