github.com/sttk/sabi@v0.5.0/runner_test.go (about) 1 package sabi_test 2 3 import ( 4 "container/list" 5 "testing" 6 "time" 7 8 "github.com/stretchr/testify/assert" 9 10 "github.com/sttk/sabi" 11 ) 12 13 var runnerLogs list.List 14 15 func clearRunnerLogs() { 16 runnerLogs.Init() 17 } 18 19 func TestRunSeq(t *testing.T) { 20 clearRunnerLogs() 21 defer clearRunnerLogs() 22 23 slowerRunner := func() sabi.Err { 24 time.Sleep(50 * time.Millisecond) 25 runnerLogs.PushBack("slower runner.") 26 return sabi.Ok() 27 } 28 29 fasterRunner := func() sabi.Err { 30 time.Sleep(10 * time.Millisecond) 31 runnerLogs.PushBack("faster runner.") 32 return sabi.Ok() 33 } 34 35 err := sabi.RunSeq(slowerRunner, fasterRunner) 36 assert.True(t, err.IsOk()) 37 38 log := runnerLogs.Front() 39 assert.Equal(t, log.Value, "slower runner.") 40 log = log.Next() 41 assert.Equal(t, log.Value, "faster runner.") 42 log = log.Next() 43 assert.Nil(t, log) 44 } 45 46 func TestRunSeq_failToRunFormerRunner(t *testing.T) { 47 clearRunnerLogs() 48 defer clearRunnerLogs() 49 50 type FailToRun struct{} 51 52 slowerRunner := func() sabi.Err { 53 time.Sleep(50 * time.Millisecond) 54 return sabi.NewErr(FailToRun{}) 55 } 56 57 fasterRunner := func() sabi.Err { 58 time.Sleep(10 * time.Millisecond) 59 runnerLogs.PushBack("faster runner.") 60 return sabi.Ok() 61 } 62 63 err := sabi.RunSeq(slowerRunner, fasterRunner) 64 assert.True(t, err.IsNotOk()) 65 switch err.Reason().(type) { 66 case FailToRun: 67 default: 68 assert.Fail(t, err.Error()) 69 } 70 71 log := runnerLogs.Front() 72 assert.Nil(t, log) 73 } 74 75 func TestRunSeq_failToRunLatterRunner(t *testing.T) { 76 clearRunnerLogs() 77 defer clearRunnerLogs() 78 79 type FailToRun struct{} 80 81 slowerRunner := func() sabi.Err { 82 time.Sleep(50 * time.Millisecond) 83 runnerLogs.PushBack("slower runner.") 84 return sabi.Ok() 85 } 86 87 fasterRunner := func() sabi.Err { 88 time.Sleep(10 * time.Millisecond) 89 return sabi.NewErr(FailToRun{}) 90 } 91 92 err := sabi.RunSeq(slowerRunner, fasterRunner) 93 assert.True(t, err.IsNotOk()) 94 switch err.Reason().(type) { 95 case FailToRun: 96 default: 97 assert.Fail(t, err.Error()) 98 } 99 100 log := runnerLogs.Front() 101 assert.Equal(t, log.Value, "slower runner.") 102 log = log.Next() 103 assert.Nil(t, log) 104 } 105 106 func TestSeq(t *testing.T) { 107 clearRunnerLogs() 108 defer clearRunnerLogs() 109 110 slowerRunner := func() sabi.Err { 111 time.Sleep(50 * time.Millisecond) 112 runnerLogs.PushBack("slower runner.") 113 return sabi.Ok() 114 } 115 116 fasterRunner := func() sabi.Err { 117 time.Sleep(10 * time.Millisecond) 118 runnerLogs.PushBack("faster runner.") 119 return sabi.Ok() 120 } 121 122 runner := sabi.Seq(slowerRunner, fasterRunner) 123 err := runner() 124 assert.True(t, err.IsOk()) 125 126 log := runnerLogs.Front() 127 assert.Equal(t, log.Value, "slower runner.") 128 log = log.Next() 129 assert.Equal(t, log.Value, "faster runner.") 130 log = log.Next() 131 assert.Nil(t, log) 132 } 133 134 func TestSeq_failToRunFormerRunner(t *testing.T) { 135 clearRunnerLogs() 136 defer clearRunnerLogs() 137 138 type FailToRun struct{} 139 140 slowerRunner := func() sabi.Err { 141 time.Sleep(50 * time.Millisecond) 142 return sabi.NewErr(FailToRun{}) 143 } 144 145 fasterRunner := func() sabi.Err { 146 time.Sleep(10 * time.Millisecond) 147 runnerLogs.PushBack("faster runner.") 148 return sabi.Ok() 149 } 150 151 runner := sabi.Seq(slowerRunner, fasterRunner) 152 err := runner() 153 assert.True(t, err.IsNotOk()) 154 switch err.Reason().(type) { 155 case FailToRun: 156 default: 157 assert.Fail(t, err.Error()) 158 } 159 160 log := runnerLogs.Front() 161 assert.Nil(t, log) 162 } 163 164 func TestSeq_failToRunLatterRunner(t *testing.T) { 165 clearRunnerLogs() 166 defer clearRunnerLogs() 167 168 type FailToRun struct{} 169 170 slowerRunner := func() sabi.Err { 171 time.Sleep(50 * time.Millisecond) 172 runnerLogs.PushBack("slower runner.") 173 return sabi.Ok() 174 } 175 176 fasterRunner := func() sabi.Err { 177 time.Sleep(10 * time.Millisecond) 178 return sabi.NewErr(FailToRun{}) 179 } 180 181 runner := sabi.Seq(slowerRunner, fasterRunner) 182 err := runner() 183 assert.True(t, err.IsNotOk()) 184 switch err.Reason().(type) { 185 case FailToRun: 186 default: 187 assert.Fail(t, err.Error()) 188 } 189 190 log := runnerLogs.Front() 191 assert.Equal(t, log.Value, "slower runner.") 192 log = log.Next() 193 assert.Nil(t, log) 194 } 195 196 func TestRunPara(t *testing.T) { 197 clearRunnerLogs() 198 defer clearRunnerLogs() 199 200 slowerRunner := func() sabi.Err { 201 time.Sleep(50 * time.Millisecond) 202 runnerLogs.PushBack("slower runner.") 203 return sabi.Ok() 204 } 205 206 fasterRunner := func() sabi.Err { 207 time.Sleep(10 * time.Millisecond) 208 runnerLogs.PushBack("faster runner.") 209 return sabi.Ok() 210 } 211 212 err := sabi.RunPara(slowerRunner, fasterRunner) 213 assert.True(t, err.IsOk()) 214 215 log := runnerLogs.Front() 216 assert.Equal(t, log.Value, "faster runner.") 217 log = log.Next() 218 assert.Equal(t, log.Value, "slower runner.") 219 log = log.Next() 220 assert.Nil(t, log) 221 } 222 223 func TestRunPara_failToRunFormerRunner(t *testing.T) { 224 clearRunnerLogs() 225 defer clearRunnerLogs() 226 227 type FailToRun struct{} 228 229 slowerRunner := func() sabi.Err { 230 time.Sleep(50 * time.Millisecond) 231 return sabi.NewErr(FailToRun{}) 232 } 233 234 fasterRunner := func() sabi.Err { 235 time.Sleep(10 * time.Millisecond) 236 runnerLogs.PushBack("faster runner.") 237 return sabi.Ok() 238 } 239 240 err := sabi.RunPara(slowerRunner, fasterRunner) 241 assert.True(t, err.IsNotOk()) 242 switch err.Reason().(type) { 243 case sabi.FailToRunInParallel: 244 errs := err.Reason().(sabi.FailToRunInParallel).Errors 245 assert.Equal(t, len(errs), 1) 246 switch errs[0].Reason().(type) { 247 case FailToRun: 248 default: 249 assert.Fail(t, errs[0].Error()) 250 } 251 default: 252 assert.Fail(t, err.Error()) 253 } 254 255 log := runnerLogs.Front() 256 assert.Equal(t, log.Value, "faster runner.") 257 log = log.Next() 258 assert.Nil(t, log) 259 } 260 261 func TestRunPara_failToRunLatterRunner(t *testing.T) { 262 clearRunnerLogs() 263 defer clearRunnerLogs() 264 265 type FailToRun struct{} 266 267 slowerRunner := func() sabi.Err { 268 time.Sleep(50 * time.Millisecond) 269 runnerLogs.PushBack("slower runner.") 270 return sabi.Ok() 271 } 272 273 fasterRunner := func() sabi.Err { 274 time.Sleep(10 * time.Millisecond) 275 return sabi.NewErr(FailToRun{}) 276 } 277 278 err := sabi.RunPara(slowerRunner, fasterRunner) 279 assert.True(t, err.IsNotOk()) 280 switch err.Reason().(type) { 281 case sabi.FailToRunInParallel: 282 errs := err.Reason().(sabi.FailToRunInParallel).Errors 283 assert.Equal(t, len(errs), 1) 284 switch errs[1].Reason().(type) { 285 case FailToRun: 286 default: 287 assert.Fail(t, errs[1].Error()) 288 } 289 default: 290 assert.Fail(t, err.Error()) 291 } 292 293 log := runnerLogs.Front() 294 assert.Equal(t, log.Value, "slower runner.") 295 log = log.Next() 296 assert.Nil(t, log) 297 } 298 299 func TestPara(t *testing.T) { 300 clearRunnerLogs() 301 defer clearRunnerLogs() 302 303 slowerRunner := func() sabi.Err { 304 time.Sleep(50 * time.Millisecond) 305 runnerLogs.PushBack("slower runner.") 306 return sabi.Ok() 307 } 308 309 fasterRunner := func() sabi.Err { 310 time.Sleep(10 * time.Millisecond) 311 runnerLogs.PushBack("faster runner.") 312 return sabi.Ok() 313 } 314 315 runner := sabi.Para(slowerRunner, fasterRunner) 316 err := runner() 317 assert.True(t, err.IsOk()) 318 319 log := runnerLogs.Front() 320 assert.Equal(t, log.Value, "faster runner.") 321 log = log.Next() 322 assert.Equal(t, log.Value, "slower runner.") 323 log = log.Next() 324 assert.Nil(t, log) 325 } 326 327 func TestPara_failToRunSlowerRunner(t *testing.T) { 328 clearRunnerLogs() 329 defer clearRunnerLogs() 330 331 type FailToRun struct{} 332 333 slowerRunner := func() sabi.Err { 334 time.Sleep(50 * time.Millisecond) 335 return sabi.NewErr(FailToRun{}) 336 } 337 338 fasterRunner := func() sabi.Err { 339 time.Sleep(10 * time.Millisecond) 340 runnerLogs.PushBack("faster runner.") 341 return sabi.Ok() 342 } 343 344 runner := sabi.Para(slowerRunner, fasterRunner) 345 err := runner() 346 assert.True(t, err.IsNotOk()) 347 switch err.Reason().(type) { 348 case sabi.FailToRunInParallel: 349 errs := err.Reason().(sabi.FailToRunInParallel).Errors 350 assert.Equal(t, len(errs), 1) 351 switch errs[0].Reason().(type) { 352 case FailToRun: 353 default: 354 assert.Fail(t, errs[1].Error()) 355 } 356 default: 357 assert.Fail(t, err.Error()) 358 } 359 360 log := runnerLogs.Front() 361 assert.Equal(t, log.Value, "faster runner.") 362 log = log.Next() 363 assert.Nil(t, log) 364 } 365 366 func TestPara_failToRunFasterRunner(t *testing.T) { 367 clearRunnerLogs() 368 defer clearRunnerLogs() 369 370 type FailToRun struct{} 371 372 slowerRunner := func() sabi.Err { 373 time.Sleep(50 * time.Millisecond) 374 runnerLogs.PushBack("slower runner.") 375 return sabi.Ok() 376 } 377 378 fasterRunner := func() sabi.Err { 379 time.Sleep(10 * time.Millisecond) 380 return sabi.NewErr(FailToRun{}) 381 } 382 383 runner := sabi.Para(slowerRunner, fasterRunner) 384 err := runner() 385 assert.True(t, err.IsNotOk()) 386 switch err.Reason().(type) { 387 case sabi.FailToRunInParallel: 388 errs := err.Reason().(sabi.FailToRunInParallel).Errors 389 assert.Equal(t, len(errs), 1) 390 switch errs[1].Reason().(type) { 391 case FailToRun: 392 default: 393 assert.Fail(t, errs[1].Error()) 394 } 395 default: 396 assert.Fail(t, err.Error()) 397 } 398 399 log := runnerLogs.Front() 400 assert.Equal(t, log.Value, "slower runner.") 401 log = log.Next() 402 assert.Nil(t, log) 403 } 404 405 func TestRunner_ifOk(t *testing.T) { 406 slowerRunner := func() sabi.Err { 407 time.Sleep(50 * time.Millisecond) 408 runnerLogs.PushBack("slower runner.") 409 return sabi.Ok() 410 } 411 412 fasterRunner := func() sabi.Err { 413 time.Sleep(10 * time.Millisecond) 414 runnerLogs.PushBack("faster runner.") 415 return sabi.Ok() 416 } 417 418 seq0 := sabi.Seq(slowerRunner) 419 seq1 := sabi.Seq(fasterRunner) 420 421 err := seq0().IfOk(seq1) 422 assert.True(t, err.IsOk()) 423 424 log := runnerLogs.Front() 425 assert.Equal(t, log.Value, "slower runner.") 426 log = log.Next() 427 assert.Equal(t, log.Value, "faster runner.") 428 log = log.Next() 429 assert.Nil(t, log) 430 }