Added more tests for types

Author: mitsuhiko

src/types.rs

@@ -341,6 +341,7 @@ pub type RedisResult<T> = Result<T, RedisError>;
 
 
 /// An info dictionary type.
+#[derive(Debug)]
 pub struct InfoDict {
     map: HashMap<String, Value>,
 }
@@ -674,6 +675,13 @@ macro_rules! from_redis_value_for_num_internal {
             let v = $v;
             match *v {
                 Value::Int(val) => Ok(val as $t),
+                Value::Status(ref s) => {
+                    match s.parse::<$t>() {
+                        Ok(rv) => Ok(rv),
+                        Err(_) => invalid_type_error!(v,
+                            "Could not convert from string.")
+                    }
+                },
                 Value::Data(ref bytes) => {
                     match try!(from_utf8(bytes)).parse::<$t>() {
                         Ok(rv) => Ok(rv),

tests/test_types.rs

@@ -20,3 +20,86 @@ fn test_is_single_arg() {
     assert_eq!(twobytesslice.is_single_arg(), false);
     assert_eq!(twobytesvec.is_single_arg(), false);
 }
+
+#[test]
+fn test_info_dict() {
+    use redis::{InfoDict, FromRedisValue, Value};
+
+    let d : InfoDict = FromRedisValue::from_redis_value(&Value::Status(
+        "# this is a comment\nkey1:foo\nkey2:42\n".into()
+    )).unwrap();
+
+    assert_eq!(d.get("key1"), Some("foo".to_string()));
+    assert_eq!(d.get("key2"), Some(42i64));
+    assert_eq!(d.get::<String>("key3"), None);
+}
+
+#[test]
+fn test_i32() {
+    use redis::{FromRedisValue, Value, ErrorKind};
+
+    let i = FromRedisValue::from_redis_value(&Value::Status("42".into()));
+    assert_eq!(i, Ok(42i32));
+
+    let i = FromRedisValue::from_redis_value(&Value::Int(42));
+    assert_eq!(i, Ok(42i32));
+
+    let i = FromRedisValue::from_redis_value(&Value::Data("42".into()));
+    assert_eq!(i, Ok(42i32));
+
+    let bad_i : Result<i32, _> = FromRedisValue::from_redis_value(
+        &Value::Status("42x".into()));
+    assert_eq!(bad_i.unwrap_err().kind(), ErrorKind::TypeError);
+}
+
+#[test]
+fn test_u32() {
+    use redis::{FromRedisValue, Value, ErrorKind};
+
+    let i = FromRedisValue::from_redis_value(&Value::Status("42".into()));
+    assert_eq!(i, Ok(42u32));
+
+    let bad_i : Result<i32, _> = FromRedisValue::from_redis_value(
+        &Value::Status("-1".into()));
+    assert_eq!(bad_i.unwrap_err().kind(), ErrorKind::TypeError);
+}
+
+#[test]
+fn test_vec() {
+    use redis::{FromRedisValue, Value};
+
+    let v = FromRedisValue::from_redis_value(&Value::Bulk(vec![
+        Value::Data("1".into()),
+        Value::Data("2".into()),
+        Value::Data("3".into()),
+    ]));
+
+    assert_eq!(v, Ok(vec![1i32, 2, 3]));
+}
+
+#[test]
+fn test_bool() {
+    use redis::{FromRedisValue, Value, ErrorKind};
+
+    let v = FromRedisValue::from_redis_value(&Value::Status("1".into()));
+    assert_eq!(v, Ok(true));
+
+    let v = FromRedisValue::from_redis_value(&Value::Status("0".into()));
+    assert_eq!(v, Ok(false));
+
+    let v : Result<bool, _> = FromRedisValue::from_redis_value(
+        &Value::Status("garbage".into()));
+    assert_eq!(v.unwrap_err().kind(), ErrorKind::TypeError);
+
+    let v = FromRedisValue::from_redis_value(&Value::Okay);
+    assert_eq!(v, Ok(true));
+
+    let v = FromRedisValue::from_redis_value(&Value::Nil);
+    assert_eq!(v, Ok(false));
+
+    let v = FromRedisValue::from_redis_value(&Value::Int(0));
+    assert_eq!(v, Ok(false));
+
+    let v = FromRedisValue::from_redis_value(&Value::Int(42));
+    assert_eq!(v, Ok(true));
+}