Merge branch 'issue-9'

chainable.go

@@ -57,7 +57,7 @@ func (c *Chainable) Unwrap() ([]Argument, error) {
 
 	for linkIndex, link := range c.links {
 		if v, err = link.process(linkIndex, v); err != nil {
-			return nil, err
+			return v, err
 		}
 	}
 
@@ -160,5 +160,9 @@ func reflectArgs(args []Argument) []reflect.Value {
 // doesReturnError returns true if the last return
 // value for vfn is a type error
 func doesReturnError(vfnType reflect.Type) bool {
+	if vfnType.NumOut() == 0 {
+		return false
+	}
+
 	return vfnType.Out(vfnType.NumOut()-1) == reflect.TypeOf((*error)(nil)).Elem()
 }

chainable_test.go

@@ -8,29 +8,133 @@ import (
 )
 
 func TestChain(t *testing.T) {
-	sum2 := func(x int) int { return x + 2 }
-	mul2 := func(x int) int { return x * 2 }
-
-	// (4 + 2) * 2 = 12
-	ret, err := New().
-		From(4).
-		Chain(sum2, mul2).
-		Unwrap()
-
-	assert.Equal(t, []Argument{12}, ret)
-	assert.NoError(t, err)
+	testCases := []struct {
+		desc        string
+		from        []Argument
+		funcs       []Function
+		returnValue []Argument
+		err         error
+	}{
+		{
+			desc: "Regular chain",
+			from: []Argument{4},
+			funcs: []Function{
+				func(x int) int { return x + 2 },
+				func(x int) int { return x * 2 },
+			},
+			returnValue: []Argument{12},
+			err:         nil,
+		},
+		{
+			desc: "No initial value in chain",
+			from: []Argument{},
+			funcs: []Function{
+				func() int { return 2 },
+				func(x int) int { return x * 2 },
+			},
+			returnValue: []Argument{4},
+			err:         nil,
+		},
+		{
+			desc: "No return value",
+			from: []Argument{4},
+			funcs: []Function{
+				func(x int) int { return x + 2 },
+				func(x int) int { return x * 2 },
+				func(int) {},
+			},
+			returnValue: []Argument{},
+			err:         nil,
+		},
+		{
+			desc: "With error",
+			from: []Argument{},
+			funcs: []Function{
+				func() int { return 0 },
+				func(x int) error { return errors.New("a generic error") },
+			},
+			returnValue: []Argument{},
+			err:         errors.New("a generic error"),
+		},
+		{
+			desc: "Without argument feedback",
+			from: []Argument{},
+			funcs: []Function{
+				func() {},
+				func() {},
+			},
+			returnValue: []Argument{},
+			err:         nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			rv, err := New().From(tc.from...).Chain(tc.funcs...).Unwrap()
+			assert.Equal(t, tc.returnValue, rv)
+			assert.Equal(t, tc.err, err)
+		})
+	}
 }
 
 func TestChainDummy(t *testing.T) {
-	genericError := errors.New("a generic error")
-
-	f1 := func() error { return genericError }
-	f2 := func(e error) int { return 0 }
-
-	ret, err := New().ChainDummy(f1, f2).Unwrap()
-
-	assert.Equal(t, []Argument{0}, ret)
-	assert.NoError(t, err)
+	testCases := []struct {
+		desc        string
+		from        []Argument
+		funcs       []Function
+		returnValue []Argument
+		err         error
+	}{
+		{
+			desc: "Regular chain",
+			from: []Argument{4},
+			funcs: []Function{
+				func(x int) int { return x + 2 },
+				func(x int) int { return x * 2 },
+			},
+			returnValue: []Argument{12},
+			err:         nil,
+		},
+		{
+			desc: "With error in the end of the chain",
+			from: []Argument{},
+			funcs: []Function{
+				func() int { return 2 },
+				func(x int) (int, error) { return x, errors.New("a generic error") },
+			},
+			returnValue: []Argument{2, errors.New("a generic error")},
+			err:         nil,
+		},
+		{
+			desc: "With cascading error",
+			from: []Argument{},
+			funcs: []Function{
+				func() error { return errors.New("a generic error") },
+				func(e error) error { return e },
+				func(e error) error { return e },
+			},
+			returnValue: []Argument{errors.New("a generic error")},
+			err:         nil,
+		},
+		{
+			desc: "With cascading error",
+			from: []Argument{errors.New("a generic error")},
+			funcs: []Function{
+				func(e error) error { return e },
+				func(e error) error { return e },
+			},
+			returnValue: []Argument{errors.New("a generic error")},
+			err:         nil,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.desc, func(t *testing.T) {
+			rv, err := New().From(tc.from...).ChainDummy(tc.funcs...).Unwrap()
+			assert.Equal(t, tc.returnValue, rv)
+			assert.Equal(t, tc.err, err)
+		})
+	}
 }
 
 func TestNotAFunction(t *testing.T) {