dothttp 0.10.0

dothttp is a text-based scriptable HTTP client. It is a fork for dot-http. It is a simple language that resembles the actual HTTP protocol but with additional features to make it practical for someone who builds and tests APIs.
Documentation 
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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

pub mod print;

mod ci;
#[cfg(test)]
mod tests;

use std::fmt;

use color_eyre::eyre::anyhow;

pub use self::{ci::CiOutput, print::FormattedOutput};
use crate::{
    http::{Method, Request, Response},
    script_engine::report::TestsReport,
    Result,
};

#[derive(Debug, Eq, PartialEq, Clone)]
pub enum FormatItem {
    FirstLine,
    Headers,
    Body,
    Tests,
    Name,
    Chars(String),
}

pub fn parse_format(format: &str) -> Result<Vec<FormatItem>> {
    let mut result = Vec::new();
    let mut marker = false;
    let mut buff = String::new();
    for ch in format.chars() {
        if marker {
            marker = false;
            let action = match ch {
                '%' => None,
                'R' => Some(FormatItem::FirstLine),
                'H' => Some(FormatItem::Headers),
                'B' => Some(FormatItem::Body),
                'T' => Some(FormatItem::Tests),
                'N' => Some(FormatItem::Name),
                _ => return Err(anyhow!("Invalid formatting character '{}'", ch)),
            };
            if let Some(a) = action {
                if !buff.is_empty() {
                    result.push(FormatItem::Chars(buff));
                    buff = String::new();
                }
                result.push(a);
            } else {
                buff.push(ch);
            }
        } else if ch == '%' {
            marker = true;
        } else {
            buff.push(ch);
        }
    }
    if !buff.is_empty() {
        result.push(FormatItem::Chars(buff));
    }
    Ok(result)
}

fn prettify_response_body(body: &str) -> String {
    match serde_json::from_str(body) {
        Ok(serde_json::Value::Object(response_body)) => {
            serde_json::to_string_pretty(&response_body).unwrap()
        }
        _ => String::from(body),
    }
}

pub trait Output {
    fn response(&mut self, response: &Response, tests: &TestsReport) -> Result<()>;
    fn request(&mut self, request: &Request, request_name: &str) -> Result<()>;
    fn tests(&mut self, tests: Vec<(String, String, TestsReport)>) -> Result<()>;

    fn exit_code(&mut self) -> std::process::ExitCode {
        std::process::ExitCode::SUCCESS
    }
}

impl Output for Box<dyn Output> {
    fn response(&mut self, response: &Response, tests: &TestsReport) -> Result<()> {
        (**self).response(response, tests)
    }

    fn request(&mut self, request: &Request, request_name: &str) -> Result<()> {
        (**self).request(request, request_name)
    }

    fn tests(&mut self, tests: Vec<(String, String, TestsReport)>) -> Result<()> {
        (**self).tests(tests)
    }

    fn exit_code(&mut self) -> std::process::ExitCode {
        (**self).exit_code()
    }
}

impl fmt::Display for Method {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let method = match *self {
            Method::Get => "GET",
            Method::Post => "POST",
            Method::Delete => "DELETE",
            Method::Put => "PUT",
            Method::Patch => "PATCH",
            Method::Options => "OPTIONS",
        };
        f.write_str(method)
    }
}