Features: Optional strict mode, expectation / function call tracing, optional expectation setting. (#8)

Signed-off-by: Christopher Agia <chrisagia@google.com>

Author: agiachris

.github/workflows/rust.yml

@@ -180,10 +180,10 @@ jobs:
       run: target/release/examples/hello_world proxy-wasm-rust-sdk/target/wasm32-unknown-unknown/release/examples/hello_world.wasm
 
     - name: Test (http_auth_random)
-      run: target/release/examples/http_auth_random proxy-wasm-rust-sdk/target/wasm32-unknown-unknown/release/examples/http_auth_random.wasm
+      run: target/release/examples/http_auth_random proxy-wasm-rust-sdk/target/wasm32-unknown-unknown/release/examples/http_auth_random.wasm -a
 
     - name: Test (http_headers)
-      run: target/release/examples/http_headers proxy-wasm-rust-sdk/target/wasm32-unknown-unknown/release/examples/http_headers.wasm
+      run: target/release/examples/http_headers proxy-wasm-rust-sdk/target/wasm32-unknown-unknown/release/examples/http_headers.wasm -a
 
   outdated:
     runs-on: ubuntu-latest

Cargo.toml

@@ -12,3 +12,4 @@ anyhow = "1.0.31"
 lazy_static = "1.4.0"
 more-asserts = "0.2.1"
 rand = "0.7.3"
+structopt = "0.3.16"

examples/hello_world.rs

@@ -13,14 +13,13 @@
 // limitations under the License.
 
 use anyhow::Result;
-use proxy_wasm_test_framework::{tester, types::*};
-use std::env;
+use proxy_wasm_test_framework::tester;
+use proxy_wasm_test_framework::types::*;
+use structopt::StructOpt;
 
 fn main() -> Result<()> {
-    let args: Vec<String> = env::args().collect();
-    assert_eq!(args.len(), 2);
-    let hello_world_path = &args[1];
-    let mut hello_world_test = tester::test(hello_world_path)?;
+    let args = tester::MockSettings::from_args();
+    let mut hello_world_test = tester::mock(args)?;
 
     hello_world_test
         .call_start()
@@ -33,18 +32,22 @@ fn main() -> Result<()> {
 
     hello_world_test
         .call_proxy_on_vm_start(root_context, 0)
-        .expect_log(LogLevel::Info, "Hello, World!")
-        .expect_set_tick_period_millis(5 * 10u64.pow(3))
+        .expect_log(Some(LogLevel::Info), Some("Hello, World!"))
+        .expect_set_tick_period_millis(Some(5 * 10u64.pow(3)))
         .execute_and_expect(ReturnType::Bool(true))?;
 
     hello_world_test
         .call_proxy_on_tick(root_context)
         .expect_get_current_time_nanos()
-        .returning(0 * 10u64.pow(9))
+        .returning(Some(0 * 10u64.pow(9)))
+        .expect_log(Some(LogLevel::Info), Some("It's 1970-01-01 00:00:00 UTC"))
         .execute_and_expect(ReturnType::None)?;
 
     hello_world_test
         .call_proxy_on_tick(root_context)
+        .expect_get_current_time_nanos()
+        .returning(None)
+        .expect_log(Some(LogLevel::Info), None)
         .execute_and_expect(ReturnType::None)?;
 
     return Ok(());

examples/http_auth_random.rs

@@ -13,14 +13,13 @@
 // limitations under the License.
 
 use anyhow::Result;
-use proxy_wasm_test_framework::{tester, types::*};
-use std::env;
+use proxy_wasm_test_framework::tester;
+use proxy_wasm_test_framework::types::*;
+use structopt::StructOpt;
 
 fn main() -> Result<()> {
-    let args: Vec<String> = env::args().collect();
-    assert_eq!(args.len(), 2);
-    let http_auth_random_path = &args[1];
-    let mut http_auth_random = tester::test(http_auth_random_path)?;
+    let args = tester::MockSettings::from_args();
+    let mut http_auth_random = tester::mock(args)?;
 
     http_auth_random
         .call_start()
@@ -37,37 +36,41 @@ fn main() -> Result<()> {
         .execute_and_expect(ReturnType::None)?;
 
     http_auth_random
-        .call_proxy_on_request_headers(http_context, 0)
+        .call_proxy_on_request_headers(http_context, 0, false)
         .expect_http_call(
-            "httpbin",
-            vec![
+            Some("httpbin"),
+            Some(vec![
                 (":method", "GET"),
                 (":path", "/bytes/1"),
                 (":authority", "httpbin.org"),
-            ],
+            ]),
             None,
-            vec![],
-            5 * 10u64.pow(3),
+            Some(vec![]),
+            Some(5 * 10u64.pow(3)),
         )
-        .returning(0)
+        .returning(Some(0))
         .execute_and_expect(ReturnType::Action(Action::Pause))?;
 
     let buffer_data = "custom_developer_body";
     http_auth_random
         .call_proxy_on_http_call_response(http_context, 0, 0, buffer_data.len() as i32, 0)
-        .expect_get_buffer_bytes(BufferType::HttpCallResponseBody)
-        .returning(buffer_data)
+        .expect_get_buffer_bytes(Some(BufferType::HttpCallResponseBody))
+        .returning(Some(buffer_data))
         .expect_send_local_response(
-            403,
+            Some(403),
             Some("Access forbidden.\n"),
-            vec![("Powered-By", "proxy-wasm")],
-            -1,
+            Some(vec![("Powered-By", "proxy-wasm")]),
+            Some(-1),
         )
         .execute_and_expect(ReturnType::None)?;
 
     http_auth_random
-        .call_proxy_on_response_headers(http_context, 0)
-        .expect_replace_header_map_value(MapType::HttpResponseHeaders, "Powered-By", "proxy-wasm")
+        .call_proxy_on_response_headers(http_context, 0, false)
+        .expect_replace_header_map_value(
+            Some(MapType::HttpResponseHeaders),
+            Some("Powered-By"),
+            Some("proxy-wasm"),
+        )
         .execute_and_expect(ReturnType::Action(Action::Continue))?;
 
     return Ok(());

examples/http_headers.rs

@@ -13,14 +13,13 @@
 // limitations under the License.
 
 use anyhow::Result;
-use proxy_wasm_test_framework::{tester, types::*};
-use std::env;
+use proxy_wasm_test_framework::tester;
+use proxy_wasm_test_framework::types::*;
+use structopt::StructOpt;
 
 fn main() -> Result<()> {
-    let args: Vec<String> = env::args().collect();
-    assert_eq!(args.len(), 2);
-    let http_headers_path = &args[1];
-    let mut http_headers_test = tester::test(http_headers_path)?;
+    let args = tester::MockSettings::from_args();
+    let mut http_headers_test = tester::mock(args)?;
 
     http_headers_test
         .call_start()
@@ -37,34 +36,34 @@ fn main() -> Result<()> {
         .execute_and_expect(ReturnType::None)?;
 
     http_headers_test
-        .call_proxy_on_request_headers(http_context, 0)
-        .expect_get_header_map_pairs(MapType::HttpRequestHeaders)
-        .returning(vec![
+        .call_proxy_on_request_headers(http_context, 0, false)
+        .expect_get_header_map_pairs(Some(MapType::HttpRequestHeaders))
+        .returning(Some(vec![
             (":method", "GET"),
             (":path", "/hello"),
             (":authority", "developer"),
-        ])
-        .expect_get_header_map_value(MapType::HttpRequestHeaders, ":path")
-        .returning("/hello")
+        ]))
+        .expect_get_header_map_value(Some(MapType::HttpRequestHeaders), Some(":path"))
+        .returning(Some("/hello"))
         .expect_send_local_response(
-            200,
+            Some(200),
             Some("Hello, World!\n"),
-            vec![("Hello", "World"), ("Powered-By", "proxy-wasm")],
-            -1,
+            Some(vec![("Hello", "World"), ("Powered-By", "proxy-wasm")]),
+            Some(-1),
         )
         .execute_and_expect(ReturnType::Action(Action::Pause))?;
 
     http_headers_test
-        .call_proxy_on_response_headers(http_context, 0)
-        .expect_get_header_map_pairs(MapType::HttpResponseHeaders)
-        .returning(vec![(":status", "200"), ("Powered-By", "proxy-wasm")])
-        .expect_log(LogLevel::Trace, "#2 <- :status: 200")
-        .expect_log(LogLevel::Trace, "#2 <- Powered-By: proxy-wasm")
+        .call_proxy_on_response_headers(http_context, 0, false)
+        .expect_get_header_map_pairs(Some(MapType::HttpResponseHeaders))
+        .returning(Some(vec![(":status", "200"), ("Powered-By", "proxy-wasm")]))
+        .expect_log(Some(LogLevel::Trace), Some("#2 <- :status: 200"))
+        .expect_log(Some(LogLevel::Trace), Some("#2 <- Powered-By: proxy-wasm"))
         .execute_and_expect(ReturnType::Action(Action::Continue))?;
 
     http_headers_test
         .call_proxy_on_log(http_context)
-        .expect_log(LogLevel::Trace, "#2 completed.")
+        .expect_log(Some(LogLevel::Trace), Some("#2 completed."))
         .execute_and_expect(ReturnType::None)?;
 
     return Ok(());

src/expect_interface.rs

@@ -16,8 +16,9 @@ use crate::tester::Tester;
 
 // As of now, the following expectations do not require "fn returning()" implementations and hence
 // no structure is provided for them. Setting of these expectations are built directly into tester.rs:
-// proxy_log(), proxy_set_tick_period_millis(), proxy_set_buffer_bytes(), proxy_replace_header_map_value(),
-// proxy_remove_header_map_value(), proxy_add_header_map_value(), proxy_send_local_response(), etc.
+// proxy_log(), proxy_set_tick_period_millis(), proxy_set_buffer_bytes(), proxy_set_header_map_pairs,
+// proxy_replace_header_map_value(), proxy_remove_header_map_value(), proxy_add_header_map_value(),
+// proxy_send_local_response(), etc.
 
 pub struct ExpectGetCurrentTimeNanos<'a> {
     tester: &'a mut Tester,
@@ -28,7 +29,7 @@ impl<'a> ExpectGetCurrentTimeNanos<'a> {
         ExpectGetCurrentTimeNanos { tester: tester }
     }
 
-    pub fn returning(&mut self, current_time_nanos: u64) -> &mut Tester {
+    pub fn returning(&mut self, current_time_nanos: Option<u64>) -> &mut Tester {
         self.tester
             .get_expect_handle()
             .staged
@@ -39,18 +40,18 @@ impl<'a> ExpectGetCurrentTimeNanos<'a> {
 
 pub struct ExpectGetBufferBytes<'a> {
     tester: &'a mut Tester,
-    buffer_type: i32,
+    buffer_type: Option<i32>,
 }
 
 impl<'a> ExpectGetBufferBytes<'a> {
-    pub fn expecting(tester: &'a mut Tester, buffer_type: i32) -> ExpectGetBufferBytes {
+    pub fn expecting(tester: &'a mut Tester, buffer_type: Option<i32>) -> ExpectGetBufferBytes {
         ExpectGetBufferBytes {
             tester: tester,
             buffer_type: buffer_type,
         }
     }
 
-    pub fn returning(&mut self, buffer_data: &str) -> &mut Tester {
+    pub fn returning(&mut self, buffer_data: Option<&str>) -> &mut Tester {
         self.tester
             .get_expect_handle()
             .staged
@@ -61,18 +62,18 @@ impl<'a> ExpectGetBufferBytes<'a> {
 
 pub struct ExpectGetHeaderMapPairs<'a> {
     tester: &'a mut Tester,
-    map_type: i32,
+    map_type: Option<i32>,
 }
 
 impl<'a> ExpectGetHeaderMapPairs<'a> {
-    pub fn expecting(tester: &'a mut Tester, map_type: i32) -> ExpectGetHeaderMapPairs {
+    pub fn expecting(tester: &'a mut Tester, map_type: Option<i32>) -> ExpectGetHeaderMapPairs {
         ExpectGetHeaderMapPairs {
             tester: tester,
             map_type: map_type,
         }
     }
 
-    pub fn returning(&mut self, header_map_pairs: Vec<(&str, &str)>) -> &mut Tester {
+    pub fn returning(&mut self, header_map_pairs: Option<Vec<(&str, &str)>>) -> &mut Tester {
         self.tester
             .get_expect_handle()
             .staged
@@ -81,39 +82,17 @@ impl<'a> ExpectGetHeaderMapPairs<'a> {
     }
 }
 
-pub struct ExpectSetHeaderMapPairs<'a> {
-    tester: &'a mut Tester,
-    map_type: i32,
-}
-
-impl<'a> ExpectSetHeaderMapPairs<'a> {
-    pub fn expecting(tester: &'a mut Tester, map_type: i32) -> ExpectSetHeaderMapPairs {
-        ExpectSetHeaderMapPairs {
-            tester: tester,
-            map_type: map_type,
-        }
-    }
-
-    pub fn returning(&mut self, header_map_pairs: Vec<(&str, &str)>) -> &mut Tester {
-        self.tester
-            .get_expect_handle()
-            .staged
-            .set_expect_set_header_map_pairs(self.map_type, header_map_pairs);
-        self.tester
-    }
-}
-
 pub struct ExpectGetHeaderMapValue<'a> {
     tester: &'a mut Tester,
-    map_type: i32,
-    header_map_key: &'static str,
+    map_type: Option<i32>,
+    header_map_key: Option<&'static str>,
 }
 
 impl<'a> ExpectGetHeaderMapValue<'a> {
     pub fn expecting(
         tester: &'a mut Tester,
-        map_type: i32,
-        header_map_key: &'static str,
+        map_type: Option<i32>,
+        header_map_key: Option<&'static str>,
     ) -> ExpectGetHeaderMapValue<'a> {
         ExpectGetHeaderMapValue {
             tester: tester,
@@ -122,7 +101,7 @@ impl<'a> ExpectGetHeaderMapValue<'a> {
         }
     }
 
-    pub fn returning(&mut self, header_map_value: &str) -> &mut Tester {
+    pub fn returning(&mut self, header_map_value: Option<&str>) -> &mut Tester {
         self.tester
             .get_expect_handle()
             .staged
@@ -133,21 +112,21 @@ impl<'a> ExpectGetHeaderMapValue<'a> {
 
 pub struct ExpectHttpCall<'a> {
     tester: &'a mut Tester,
-    upstream: &'a str,
-    headers: Option<Vec<(&'a str, &'a str)>>,
+    upstream: Option<&'a str>,
+    headers: Option<Option<Vec<(&'a str, &'a str)>>>,
     body: Option<&'a str>,
-    trailers: Option<Vec<(&'a str, &'a str)>>,
-    timeout: u64,
+    trailers: Option<Option<Vec<(&'a str, &'a str)>>>,
+    timeout: Option<u64>,
 }
 
 impl<'a> ExpectHttpCall<'a> {
     pub fn expecting(
         tester: &'a mut Tester,
-        upstream: &'a str,
-        headers: Vec<(&'a str, &'a str)>,
+        upstream: Option<&'a str>,
+        headers: Option<Vec<(&'a str, &'a str)>>,
         body: Option<&'a str>,
-        trailers: Vec<(&'a str, &'a str)>,
-        timeout: u64,
+        trailers: Option<Vec<(&'a str, &'a str)>>,
+        timeout: Option<u64>,
     ) -> ExpectHttpCall<'a> {
         ExpectHttpCall {
             tester: tester,
@@ -159,7 +138,7 @@ impl<'a> ExpectHttpCall<'a> {
         }
     }
 
-    pub fn returning(&mut self, token_id: u32) -> &mut Tester {
+    pub fn returning(&mut self, token_id: Option<u32>) -> &mut Tester {
         self.tester.get_expect_handle().staged.set_expect_http_call(
             self.upstream,
             self.headers.take().unwrap(),