hurley 0.1.5

A curl-like HTTP client with performance testing capabilities
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use super::{Workflow, WorkflowContext};
use crate::error::Result;
use crate::http::{HttpClient, HttpRequest};
use colored::Colorize;
use serde_json::Value as JsonValue;

pub struct WorkflowRunner {
    base_url: String,
    base_request: HttpRequest,
    verbose: bool,
}

impl WorkflowRunner {
    pub fn new(base_url: String, base_request: HttpRequest, verbose: bool) -> Self {
        Self {
            base_url,
            base_request,
            verbose,
        }
    }

    pub async fn run(&self, workflow: &Workflow) -> Result<()> {
        println!("{}", "🚀 Starting Workflow Execution".cyan().bold());
        let mut context = WorkflowContext::new();
        let client = HttpClient::new(self.verbose);

        for step in &workflow.steps {
            println!("\n{} Step: {}", "➜".yellow(), step.id.bold());

            // 1. Evaluate condition
            if let Some(condition) = &step.condition {
                print!("  Evaluating condition: {} ... ", condition.black());
                match context.evaluate_condition(condition) {
                    Ok(true) => println!("{}", "Matched".green()),
                    Ok(false) => {
                        println!("{}", "Skipped (false)".yellow());
                        continue;
                    }
                    Err(e) => {
                        println!("{}", "Error".red());
                        return Err(e);
                    }
                }
            }

            // 2. Build Request
            let url = if step.request.path.starts_with("http") {
                step.request.path.clone()
            } else {
                format!(
                    "{}{}",
                    self.base_url.trim_end_matches('/'),
                    step.request.path
                )
            };

            let mut req = HttpRequest::new(url)
                .method(&step.request.method)?
                .timeout(self.base_request.timeout)
                .follow_redirects(self.base_request.follow_redirects);

            if let Some(ref body) = step.request.body {
                req = req.body(body.to_string());
            }

            // 3. Execute Request
            let response = client.execute(&req).await?;
            response.print(false, self.verbose);

            // 4. Store Response in Context
            if let Ok(json_body) = serde_json::from_str::<JsonValue>(&response.body) {
                context.store_response(&step.id, json_body);
            }
        }

        println!("\n{}", "✅ Workflow Completed".green().bold());
        Ok(())
    }
}