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
129
130
131
132
133
134
135
136
137
138
|
package tasks
import (
"errors"
"log"
"os"
"testing"
"time"
)
type tShortTask struct{}
func (t *tShortTask) Run() error {
time.Sleep(time.Second * 1)
return nil
}
type tLongTask struct{}
func (t *tLongTask) Run() error {
time.Sleep(time.Second * 2)
return nil
}
type tErrorTask struct{}
func (t *tErrorTask) Run() error {
time.Sleep(time.Second * 2)
return eErrorTask
}
var (
eErrorTask = errors.New("tErrorTask testing error")
testLogger = log.New(os.Stderr, "", log.LstdFlags|log.Lshortfile)
)
func TestIntegration(t *testing.T) {
logger = testLogger
tg := NewGroup()
pairs := map[string]Task{
"tShortTask": &tShortTask{},
"tLongTask": &tLongTask{},
"tErrorTask": &tErrorTask{},
}
done := []string{}
for name, task := range pairs {
err := tg.Add(name, task)
if err != nil {
t.Fatalf("while adding: %s", err)
}
testLogger.Println("Added: ", name)
registered := tg.Registered()
testLogger.Println("Currently registered: ", registered)
for _, n := range done {
_, ok := registered[n]
if !ok {
t.Fatalf("%s is supposed to be registered", n)
}
}
}
reg := tg.Registered()
testLogger.Println("Registered tasks: ", reg)
err := tg.Add("tLongTask", &tLongTask{})
if !errors.Is(err, EAlreadyRegistered) {
t.Errorf("tLongTask should already be registered got: %s", err)
}
err = tg.Start("tLongTask")
if err != nil {
t.Errorf("starting tLongTask err should've been nil: %s", err)
}
testLogger.Println("tried starting tLongTask again")
err = tg.Run("tShortTask")
if err != nil {
t.Errorf("running tShortTask err should've been nil: %s", err)
}
finished := tg.Finished()
testLogger.Println("Finished tasks: ", finished)
_, ok := finished["tShortTask"]
if !ok {
t.Errorf("tShortTask should've been finished and isn't")
}
_, ok = finished["tLongTask"]
if ok {
t.Errorf("tLongTask is finished and it shouldn't be")
}
err = tg.Start("tLongTask")
if !errors.Is(err, EAlreadyStarted) {
t.Errorf("tLongTask should've already been started got: %s", err)
}
err = tg.Run("tLongTask")
if !errors.Is(err, EAlreadyStarted) {
t.Errorf("tLongTask should've already been started got: %s", err)
}
running := tg.Running()
testLogger.Println("Running tasks: ", running)
err = tg.Run("tErrorTask")
if err == nil {
t.Error("tErrorTask should have produced an error")
}
withErrors := tg.Error()
testLogger.Println("Errored tasks: ", withErrors)
_, ok = withErrors["tErrorTask"]
if !ok {
t.Error("tErrorTask should've been found within tg.Error()")
}
err = tg.GetError("tErrorTask")
if !errors.Is(err, eErrorTask) {
t.Errorf("tErrorTask should've returned an error got: %s", err)
}
finished = tg.Finished()
testLogger.Println("Finished tasks: ", finished)
for name := range pairs {
_, ok := finished[name]
if !ok {
t.Errorf("'%s' should be finished and isn't", name)
}
}
}
|
