feat: add AllCompleted.

Author: ghosind

all.go

@@ -3,6 +3,7 @@ package async
 import (
 	"context"
 	"errors"
+	"sync"
 )
 
 func All(funcs ...func(context.Context) error) error {
@@ -65,3 +66,44 @@ func all(parent context.Context, funcs ...func(context.Context) error) error {
 		}
 	}
 }
+
+func AllCompleted(funcs ...func(context.Context) error) ([]error, bool) {
+	return allCompleted(context.Background(), funcs...)
+}
+
+func AllCompletedWithContext(ctx context.Context, funcs ...func(context.Context) error) ([]error, bool) {
+	return allCompleted(ctx, funcs...)
+}
+
+func allCompleted(parent context.Context, funcs ...func(context.Context) error) (errs []error, hasError bool) {
+	hasError = false
+	errs = make([]error, len(funcs))
+	if len(funcs) == 0 {
+		return
+	}
+
+	wg := sync.WaitGroup{}
+	wg.Add(len(funcs))
+
+	for i := 0; i < len(funcs); i++ {
+		n := i
+		fn := funcs[n]
+		go func() {
+			childCtx, childCanFunc := context.WithCancel(parent)
+			defer childCanFunc()
+			defer wg.Done()
+
+			err := executionContainer(func() error {
+				return fn(childCtx)
+			})
+			if err != nil {
+				hasError = true
+				errs[n] = err
+			}
+		}()
+	}
+
+	wg.Wait()
+
+	return
+}

all_test.go

@@ -58,7 +58,7 @@ func TestAllFailure(t *testing.T) {
 	a.EqualNow(data, []bool{true, true, false, false, false})
 }
 
-func TestAllWithTimeoutedContext(t *testing.T) {
+func TestAllWithTimeoutContext(t *testing.T) {
 	a := assert.New(t)
 
 	data := make([]bool, 5)
@@ -80,3 +80,86 @@ func TestAllWithTimeoutedContext(t *testing.T) {
 	a.Equal(err.Error(), "context canceled")
 	a.EqualNow(data, []bool{true, true, false, false, false})
 }
+
+func TestAllCompletedWithoutFuncs(t *testing.T) {
+	a := assert.New(t)
+
+	errs, hasError := AllCompleted()
+	a.NotTrueNow(hasError)
+	a.EqualNow(errs, []error{})
+}
+
+func TestAllCompletedSuccess(t *testing.T) {
+	a := assert.New(t)
+
+	data := make([]bool, 5)
+	funcs := make([]func(context.Context) error, 0, 5)
+	for i := 0; i < 5; i++ {
+		n := i
+		funcs = append(funcs, func(ctx context.Context) error {
+			time.Sleep(time.Duration(n*100) * time.Millisecond)
+			data[n] = true
+			return nil
+		})
+	}
+
+	errs, hasError := AllCompleted(funcs...)
+	a.NotTrueNow(hasError)
+	a.EqualNow(data, []bool{true, true, true, true, true})
+	a.EqualNow(errs, []error{nil, nil, nil, nil, nil})
+}
+
+func TestAllCompletedPartialFailure(t *testing.T) {
+	a := assert.New(t)
+
+	errNIs2 := errors.New("n = 2")
+
+	data := make([]bool, 5)
+	funcs := make([]func(context.Context) error, 0, 5)
+	for i := 0; i < 5; i++ {
+		n := i
+		funcs = append(funcs, func(ctx context.Context) error {
+			time.Sleep(time.Duration(n*100) * time.Millisecond)
+			if n == 2 {
+				return errNIs2
+			}
+			data[n] = true
+			return nil
+		})
+	}
+
+	errs, hasError := AllCompleted(funcs...)
+	a.TrueNow(hasError)
+	a.EqualNow(data, []bool{true, true, false, true, true})
+	a.EqualNow(errs, []error{nil, nil, errNIs2, nil, nil})
+}
+
+func TestAllCompletedWithTimeoutContext(t *testing.T) {
+	a := assert.New(t)
+
+	errTimeout := errors.New("timeout")
+
+	data := make([]bool, 5)
+	funcs := make([]func(context.Context) error, 0, 5)
+	for i := 0; i < 5; i++ {
+		n := i
+		funcs = append(funcs, func(ctx context.Context) error {
+			time.Sleep(time.Duration(n*100) * time.Millisecond)
+			select {
+			case <-ctx.Done():
+				return errTimeout
+			default:
+				data[n] = true
+				return nil
+			}
+		})
+	}
+
+	ctx, canFunc := context.WithTimeout(context.Background(), 150*time.Millisecond)
+	defer canFunc()
+
+	errs, hasError := AllCompletedWithContext(ctx, funcs...)
+	a.TrueNow(hasError)
+	a.EqualNow(data, []bool{true, true, false, false, false})
+	a.EqualNow(errs, []error{nil, nil, errTimeout, errTimeout, errTimeout})
+}