apimock-config 5.10.0

Configuration model for apimock: loading, validation, editing, saving.
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! RFC 016 — per-condition NodeId addressability.

use super::common::make_workspace_with_headers_and_body;
use crate::{
    view::{ConfigFileKind, EditCommand, NodeKind},
    workspace::Workspace,
};

#[test]
fn add_header_condition_creates_condition() {
    let (dir, root) = make_workspace_with_headers_and_body();
    let mut ws = Workspace::load(root).expect("load");
    let snap = ws.snapshot();
    let rule_id = snap
        .files.iter()
        .find(|f| matches!(f.kind, ConfigFileKind::RuleSet)).unwrap()
        .nodes.iter()
        .find(|n| matches!(n.kind, NodeKind::Rule)).unwrap()
        .id;

    let result = ws.apply(EditCommand::AddHeaderCondition {
        rule_id,
        condition: crate::view::HeaderConditionPayload {
            name: "x-new-header".to_owned(),
            op: crate::view::HeaderOp::Equal,
            value: Some("new-value".to_owned()),
        },
    }).expect("add ok");

    assert!(!result.changed_nodes.is_empty(), "should return changed node ids");

    // Verify the condition was actually added.
    let rule = &ws.config().service.rule_sets[0].rules[0];
    assert!(rule.when.request.headers.is_some());
    let headers = rule.when.request.headers.as_ref().unwrap();
    assert!(headers.0.contains_key("x-new-header"), "header should be present");
    let _ = dir;
}

#[test]
fn remove_header_condition_deletes_it() {
    let (_dir, root) = make_workspace_with_headers_and_body();
    let mut ws = Workspace::load(root).expect("load");
    let snap = ws.snapshot();
    let rule_id = snap
        .files.iter()
        .find(|f| matches!(f.kind, ConfigFileKind::RuleSet)).unwrap()
        .nodes.iter()
        .find(|n| matches!(n.kind, NodeKind::Rule)).unwrap()
        .id;

    // Add a header condition first so we have one to remove.
    let add_result = ws.apply(EditCommand::AddHeaderCondition {
        rule_id,
        condition: crate::view::HeaderConditionPayload {
            name: "x-remove-me".to_owned(),
            op: crate::view::HeaderOp::Equal,
            value: Some("gone".to_owned()),
        },
    }).expect("add");

    let cond_id = add_result.changed_nodes.iter().copied()
        .find(|id| *id != rule_id)
        .expect("cond id");

    // Now remove it.
    ws.apply(EditCommand::RemoveHeaderCondition { id: cond_id }).expect("remove");

    let rule = &ws.config().service.rule_sets[0].rules[0];
    let absent = rule.when.request.headers
        .as_ref()
        .map(|h| !h.0.contains_key("x-remove-me"))
        .unwrap_or(true);
    assert!(absent, "header should be removed");
}

#[test]
fn add_body_condition_creates_condition() {
    let (_dir, root) = make_workspace_with_headers_and_body();
    let mut ws = Workspace::load(root).expect("load");
    let snap = ws.snapshot();
    let rule_id = snap
        .files.iter()
        .find(|f| matches!(f.kind, ConfigFileKind::RuleSet)).unwrap()
        .nodes.iter()
        .find(|n| matches!(n.kind, NodeKind::Rule)).unwrap()
        .id;

    ws.apply(EditCommand::AddBodyCondition {
        rule_id,
        condition: crate::view::BodyConditionPayload {
            kind: crate::view::BodyConditionKind::Json,
            path: "user.role".to_owned(),
            op: crate::view::BodyOp::Equal,
            value: serde_json::Value::String("admin".to_owned()),
        },
    }).expect("add body condition");

    let rule = &ws.config().service.rule_sets[0].rules[0];
    assert!(rule.when.request.body.is_some(), "body conditions should exist");
}

#[test]
fn remove_body_condition_deletes_it() {
    let (_dir, root) = make_workspace_with_headers_and_body();
    let mut ws = Workspace::load(root).expect("load");
    let snap = ws.snapshot();
    let rule_id = snap
        .files.iter()
        .find(|f| matches!(f.kind, ConfigFileKind::RuleSet)).unwrap()
        .nodes.iter()
        .find(|n| matches!(n.kind, NodeKind::Rule)).unwrap()
        .id;

    let add_result = ws.apply(EditCommand::AddBodyCondition {
        rule_id,
        condition: crate::view::BodyConditionPayload {
            kind: crate::view::BodyConditionKind::Json,
            path: "temp.field".to_owned(),
            op: crate::view::BodyOp::Equal,
            value: serde_json::Value::String("x".to_owned()),
        },
    }).expect("add");

    let cond_id = add_result.changed_nodes.iter().copied()
        .find(|id| *id != rule_id)
        .expect("cond id");

    ws.apply(EditCommand::RemoveBodyCondition { id: cond_id }).expect("remove");
}