github.com/goreleaser/goreleaser@v1.25.1/internal/semerrgroup/sem_test.go (about)

     1  package semerrgroup
     2  
     3  import (
     4  	"fmt"
     5  	"sync"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/goreleaser/goreleaser/internal/pipe"
    10  	"github.com/hashicorp/go-multierror"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  func TestSemaphore(t *testing.T) {
    15  	for _, i := range []int{1, 4} {
    16  		t.Run(fmt.Sprintf("limit-%d", i), func(t *testing.T) {
    17  			g := New(i)
    18  			var lock sync.Mutex
    19  			var counter int
    20  			for i := 0; i < 10; i++ {
    21  				g.Go(func() error {
    22  					time.Sleep(10 * time.Millisecond)
    23  					lock.Lock()
    24  					counter++
    25  					lock.Unlock()
    26  					return nil
    27  				})
    28  			}
    29  			require.NoError(t, g.Wait())
    30  			require.Equal(t, 10, counter)
    31  		})
    32  	}
    33  }
    34  
    35  func TestSemaphoreOrder(t *testing.T) {
    36  	num := 10
    37  	g := New(1)
    38  	output := []int{}
    39  	for i := 0; i < num; i++ {
    40  		i := i
    41  		g.Go(func() error {
    42  			output = append(output, i)
    43  			return nil
    44  		})
    45  	}
    46  	require.NoError(t, g.Wait())
    47  	require.Equal(t, []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, output)
    48  }
    49  
    50  func TestSemaphoreError(t *testing.T) {
    51  	for _, i := range []int{1, 4} {
    52  		t.Run(fmt.Sprintf("limit-%d", i), func(t *testing.T) {
    53  			g := New(i)
    54  			var lock sync.Mutex
    55  			output := []int{}
    56  			for i := 0; i < 10; i++ {
    57  				i := i
    58  				g.Go(func() error {
    59  					lock.Lock()
    60  					defer lock.Unlock()
    61  					output = append(output, i)
    62  					return fmt.Errorf("fake err")
    63  				})
    64  			}
    65  			require.EqualError(t, g.Wait(), "fake err")
    66  			require.Len(t, output, 10)
    67  		})
    68  	}
    69  }
    70  
    71  func TestSemaphoreSkipAware(t *testing.T) {
    72  	for _, i := range []int{1, 4} {
    73  		t.Run(fmt.Sprintf("limit-%d", i), func(t *testing.T) {
    74  			g := NewSkipAware(New(i))
    75  			for i := 0; i < 10; i++ {
    76  				g.Go(func() error {
    77  					time.Sleep(10 * time.Millisecond)
    78  					return pipe.Skip("fake skip")
    79  				})
    80  			}
    81  			merr := &multierror.Error{}
    82  			require.ErrorAs(t, g.Wait(), &merr, "must be a multierror")
    83  			require.Len(t, merr.Errors, 10)
    84  		})
    85  	}
    86  }
    87  
    88  func TestSemaphoreSkipAwareSingleError(t *testing.T) {
    89  	for _, i := range []int{1, 4} {
    90  		t.Run(fmt.Sprintf("limit-%d", i), func(t *testing.T) {
    91  			g := NewSkipAware(New(i))
    92  			for i := 0; i < 10; i++ {
    93  				i := i
    94  				g.Go(func() error {
    95  					time.Sleep(10 * time.Millisecond)
    96  					if i == 5 {
    97  						return pipe.Skip("fake skip")
    98  					}
    99  					return nil
   100  				})
   101  			}
   102  			require.EqualError(t, g.Wait(), "fake skip")
   103  		})
   104  	}
   105  }
   106  
   107  func TestSemaphoreSkipAwareNoSkips(t *testing.T) {
   108  	for _, i := range []int{1, 4} {
   109  		t.Run(fmt.Sprintf("limit-%d", i), func(t *testing.T) {
   110  			g := NewSkipAware(New(i))
   111  			for i := 0; i < 10; i++ {
   112  				g.Go(func() error {
   113  					time.Sleep(10 * time.Millisecond)
   114  					return nil
   115  				})
   116  			}
   117  			require.NoError(t, g.Wait())
   118  		})
   119  	}
   120  }
   121  
   122  func TestSemaphoreSkipAndRealError(t *testing.T) {
   123  	g := NewSkipAware(New(10))
   124  	for i := 0; i < 100; i++ {
   125  		g.Go(func() error {
   126  			time.Sleep(10 * time.Millisecond)
   127  			return pipe.Skip("fake skip")
   128  		})
   129  	}
   130  	g.Go(func() error {
   131  		time.Sleep(10 * time.Millisecond)
   132  		return fmt.Errorf("errrrrr")
   133  	})
   134  	require.EqualError(t, g.Wait(), "errrrrr")
   135  }