initial import

core/errorx/atomicerror.go

@@ -0,0 +1,21 @@
+package errorx
+
+import "sync"
+
+type AtomicError struct {
+	err  error
+	lock sync.Mutex
+}
+
+func (ae *AtomicError) Set(err error) {
+	ae.lock.Lock()
+	ae.err = err
+	ae.lock.Unlock()
+}
+
+func (ae *AtomicError) Load() error {
+	ae.lock.Lock()
+	err := ae.err
+	ae.lock.Unlock()
+	return err
+}

core/errorx/atomicerror_test.go

@@ -0,0 +1,21 @@
+package errorx
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+var errDummy = errors.New("hello")
+
+func TestAtomicError(t *testing.T) {
+	var err AtomicError
+	err.Set(errDummy)
+	assert.Equal(t, errDummy, err.Load())
+}
+
+func TestAtomicErrorNil(t *testing.T) {
+	var err AtomicError
+	assert.Nil(t, err.Load())
+}

core/errorx/batcherror.go

@@ -0,0 +1,45 @@
+package errorx
+
+import "bytes"
+
+type (
+	BatchError struct {
+		errs errorArray
+	}
+
+	errorArray []error
+)
+
+func (be *BatchError) Add(err error) {
+	if err != nil {
+		be.errs = append(be.errs, err)
+	}
+}
+
+func (be *BatchError) Err() error {
+	switch len(be.errs) {
+	case 0:
+		return nil
+	case 1:
+		return be.errs[0]
+	default:
+		return be.errs
+	}
+}
+
+func (be *BatchError) NotNil() bool {
+	return len(be.errs) > 0
+}
+
+func (ea errorArray) Error() string {
+	var buf bytes.Buffer
+
+	for i := range ea {
+		if i > 0 {
+			buf.WriteByte('\n')
+		}
+		buf.WriteString(ea[i].Error())
+	}
+
+	return buf.String()
+}

core/errorx/batcherror_test.go

@@ -0,0 +1,48 @@
+package errorx
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	err1 = "first error"
+	err2 = "second error"
+)
+
+func TestBatchErrorNil(t *testing.T) {
+	var batch BatchError
+	assert.Nil(t, batch.Err())
+	assert.False(t, batch.NotNil())
+	batch.Add(nil)
+	assert.Nil(t, batch.Err())
+	assert.False(t, batch.NotNil())
+}
+
+func TestBatchErrorNilFromFunc(t *testing.T) {
+	err := func() error {
+		var be BatchError
+		return be.Err()
+	}()
+	assert.True(t, err == nil)
+}
+
+func TestBatchErrorOneError(t *testing.T) {
+	var batch BatchError
+	batch.Add(errors.New(err1))
+	assert.NotNil(t, batch)
+	assert.Equal(t, err1, batch.Err().Error())
+	assert.True(t, batch.NotNil())
+}
+
+func TestBatchErrorWithErrors(t *testing.T) {
+	var batch BatchError
+	batch.Add(errors.New(err1))
+	batch.Add(errors.New(err2))
+	assert.NotNil(t, batch)
+	assert.Equal(t, fmt.Sprintf("%s\n%s", err1, err2), batch.Err().Error())
+	assert.True(t, batch.NotNil())
+}