new-home-application 0.1.3

#[cfg(test)]
#[macro_use]
extern crate mockall;

#[cfg(test)]
mod tests {
    use std::io::Error;
    use std::collections::HashMap;

    use mockall::predicate::*;

    use new_home_application::communication::client_handler::{ClientHandler, ClientHandlerImpl};
    use new_home_application::method::method_callable::*;
    use new_home_application::method::method_manager::*;
    use new_home_application::method::method_structure::*;
    use new_home_application::net::tcp_reader::*;
    use new_home_application::net::tcp_writer::*;
    use serde_json::Value;

    mock! {
        TestReader {}

        trait TcpReader {
            fn read_line(&mut self) -> Result<String, Error>;
        }
    }

    mock! {
        TestWriter {}

        trait TcpWriter {
            fn write_line(&mut self, message: &String) -> Result<(), Error>;

            fn write(&mut self, message: &String) -> Result<usize, Error>;

            fn flush(&mut self) -> Result<(), Error>;
        }
    }

    mock! {
        TestMethodManager {}

        trait MethodManager {
            fn add_method(&mut self, method: Method, callable: Box<dyn MethodCallable>) -> ();

            fn get_method(&self, name: &String) -> Option<Method>;

            fn get_method_callback(&self, name: &String) -> Option<&'static Box<dyn MethodCallable>>;


            fn get_methods(&self) -> HashMap<String, Method>;
        }
    }

    #[test]
    fn test_client_handler_handler_with_invalid_json() {
        let mut reader = MockTestReader::new();
        let mut writer = MockTestWriter::new();
        let method_manager = MockTestMethodManager::new();

        reader.expect_read_line()
            .times(1)
            .returning(|| Ok(String::from("Invalid JSON string")));

        writer.expect_write_line()
            .times(1)
            .with(eq(String::from(r#"{"code":1,"message":[{"error":"There was an error in your JSON string"}]}"#)))
            .returning(|_| Ok(()));

        let method_manager_box: Box<dyn MethodManager> = Box::new(method_manager);

        let mut handler = ClientHandlerImpl::new(
            Box::new(writer),
            Box::new(reader),
            &method_manager_box,
        );

        assert!(handler.handle().is_ok());
    }

    #[test]
    fn test_client_handler_handler_with_correct_format_invalid_data_json() {
        let mut reader = MockTestReader::new();
        let mut writer = MockTestWriter::new();
        let method_manager = MockTestMethodManager::new();

        reader.expect_read_line()
            .times(1)
            .returning(|| Ok(String::from(r#"{"valid_json_format": "invalid_data_for_struct"}"#)));

        writer.expect_write_line()
            .times(1)
            .with(eq(String::from(r#"{"code":1,"message":[{"error":"There was an error in your JSON string"}]}"#)))
            .returning(|_| Ok(()));

        let method_manager_box: Box<dyn MethodManager> = Box::new(method_manager);

        let mut handler = ClientHandlerImpl::new(
            Box::new(writer),
            Box::new(reader),
            &method_manager_box,
        );

        assert!(handler.handle().is_ok());
    }

    #[test]
    fn test_client_handler_handler_with_missing_method() {
        let mut reader = MockTestReader::new();
        let mut writer = MockTestWriter::new();
        let mut method_manager = MockTestMethodManager::new();

        reader.expect_read_line()
            .times(1)
            .returning(|| Ok(String::from(r#"{"method_name": "not_registered_method_name", "arguments": null}"#)));

        writer.expect_write_line()
            .times(1)
            .with(eq(String::from(r#"{"code":1,"message":[{"error":"Method not found!"}]}"#)))
            .returning(|_| Ok(()));

        method_manager.expect_get_method_callback()
            .times(1)
            .with(eq(String::from("not_registered_method_name")))
            .returning(|_| None);

        let method_manager_box: Box<dyn MethodManager> = Box::new(method_manager);
        let mut handler = ClientHandlerImpl::new(
            Box::new(writer),
            Box::new(reader),
            &method_manager_box,
        );

        assert!(handler.handle().is_ok());
    }

    #[test]
    fn test_client_handler_handler_with_method_found() {
        let mut reader = MockTestReader::new();
        let mut writer = MockTestWriter::new();
        let mut method_manager = MethodManagerImpl::new();

        method_manager.add_method(Method {
            name: String::from("registered_method"),
            description: "".to_string(),
            help: "".to_string(),
            arguments: vec![],
        }, Box::new(MethodCallableClosure::new(|_| MethodResult {
            code: 0,
            message: Some(Value::from(String::from("test method result"))),
        })));

        reader.expect_read_line()
            .times(1)
            .returning(|| Ok(String::from(r#"{"method_name": "registered_method", "arguments": null}"#)));

        writer.expect_write_line()
            .times(1)
            .with(eq(String::from(r#"{"code":0,"message":"test method result"}"#)))
            .returning(|_| Ok(()));

        let method_manager_box: Box<dyn MethodManager> = Box::new(method_manager);
        let mut handler = ClientHandlerImpl::new(
            Box::new(writer),
            Box::new(reader),
            &method_manager_box,
        );

        assert!(handler.handle().is_ok());
    }
}