new-home-application 0.1.3

#[cfg(test)]
mod tests {
    use serde_json::{Map, Value};

    use new_home_application::communication::client_argument_parser::{ClientArgumentParser, ClientArgumentParserImpl};
    use new_home_application::method::method_structure::MethodArgument;

    #[test]
    fn test_client_argument_parser_test_no_arguments_no_values() {
        let parser = ClientArgumentParserImpl {};
        let arguments: Vec<MethodArgument> = vec![];
        let values = Value::from(());
        let parsed = parser.parse(arguments.clone(), &values);

        assert!(parsed.is_ok());
    }

    #[test]
    fn test_client_argument_parser_test_need_arguments_no_values() {
        let parser = ClientArgumentParserImpl {};
        let arguments: Vec<MethodArgument> = vec![
            MethodArgument {
                name: String::from("my_argument"),
                description: String::new(),
                help: String::new(),
                value: None,
                required: false,
            }
        ];
        let values = Value::from(());
        let parsed = parser.parse(arguments.clone(), &values);

        assert!(parsed.is_err());
        assert_eq!(parsed.err().unwrap().to_string(), "Arguments has to be an object")
    }

    #[test]
    fn test_client_argument_parser_test_need_arguments_has_values() {
        let parser = ClientArgumentParserImpl {};
        let arguments: Vec<MethodArgument> = vec![
            MethodArgument {
                name: String::from("my_argument"),
                description: String::new(),
                help: String::new(),
                value: None,
                required: true,
            },
            MethodArgument {
                name: String::from("my_none_argument"),
                description: String::new(),
                help: String::new(),
                value: None,
                required: false,
            }
        ];

        let mut values_map = Map::new();
        values_map.insert(String::from("my_argument"), Value::from(String::from("My Argument Value")));
        let values = Value::from(values_map);

        let parsed = parser.parse(arguments.clone(), &values);
        assert!(parsed.is_ok());

        let argument = parsed.unwrap().get_argument(&String::from("my_argument"));
        assert!(argument.is_some());
        assert_eq!(argument.unwrap().as_str().unwrap(), "My Argument Value");
    }

    #[test]
    fn test_client_argument_parser_test_required_argument_missing() {
        let parser = ClientArgumentParserImpl {};
        let arguments: Vec<MethodArgument> = vec![
            MethodArgument {
                name: String::from("my_argument"),
                description: String::new(),
                help: String::new(),
                value: None,
                required: true,
            }
        ];

        let mut values_map = Map::new();
        values_map.insert(String::from("my_wrong_argument"), Value::from(()));
        let values = Value::from(values_map);
        let parsed = parser.parse(arguments.clone(), &values);

        assert!(parsed.is_err());
        assert_eq!(parsed.err().unwrap().to_string(), "Argument my_argument is required");
    }
}