pact_matching 2.0.3

Pact-Rust support library that implements request and response matching logic
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

//! Structs and functions for dealing with XML

use std::fmt::{Display, Formatter};

use anyhow::anyhow;
use kiss_xml::dom::Element;

use pact_models::matchingrules::MatchingRule;
use pact_models::xml_utils::XmlResult;

use crate::engine::escape;
use crate::matchingrules::DoMatch;

/// Enum to store different XML nodes
#[derive(Debug, Clone, PartialOrd, PartialEq)]
pub enum XmlValue {
  /// XML element
  Element(Element),
  /// XML text
  Text(String),
  /// Attribute
  Attribute(String, String)
}

impl XmlValue {
  /// Returns the value if it is an XML element
  pub fn as_element(&self) -> Option<Element> {
    match self {
      XmlValue::Element(element) => Some(element.clone()),
      _ => None
    }
  }

  /// Returns the value if it is XML text
  pub fn as_text(&self) -> Option<String> {
    match self {
      XmlValue::Text(text) => Some(text.clone()),
      _ => None
    }
  }

  /// Returns the value if it is an XML attribute
  pub fn as_attribute(&self) -> Option<(String, String)> {
    match self {
      XmlValue::Attribute(name, value) => Some((name.clone(), value.clone())),
      _ => None
    }
  }
}

impl Display for XmlValue {
  fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
    match self {
      XmlValue::Element(el) => write!(f, "{}", el),
      XmlValue::Text(txt) => write!(f, "{}", escape(txt.as_str())),
      XmlValue::Attribute(name, value) => write!(f, "@{}={}", name, escape(value.as_str()))
    }
  }
}

impl From<XmlResult> for XmlValue {
  fn from(value: XmlResult) -> Self {
    match value {
      XmlResult::ElementNode(element) => XmlValue::Element(element),
      XmlResult::TextNode(text) => XmlValue::Text(text),
      XmlResult::Attribute(name, value) => XmlValue::Attribute(name, value)
    }
  }
}

impl DoMatch<XmlValue> for MatchingRule {
  fn match_value(
    &self,
    expected_value: XmlValue,
    actual_value: XmlValue,
    cascaded: bool,
    show_types: bool
  ) -> anyhow::Result<()> {
    self.match_value(&expected_value, &actual_value, cascaded, show_types)
  }
}

impl DoMatch<&XmlValue> for MatchingRule {
  fn match_value(
    &self,
    expected_value: &XmlValue,
    actual_value: &XmlValue,
    cascaded: bool,
    show_types: bool
  ) -> anyhow::Result<()> {
    match expected_value {
      XmlValue::Element(expected) => if let Some(actual) = actual_value.as_element() {
        self.match_value(expected, &actual, cascaded, show_types)
      } else {
        Err(anyhow!("Was expecting an XML element but got {}", actual_value))
      }
      XmlValue::Text(expected) => if let Some(actual) = actual_value.as_text() {
        self.match_value(expected.as_str(), actual.as_str(), cascaded, show_types)
      } else {
        Err(anyhow!("Was expecting XML text but got {}", actual_value))
      }
      XmlValue::Attribute(_, expected_value) => if let Some((_, value)) = actual_value.as_attribute() {
        self.match_value(expected_value.as_str(), value.as_str(), cascaded, show_types)
      } else {
        Err(anyhow!("Was expecting an XML attribute but got {}", actual_value))
      }
    }
  }
}