feat: add support for custom headers with the verifier FFI calls #182

Author: Ronald Holshausen

rust/Cargo.lock

@@ -109,7 +109,7 @@ pub fn process_object(
     Value::Object(obj.iter()
       .filter(|(key, _)| !key.starts_with("pact:"))
       .map(|(key, val)| {
-      let mut item_path = path.join(key);
+      let item_path = path.join(key);
       (key.clone(), match val {
         Value::Object(ref map) => process_object(map, matching_rules, generators, item_path, false, skip_matchers),
         Value::Array(ref array) => process_array(array, matching_rules, generators, item_path, false, skip_matchers),

rust/pact_ffi/src/mock_server/bodies.rs

@@ -1,7 +1,9 @@
 //! Handle interface to creating a verifier
 
+use std::collections::HashMap;
 use std::sync::Arc;
 use itertools::Itertools;
+use libc::clone;
 
 use log::debug;
 use pact_models::prelude::HttpAuth;
@@ -204,11 +206,8 @@ impl VerifierHandle {
     disable_ssl_verification: bool,
     request_timeout: u64
   ) {
-    self.verification_options = VerificationOptions {
-      request_filter: None::<Arc<NullRequestFilterExecutor>>,
-      disable_ssl_verification,
-      request_timeout
-    }
+    self.verification_options.disable_ssl_verification = disable_ssl_verification;
+    self.verification_options.request_timeout = request_timeout;
   }
 
   /// Update the details used when publishing results
@@ -295,6 +294,11 @@ impl VerifierHandle {
   pub fn set_output(&mut self, out: &str) {
     self.verifier_output.output = out.split('\n').map(|s| s.to_string()).collect();
   }
+
+  /// Add a custom header to be included in the call to the provider
+  pub fn add_custom_header(&mut self, header_name: &str, header_value: &str) {
+    self.verification_options.custom_headers.insert(header_name.to_string(), header_value.to_string());
+  }
 }
 
 impl Default for VerifierHandle {

rust/pact_ffi/src/verifier/handle.rs

@@ -310,6 +310,26 @@ ffi_fn! {
     }
 }
 
+ffi_fn! {
+    /// Adds a custom header to be added to the requests made to the provider.
+    ///
+    /// # Safety
+    ///
+    /// The header name and value must point to a valid NULL terminated string and must contain
+    /// valid UTF-8.
+    fn pactffi_verifier_add_custom_header(
+      handle: *mut handle::VerifierHandle,
+      header_name: *const c_char,
+      header_value: *const c_char
+    ) {
+      let handle = as_mut!(handle);
+      let header_name = safe_str!(header_name);
+      let header_value = safe_str!(header_value);
+
+      handle.add_custom_header(header_name, header_value);
+    }
+}
+
 ffi_fn! {
     /// Adds a Pact file as a source to verify.
     ///

rust/pact_ffi/src/verifier/mod.rs

@@ -222,7 +222,8 @@ async fn handle_matches(matches: &clap::ArgMatches<'_>) -> Result<(), i32> {
       request_filter: None::<Arc<NullRequestFilterExecutor>>,
       disable_ssl_verification: matches.is_present("disable-ssl-verification"),
       request_timeout: matches.value_of("request-timeout")
-        .map(|t| t.parse::<u64>().unwrap_or(5000)).unwrap_or(5000)
+        .map(|t| t.parse::<u64>().unwrap_or(5000)).unwrap_or(5000),
+      custom_headers: Default::default()
     };
 
     let publish_options = if matches.is_present("publish") {

rust/pact_ffi/src/verifier/verifier.rs

@@ -562,14 +562,17 @@ pub struct VerificationOptions<F> where F: RequestFilterExecutor {
   pub disable_ssl_verification: bool,
   /// Timeout in ms for verification requests and state callbacks
   pub request_timeout: u64,
+  /// Custom headers to be added to the requests to the provider
+  pub custom_headers: HashMap<String, String>
 }
 
 impl <F: RequestFilterExecutor> Default for VerificationOptions<F> {
   fn default() -> Self {
     VerificationOptions {
       request_filter: None,
       disable_ssl_verification: false,
-      request_timeout: 5000
+      request_timeout: 5000,
+      custom_headers: Default::default()
     }
   }
 }

rust/pact_verifier/src/lib.rs

@@ -334,6 +334,7 @@ async fn handle_matches(matches: &clap::ArgMatches<'_>) -> Result<(), i32> {
     disable_ssl_verification: matches.is_present("disable-ssl-verification"),
     request_timeout: matches.value_of("request-timeout")
       .map(|t| t.parse::<u64>().unwrap_or(5000)).unwrap_or(5000),
+    custom_headers: Default::default()
   };
 
   let publish_options = if matches.is_present("publish") {
@@ -364,7 +365,7 @@ async fn handle_matches(matches: &clap::ArgMatches<'_>) -> Result<(), i32> {
       test_framework: "pact_verifier_cli".to_string(),
       app_name: "pact_verifier_cli".to_string(),
       app_version: env!("CARGO_PKG_VERSION").to_string()
-    })
+    }),
   ).await
     .map_err(|err| {
       error!("Verification failed with error: {}", err);