assert grpc call errors

src/expect_interface.rs

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 use crate::tester::Tester;
+use crate::types::Status;
 
 // 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:
@@ -182,15 +183,15 @@ impl<'a> ExpectGrpcCall<'a> {
         }
     }
 
-    pub fn returning(&mut self, token_id: Option<u32>) -> &mut Tester {
+    pub fn returning(&mut self, res: Result<u32, Status>) -> &mut Tester {
         self.tester.get_expect_handle().staged.set_expect_grpc_call(
             self.service,
             self.service_name,
             self.method_name,
             self.initial_metadata,
             self.request,
             self.timeout,
-            token_id,
+            res,
         );
         self.tester
     }

src/expectations.rs

@@ -96,7 +96,7 @@ pub struct Expect {
         Option<Bytes>,
         Option<Bytes>,
         Option<Duration>,
-        Option<u32>,
+        Result<u32, Status>,
     )>,
     get_property_value: Vec<(Option<Bytes>, Option<Bytes>)>,
 }
@@ -593,7 +593,7 @@ impl Expect {
         initial_metadata: Option<&[u8]>,
         request: Option<&[u8]>,
         timeout: Option<u64>,
-        token_id: Option<u32>,
+        res: Result<u32, Status>,
     ) {
         self.expect_count += 1;
         self.grpc_call.push((
@@ -603,7 +603,7 @@ impl Expect {
             initial_metadata.map(|s| s.to_vec()),
             request.map(|s| s.to_vec()),
             timeout.map(Duration::from_millis),
-            token_id,
+            res,
         ));
     }
 
@@ -615,7 +615,7 @@ impl Expect {
         initial_metadata: &[u8],
         request: &[u8],
         timeout: i32,
-    ) -> Option<u32> {
+    ) -> Option<Result<u32, Status>> {
         match self.grpc_call.len() {
             0 => {
                 if !self.allow_unexpected {
@@ -649,7 +649,7 @@ impl Expect {
                         .map(|e| e.as_millis() as i32 == timeout)
                         .unwrap_or(true);
                 set_expect_status(expected);
-                return result;
+                return Some(result);
             }
         }
     }

src/hostcalls.rs

@@ -1485,9 +1485,9 @@ fn get_hostfunc(
                     let mem = match caller.get_export("memory") {
                         Some(Extern::Memory(mem)) => mem,
                         _ => {
-                            println!("Error: proxy_http_call cannot get export \"memory\"");
+                            println!("Error: proxy_grpc_call cannot get export \"memory\"");
                             println!(
-                                "[vm<-host] proxy_http_call(...) -> (return_token) return: {:?}",
+                                "[vm<-host] proxy_grpc_call(...) -> (return_token) return: {:?}",
                                 Status::InternalFailure
                             );
                             return Status::InternalFailure as i32;
@@ -1506,25 +1506,34 @@ fn get_hostfunc(
                     println!(
                         "[vm->host] proxy_grpc_call(service={service}, service_name={service_name}, method_name={method_name}, initial_metadata={initial_metadata:?}, request={request:?}, timeout={timeout_milliseconds}");
 
-                    let token_id = match EXPECT.lock().unwrap().staged.get_expect_grpc_call(
-                        service,
-                        service_name,
-                        method_name,
-                        initial_metadata,
-                        request,
-                        timeout_milliseconds,
-                    ) {
-                        Some(expect_token) => expect_token,
-                        None => 0,
-                    };
-
-                    unsafe {
-                        let return_token_add = mem.data_mut(&mut caller).get_unchecked_mut(
-                            token_ptr as u32 as usize..token_ptr as u32 as usize + 4,
-                        );
-                        return_token_add.copy_from_slice(&token_id.to_le_bytes());
+                    let call_result = EXPECT
+                        .lock()
+                        .unwrap()
+                        .staged
+                        .get_expect_grpc_call(
+                            service,
+                            service_name,
+                            method_name,
+                            initial_metadata,
+                            request,
+                            timeout_milliseconds,
+                        )
+                        .unwrap_or(Ok(0));
+
+                    if let Ok(token_id) = call_result {
+                        unsafe {
+                            let return_token_add = mem.data_mut(&mut caller).get_unchecked_mut(
+                                token_ptr as u32 as usize..token_ptr as u32 as usize + 4,
+                            );
+                            return_token_add.copy_from_slice(&token_id.to_le_bytes());
+                        }
                     }
 
+                    let call_status = match call_result {
+                        Ok(_) => Status::Ok,
+                        Err(s) => s,
+                    };
+
                     // Default Function:
                     // Expectation:
                     println!(
@@ -1536,7 +1545,7 @@ fn get_hostfunc(
                         Status::Ok
                     );
                     assert_ne!(get_status(), ExpectStatus::Failed);
-                    return Status::Ok as i32;
+                    return call_status as i32;
                 },
             ))
         }

src/types.rs

@@ -59,6 +59,8 @@ pub enum Status {
     Ok = 0,
     NotFound = 1,
     BadArgument = 2,
+    SerializationFailure = 3,
+    ParseFailure = 4,
     Empty = 7,
     CasMismatch = 8,
     InternalFailure = 10,