From 8f0c60cadef0105f889770026a75c42f514e52bc Mon Sep 17 00:00:00 2001
From: dudaodong <lanliddd.2007@163.com>
Date: Fri, 17 Mar 2023 13:59:18 +0800
Subject: [PATCH] test: add unit test for promise Race and Any function

---
 async/promise.go      |   2 +-
 async/promise_test.go | 121 +++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 120 insertions(+), 3 deletions(-)

diff --git a/async/promise.go b/async/promise.go
index 2d185e7..ebf5a7c 100644
--- a/async/promise.go
+++ b/async/promise.go
@@ -237,7 +237,7 @@ func Race[T any](promises []*Promise[T]) *Promise[T] {
 
 // Any resolves as soon as any of the input's Promises resolve, with the value of the resolved Promise.
 // Any rejects if all of the given Promises are rejected with a combination of all errors.
-func Any[T any](promises ...*Promise[T]) *Promise[T] {
+func Any[T any](promises []*Promise[T]) *Promise[T] {
 	if len(promises) == 0 {
 		return nil
 	}
diff --git a/async/promise_test.go b/async/promise_test.go
index 84feffe..5a25450 100644
--- a/async/promise_test.go
+++ b/async/promise_test.go
@@ -3,6 +3,7 @@ package async
 import (
 	"errors"
 	"testing"
+	"time"
 
 	"github.com/duke-git/lancet/v2/internal"
 )
@@ -117,7 +118,7 @@ func TestPromise_Catch(t *testing.T) {
 }
 
 func TestAll(t *testing.T) {
-	assert := internal.NewAssert(t, "TestPromise_Catch")
+	assert := internal.NewAssert(t, "TestPromise_All")
 
 	t.Run("AllPromisesFullfilled", func(_ *testing.T) {
 		p1 := New(func(resolve func(string), reject func(error)) {
@@ -159,7 +160,7 @@ func TestAll(t *testing.T) {
 		_, err := p.Await()
 
 		assert.IsNotNil(err)
-		// assert.Equal("error1", err.Error())
+		assert.Equal("error1", err.Error())
 	})
 
 	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
@@ -183,3 +184,119 @@ func TestAll(t *testing.T) {
 	})
 
 }
+
+func TestAny(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Any")
+
+	t.Run("AnyFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 250)
+			resolve("fast")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 500)
+			resolve("slow")
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+		assert.Equal("fast", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Any(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("OnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Any([]*Promise[string]{p1, p2})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}
+
+func TestRace(t *testing.T) {
+	assert := internal.NewAssert(t, "TestPromise_Race")
+
+	t.Run("PromisesFullfilled", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 300)
+			resolve("b")
+		})
+
+		p := Race([]*Promise[string]{p1, p2})
+
+		val, err := p.Await()
+		assert.Equal("a", val)
+		assert.IsNil(err)
+	})
+
+	t.Run("EmptyPromises", func(_ *testing.T) {
+		var empty = []*Promise[any]{}
+		p := Race(empty)
+		assert.IsNil(p)
+	})
+
+	t.Run("PromisesContainRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			time.Sleep(time.Millisecond * 100)
+			resolve("a")
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		val, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+		assert.Equal("", val)
+	})
+
+	t.Run("PromisesOnlyRejected", func(_ *testing.T) {
+		p1 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error1"))
+
+		})
+		p2 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error2"))
+		})
+		p3 := New(func(resolve func(string), reject func(error)) {
+			reject(errors.New("error3"))
+		})
+
+		p := Race([]*Promise[string]{p1, p2, p3})
+
+		_, err := p.Await()
+
+		assert.IsNotNil(err)
+		// assert.Equal("error1", err.Error())
+	})
+
+}