1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package tasks
17
18 import (
19 "fmt"
20 "testing"
21
22 "github.com/go-logr/logr"
23 "github.com/go-logr/zapr"
24 "github.com/pkg/errors"
25 "github.com/stretchr/testify/assert"
26 "go.uber.org/zap"
27
28 "github.com/chaos-mesh/chaos-mesh/pkg/cerr"
29 )
30
31 type FakeConfig struct {
32 i int
33 }
34
35 func (f *FakeConfig) Merge(a Mergeable) error {
36 A, OK := a.(*FakeConfig)
37 if OK {
38 f.i += A.i
39 return nil
40 }
41 return cerr.NotType[*FakeConfig]().WrapInput(a).Err()
42 }
43
44 func (f *FakeConfig) DeepCopy() Object {
45 temp := *f
46 return &temp
47 }
48
49 func (f *FakeConfig) Assign(c Injectable) error {
50 C, OK := c.(*FakeChaos)
51 if OK {
52 C.C.i = f.i
53 return nil
54 }
55 return cerr.NotType[*FakeConfig]().WrapInput(c).Err()
56 }
57
58 func (f *FakeConfig) New(immutableValues interface{}) (Injectable, error) {
59 temp := immutableValues.(*FakeChaos)
60 f.Assign(temp)
61 return temp, nil
62 }
63
64 type FakeChaos struct {
65 C FakeConfig
66 ErrWhenRecover bool
67 ErrWhenInject bool
68 logger logr.Logger
69 }
70
71 func (f *FakeChaos) Inject(pid IsID) error {
72 if f.ErrWhenInject {
73 return cerr.NotImpl[Injectable]().Err()
74 }
75 return nil
76 }
77
78 func (f *FakeChaos) Recover(pid IsID) error {
79 if f.ErrWhenRecover {
80 return cerr.NotImpl[Recoverable]().Err()
81 }
82 return nil
83 }
84
85 func TestTasksManager(t *testing.T) {
86 var log logr.Logger
87
88 zapLog, err := zap.NewDevelopment()
89 if err != nil {
90 panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
91 }
92 log = zapr.NewLogger(zapLog)
93
94 m := NewTaskManager(log)
95
96 chaos := FakeChaos{
97 ErrWhenRecover: false,
98 ErrWhenInject: false,
99 logger: log,
100 }
101 task1 := FakeConfig{i: 1}
102 uid1 := "1"
103 err = m.Create(uid1, SysPID(1), &task1, &chaos)
104 chaosInterface, err := m.GetTaskWithPID(SysPID(1))
105 assert.NoError(t, err)
106 chaoso := chaosInterface.(*FakeChaos)
107 assert.Equal(t, chaoso.C, task1)
108 assert.Equal(t, chaoso, &chaos)
109
110 task2 := FakeConfig{i: 1}
111 uid2 := "2"
112 err = m.Apply(uid2, SysPID(1), &task2)
113 chaosInterface, err = m.GetTaskWithPID(SysPID(1))
114 assert.NoError(t, err)
115 chaoso = chaosInterface.(*FakeChaos)
116 assert.Equal(t, chaoso.C, FakeConfig{i: 2})
117 assert.Equal(t, chaos.C, FakeConfig{i: 2})
118
119 assert.Equal(t, task1, FakeConfig{1})
120 assert.Equal(t, task2, FakeConfig{1})
121 }
122
123 func TestTasksManagerError(t *testing.T) {
124 var log logr.Logger
125
126 zapLog, err := zap.NewDevelopment()
127 if err != nil {
128 panic(fmt.Sprintf("who watches the watchmen (%v)?", err))
129 }
130 log = zapr.NewLogger(zapLog)
131
132 m := NewTaskManager(log)
133
134 chaos := FakeChaos{
135 ErrWhenRecover: false,
136 ErrWhenInject: false,
137 logger: log,
138 }
139 task1 := FakeConfig{i: 1}
140 uid1 := "1"
141 err = m.Create(uid1, SysPID(1), &task1, &chaos)
142 assert.NoError(t, err)
143 err = m.Apply(uid1, SysPID(1), &task1)
144 assert.Equal(t, errors.Cause(err), cerr.ErrDuplicateEntity)
145 err = m.Recover(uid1, SysPID(1))
146 assert.NoError(t, err)
147 err = m.Recover(uid1, SysPID(1))
148 assert.Equal(t, errors.Cause(err), ErrNotFoundTaskID.Err())
149
150 chaos.ErrWhenInject = true
151 tasks2 := FakeConfig{i: 1}
152 err = m.Create(uid1, SysPID(1), &tasks2, &chaos)
153 assert.Equal(t, errors.Cause(err).Error(), cerr.NotImpl[Injectable]().Err().Error())
154 _, err = m.GetConfigWithUID(uid1)
155 assert.Equal(t, errors.Cause(err), ErrNotFoundTaskID.Err())
156
157 chaos.ErrWhenInject = false
158 chaos.ErrWhenRecover = true
159 tasks3 := FakeConfig{i: 1}
160 err = m.Create(uid1, SysPID(1), &tasks3, &chaos)
161 assert.NoError(t, err)
162 err = m.Recover(uid1, SysPID(1))
163 assert.Equal(t, errors.Cause(err).Error(), cerr.NotImpl[Recoverable]().Err().Error())
164 p, err := m.GetTaskWithPID(SysPID(1))
165 inner := p.(*FakeChaos)
166 inner.ErrWhenRecover = false
167 err = m.Recover(uid1, SysPID(1))
168 assert.NoError(t, err)
169 }
170