feat(tests): adds test with invalid virtual host (#172)

Author: wolf4ood

protocol/src/commands/mod.rs

@@ -50,4 +50,19 @@ mod tests {
 
         assert!(remaining.is_empty());
     }
+
+    pub(crate) fn specific_command_encode_decode_test<T>(command: T)
+    where
+        T: Encoder + Decoder + Debug + PartialEq,
+    {
+        let mut buffer = vec![];
+
+        let _ = command.encode(&mut buffer);
+
+        let (remaining, decoded) = T::decode(&buffer).unwrap();
+
+        assert_eq!(command, decoded);
+
+        assert!(remaining.is_empty());
+    }
 }

protocol/src/commands/open.rs

@@ -55,6 +55,17 @@ pub struct OpenResponse {
     pub connection_properties: HashMap<String, String>,
 }
 
+impl OpenResponse {
+    /// Get a reference to the generic response's code.
+    pub fn code(&self) -> &ResponseCode {
+        &self.code
+    }
+
+    pub fn is_ok(&self) -> bool {
+        self.code == ResponseCode::Ok
+    }
+}
+
 impl OpenResponse {
     /// Get a reference to the open response's connection properties.
     pub fn connection_properties(&self) -> &HashMap<String, String> {
@@ -75,7 +86,12 @@ impl Decoder for OpenResponse {
     fn decode(input: &[u8]) -> Result<(&[u8], Self), DecodeError> {
         let (input, correlation_id) = u32::decode(input)?;
         let (input, response_code) = ResponseCode::decode(input)?;
-        let (input, connection_properties) = HashMap::decode(input)?;
+
+        let (input, connection_properties) = if response_code == ResponseCode::Ok {
+            HashMap::decode(input)?
+        } else {
+            (input, HashMap::new())
+        };
 
         Ok((
             input,
@@ -106,10 +122,16 @@ impl Decoder for OpenCommand {
 #[cfg(test)]
 mod tests {
 
+    use fake::{Fake, Faker};
+
     use super::OpenCommand;
     use crate::{
         codec::Encoder,
-        commands::{open::OpenResponse, tests::command_encode_decode_test},
+        commands::{
+            open::OpenResponse,
+            tests::{command_encode_decode_test, specific_command_encode_decode_test},
+        },
+        ResponseCode,
     };
 
     #[test]
@@ -135,6 +157,8 @@ mod tests {
 
     #[test]
     fn open_response_test() {
-        command_encode_decode_test::<OpenResponse>();
+        let mut response: OpenResponse = Faker.fake();
+        response.code = ResponseCode::Ok;
+        specific_command_encode_decode_test(response);
     }
 }

protocol/src/response/mod.rs

@@ -188,6 +188,8 @@ where
 #[cfg(test)]
 mod tests {
 
+    use std::collections::HashMap;
+
     use byteorder::{BigEndian, WriteBytesExt};
 
     use crate::{
@@ -212,6 +214,7 @@ mod tests {
             version::PROTOCOL_VERSION,
         },
         types::Header,
+        ResponseCode,
     };
 
     use super::{Response, ResponseKind};
@@ -302,9 +305,31 @@ mod tests {
         };
     }
 
+    macro_rules! response_payload_test {
+        ($payload:expr, $variant:path, $cmd:expr) => {
+            let response = Response {
+                header: Header::new($cmd, PROTOCOL_VERSION),
+                kind: $variant($payload),
+            };
+
+            let mut buffer = vec![];
+
+            response.encode(&mut buffer).unwrap();
+
+            let (remaining, decoded) = Response::decode(&buffer).unwrap();
+
+            assert_eq!(response, decoded);
+
+            assert!(remaining.is_empty());
+        };
+    }
+
     #[test]
-    fn open_response_test() {
-        response_test!(OpenResponse, ResponseKind::Open, COMMAND_OPEN);
+    fn open_response_ok_test() {
+        use {fake::Fake, fake::Faker};
+        let mut response: OpenResponse = Faker.fake();
+        response.code = ResponseCode::Ok;
+        response_payload_test!(response, ResponseKind::Open, COMMAND_OPEN);
     }
 
     #[test]

src/client/mod.rs

@@ -551,7 +551,13 @@ impl Client {
             OpenCommand::new(correlation_id, self.opts.v_host.clone())
         })
         .await
-        .map(|open| open.connection_properties)
+        .and_then(|open| {
+            if open.is_ok() {
+                Ok(open.connection_properties)
+            } else {
+                Err(ClientError::RequestError(open.code().clone()))
+            }
+        })
     }
 
     async fn peer_properties(&self) -> Result<HashMap<String, String>, ClientError> {

tests/integration/environment_test.rs

@@ -57,6 +57,21 @@ async fn environment_fail_to_connect_wrong_credentials() {
     ));
 }
 
+#[tokio::test(flavor = "multi_thread")]
+async fn environment_fail_to_connect_v_host() {
+    let env = Environment::builder()
+        .virtual_host("wrong_virtual_host")
+        .build()
+        .await;
+
+    assert!(matches!(
+        env,
+        Err(rabbitmq_stream_client::error::ClientError::RequestError(
+            ResponseCode::VirtualHostAccessFailure
+        ))
+    ));
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn environment_create_delete_stream_twice() {
     // In this test we don't use the TestEnvironment because we want to test