Add guard conditions to enforce how mapper func should be passed

Author: aswinkarthik

map.go

@@ -7,17 +7,32 @@ import (
 
 // Map applies mapperFn on each item of in and puts it in out
 func Map(in, out, mapperFn interface{}) error {
-	mapper := reflect.ValueOf(mapperFn)
-	if mapper.Kind() != reflect.Func {
-		return fmt.Errorf("mapperFn has to be a function")
-	}
 	input := reflect.ValueOf(in)
 	output := reflect.ValueOf(out)
+
+	zeroValue := reflect.Value{}
+	if output == zeroValue {
+		return fmt.Errorf("output is nil. Pass a reference to set output")
+	}
+
+	if output.IsNil() {
+		return fmt.Errorf("output is nil. Pass a reference to set output")
+	}
+
 	if !output.Elem().CanSet() {
 		return fmt.Errorf("cannot set out. Pass a reference to set output")
 	}
 
+	mapper := reflect.ValueOf(mapperFn)
+	if err := validateMapperFunction(mapper); err != nil {
+		return err
+	}
+
 	if input.Kind() == reflect.Slice {
+		if input.Type().Elem().Kind() != mapper.Type().In(0).Kind() {
+			return fmt.Errorf("mapper function's first argument has to be the type of element of input slice")
+		}
+
 		result := reflect.MakeSlice(output.Elem().Type(), 0, input.Len())
 		for i := 0; i < input.Len(); i++ {
 			arg := input.Index(i)
@@ -32,3 +47,20 @@ func Map(in, out, mapperFn interface{}) error {
 	}
 	return fmt.Errorf("not implemented")
 }
+
+func validateMapperFunction(mapper reflect.Value) error {
+	if mapper.Kind() != reflect.Func {
+		return fmt.Errorf("mapperFn has to be a function")
+	}
+
+	mapperFnType := mapper.Type()
+	if mapperFnType.NumIn() != 1 {
+		return fmt.Errorf("mapper function has to take only one argument")
+	}
+
+	if mapperFnType.NumOut() != 1 {
+		return fmt.Errorf("mapper function should return only one return value")
+	}
+
+	return nil
+}

map_test.go

@@ -40,4 +40,79 @@ func TestMap(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, expected, out)
 	})
+
+	squared := func(element int) int {
+		return element * element
+	}
+
+	t.Run("should not panic if output is nil", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		{
+			var out []int
+
+			err := godash.Map(in, out, squared)
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+
+		{
+			err := godash.Map(in, nil, squared)
+
+			assert.EqualError(t, err, "output is nil. Pass a reference to set output")
+		}
+	})
+
+	t.Run("should not accept mapper function that are not functions", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out []int
+
+		err := godash.Map(in, &out, 7)
+
+		assert.EqualError(t, err, "mapperFn has to be a function")
+	})
+
+	t.Run("should not accept mapper function that do not take exactly one argument", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func() int { return 0 })
+			assert.EqualError(t, err, "mapper function has to take only one argument")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int, int) int { return 0 })
+			assert.EqualError(t, err, "mapper function has to take only one argument")
+		}
+	})
+
+	t.Run("should not accept mapper function that do not return exactly one value", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func(int) {})
+			assert.EqualError(t, err, "mapper function should return only one return value")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int) (int, int) { return 0, 0 })
+			assert.EqualError(t, err, "mapper function should return only one return value")
+		}
+	})
+
+	t.Run("should accept mapper function whose argument's kind should be slice's element kind", func(t *testing.T) {
+		in := []int{1, 2, 3}
+		var out []int
+
+		{
+			err := godash.Map(in, &out, func(string) string { return "" })
+			assert.EqualError(t, err, "mapper function's first argument has to be the type of element of input slice")
+		}
+
+		{
+			err := godash.Map(in, &out, func(int) int { return 0 })
+			assert.NoError(t, err)
+		}
+	})
 }