Skip to content

Commit 7b80063

Browse files
ghosindghosind
committed
test: update test cases.
Signed-off-by: ghosind <ghosind@gmail.com>
1 parent bd49db7 commit 7b80063

13 files changed

+62
-48
lines changed

‎all_test.go‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -59,6 +59,7 @@ func TestAllFailure(t *testing.T) {
5959

6060
out, err := async.All(funcs...)
6161
a.NotNilNow(err)
62+
a.IsErrorNow(err, expectedErr)
6263
a.EqualNow(err.Error(), "function 2 error: n = 2")
6364
a.EqualNow(data, []bool{true, true, false, false, false})
6465
a.EqualNow(out, [][]any{{nil}, {nil}, {expectedErr}, nil, nil})
@@ -174,6 +175,7 @@ func TestAllCompletedPartialFailure(t *testing.T) {
174175

175176
out, err := async.AllCompleted(funcs...)
176177
a.NotNilNow(err)
178+
a.IsErrorNow(err, errNIs2)
177179
a.EqualNow(err.Error(), "function 2 error: n = 2")
178180
a.EqualNow(data, []bool{true, true, false, true, true})
179181
a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, errNIs2}, {3, nil}, {4, nil}})

‎error_go120_test.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,6 @@ func TestUnwrapExecutionsError(t *testing.T) {
1919
}
2020

2121
errs := ExecutionErrors{err}
22-
a.TrueNow(errors.Is(errs, err))
23-
a.TrueNow(errors.Is(errs, innerErr))
22+
a.IsErrorNow(errs, err)
23+
a.IsErrorNow(errs, innerErr)
2424
}

‎error_test.go‎

Lines changed: 9 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -16,27 +16,31 @@ func TestExecutionError(t *testing.T) {
1616
err: innerErr,
1717
}
1818

19-
a.EqualNow(err.Error(), "function 0 error: inner error")
19+
a.IsErrorNow(err, innerErr)
2020
a.EqualNow(err.Index(), 0)
2121
a.EqualNow(err.Err(), innerErr)
2222
}
2323

2424
func TestExecutionErrors(t *testing.T) {
2525
a := assert.New(t)
26+
err1 := errors.New("inner error 1")
27+
err2 := errors.New("inner error 2")
2628

2729
var ee ExecutionErrors = []ExecutionError{
2830
&executionError{
2931
index: 0,
30-
err: errors.New("inner error 1"),
32+
err: err1,
3133
},
3234
&executionError{
3335
index: 1,
34-
err: errors.New("inner error 2"),
36+
err: err2,
3537
},
3638
}
3739

3840
a.EqualNow(ee.Error(), `function 0 error: inner error 1
3941
function 1 error: inner error 2`)
42+
a.IsErrorNow(ee, err1)
43+
a.IsErrorNow(ee, err2)
4044
}
4145

4246
func TestConvertErrorListToExecutionErrors(t *testing.T) {
@@ -72,6 +76,6 @@ func TestUnwrapExecutionError(t *testing.T) {
7276
index: 0,
7377
}
7478

75-
a.TrueNow(errors.Is(err, innerErr))
76-
a.NotTrueNow(errors.Is(err, errors.New("unexpected error")))
79+
a.IsErrorNow(err, innerErr)
80+
a.NotIsErrorNow(err, errors.New("unexpected error"))
7781
}

‎forever_test.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ func TestForever(t *testing.T) {
3030
v = append(v, i)
3131
return nil
3232
})
33-
a.EqualNow(err, done)
33+
a.IsErrorNow(err, done)
3434
a.EqualNow(i, 5)
3535
a.EqualNow(v, []int{1, 2, 3, 4})
3636
}
@@ -62,7 +62,7 @@ func TestForeverWithContext(t *testing.T) {
6262

6363
return nil
6464
})
65-
a.EqualNow(err, done)
65+
a.IsErrorNow(err, done)
6666
a.EqualNow(i, 5)
6767
a.EqualNow(v, []int{0, 0, 1, 1})
6868
}

‎parallel_test.go‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,7 @@ func TestParallelWithFailedTask(t *testing.T) {
8888
out, err := async.Parallel(2, funcs...)
8989
dur := time.Since(start)
9090
a.NotNilNow(err)
91+
a.IsErrorNow(err, expectedErr)
9192
a.EqualNow(err.Error(), "function 2 error: expected error")
9293
a.GteNow(dur, 150*time.Millisecond)
9394
a.LteNow(dur, 180*time.Millisecond) // allow 30ms deviation
@@ -249,6 +250,7 @@ func TestParallelCompletedWithFailedTask(t *testing.T) {
249250

250251
out, err := async.ParallelCompleted(0, funcs...)
251252
a.NotNilNow(err)
253+
a.IsErrorNow(err, expectedErr)
252254
a.EqualNow(err.Error(), "function 2 error: expected error")
253255
a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {2, expectedErr}, {3, nil}, {4, nil}})
254256
}
@@ -307,6 +309,7 @@ func TestParallelCompletedWithTimedOutContext(t *testing.T) {
307309

308310
out, err := async.ParallelCompletedWithContext(ctx, 2, funcs...)
309311
a.NotNilNow(err)
312+
a.IsErrorNow(err, timeoutErr)
310313
a.EqualNow(err.Error(), `function 2 error: timed out
311314
function 3 error: timed out
312315
function 4 error: timed out`)

‎paralleler_test.go‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,7 @@ func TestParallelerRunWithFailure(t *testing.T) {
6262

6363
out, err := p.Run()
6464
a.NotNilNow(err)
65+
a.IsErrorNow(err, expectedErr)
6566
a.EqualNow(out, [][]any{{nil}, {nil}, {expectedErr}, {}, {}})
6667
a.EqualNow(cnt.Load(), 3)
6768
}
@@ -200,6 +201,7 @@ func TestParallelerRunCompletedWithFailure(t *testing.T) {
200201

201202
out, err := p.RunCompleted()
202203
a.NotNilNow(err)
204+
a.IsErrorNow(err, expectedErr)
203205
a.EqualNow(out, [][]any{{nil}, {nil}, {expectedErr}, {nil}, {nil}})
204206
a.EqualNow(cnt.Load(), 5)
205207
}

‎race_test.go‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -66,6 +66,7 @@ func TestRaceWithFailed(t *testing.T) {
6666

6767
out, index, err := async.Race(funcs...)
6868
a.NotNilNow(err)
69+
a.IsErrorNow(err, expectedErr)
6970
a.EqualNow(err.Error(), "function 2 error: expected error")
7071
a.EqualNow(index, 2)
7172
a.EqualNow(data, []bool{false, false, false, false, false})

‎retry_test.go‎

Lines changed: 24 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -40,43 +40,43 @@ func TestRetryWithFailed(t *testing.T) {
4040

4141
func TestRetryAlwaysFailed(t *testing.T) {
4242
a := assert.New(t)
43-
expected := errors.New("expected error")
43+
expectedErr := errors.New("expected error")
4444

4545
out, err := async.Retry(func() (int, error) {
46-
return 0, expected
46+
return 0, expectedErr
4747
})
48-
a.EqualNow(err, expected)
49-
a.EqualNow(out, []any{0, expected})
48+
a.IsErrorNow(err, expectedErr)
49+
a.EqualNow(out, []any{0, expectedErr})
5050
}
5151

5252
func TestRetryWithTimes(t *testing.T) {
5353
a := assert.New(t)
54-
expected := errors.New("expected error")
54+
expectedErr := errors.New("expected error")
5555
i := 0
5656

5757
out, err := async.Retry(func() (int, error) {
5858
i++
59-
return 0, expected
59+
return 0, expectedErr
6060
}, async.RetryOptions{
6161
Times: 3,
6262
})
63-
a.EqualNow(err, expected)
64-
a.EqualNow(out, []any{0, expected})
63+
a.IsErrorNow(err, expectedErr)
64+
a.EqualNow(out, []any{0, expectedErr})
6565
a.EqualNow(i, 3)
6666
}
6767

6868
func TestRetryWithInterval(t *testing.T) {
6969
a := assert.New(t)
70-
expected := errors.New("expected error")
70+
expectedErr := errors.New("expected error")
7171

7272
start := time.Now()
7373
out, err := async.Retry(func() (int, error) {
74-
return 0, expected
74+
return 0, expectedErr
7575
}, async.RetryOptions{
7676
Interval: 100,
7777
})
78-
a.EqualNow(err, expected)
79-
a.EqualNow(out, []any{0, expected})
78+
a.IsErrorNow(err, expectedErr)
79+
a.EqualNow(out, []any{0, expectedErr})
8080

8181
dur := time.Since(start)
8282
a.GteNow(dur, 400*time.Millisecond)
@@ -85,18 +85,18 @@ func TestRetryWithInterval(t *testing.T) {
8585

8686
func TestRetryWithIntervalFunc(t *testing.T) {
8787
a := assert.New(t)
88-
expected := errors.New("expected error")
88+
expectedErr := errors.New("expected error")
8989

9090
start := time.Now()
9191
out, err := async.Retry(func() (int, error) {
92-
return 0, expected
92+
return 0, expectedErr
9393
}, async.RetryOptions{
9494
IntervalFunc: func(n int) int {
9595
return n * 50
9696
},
9797
})
98-
a.EqualNow(err, expected)
99-
a.EqualNow(out, []any{0, expected})
98+
a.IsErrorNow(err, expectedErr)
99+
a.EqualNow(out, []any{0, expectedErr})
100100

101101
dur := time.Since(start)
102102
a.GteNow(dur, 500*time.Millisecond)
@@ -105,23 +105,25 @@ func TestRetryWithIntervalFunc(t *testing.T) {
105105

106106
func TestRetryWithErrorFilter(t *testing.T) {
107107
a := assert.New(t)
108-
expected := errors.New("expected error")
108+
expectedErr := errors.New("expected error")
109+
unexpectedErr := errors.New("not 3")
109110
i := 0
110111

111112
out, err := async.Retry(func() error {
112113
i++
113114
if i == 3 {
114-
return expected
115+
return expectedErr
115116
} else {
116-
return errors.New("not 3")
117+
return unexpectedErr
117118
}
118119
}, async.RetryOptions{
119120
ErrorFilter: func(err error) bool {
120-
return !errors.Is(err, expected)
121+
return !errors.Is(err, expectedErr)
121122
},
122123
})
123-
a.EqualNow(err, expected)
124-
a.EqualNow(out, []any{expected})
124+
a.IsErrorNow(err, expectedErr)
125+
a.NotIsErrorNow(err, unexpectedErr)
126+
a.EqualNow(out, []any{expectedErr})
125127
}
126128

127129
func TestRetryWithContext(t *testing.T) {

‎seq_test.go‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ func TestSeqWithFailure(t *testing.T) {
3333
}, func(err error) {
3434
a.FailNow()
3535
})
36-
a.NotNilNow(err)
36+
a.IsErrorNow(err, expectedErr)
3737
a.ContainsStringNow(err.Error(), expectedErr.Error())
3838
}
3939

@@ -63,17 +63,17 @@ func TestSeqCheckFuncs(t *testing.T) {
6363
_, err = async.Seq(func() string { return "" }, func(ctx context.Context) {})
6464
a.NilNow(err)
6565
_, err = async.Seq(nil)
66-
a.EqualNow(err, async.ErrNotFunction)
66+
a.IsErrorNow(err, async.ErrNotFunction)
6767
_, err = async.Seq(1, 2)
68-
a.EqualNow(err, async.ErrNotFunction)
68+
a.IsErrorNow(err, async.ErrNotFunction)
6969
_, err = async.Seq(func() {}, nil)
70-
a.EqualNow(err, async.ErrNotFunction)
70+
a.IsErrorNow(err, async.ErrNotFunction)
7171
_, err = async.Seq(func() {}, func(n int) {})
72-
a.EqualNow(err, async.ErrInvalidSeqFuncs)
72+
a.IsErrorNow(err, async.ErrInvalidSeqFuncs)
7373
_, err = async.Seq(func() string { return "" }, func(n int) {})
74-
a.EqualNow(err, async.ErrInvalidSeqFuncs)
74+
a.IsErrorNow(err, async.ErrInvalidSeqFuncs)
7575
_, err = async.Seq(func() string { return "" }, func(ctx context.Context, s string, n int) {})
76-
a.EqualNow(err, async.ErrInvalidSeqFuncs)
76+
a.IsErrorNow(err, async.ErrInvalidSeqFuncs)
7777
}
7878

7979
func TestSeqWithContext(t *testing.T) {
@@ -186,7 +186,7 @@ func TestSeqGroupsWithFailure(t *testing.T) {
186186

187187
err := async.SeqGroups(groups...)
188188
a.NotNilNow(err)
189-
a.ContainsStringNow(err.Error(), expectedErr.Error())
189+
a.IsErrorNow(err, expectedErr)
190190

191191
for i := 0; i < 3; i++ {
192192
if i == 1 {

‎series_test.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ func TestSeriesFailure(t *testing.T) {
4747
}
4848
out, err := async.Series(tasks...)
4949
a.NotNilNow(err)
50-
a.ContainsString(err.Error(), expectedErr.Error())
50+
a.IsErrorNow(err, expectedErr)
5151
a.EqualNow(out, [][]any{{0, nil}, {1, nil}, {0, expectedErr}, {}, {}})
5252
a.EqualNow(seq, []int{0, 1})
5353
}
@@ -74,7 +74,7 @@ func TestSeriesWithContext(t *testing.T) {
7474

7575
out, err := async.SeriesWithContext(ctx, tasks...)
7676
a.NotNilNow(err)
77-
a.ContainsStringNow(err.Error(), timeoutErr.Error())
77+
a.IsErrorNow(err, timeoutErr)
7878
a.EqualNow(out, [][]any{{nil}, {nil}, {timeoutErr}, {}, {}})
7979
}
8080

0 commit comments

Comments
 (0)