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  }