chore: maintenance

Author: Tochemey

durable_state_actor.go

@@ -78,8 +78,8 @@ func (entity *durableStateActor) PreStart(ctx context.Context) error {
 
 	return errorschain.
 		New(errorschain.ReturnFirst()).
-		AddError(entity.stateStore.Ping(ctx)).
-		AddError(entity.recoverFromStore(ctx)).
+		AddErrorFn(func() error { return entity.stateStore.Ping(ctx) }).
+		AddErrorFn(func() error { return entity.recoverFromStore(ctx) }).
 		Error()
 }
 
@@ -99,8 +99,8 @@ func (entity *durableStateActor) Receive(ctx *goakt.ReceiveContext) {
 func (entity *durableStateActor) PostStop(ctx context.Context) error {
 	return errorschain.
 		New(errorschain.ReturnFirst()).
-		AddError(entity.stateStore.Ping(ctx)).
-		AddError(entity.persistStateAndPublish(ctx)).
+		AddErrorFn(func() error { return entity.stateStore.Ping(ctx) }).
+		AddErrorFn(func() error { return entity.persistStateAndPublish(ctx) }).
 		Error()
 }
 

internal/errorschain/errorschain.go

@@ -51,30 +51,65 @@ func New(opts ...ChainOption) *Chain {
 
 // AddError add an error to the chain
 func (c *Chain) AddError(err error) *Chain {
-	c.errs = append(c.errs, err)
+	if c.returnFirst {
+		if len(c.errs) == 0 {
+			if err != nil {
+				c.errs = append(c.errs, err)
+				return c
+			}
+		}
+		return c
+	}
+
+	if err != nil {
+		c.errs = append(c.errs, err)
+		return c
+	}
+
 	return c
 }
 
-// AddErrors add a slice of errors to the chain. Remember the slice order does matter here
-func (c *Chain) AddErrors(errs ...error) *Chain {
-	c.errs = append(c.errs, errs...)
+// AddErrorFn add an error to the chain
+func (c *Chain) AddErrorFn(fn func() error) *Chain {
+	if c.returnFirst {
+		if len(c.errs) == 0 {
+			if err := fn(); err != nil {
+				c.errs = append(c.errs, err)
+				return c
+			}
+		}
+		return c
+	}
+
+	if err := fn(); err != nil {
+		c.errs = append(c.errs, err)
+		return c
+	}
+
+	return c
+}
+
+// AddErrorFns add a slice of error functions to the chain. Remember the slice order does matter here
+func (c *Chain) AddErrorFns(fn ...func() error) *Chain {
+	for _, f := range fn {
+		c = c.AddErrorFn(f)
+	}
 	return c
 }
 
 // Error returns the error
 func (c *Chain) Error() error {
 	if c.returnFirst {
-		for _, v := range c.errs {
-			if v != nil {
-				return v
-			}
+		if len(c.errs) == 0 {
+			return nil
 		}
-		return nil
+		return c.errs[0]
 	}
 
 	var err error
 	for _, v := range c.errs {
 		if v != nil {
+			// append error to the violations
 			err = multierr.Append(err, v)
 		}
 	}

internal/errorschain/errorschain_test.go

@@ -28,7 +28,7 @@ import (
 	"errors"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestErrorsChain(t *testing.T) {
@@ -39,15 +39,92 @@ func TestErrorsChain(t *testing.T) {
 
 		chain := New(ReturnFirst()).AddError(e1).AddError(e2).AddError(e3)
 		actual := chain.Error()
-		assert.True(t, errors.Is(actual, e1))
+		require.True(t, errors.Is(actual, e1))
 	})
+
+	t.Run("With Error", func(t *testing.T) {
+		chain := New(ReturnFirst()).AddError(nil)
+		actual := chain.Error()
+		require.NoError(t, actual)
+	})
+
+	t.Run("With AddErrorFn ReturnFirst", func(t *testing.T) {
+		var (
+			calledFn1 = false
+			calledFn2 = false
+			calledFn3 = false
+		)
+
+		fn1 := func() error { calledFn1 = true; return errors.New("err1") }
+		fn2 := func() error { calledFn2 = true; return errors.New("err2") }
+		fn3 := func() error { calledFn3 = true; return errors.New("err3") }
+
+		chain := New(ReturnFirst()).
+			AddErrorFn(fn1).
+			AddErrorFn(fn2).
+			AddErrorFn(fn3)
+		actual := chain.Error()
+
+		require.EqualError(t, actual, "err1")
+		require.True(t, calledFn1)
+		require.False(t, calledFn2)
+		require.False(t, calledFn3)
+	})
+
+	t.Run("With AddErrorFns ReturnFirst", func(t *testing.T) {
+		var (
+			calledFn1 = false
+			calledFn2 = false
+			calledFn3 = false
+		)
+
+		fn1 := func() error { calledFn1 = true; return errors.New("err1") }
+		fn2 := func() error { calledFn2 = true; return errors.New("err2") }
+		fn3 := func() error { calledFn3 = true; return errors.New("err3") }
+
+		chain := New(ReturnFirst()).AddErrorFns(fn1, fn2, fn3)
+		actual := chain.Error()
+
+		require.EqualError(t, actual, "err1")
+		require.True(t, calledFn1)
+		require.False(t, calledFn2)
+		require.False(t, calledFn3)
+	})
+
+	t.Run("With AddErrorFn ReturnAll", func(t *testing.T) {
+		var (
+			calledFn1 = false
+			calledFn2 = false
+			calledFn3 = false
+		)
+
+		fn1 := func() error { calledFn1 = true; return errors.New("err1") }
+		fn2 := func() error { calledFn2 = true; return errors.New("err2") }
+		fn3 := func() error { calledFn3 = true; return nil }
+
+		chain := New(ReturnAll()).
+			AddErrorFn(fn1).
+			AddErrorFn(fn2).
+			AddErrorFn(fn3)
+		actual := chain.Error()
+
+		require.EqualError(t, actual, "err1; err2")
+		require.True(t, calledFn1)
+		require.True(t, calledFn2)
+		require.True(t, calledFn3)
+	})
+
 	t.Run("With ReturnAll", func(t *testing.T) {
 		e1 := errors.New("err1")
 		e2 := errors.New("err2")
 		e3 := errors.New("err3")
 
-		chain := New(ReturnAll()).AddError(e1).AddError(e2).AddError(e3)
+		chain := New(ReturnAll()).
+			AddError(e1).
+			AddError(e2).
+			AddError(e3).
+			AddError(nil)
 		actual := chain.Error()
-		assert.EqualError(t, actual, "err1; err2; err3")
+		require.EqualError(t, actual, "err1; err2; err3")
 	})
 }