chore(v2-matching-engine): Support root matching rules for bodies

Author: rholshausen

rust/pact_matching/src/engine/interpreter.rs

@@ -1,6 +1,6 @@
 //! This module provides the interpreter that can execute a matching plan AST
 
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::{HashSet, VecDeque};
 use std::iter::once;
 
 use anyhow::anyhow;

rust/pact_matching/src/engine/mod.rs

@@ -9,6 +9,7 @@ use ansi_term::Colour::{Green, Red};
 use anyhow::anyhow;
 use base64::Engine;
 use base64::engine::general_purpose::STANDARD as BASE64;
+use bytes::Bytes;
 use itertools::Itertools;
 #[cfg(feature = "xml")] use kiss_xml::dom::Element;
 use maplit::hashmap;
@@ -250,6 +251,14 @@ impl NodeValue {
     }
   }
 
+  /// If this value is a byte array, returns it, otherwise returns None
+  pub fn as_bytes(&self) -> Option<&Vec<u8>> {
+    match self {
+      NodeValue::BARRAY(b) => Some(b),
+      _ => None
+    }
+  }
+
   /// Calculates an AND of two values
   pub fn and(&self, other: &Self) -> Self {
     match self {
@@ -386,8 +395,14 @@ impl From<&Element> for NodeValue {
 
 impl Matches<NodeValue> for NodeValue {
   fn matches_with(&self, actual: NodeValue, matcher: &MatchingRule, cascaded: bool) -> anyhow::Result<()> {
+    self.matches_with(&actual, matcher, cascaded)
+  }
+}
+
+impl Matches<&NodeValue> for NodeValue {
+  fn matches_with(&self, actual: &NodeValue, matcher: &MatchingRule, cascaded: bool) -> anyhow::Result<()> {
     match self {
-      NodeValue::NULL => Value::Null.matches_with(actual.as_json().unwrap_or_default(), matcher, cascaded),
+      NodeValue::NULL => actual.matches_with(actual, matcher, cascaded),
       NodeValue::STRING(s) => if let Some(actual_str) = actual.as_string() {
         s.matches_with(actual_str, matcher, cascaded)
       } else if let Some(list) = actual.as_slist() {
@@ -425,6 +440,7 @@ impl Matches<NodeValue> for NodeValue {
       } else {
         Err(anyhow!("Was expecting an XML value but got {}", actual))
       },
+      NodeValue::BARRAY(b) => Bytes::new().matches_with(Bytes::copy_from_slice(b.as_slice()), matcher, cascaded),
       _ => Err(anyhow!("Matching rules can not be applied to {} values", self.str_form()))
     }
   }
@@ -1298,6 +1314,22 @@ impl ExecutionPlan {
   }
 }
 
+impl From<ExecutionPlanNode> for ExecutionPlan {
+  fn from(value: ExecutionPlanNode) -> Self {
+    ExecutionPlan {
+      plan_root: value
+    }
+  }
+}
+
+impl From<&ExecutionPlanNode> for ExecutionPlan {
+  fn from(value: &ExecutionPlanNode) -> Self {
+    ExecutionPlan {
+      plan_root: value.clone()
+    }
+  }
+}
+
 impl Into<Vec<Mismatch>> for ExecutionPlan {
   fn into(self) -> Vec<Mismatch> {
     let mut result = vec![];
@@ -1862,35 +1894,49 @@ fn setup_body_plan<T: HttpPart>(
 ) -> anyhow::Result<ExecutionPlanNode> {
   // TODO: Look at the matching rules and generators here
   let mut plan_node = ExecutionPlanNode::container("body");
+  let body_path = DocPath::body();
 
   match &expected.body() {
     OptionalBody::Missing => {}
     OptionalBody::Empty | OptionalBody::Null => {
       plan_node.add(ExecutionPlanNode::action("expect:empty")
-        .add(ExecutionPlanNode::resolve_value(DocPath::new("$.body")?)));
+        .add(ExecutionPlanNode::resolve_value(body_path)));
     }
     OptionalBody::Present(content, _, _) => {
       let content_type = expected.content_type().unwrap_or_else(|| TEXT.clone());
-      let mut content_type_check_node = ExecutionPlanNode::action("if");
-      content_type_check_node
-        .add(
-          ExecutionPlanNode::action("match:equality")
-            .add(ExecutionPlanNode::value_node(content_type.to_string()))
-            .add(ExecutionPlanNode::resolve_value(DocPath::new("$.content-type")?))
-            .add(ExecutionPlanNode::value_node(NodeValue::NULL))
-            .add(
-              ExecutionPlanNode::action("error")
-                .add(ExecutionPlanNode::value_node(NodeValue::STRING("Body type error - ".to_string())))
-                .add(ExecutionPlanNode::action("apply"))
-            )
-        );
-      if let Some(plan_builder) = get_body_plan_builder(&content_type) {
-        content_type_check_node.add(plan_builder.build_plan(content, context)?);
+      let root_matcher = expected.matching_rules()
+        .rules_for_category("body")
+        .map(|category| category.rules.get(&DocPath::root()).cloned())
+        .flatten();
+      if let Some(root_matcher) = root_matcher && root_matcher.can_match(&content_type) {
+        plan_node.add(build_matching_rule_node(
+          &ExecutionPlanNode::value_node(NodeValue::NULL),
+          &ExecutionPlanNode::resolve_value(body_path),
+          &root_matcher,
+          false
+        ));
       } else {
-        let plan_builder = PlainTextBuilder::new();
-        content_type_check_node.add(plan_builder.build_plan(content, context)?);
+        let mut content_type_check_node = ExecutionPlanNode::action("if");
+        content_type_check_node
+          .add(
+            ExecutionPlanNode::action("match:equality")
+              .add(ExecutionPlanNode::value_node(content_type.to_string()))
+              .add(ExecutionPlanNode::resolve_value(DocPath::new("$.content-type")?))
+              .add(ExecutionPlanNode::value_node(NodeValue::NULL))
+              .add(
+                ExecutionPlanNode::action("error")
+                  .add(ExecutionPlanNode::value_node(NodeValue::STRING("Body type error - ".to_string())))
+                  .add(ExecutionPlanNode::action("apply"))
+              )
+          );
+        if let Some(plan_builder) = get_body_plan_builder(&content_type) {
+          content_type_check_node.add(plan_builder.build_plan(content, context)?);
+        } else {
+          let plan_builder = PlainTextBuilder::new();
+          content_type_check_node.add(plan_builder.build_plan(content, context)?);
+        }
+        plan_node.add(content_type_check_node);
       }
-      plan_node.add(content_type_check_node);
     }
   }
 

rust/pact_matching/src/engine/tests/mod.rs

@@ -19,7 +19,8 @@ use crate::engine::{
   execute_response_plan,
   NodeResult,
   NodeValue,
-  PlanMatchingContext
+  PlanMatchingContext,
+  setup_body_plan
 };
 use crate::Mismatch::{self, BodyMismatch, MethodMismatch};
 
@@ -765,3 +766,39 @@ fn match_status_with_matching_rule() -> anyhow::Result<()> {
 
   Ok(())
 }
+
+#[test_log::test]
+fn body_with_root_matcher() {
+  let matching_rules = matchingrules! {
+      "body" => { "$" => [ MatchingRule::Regex(".*[0-9]+.*".to_string()) ] }
+    };
+  let mut context = PlanMatchingContext::default();
+  let response = HttpResponse {
+    body: OptionalBody::from("This is a 100+ body"),
+    matching_rules,
+    .. Default::default()
+  };
+  let body_plan = setup_body_plan(&response, &context).unwrap();
+  let mut buffer = String::new();
+  body_plan.pretty_form(&mut buffer, 0);
+  assert_eq!(r#":body (
+  %match:regex (
+    NULL,
+    $.body,
+    json:{"regex":".*[0-9]+.*"}
+  )
+)"#, buffer);
+
+  let plan = body_plan.into();
+  let executed_plan = execute_response_plan(&plan, &response, &mut context).unwrap();
+  assert_eq!(r#"(
+  :body (
+    %match:regex (
+      NULL => NULL,
+      $.body => BYTES(19, VGhpcyBpcyBhIDEwMCsgYm9keQ==),
+      json:{"regex":".*[0-9]+.*"} => json:{"regex":".*[0-9]+.*"}
+    ) => BOOL(true)
+  ) => BOOL(true)
+)
+"#, executed_plan.pretty_form());
+}

rust/pact_models/src/matchingrules/mod.rs

@@ -14,6 +14,7 @@ use serde_json::{json, Map, Value};
 use tracing::{error, trace};
 
 use crate::{HttpStatus, PactSpecification};
+use crate::content_types::ContentType;
 use crate::generators::{Generator, GeneratorCategory, Generators};
 use crate::json_utils::{json_to_num, json_to_string};
 use crate::matchingrules::expressions::{MatchingReference, MatchingRuleDefinition, ValueType};
@@ -578,6 +579,19 @@ impl MatchingRule {
       _ => self.clone()
     }
   }
+
+  /// If the matching rule can be applied data in the form of the content type
+  pub fn can_match(&self, content_type: &ContentType) -> bool {
+    match self {
+      MatchingRule::NotEmpty => true,
+      MatchingRule::ArrayContains(_) => true, // why? This is set in Pact-JVM
+      MatchingRule::ContentType(_) => true,
+      MatchingRule::Equality => true,
+      MatchingRule::Include(_) => true,
+      MatchingRule::Regex(_) => content_type.is_text(),
+      _ => false
+    }
+  }
 }
 
 impl Hash for MatchingRule {
@@ -793,6 +807,11 @@ impl RuleList {
       cascaded: self.cascaded
     }
   }
+
+  /// If all the matching rules in this list can match data on the form of the content type
+  pub fn can_match(&self, content_type: &ContentType) -> bool {
+    self.rules.iter().all(|rule| rule.can_match(content_type))
+  }
 }
 
 impl Hash for RuleList {

rust/pact_models/src/path_exp.rs

@@ -129,6 +129,14 @@ impl DocPath {
     }
   }
 
+  /// Construct a new DocPath for `$.body`
+  pub fn body() -> Self {
+    Self {
+      path_tokens: vec![PathToken::Root, PathToken::Field("body".to_string())],
+      expr: "$.body".into(),
+    }
+  }
+
   /// Construct a new DocPath from a list of tokens
   pub fn from_tokens<I>(tokens: I) -> Self
     where I: IntoIterator<Item = PathToken> {