1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
package async
import (
"fmt"
"testing"
"time"
"github.com/scaleway/scaleway-sdk-go/internal/testhelpers"
)
const flakiness = 500 * time.Millisecond
type value struct {
doneIterations int
totalDuration time.Duration
}
func getMock(iterations int, sleepTime time.Duration) func() (interface{}, bool, error) {
cpt := iterations
var startTime time.Time
return func() (interface{}, bool, error) {
if cpt == iterations {
startTime = time.Now()
}
cpt--
// fake working time
time.Sleep(sleepTime)
v := &value{
doneIterations: iterations - cpt,
totalDuration: time.Since(startTime),
}
return v, cpt == 0, nil
}
}
func TestWaitSync(t *testing.T) {
testsCases := []struct {
name string
config *WaitSyncConfig
expValue interface{}
expErr error
}{
{
name: "With default timeout and interval",
config: &WaitSyncConfig{
Get: getMock(2, 0),
},
expValue: &value{
doneIterations: 2,
totalDuration: time.Second,
},
},
{
name: "With useless timeout",
config: &WaitSyncConfig{
Get: getMock(2, time.Second),
Timeout: 4 * time.Second,
},
expValue: &value{
doneIterations: 2,
totalDuration: 3 * time.Second,
},
},
{
name: "Should timeout",
config: &WaitSyncConfig{
Get: getMock(2, 2*time.Second),
Timeout: time.Second,
},
expValue: nil,
expErr: fmt.Errorf("timeout after 1s"),
},
{
name: "With interval",
config: &WaitSyncConfig{
Get: getMock(2, 0),
IntervalStrategy: LinearIntervalStrategy(2 * time.Second),
},
expValue: &value{
doneIterations: 2,
totalDuration: 2 * time.Second,
},
},
{
name: "With fibonacci interval",
config: &WaitSyncConfig{
Get: getMock(5, 0),
IntervalStrategy: FibonacciIntervalStrategy(time.Second, 1),
},
expValue: &value{
doneIterations: 5,
totalDuration: 7 * time.Second,
},
},
{
name: "Should timeout with interval",
config: &WaitSyncConfig{
Get: getMock(2, time.Second),
Timeout: 2 * time.Second,
IntervalStrategy: LinearIntervalStrategy(2 * time.Second),
},
expValue: nil,
expErr: fmt.Errorf("timeout after 2s"),
},
}
for _, c := range testsCases {
c := c // do not remove me
t.Run(c.name, func(t *testing.T) {
t.Parallel()
terminalValue, err := WaitSync(c.config)
testhelpers.Equals(t, c.expErr, err)
if c.expValue != nil {
exp := c.expValue.(*value)
acc := terminalValue.(*value)
testhelpers.Equals(t, exp.doneIterations, acc.doneIterations)
ok := exp.totalDuration > acc.totalDuration-flakiness && exp.totalDuration < acc.totalDuration+flakiness
testhelpers.Assert(t, ok, "totalDuration don't match the target: (acc: %v, exp: %v)", acc.totalDuration, exp.totalDuration)
}
})
}
}
|
