github.1485827954.workers.dev/nektos/act@v0.2.63/pkg/common/executor_test.go (about)

     1  package common
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestNewWorkflow(t *testing.T) {
    13  	assert := assert.New(t)
    14  
    15  	ctx := context.Background()
    16  
    17  	// empty
    18  	emptyWorkflow := NewPipelineExecutor()
    19  	assert.Nil(emptyWorkflow(ctx))
    20  
    21  	// error case
    22  	errorWorkflow := NewErrorExecutor(fmt.Errorf("test error"))
    23  	assert.NotNil(errorWorkflow(ctx))
    24  
    25  	// multiple success case
    26  	runcount := 0
    27  	successWorkflow := NewPipelineExecutor(
    28  		func(ctx context.Context) error {
    29  			runcount++
    30  			return nil
    31  		},
    32  		func(ctx context.Context) error {
    33  			runcount++
    34  			return nil
    35  		})
    36  	assert.Nil(successWorkflow(ctx))
    37  	assert.Equal(2, runcount)
    38  }
    39  
    40  func TestNewConditionalExecutor(t *testing.T) {
    41  	assert := assert.New(t)
    42  
    43  	ctx := context.Background()
    44  
    45  	trueCount := 0
    46  	falseCount := 0
    47  
    48  	err := NewConditionalExecutor(func(ctx context.Context) bool {
    49  		return false
    50  	}, func(ctx context.Context) error {
    51  		trueCount++
    52  		return nil
    53  	}, func(ctx context.Context) error {
    54  		falseCount++
    55  		return nil
    56  	})(ctx)
    57  
    58  	assert.Nil(err)
    59  	assert.Equal(0, trueCount)
    60  	assert.Equal(1, falseCount)
    61  
    62  	err = NewConditionalExecutor(func(ctx context.Context) bool {
    63  		return true
    64  	}, func(ctx context.Context) error {
    65  		trueCount++
    66  		return nil
    67  	}, func(ctx context.Context) error {
    68  		falseCount++
    69  		return nil
    70  	})(ctx)
    71  
    72  	assert.Nil(err)
    73  	assert.Equal(1, trueCount)
    74  	assert.Equal(1, falseCount)
    75  }
    76  
    77  func TestNewParallelExecutor(t *testing.T) {
    78  	assert := assert.New(t)
    79  
    80  	ctx := context.Background()
    81  
    82  	count := 0
    83  	activeCount := 0
    84  	maxCount := 0
    85  	emptyWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
    86  		count++
    87  
    88  		activeCount++
    89  		if activeCount > maxCount {
    90  			maxCount = activeCount
    91  		}
    92  		time.Sleep(2 * time.Second)
    93  		activeCount--
    94  
    95  		return nil
    96  	})
    97  
    98  	err := NewParallelExecutor(2, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
    99  
   100  	assert.Equal(3, count, "should run all 3 executors")
   101  	assert.Equal(2, maxCount, "should run at most 2 executors in parallel")
   102  	assert.Nil(err)
   103  
   104  	// Reset to test running the executor with 0 parallelism
   105  	count = 0
   106  	activeCount = 0
   107  	maxCount = 0
   108  
   109  	errSingle := NewParallelExecutor(0, emptyWorkflow, emptyWorkflow, emptyWorkflow)(ctx)
   110  
   111  	assert.Equal(3, count, "should run all 3 executors")
   112  	assert.Equal(1, maxCount, "should run at most 1 executors in parallel")
   113  	assert.Nil(errSingle)
   114  }
   115  
   116  func TestNewParallelExecutorFailed(t *testing.T) {
   117  	assert := assert.New(t)
   118  
   119  	ctx, cancel := context.WithCancel(context.Background())
   120  	cancel()
   121  
   122  	count := 0
   123  	errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
   124  		count++
   125  		return fmt.Errorf("fake error")
   126  	})
   127  	err := NewParallelExecutor(1, errorWorkflow)(ctx)
   128  	assert.Equal(1, count)
   129  	assert.ErrorIs(context.Canceled, err)
   130  }
   131  
   132  func TestNewParallelExecutorCanceled(t *testing.T) {
   133  	assert := assert.New(t)
   134  
   135  	ctx, cancel := context.WithCancel(context.Background())
   136  	cancel()
   137  
   138  	errExpected := fmt.Errorf("fake error")
   139  
   140  	count := 0
   141  	successWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
   142  		count++
   143  		return nil
   144  	})
   145  	errorWorkflow := NewPipelineExecutor(func(ctx context.Context) error {
   146  		count++
   147  		return errExpected
   148  	})
   149  	err := NewParallelExecutor(3, errorWorkflow, successWorkflow, successWorkflow)(ctx)
   150  	assert.Equal(3, count)
   151  	assert.Error(errExpected, err)
   152  }