added vpn ip rotation

examples/test_vpn_setup.rs

@@ -0,0 +1,187 @@
+// examples/test_vpn_setup.rs
+//! Quick VPN Setup Test
+//!
+//! Testet nur die VPN-Verbindung und IP-Überprüfung ohne Scraping-Tasks
+//!
+//! Usage:
+//!   ENABLE_VPN_ROTATION=true VPN_SERVERS=US cargo run --example test_vpn_setup
+//!
+//! Or with debug logging:
+//!   RUST_LOG=debug ENABLE_VPN_ROTATION=true VPN_SERVERS=US cargo run --example test_vpn_setup
+
+use anyhow::Result;
+use std::sync::Arc;
+
+// Import von main crate
+use event_backtest_engine::config::Config;
+use event_backtest_engine::scraper::vpn_integration::VpnIntegration;
+use event_backtest_engine::scraper::webdriver::ChromeDriverPool;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize logging
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .with_target(false)
+        .init();
+
+    println!("\n═══════════════════════════════════════════════════════════");
+    println!("  🔧 VPN Setup Test - Quick Validation");
+    println!("═══════════════════════════════════════════════════════════\n");
+
+    // 1. Load config
+    println!("1️⃣  Loading configuration...");
+    let config = match Config::load() {
+        Ok(cfg) => {
+            println!("   ✓ Config loaded successfully");
+            cfg
+        }
+        Err(e) => {
+            println!("   ❌ Failed to load config: {}", e);
+            return Err(e);
+        }
+    };
+
+    // 2. Display VPN settings
+    println!("\n2️⃣  VPN Configuration:");
+    println!(
+        "   - VPN Rotation: {}",
+        if config.enable_vpn_rotation {
+            "✅ ENABLED"
+        } else {
+            "⚠️  DISABLED"
+        }
+    );
+
+    if config.enable_vpn_rotation {
+        let servers = config.get_vpn_servers();
+        if servers.is_empty() {
+            println!("   - Servers: ❌ NO SERVERS CONFIGURED");
+            println!("\n❌ Error: VPN rotation enabled but no servers configured!");
+            println!("   Please set VPN_SERVERS in .env (e.g., VPN_SERVERS=US,UK,JP)");
+            return Ok(());
+        }
+        println!("   - Servers: {:?}", servers);
+        println!("   - Tasks per Session: {}", config.tasks_per_vpn_session);
+        println!("   - Extension ID: {}", config.protonvpn_extension_id);
+    } else {
+        println!("   ℹ️  VPN rotation is disabled. Test with:");
+        println!(
+            "       ENABLE_VPN_ROTATION=true VPN_SERVERS=US cargo run --example test_vpn_setup"
+        );
+        return Ok(());
+    }
+
+    // 3. Create VPN Integration
+    println!("\n3️⃣  Initializing VPN Integration...");
+    let vpn = match VpnIntegration::from_config(&config) {
+        Ok(v) => {
+            println!("   ✓ VPN Integration created");
+            v
+        }
+        Err(e) => {
+            println!("   ❌ Failed to initialize VPN: {}", e);
+            return Err(e);
+        }
+    };
+
+    if !vpn.enabled {
+        println!("   ⚠️  VPN is not enabled in config");
+        return Ok(());
+    }
+
+    // 4. Create ChromeDriver Pool (single instance for testing)
+    println!("\n4️⃣  Creating ChromeDriver Pool (1 instance for testing)...");
+    let pool: Arc<ChromeDriverPool> = match ChromeDriverPool::new(1).await {
+        Ok(p) => {
+            println!("   ✓ ChromeDriver pool created");
+            Arc::new(p)
+        }
+        Err(e) => {
+            println!("   ❌ Failed to create ChromeDriver pool: {}", e);
+            println!("   Make sure chromedriver-win64/chromedriver.exe exists");
+            return Err(e);
+        }
+    };
+
+    println!("   - Instances: {}", pool.get_number_of_instances());
+
+    // 5. Initialize first VPN session
+    println!("\n5️⃣  Creating VPN Session...");
+    match vpn.initialize_session().await {
+        Ok(session_id) => {
+            println!("   ✓ VPN session created: {}", session_id);
+        }
+        Err(e) => {
+            println!("   ❌ Failed to create VPN session: {}", e);
+            return Err(e);
+        }
+    }
+
+    // 6. Get current session info
+    println!("\n6️⃣  VPN Session Info:");
+    if let Some(session) = vpn.get_current_session_id().await {
+        println!("   - Session ID: {}", session);
+    }
+
+    // 7. Test WebDriver basic navigation
+    println!("\n7️⃣  Testing WebDriver Navigation...");
+    match test_webdriver_navigation(&pool).await {
+        Ok(_) => {
+            println!("   ✓ WebDriver navigation successful");
+        }
+        Err(e) => {
+            println!("   ⚠️  WebDriver test had issues: {}", e);
+            println!("   This might be normal if extension UI differs");
+        }
+    }
+
+    // Summary
+    println!("\n═══════════════════════════════════════════════════════════");
+    println!("  ✅ VPN Setup Test Complete!");
+    println!("═══════════════════════════════════════════════════════════");
+    println!("\nNext steps:");
+    println!("  1. Check if VPN connection is established in Chrome");
+    println!("  2. Verify IP address changed (should be from VPN server)");
+    println!("  3. If all looks good, you can run the full scraper:");
+    println!("     cargo run");
+
+    Ok(())
+}
+
+/// Test basic WebDriver navigation to extension
+async fn test_webdriver_navigation(pool: &Arc<ChromeDriverPool>) -> Result<()> {
+    println!("   Navigating to IP check site...");
+
+    // Simple test: navigate to whatismyipaddress.com
+    match pool
+        .execute("https://whatismyipaddress.com/".to_string(), |client| {
+            async move {
+                let source = client.source().await?;
+
+                // Try to extract IP
+                if let Some(start) = source.find("IPv4") {
+                    let section = &source[start..];
+                    if let Some(ip_start) = section.find(|c: char| c.is_numeric()) {
+                        if let Some(ip_end) =
+                            section[ip_start..].find(|c: char| !c.is_numeric() && c != '.')
+                        {
+                            let ip = &section[ip_start..ip_start + ip_end];
+                            println!("   - Detected IP: {}", ip);
+                            return Ok(ip.to_string());
+                        }
+                    }
+                }
+
+                Ok("IP extraction attempted".to_string())
+            }
+        })
+        .await
+    {
+        Ok(result) => {
+            println!("   Result: {}", result);
+            Ok(())
+        }
+        Err(e) => Err(e),
+    }
+}