hen 0.18.1

Run protocol-aware API request collections from the command line or through MCP.
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

use std::collections::HashMap;

use crate::{
    parser::context,
    request::{Assertion, ResponseCapture},
    schema::SchemaRegistry,
};

use super::{
    Rule,
    request_error,
};

pub(in crate::parser) fn parse_response_captures(
    response_capture_raw: Vec<(String, pest::Span<'_>)>,
    scalar_map: &HashMap<String, String>,
) -> Result<Vec<ResponseCapture>, pest::error::Error<Rule>> {
    let mut response_captures = Vec::new();

    for (raw, span) in response_capture_raw {
        let capture = ResponseCapture::parse(raw.as_str(), scalar_map).map_err(|error| {
            request_error(error.0.as_str(), span)
        })?;
        response_captures.push(capture);
    }

    Ok(response_captures)
}

pub(in crate::parser) fn parse_assertions(
    assertion_raw: Vec<(String, pest::Span<'_>, Option<String>)>,
    scalar_map: &HashMap<String, String>,
    schema_registry: &SchemaRegistry,
) -> Result<Vec<Assertion>, pest::error::Error<Rule>> {
    let mut assertions = Vec::new();

    for (raw, span, label) in assertion_raw {
        let assertion = Assertion::parse_with_registry(raw.as_str(), scalar_map, schema_registry)
            .map_err(|error| request_error(error.0.as_str(), span.clone()))?
            .with_label(label.map(|label| context::inject_from_variable(label.as_str(), scalar_map)));
        assertions.push(assertion);
    }

    Ok(assertions)
}

pub(in crate::parser) fn validate_fragment_guards(
    fragment_guard_raw: Vec<(String, pest::Span<'_>)>,
    scalar_map: &HashMap<String, String>,
    schema_registry: &SchemaRegistry,
) -> Result<(), pest::error::Error<Rule>> {
    for (guard, span) in fragment_guard_raw {
        let wrapped = format!("^ {}", guard);
        Assertion::parse_with_registry(wrapped.as_str(), scalar_map, schema_registry)
            .map_err(|error| request_error(error.0.as_str(), span))?;
    }

    Ok(())
}