github.com/argoproj/argo-cd@v1.8.7/reposerver/repository/lock_test.go (about)

     1  package repository
     2  
     3  import (
     4  	"errors"
     5  	"io"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  
    11  	util "github.com/argoproj/argo-cd/util/io"
    12  )
    13  
    14  // execute given action and return false if action have not completed within 1 second
    15  func lockQuickly(action func() (io.Closer, error)) (io.Closer, bool) {
    16  	done := make(chan io.Closer)
    17  	go func() {
    18  		closer, _ := action()
    19  		done <- closer
    20  	}()
    21  	select {
    22  	case <-time.After(1 * time.Second):
    23  		return nil, false
    24  	case closer := <-done:
    25  		return closer, true
    26  	}
    27  }
    28  
    29  func numberOfInits(initializedTimes *int) func() error {
    30  	return func() error {
    31  		*initializedTimes++
    32  		return nil
    33  	}
    34  }
    35  
    36  func TestLock_SameRevision(t *testing.T) {
    37  	lock := NewRepositoryLock()
    38  	initializedTimes := 0
    39  	init := numberOfInits(&initializedTimes)
    40  	closer1, done := lockQuickly(func() (io.Closer, error) {
    41  		return lock.Lock("myRepo", "1", true, init)
    42  	})
    43  
    44  	if !assert.True(t, done) {
    45  		return
    46  	}
    47  
    48  	closer2, done := lockQuickly(func() (io.Closer, error) {
    49  		return lock.Lock("myRepo", "1", true, init)
    50  	})
    51  
    52  	if !assert.True(t, done) {
    53  		return
    54  	}
    55  
    56  	assert.Equal(t, 1, initializedTimes)
    57  
    58  	util.Close(closer1)
    59  
    60  	util.Close(closer2)
    61  }
    62  
    63  func TestLock_DifferentRevisions(t *testing.T) {
    64  	lock := NewRepositoryLock()
    65  	initializedTimes := 0
    66  	init := numberOfInits(&initializedTimes)
    67  
    68  	closer1, done := lockQuickly(func() (io.Closer, error) {
    69  		return lock.Lock("myRepo", "1", true, init)
    70  	})
    71  
    72  	if !assert.True(t, done) {
    73  		return
    74  	}
    75  
    76  	_, done = lockQuickly(func() (io.Closer, error) {
    77  		return lock.Lock("myRepo", "2", true, init)
    78  	})
    79  
    80  	if !assert.False(t, done) {
    81  		return
    82  	}
    83  
    84  	util.Close(closer1)
    85  
    86  	_, done = lockQuickly(func() (io.Closer, error) {
    87  		return lock.Lock("myRepo", "2", true, init)
    88  	})
    89  
    90  	if !assert.True(t, done) {
    91  		return
    92  	}
    93  }
    94  
    95  func TestLock_NoConcurrentWithSameRevision(t *testing.T) {
    96  	lock := NewRepositoryLock()
    97  	initializedTimes := 0
    98  	init := numberOfInits(&initializedTimes)
    99  
   100  	closer1, done := lockQuickly(func() (io.Closer, error) {
   101  		return lock.Lock("myRepo", "1", false, init)
   102  	})
   103  
   104  	if !assert.True(t, done) {
   105  		return
   106  	}
   107  
   108  	_, done = lockQuickly(func() (io.Closer, error) {
   109  		return lock.Lock("myRepo", "1", false, init)
   110  	})
   111  
   112  	if !assert.False(t, done) {
   113  		return
   114  	}
   115  
   116  	util.Close(closer1)
   117  }
   118  
   119  func TestLock_FailedInitialization(t *testing.T) {
   120  	lock := NewRepositoryLock()
   121  
   122  	closer1, done := lockQuickly(func() (io.Closer, error) {
   123  		return lock.Lock("myRepo", "1", true, func() error {
   124  			return errors.New("failed")
   125  		})
   126  	})
   127  
   128  	if !assert.True(t, done) {
   129  		return
   130  	}
   131  
   132  	assert.Nil(t, closer1)
   133  
   134  	closer2, done := lockQuickly(func() (io.Closer, error) {
   135  		return lock.Lock("myRepo", "1", true, func() error {
   136  			return nil
   137  		})
   138  	})
   139  
   140  	if !assert.True(t, done) {
   141  		return
   142  	}
   143  
   144  	util.Close(closer2)
   145  }
   146  
   147  func TestLock_SameRevisionFirstNotConcurrent(t *testing.T) {
   148  	lock := NewRepositoryLock()
   149  	initializedTimes := 0
   150  	init := numberOfInits(&initializedTimes)
   151  	closer1, done := lockQuickly(func() (io.Closer, error) {
   152  		return lock.Lock("myRepo", "1", false, init)
   153  	})
   154  
   155  	if !assert.True(t, done) {
   156  		return
   157  	}
   158  
   159  	_, done = lockQuickly(func() (io.Closer, error) {
   160  		return lock.Lock("myRepo", "1", true, init)
   161  	})
   162  
   163  	if !assert.False(t, done) {
   164  		return
   165  	}
   166  
   167  	assert.Equal(t, 1, initializedTimes)
   168  
   169  	util.Close(closer1)
   170  }