new-home-application 0.1.3

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

    use serde_json::Value;

    use new_home_application::method::method_callable::MethodCallableClosure;
    use new_home_application::method::method_manager::{MethodManager, MethodManagerImpl};
    use new_home_application::method::method_structure::{Method, MethodArgument, MethodArguments, MethodResult};

    fn get_filled_manager() -> MethodManagerImpl {
        let mut method_manager = MethodManagerImpl::new();
        method_manager.add_method(Method {
            name: String::from("test_method"),
            description: String::from("Test description"),
            help: String::from("Test help"),
            arguments: vec![
                MethodArgument {
                    name: String::from("test_argument"),
                    description: String::from("Test argument description"),
                    help: String::from("Test argument help"),
                    value: None,
                    required: false,
                }
            ],
        }, Box::new(MethodCallableClosure::new(|args| {
            MethodResult {
                code: 0,
                message: Some(
                    Value::from(String::from(
                        args.get_argument(&String::from("my_arg"))
                            .unwrap_or(Value::String(String::new()))
                            .as_str().unwrap_or("")
                    ))
                ),
            }
        })));

        method_manager
    }

    #[test]
    fn test_method_manager_success_method() {
        let method_manager = get_filled_manager();

        let test_method = method_manager.get_method(&String::from("test_method"));
        assert!(test_method.is_some());

        let method = test_method.unwrap();
        assert_eq!(method.name, "test_method");
        assert_eq!(method.arguments[0].name, "test_argument");
    }

    #[test]
    fn test_method_manager_failed_method() {
        let method_manager = get_filled_manager();

        let unknown_method = method_manager.get_method(&String::from("unknown_method"));
        assert!(unknown_method.is_none());
    }

    #[test]
    fn test_method_manager_success_callable() {
        let method_manager = get_filled_manager();

        let callable = method_manager.get_method_callback(&String::from("test_method"));
        assert!(callable.is_some());

        let result = callable.unwrap().call(MethodArguments::empty());
        assert_eq!(result.code, 0);
    }

    #[test]
    fn test_method_manager_success_callable_with_arguments() {
        let method_manager = get_filled_manager();

        let callable = method_manager.get_method_callback(&String::from("test_method"));
        assert!(callable.is_some());

        let callable_unwarped = callable.unwrap();
        let mut arguments = HashMap::new();
        arguments.insert(String::from("my_arg"), Value::String(String::from("my_arg_value")));

        let result = callable_unwarped.call(MethodArguments::new(arguments));
        assert_eq!(result.code, 0);
        assert_eq!(result.message.unwrap_or(Value::from(String::from("error"))), "my_arg_value");
    }

    #[test]
    fn test_method_manager_failed_callable() {
        let method_manager = get_filled_manager();

        let callable = method_manager.get_method_callback(&String::from("unknown_method"));
        assert!(callable.is_none());
    }

    #[test]
    fn test_method_manager_get_methods() {
        let method_manager = get_filled_manager();

        assert!(method_manager.get_methods().get(&String::from("test_method")).is_some());
    }
}