Add testing framework and unit tests

This commit creates the testing framework used to verify the client
library. It also adds unit tests for the operations implemented thus
far.

Signed-off-by: Ionut Mihalcea <[email protected]>

Author: ionut-arm

Cargo.toml

@@ -17,3 +17,7 @@ num = "0.2.1"
 rand = "0.7.3"
 log = "0.4.8"
 derivative = "2.0.2"
+
+[dev-dependencies]
+mockstream = "0.0.3"
+uuid = "0.7.4"

README.md

@@ -16,6 +16,8 @@ This project uses the following third party crates:
 * rand (Apache-2.0)
 * log (Apache-2.0)
 * derivative (MIT and Apache-2.0)
+* mockstream (MIT)
+* uuid (MIT and Apache-2.0)
 
 ## Contributing
 

src/core/mod.rs

@@ -82,14 +82,20 @@ impl CoreClient {
     }
 
     /// ping
-    pub fn ping(&self) -> Result<()> {
-        let _ = self.op_handler.process_operation(
+    pub fn ping(&self) -> Result<(u8, u8)> {
+        let res = self.op_handler.process_operation(
             NativeOperation::Ping(Ping {}),
             ProviderID::Core,
             &AuthenticationData::None,
         )?;
 
-        Ok(())
+        if let NativeResult::Ping(res) = res {
+            Ok((res.wire_protocol_version_maj, res.wire_protocol_version_min))
+        } else {
+            // Should really not be reached given the checks we do, but it's not impossible if some
+            // changes happen in the interface
+            Err(Error::Client(ClientErrorKind::InvalidServiceResponseType))
+        }
     }
 
     /// generate key

src/core/operation_handler.rs

@@ -22,6 +22,7 @@ pub struct OperationHandler {
     pub wire_protocol_version_min: u8,
     pub content_type: BodyType,
     pub accept_type: BodyType,
+    #[cfg_attr(test, derivative(Debug = "ignore"))]
     pub request_handler: RequestHandler,
 }
 

src/core/request_handler.rs

@@ -2,28 +2,51 @@
 // SPDX-License-Identifier: Apache-2.0
 #![allow(dead_code)]
 
-use crate::error::{ClientErrorKind, Error, Result};
+use crate::error::{ClientErrorKind, Result};
+#[cfg(test)]
+use mockstream::SyncMockStream;
 use parsec_interface::requests::{Request, Response};
+use std::io::{Read, Write};
+#[cfg(not(test))]
 use std::os::unix::net::UnixStream;
 use std::path::PathBuf;
 use std::time::Duration;
 
-const DEFAULT_MAX_BODY_SIZE: usize = 1 << 31;
+const DEFAULT_MAX_BODY_SIZE: usize = usize::max_value();
 const DEFAULT_SOCKET_PATH: &str = "/tmp/security-daemon-socket";
 
 /// Low level client structure to send a `Request` and get a `Response`.
-#[derive(Clone, Debug)]
+#[derive(Clone)]
+#[cfg_attr(not(test), derive(Debug))]
 pub struct RequestHandler {
     pub max_body_size: usize,
     pub timeout: Option<Duration>,
     pub socket_path: PathBuf,
+    #[cfg(test)]
+    pub mock_stream: SyncMockStream,
 }
 
 impl RequestHandler {
     /// Send a request and get a response.
     pub fn process_request(&self, request: Request) -> Result<Response> {
         // Try to connect once, wait for a timeout until trying again.
-        let mut stream = UnixStream::connect(&self.socket_path).map_err(ClientErrorKind::Ipc)?;
+        let mut stream = self.connect_to_socket()?;
+
+        request
+            .write_to_stream(&mut stream)
+            .map_err(ClientErrorKind::Interface)?;
+        Ok(Response::read_from_stream(&mut stream, self.max_body_size)
+            .map_err(ClientErrorKind::Interface)?)
+    }
+
+    #[cfg(test)]
+    fn connect_to_socket(&self) -> Result<impl Read + Write> {
+        Ok(self.mock_stream.clone())
+    }
+
+    #[cfg(not(test))]
+    fn connect_to_socket(&self) -> Result<impl Read + Write> {
+        let stream = UnixStream::connect(&self.socket_path).map_err(ClientErrorKind::Ipc)?;
 
         stream
             .set_read_timeout(self.timeout)
@@ -32,10 +55,7 @@ impl RequestHandler {
             .set_write_timeout(self.timeout)
             .map_err(ClientErrorKind::Ipc)?;
 
-        request
-            .write_to_stream(&mut stream)
-            .map_err(ClientErrorKind::Interface)?;
-        Ok(Response::read_from_stream(&mut stream, self.max_body_size).map_err(Error::Service)?)
+        Ok(stream)
     }
 }
 
@@ -45,6 +65,8 @@ impl Default for RequestHandler {
             max_body_size: DEFAULT_MAX_BODY_SIZE,
             timeout: None,
             socket_path: DEFAULT_SOCKET_PATH.into(),
+            #[cfg(test)]
+            mock_stream: SyncMockStream::new(),
         }
     }
 }
@@ -66,4 +88,22 @@ impl crate::CoreClient {
     pub fn set_socket_path(&mut self, socket_path: PathBuf) {
         self.op_handler.request_handler.socket_path = socket_path;
     }
+
+    /// Test helper used to set the data to be returned from the mock stream
+    #[cfg(test)]
+    pub fn set_mock_read(&mut self, data: &[u8]) {
+        self.op_handler
+            .request_handler
+            .mock_stream
+            .push_bytes_to_read(data);
+    }
+
+    /// Test helper used to verify the data written to the mock stream
+    #[cfg(test)]
+    pub fn get_mock_write(&mut self) -> Vec<u8> {
+        self.op_handler
+            .request_handler
+            .mock_stream
+            .pop_bytes_written()
+    }
 }

src/error.rs

@@ -4,7 +4,7 @@
 use parsec_interface::requests::ResponseStatus;
 
 /// Enum used to denote errors returned to the library user
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Error {
     /// Errors originating in the service
     Service(ResponseStatus),
@@ -29,5 +29,33 @@ impl From<ClientErrorKind> for Error {
     }
 }
 
+impl PartialEq for ClientErrorKind {
+    fn eq(&self, other: &Self) -> bool {
+        match self {
+            ClientErrorKind::Interface(status) => {
+                if let ClientErrorKind::Interface(other_status) = other {
+                    other_status == status
+                } else {
+                    false
+                }
+            }
+            ClientErrorKind::Ipc(error) => {
+                if let ClientErrorKind::Ipc(other_error) = other {
+                    other_error.kind() == error.kind()
+                } else {
+                    false
+                }
+            }
+            ClientErrorKind::InvalidServiceResponseType => {
+                if let ClientErrorKind::InvalidServiceResponseType = other {
+                    true
+                } else {
+                    false
+                }
+            }
+        }
+    }
+}
+
 /// Result type used for the internals and interface of the Parsec client
 pub type Result<T> = ::std::result::Result<T, Error>;

src/lib.rs

@@ -34,5 +34,6 @@
 pub mod auth;
 mod core;
 pub mod error;
+mod tests;
 
 pub use crate::core::CoreClient;