feat: consumer test with binary file

Ronald Holshausen · Ronald Holshausen · commit d533bb7498e3 · 2021-02-21T13:59:36.000+11:00
diff --git a/examples/v3/todo/src/todo_consumer.py b/examples/v3/todo/src/todo_consumer.py
@@ -19,12 +19,8 @@ def get_projects(self, format='json'):
         else:
             return ET.fromstring(response.text)
 
-#   postImage: (id, image) => {
-#     const data = fs.readFileSync(image)
-#     return axios.post(serverUrl + "/projects/" + id + "/images", data, {
-#       headers: {
-#         "Content-Type": "application/octet-stream",
-#       },
-#     })
-#   },
-# }
+    def post_image(self, id, file_path):
+        """Store an image against a project"""
+        uri = self.base_uri + '/projects/' + str(id) + '/images'
+        response = requests.post(uri, data=open(file_path, 'rb'), headers={'Content-Type': 'application/octet-stream'})
+        response.raise_for_status()
diff --git a/examples/v3/todo/tests/test_todo_consumer.py b/examples/v3/todo/tests/test_todo_consumer.py
@@ -14,16 +14,16 @@ def test_get_projects_as_json(provider):
         .upon_receiving('a request for projects')
         .with_request(method="GET", path="/projects", query={'from': "today"}, headers={'Accept': "application/json"})
         .will_respond_with(
-            headers={"Content-Type": "application/json"},
-            body=EachLike({
-                'id': Integer(1),
-                'name': Like("Project 1"),
-                'due': DateTime("yyyy-MM-dd'T'HH:mm:ss.SSSX", "2016-02-11T09:46:56.023Z"),
-                'tasks': AtLeastOneLike({
-                    'id': Integer(),
-                    'name': Like("Do the laundry"),
-                    'done': Like(True)
-                }, examples=4)
+        headers={"Content-Type": "application/json"},
+        body=EachLike({
+            'id': Integer(1),
+            'name': Like("Project 1"),
+            'due': DateTime("yyyy-MM-dd'T'HH:mm:ss.SSSX", "2016-02-11T09:46:56.023Z"),
+            'tasks': AtLeastOneLike({
+                'id': Integer(),
+                'name': Like("Do the laundry"),
+                'done': Like(True)
+            }, examples=4)
         })))
 
     with provider as mock_server:
@@ -43,8 +43,8 @@ def test_with_xml_requests(provider):
         .upon_receiving('a request for projects in XML')
         .with_request(method="GET", path="/projects", query={'from': "today"}, headers={'Accept': "application/xml"})
         .will_respond_with(
-            headers={"Content-Type": "application/xml"},
-            body='''<?xml version="1.0" encoding="UTF-8"?>
+        headers={"Content-Type": "application/xml"},
+        body='''<?xml version="1.0" encoding="UTF-8"?>
                     <projects foo="bar">
                       <project id="1" name="Project 1" due="2016-02-11T09:46:56.023Z">
                         <tasks>
@@ -56,42 +56,42 @@ def test_with_xml_requests(provider):
                       </project>
                       <project/>
                     </projects>'''
-            #             body: new XmlBuilder("1.0", "UTF-8", "ns1:projects").build(el => {
-            #               el.setAttributes({
-            #                 id: "1234",
-            #                 "xmlns:ns1": "http://some.namespace/and/more/stuff",
-            #               })
-            #               el.eachLike(
-            #                 "ns1:project",
-            #                 {
-            #                   id: integer(1),
-            #                   type: "activity",
-            #                   name: string("Project 1"),
-            #                   // TODO: implement XML generators
-            #                   // due: timestamp(
-            #                   //   "yyyy-MM-dd'T'HH:mm:ss.SZ",
-            #                   //   "2016-02-11T09:46:56.023Z"
-            #                   // ),
-            #                 },
-            #                 project => {
-            #                   project.appendElement("ns1:tasks", {}, task => {
-            #                     task.eachLike(
-            #                       "ns1:task",
-            #                       {
-            #                         id: integer(1),
-            #                         name: string("Task 1"),
-            #                         done: boolean(true),
-            #                       },
-            #                       null,
-            #                       { examples: 5 }
-            #                     )
-            #                   })
-            #                 },
-            #                 { examples: 2 }
-            #               )
-            #             }),
-
-        ))
+        #             body: new XmlBuilder("1.0", "UTF-8", "ns1:projects").build(el => {
+        #               el.setAttributes({
+        #                 id: "1234",
+        #                 "xmlns:ns1": "http://some.namespace/and/more/stuff",
+        #               })
+        #               el.eachLike(
+        #                 "ns1:project",
+        #                 {
+        #                   id: integer(1),
+        #                   type: "activity",
+        #                   name: string("Project 1"),
+        #                   // TODO: implement XML generators
+        #                   // due: timestamp(
+        #                   //   "yyyy-MM-dd'T'HH:mm:ss.SZ",
+        #                   //   "2016-02-11T09:46:56.023Z"
+        #                   // ),
+        #                 },
+        #                 project => {
+        #                   project.appendElement("ns1:tasks", {}, task => {
+        #                     task.eachLike(
+        #                       "ns1:task",
+        #                       {
+        #                         id: integer(1),
+        #                         name: string("Task 1"),
+        #                         done: boolean(true),
+        #                       },
+        #                       null,
+        #                       { examples: 5 }
+        #                     )
+        #                   })
+        #                 },
+        #                 { examples: 2 }
+        #               )
+        #             }),
+
+    ))
 
     with provider as mock_server:
         print("Mock server is running at " + mock_server.get_url())
@@ -106,36 +106,15 @@ def test_with_xml_requests(provider):
         assert tasks[0].get('id') == '1'
 
 
-#     describe("with image uploads", () => {
-#       before(() => {
-#         provider = new PactV3({
-#           consumer: "TodoApp",
-#           provider: "TodoServiceV3",
-#           dir: path.resolve(process.cwd(), "pacts"),
-#         })
-#         provider
-#           .given("i have a project", { id: "1001", name: "Home Chores" })
-#           .uponReceiving("a request to store an image against the project")
-#           .withRequestBinaryFile(
-#             { method: "POST", path: "/projects/1001/images" },
-#             "image/jpeg",
-#             path.resolve(__dirname, "example.jpg")
-#           )
-#           .willRespondWith({ status: 201 })
-#       })
-
-#       it("stores the image against the project", async () => {
-#         let result = await provider.executeTest(mockserver => {
-#           console.log("In Test Function", mockserver)
-#           return TodoApp.setUrl(mockserver.url).postImage(
-#             1001,
-#             path.resolve(__dirname, "example.jpg")
-#           )
-#         })
-#         console.log("result from runTest", result.status)
-#         expect(result.status).to.be.eq(201)
-#         return result
-#       })
-#     })
-#   })
-# })
+def test_with_image_upload(provider):
+    (provider.given('i have a project', {'id': 1001, 'name': 'Home Chores'})
+        .upon_receiving('a request to store an image against the project')
+        .with_request_with_binary_file('image/jpeg', 'tests/example.jpg', path="/projects/1001/images")
+        .will_respond_with(status=201))
+
+    with provider as mock_server:
+        print("Mock server is running at " + mock_server.get_url())
+
+        todo = TodoConsumer(mock_server.get_url())
+        todo.post_image(1001, 'tests/example.jpg')
+
diff --git a/pact-python-v3/src/lib.rs b/pact-python-v3/src/lib.rs
@@ -1,18 +1,19 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
+use std::fs;
 use std::str::FromStr;
 use std::sync::Mutex;
 
+use bytes::Bytes;
 use cpython::*;
 use env_logger::{Builder, Target};
 use lazy_static::*;
 use log::*;
 use maplit::*;
-use bytes::Bytes;
 use pact_matching::models::*;
 use pact_matching::models::content_types::ContentType;
 use pact_matching::models::generators::Generators;
-use pact_matching::models::matchingrules::MatchingRules;
+use pact_matching::models::matchingrules::{MatchingRules, MatchingRule, RuleLogic};
 use pact_matching::models::provider_states::ProviderState;
 use pact_matching::time_utils::generate_string;
 use pact_mock_server::mock_server::MockServerConfig;
@@ -149,6 +150,81 @@ py_class!(class PactNative |py| {
     })
   }
 
+  def add_request_binary_file(&self, content_type: &str, file_path: &str, method: &str, path, query, headers) -> PyResult<PyObject> {
+    self.with_current_interaction(py, &|interaction| {
+      interaction.request.method = method.to_string();
+
+      if let Ok(path) = path.cast_as::<PyString>(py) {
+        interaction.request.path = path.to_string_lossy(py).to_string();
+      } else {
+        // TODO: deal with a matcher
+      }
+
+      if let Ok(query) = query.cast_as::<PyDict>(py) {
+        let mut query_map = hashmap!{};
+        for (k, v) in query.items(py) {
+          let k = k.cast_as::<PyString>(py)?.to_string_lossy(py).to_string();
+          let v = if let Ok(v) = v.cast_as::<PyString>(py) {
+            vec![ v.to_string_lossy(py).to_string() ]
+          } else {
+            // TODO: deal with a matcher or a list
+            vec![]
+          };
+          query_map.insert(k, v);
+        }
+        if !query_map.is_empty() {
+          interaction.request.query = Some(query_map);
+        }
+      } else if query.get_type(py).name(py) != "NoneType" {
+        return Err(PyErr::new::<exc::TypeError, _>(py, format!("with_request: Query parameters must be supplied as a Dict, got '{}'", query.get_type(py).name(py))));
+      }
+
+      if let Ok(headers) = headers.cast_as::<PyDict>(py) {
+        let mut header_map = hashmap!{};
+        for (k, v) in headers.items(py) {
+          let k = k.cast_as::<PyString>(py)?.to_string_lossy(py).to_string();
+          let v = if let Ok(v) = v.cast_as::<PyString>(py) {
+            vec![ v.to_string_lossy(py).to_string() ]
+          } else {
+            // TODO: deal with a matcher or a list
+            vec![]
+          };
+          header_map.insert(k, v);
+        }
+        if !header_map.is_empty() {
+          interaction.request.headers = Some(header_map);
+        }
+      } else if headers.get_type(py).name(py) != "NoneType" {
+        return Err(PyErr::new::<exc::TypeError, _>(py, format!("with_request: Headers must be supplied as a Dict, got '{}'", headers.get_type(py).name(py))));
+      }
+
+      let file = fs::read(file_path).map(|data| OptionalBody::Present(Bytes::from(data), None));
+      match file {
+        Ok(body) => {
+          interaction.request.body = body;
+          interaction.request.matching_rules.add_category("body").add_rule("$",
+            MatchingRule::ContentType(content_type.to_string()), &RuleLogic::And);
+          if !interaction.request.has_header(&"Content-Type".to_string()) {
+            match interaction.request.headers {
+              Some(ref mut headers) => {
+                headers.insert("Content-Type".to_string(), vec!["application/octet-stream".to_string()]);
+              },
+              None => {
+                interaction.request.headers = Some(hashmap! { "Content-Type".to_string() => vec!["application/octet-stream".to_string()]});
+              }
+            }
+          };
+        },
+        Err(err) => {
+          error!("Could not load file '{}': {}", file_path, err);
+          return Err(PyErr::new::<exc::TypeError, _>(py, format!("add_request_binary_file: could not load binary file - {}'", err)));
+        }
+      }
+
+      Ok(py.None())
+    })
+  }
+
   def will_respond_with(&self, status, headers, body) -> PyResult<PyObject> {
     self.with_current_interaction(py, &|interaction| {
       interaction.response.status = status.extract(py)?;
diff --git a/pact/matchers_v3.py b/pact/matchers_v3.py
@@ -1,5 +1,6 @@
 from pact_python_v3 import generate_datetime_string
 
+
 class V3Matcher(object):
     """Base class for defining complex contract expectations."""
 
@@ -43,14 +44,15 @@ def generate(self):
         json = {
             "pact:matcher:type": "type",
             'value': [self.template for i in range(self.examples)]
-            }
+        }
         if self.minimum is not None:
             json['min'] = self.minimum
         if self.maximum is not None:
             json['max'] = self.maximum
 
         return json
 
+
 class AtLeastOneLike(V3Matcher):
     """
     An array that has to have at least one element and each element must match the given template
@@ -77,6 +79,7 @@ def generate(self):
             'value': [self.template for i in range(self.examples)]
         }
 
+
 class Like(V3Matcher):
     """
     Value must be the same type as the example
@@ -88,9 +91,10 @@ def __init__(self, example):
     def generate(self):
         return {
             "pact:matcher:type": "type",
-            'value': self.example 
+            'value': self.example
         }
 
+
 class Integer(V3Matcher):
     """
     Value must be an integer (must be a number and have no decimal places)
@@ -111,16 +115,17 @@ def __init__(self, *args):
     def generate(self):
         if self.example is not None:
             return {
-              'pact:matcher:type': 'integer',
-              'value': self.example
+                'pact:matcher:type': 'integer',
+                'value': self.example
             }
         else:
             return {
-              "pact:generator:type": "RandomInt",
-              "pact:matcher:type": "integer",
-              "value": 101
+                "pact:generator:type": "RandomInt",
+                "pact:matcher:type": "integer",
+                "value": 101
             }
 
+
 class DateTime(V3Matcher):
     """
     String value that must match the provided datetime format string.
diff --git a/pact/pact_v3.py b/pact/pact_v3.py
@@ -33,6 +33,10 @@ def with_request(self, method='GET', path='/', query=None, headers=None, body=No
         self.pact.with_request(method, path, query, headers, self.__process_body(body))
         return self
 
+    def with_request_with_binary_file(self, content_type, file, method='POST', path='/', query=None, headers=None):
+        self.pact.add_request_binary_file(content_type, file, method, path, query, headers)
+        return self
+
     def will_respond_with(self, status=200, headers=None, body=None):
         self.pact.will_respond_with(status, headers, self.__process_body(body))
         return self
@@ -57,8 +61,7 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                     if 'mismatches' in result:
                         j = 1
                         for mismatch in result['mismatches']:
-                            error += "\n\t    {}) {} {} {}".format(j, mismatch["type"], mismatch["path"],
-                                                                   mismatch["mismatch"])
+                            error += "\n\t    {}) {} {}".format(j, mismatch["type"], mismatch["mismatch"])
 
                     if result['type'] == "request-not-found":
                         error += "\n    The following request was not expected: {}".format(result["request"])
