feat(browser): add browser automation support

- Introduce a new DSL configuration (BrowserTestConfig) for defining browser actions
- Implement BrowserTestItem conversion and browser action execution using chromiumoxide
- Update request processing to route tests with a browser configuration to the new browser automation flow
- Provide example YAML configuration for browser tests (e.g. browser_test.tk.yaml)
- Adjust default handling for HTTP method flattening to accommodate browser tests

This commit lays the foundation for automating browser interactions as part of the test suite.

Author: iPeluwa

Cargo.toml

@@ -34,8 +34,10 @@ serde_with = "3.0.0"
 colored_json = "5"
 chrono = "0.4.26"
 walkdir = "2.3.3"
-# core-foundation = {git="https://github.com/servo/core-foundation-rs", rev="9effb788767458ad639ce36229cc07fd3b1dc7ba"}
+chromiumoxide = "0.7"
+futures-util = "0.3"
 
+# core-foundation = {git="https://github.com/servo/core-foundation-rs", rev="9effb788767458ad639ce36229cc07fd3b1dc7ba"}
 [dev-dependencies]
 httpmock = "0.7"
 testing_logger = "0.1.1"

browser_test.tk.yaml

@@ -0,0 +1,5 @@
+- title: "Browser: Open Google"
+  GET: ""        # This key satisfies the flattened HttpMethod (default is GET)
+  browser:
+    action: "navigate"
+    url: "https://www.google.com"

combined_test.yaml renamed to combined_test.tk.yaml

@@ -0,0 +1,101 @@
+// src/base_browser.rs
+
+use anyhow::Result;
+use chromiumoxide::browser::{Browser, BrowserConfig, HeadlessMode};
+use chromiumoxide::page::ScreenshotParams;
+use futures_util::stream::StreamExt;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// Define the supported browser actions.
+#[derive(Debug, Serialize, Deserialize)]
+pub enum BrowserAction {
+    /// Navigate to a URL.
+    Navigate { url: String },
+    /// Click an element specified by a CSS selector.
+    Click { selector: String },
+    /// Fill out form fields and then click the submit element.
+    FillAndSubmit {
+        fields: HashMap<String, String>,
+        submit_selector: String,
+    },
+}
+
+// A browser test item combines an optional title with a browser action.
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BrowserTestItem {
+    pub title: Option<String>,
+    pub browser: BrowserAction,
+}
+
+// Import the DSL browser configuration from base_request.
+use crate::base_request::BrowserTestConfig;
+
+impl BrowserTestItem {
+    /// Converts a DSL browser configuration (BrowserTestConfig) into a BrowserTestItem.
+    pub fn from_config(title: Option<String>, config: &BrowserTestConfig) -> Self {
+        let action = match config.action.as_str() {
+            "navigate" => BrowserAction::Navigate {
+                url: config.url.clone().unwrap_or_default(),
+            },
+            "click" => BrowserAction::Click {
+                selector: config.selector.clone().unwrap_or_default(),
+            },
+            "fillAndSubmit" => BrowserAction::FillAndSubmit {
+                fields: config.fields.clone().unwrap_or_default(),
+                submit_selector: config.submit_selector.clone().unwrap_or_default(),
+            },
+            _ => BrowserAction::Navigate { url: "".into() },
+        };
+        BrowserTestItem { title, browser: action }
+    }
+}
+
+/// Runs the browser action defined by the BrowserTestItem.
+pub async fn run_browser_action(item: BrowserTestItem) -> Result<()> {
+    log::info!("Running browser test: {:?}", item);
+    
+    let (mut browser, mut handler) = Browser::launch(
+        BrowserConfig::builder()
+            .headless_mode(HeadlessMode::True)
+            .build()
+            .map_err(|e| anyhow::anyhow!(e))?
+    )
+    .await?;
+    
+    // Process browser events in a spawned task.
+    tokio::spawn(async move {
+        while let Some(event) = handler.next().await {
+            log::debug!("Browser event: {:?}", event);
+        }
+    });
+    
+    let page = browser.new_page("about:blank").await?;
+    
+    match item.browser {
+        BrowserAction::Navigate { url } => {
+            page.goto(&url).await?;
+            page.wait_for_navigation().await?;
+        }
+        BrowserAction::Click { selector } => {
+            let element = page.find_element(&selector).await?;
+            element.click().await?;
+        }
+        BrowserAction::FillAndSubmit { fields, submit_selector } => {
+            for (field_selector, value) in fields {
+                let element = page.find_element(&field_selector).await?;
+                element.type_str(&value).await?;
+            }
+            let submit_element = page.find_element(&submit_selector).await?;
+            submit_element.click().await?;
+            page.wait_for_navigation().await?;
+        }
+    }
+    
+    let screenshot = page.screenshot(ScreenshotParams::default()).await?;
+    log::info!("Screenshot taken ({} bytes)", screenshot.len());
+    
+    page.close().await?;
+    browser.close().await?;
+    Ok(())
+}

src/base_browser.rs

@@ -1,11 +1,16 @@
+// src/base_cli.rs
+
 use clap::{Parser, Subcommand};
 use std::path::PathBuf;
 
 #[derive(Parser)]
-#[command(name = "testkit")]
-#[command(author = "APIToolkit. <[email protected]>")]
-#[command(version = "1.0")]
-#[command(about = "Manually and Automated testing starting with APIs", long_about = None)]
+#[command(
+    name = "testkit",
+    author = "APIToolkit. <[email protected]>",
+    version = "1.0",
+    about = "Manually and Automated testing starting with APIs and Browser automation",
+    long_about = None
+)]
 pub struct Cli {
     #[command(subcommand)]
     pub command: Option<Commands>,
@@ -31,6 +36,15 @@ pub enum Commands {
         #[arg(short, long)]
         file: Option<PathBuf>,
     },
+    /// Create a new boilerplate test file.
+    New {
+        /// Path where the boilerplate file should be created (default: boilerplate_test.yaml).
+        #[arg(short, long)]
+        file: Option<PathBuf>,
+        /// Type of test file to create: "api", "browser", or "both" (default: both).
+        #[arg(short, long, default_value = "both")]
+        test_type: String,
+    },
     /// Run the application mode (not implemented yet).
     App {},
 }