Refactor and add unit tests

Author: gavrie

Cargo.toml

@@ -22,6 +22,7 @@ libc = "0.2"
 time = "0.1"
 enum-primitive-derive = "^0.1"
 num-traits = "^0.1"
+failure = "0.1"
 
 [build-dependencies]
 bindgen = "0.47"

examples/hello.rs

@@ -1,8 +1,13 @@
+//#[macro_use]
+//extern crate failure;
+
+#[macro_use]
+extern crate redismodule;
+
 use std::iter;
 use std::ffi::CString;
 
-//#[macro_use]
-extern crate redismodule;
+//use failure::Error;
 
 use redismodule::{Context, Command, RedisResult, RedisValue, RedisError};
 
@@ -11,27 +16,25 @@ fn hello_mul(_: &Context, args: Vec<String>) -> RedisResult {
         return Err(RedisError::WrongArity);
     }
 
-    let mut nums = vec![];
-
-    for arg in args.into_iter().skip(1) {
-        nums.push(parse_integer(&arg)?);
-    }
+    let nums = args
+        .into_iter()
+        .skip(1)
+        .map(parse_integer)
+        .collect::<Result<Vec<i64>, RedisError>>()?;
 
     let product = nums.iter().product();
 
-    let results = nums
-        .into_iter()
-        .chain(iter::once(product));
-
     return Ok(RedisValue::Array(
-        results
+        nums
+            .into_iter()
+            .chain(iter::once(product))
             .map(RedisValue::Integer)
             .collect()));
 }
 
 //////////////////////////////////////////////////////
 
-fn parse_integer(arg: &str) -> Result<i64, RedisError> {
+fn parse_integer(arg: String) -> Result<i64, RedisError> {
     arg.parse::<i64>()
         .map_err(|_| RedisError::String(format!("Couldn't parse as integer: {}", arg)))
 }
@@ -41,8 +44,51 @@ fn parse_integer(arg: &str) -> Result<i64, RedisError> {
 const MODULE_NAME: &str = "hello";
 const MODULE_VERSION: u32 = 1;
 
-/*
 redis_module!(MODULE_NAME, MODULE_VERSION, [
     Command::new("hello.mul", hello_mul, "write"),
 ]);
-*/
+
+//////////////////////////////////////////////////////
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn run_hello_mul(args: &[&str]) -> RedisResult {
+        hello_mul(
+            &Context::dummy(),
+            args
+                .iter()
+                .map(|v| String::from(*v))
+                .collect(),
+        )
+    }
+
+    #[test]
+    fn hello_mul_valid_integer_args() {
+        let result = run_hello_mul(&vec!["hello.mul", "10", "20", "30"]);
+
+        match result {
+            Ok(RedisValue::Array(v)) => {
+                assert_eq!(v, vec![10, 20, 30, 6000]
+                    .into_iter()
+                    .map(RedisValue::Integer)
+                    .collect::<Vec<_>>());
+            }
+            _ => assert!(false, "Bad result: {:?}", result)
+        }
+    }
+
+    #[test]
+    fn hello_mul_bad_integer_args() {
+        let result = run_hello_mul(&vec!["hello.mul", "10", "xx", "30"]);
+
+        match result {
+            Err(RedisError::String(s)) => {
+                assert_eq!(s, "Couldn't parse as integer: xx");
+            }
+            _ => assert!(false, "Bad result: {:?}", result)
+        }
+    }
+}
+

src/context.rs

@@ -1,3 +1,4 @@
+use std::ptr;
 use std::os::raw::c_long;
 use std::ffi::CString;
 
@@ -17,6 +18,10 @@ impl Context {
         Self { ctx }
     }
 
+    pub fn dummy() -> Self {
+        Self { ctx: ptr::null_mut() }
+    }
+
     pub fn log(&self, level: LogLevel, message: &str) {
         let level = CString::new(format!("{:?}", level).to_lowercase()).unwrap();
         let fmt = CString::new(message).unwrap();

src/redismodule.rs

@@ -13,7 +13,7 @@ pub enum RedisError {
     String(String),
 }
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum RedisValue {
     String(String),
     Integer(i64),