github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/pkg/persistence/txtest/txtest.go (about)

     1  package txtest
     2  
     3  import (
     4  	"context"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/pkg/persistence"
     7  	"github.com/kyma-incubator/compass/components/director/pkg/persistence/automock"
     8  	"github.com/stretchr/testify/mock"
     9  )
    10  
    11  // PersistenceContextThatExpectsCommit missing godoc
    12  func PersistenceContextThatExpectsCommit() *automock.PersistenceTx {
    13  	persistTx := &automock.PersistenceTx{}
    14  	persistTx.On("Commit").Return(nil).Once()
    15  	return persistTx
    16  }
    17  
    18  // PersistenceContextThatDoesntExpectCommit missing godoc
    19  func PersistenceContextThatDoesntExpectCommit() *automock.PersistenceTx {
    20  	persistTx := &automock.PersistenceTx{}
    21  	return persistTx
    22  }
    23  
    24  // TransactionerThatSucceeds missing godoc
    25  func TransactionerThatSucceeds(persistTx *automock.PersistenceTx) *automock.Transactioner {
    26  	transact := &automock.Transactioner{}
    27  	transact.On("Begin").Return(persistTx, nil).Once()
    28  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(false).Once()
    29  	return transact
    30  }
    31  
    32  // TransactionerThatSucceedsTwice missing godoc
    33  func TransactionerThatSucceedsTwice(persistTx *automock.PersistenceTx) *automock.Transactioner {
    34  	transact := &automock.Transactioner{}
    35  	transact.On("Begin").Return(persistTx, nil).Twice()
    36  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(false).Twice()
    37  	return transact
    38  }
    39  
    40  // TransactionerThatDoesARollback missing godoc
    41  func TransactionerThatDoesARollback(persistTx *automock.PersistenceTx) *automock.Transactioner {
    42  	transact := &automock.Transactioner{}
    43  	transact.On("Begin").Return(persistTx, nil).Once()
    44  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(true).Once()
    45  	return transact
    46  }
    47  
    48  // TransactionerThatDoesARollbackTwice missing godoc
    49  func TransactionerThatDoesARollbackTwice(persistTx *automock.PersistenceTx) *automock.Transactioner {
    50  	transact := &automock.Transactioner{}
    51  	transact.On("Begin").Return(persistTx, nil).Twice()
    52  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(true).Twice()
    53  	return transact
    54  }
    55  
    56  // NoopTransactioner missing godoc
    57  func NoopTransactioner(_ *automock.PersistenceTx) *automock.Transactioner {
    58  	return &automock.Transactioner{}
    59  }
    60  
    61  // CtxWithDBMatcher missing godoc
    62  func CtxWithDBMatcher() interface{} {
    63  	return mock.MatchedBy(func(ctx context.Context) bool {
    64  		persistenceOp, err := persistence.FromCtx(ctx)
    65  		return err == nil && persistenceOp != nil
    66  	})
    67  }
    68  
    69  type txCtxGenerator struct {
    70  	returnedError error
    71  }
    72  
    73  // NewTransactionContextGenerator missing godoc
    74  func NewTransactionContextGenerator(potentialError error) *txCtxGenerator {
    75  	return &txCtxGenerator{returnedError: potentialError}
    76  }
    77  
    78  // ThatSucceeds missing godoc
    79  func (g txCtxGenerator) ThatSucceeds() (*automock.PersistenceTx, *automock.Transactioner) {
    80  	return g.ThatSucceedsMultipleTimes(1)
    81  }
    82  
    83  func (g txCtxGenerator) ThatSucceedsTwice() (*automock.PersistenceTx, *automock.Transactioner) {
    84  	return g.ThatSucceedsMultipleTimes(2)
    85  }
    86  
    87  // ThatSucceedsMultipleTimes missing godoc
    88  func (g txCtxGenerator) ThatSucceedsMultipleTimes(times int) (*automock.PersistenceTx, *automock.Transactioner) {
    89  	persistTx := &automock.PersistenceTx{}
    90  	persistTx.On("Commit").Return(nil).Times(times)
    91  
    92  	transact := &automock.Transactioner{}
    93  	transact.On("Begin").Return(persistTx, nil).Times(times)
    94  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(false).Times(times)
    95  
    96  	return persistTx, transact
    97  }
    98  
    99  // ThatSucceedsMultipleTimesAndCommitsMultipleTimes missing godoc
   100  func (g txCtxGenerator) ThatSucceedsMultipleTimesAndCommitsMultipleTimes(begins, commits int) (*automock.PersistenceTx, *automock.Transactioner) {
   101  	persistTx := &automock.PersistenceTx{}
   102  	persistTx.On("Commit").Return(nil).Times(commits)
   103  
   104  	transact := &automock.Transactioner{}
   105  	transact.On("Begin").Return(persistTx, nil).Times(begins)
   106  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(false).Times(begins)
   107  
   108  	return persistTx, transact
   109  }
   110  
   111  // ThatDoesntExpectCommit missing godoc
   112  func (g txCtxGenerator) ThatDoesntExpectCommit() (*automock.PersistenceTx, *automock.Transactioner) {
   113  	persistTx := &automock.PersistenceTx{}
   114  
   115  	transact := &automock.Transactioner{}
   116  	transact.On("Begin").Return(persistTx, nil).Once()
   117  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(true).Once()
   118  
   119  	return persistTx, transact
   120  }
   121  
   122  // ThatFailsOnCommit missing godoc
   123  func (g txCtxGenerator) ThatFailsOnCommit() (*automock.PersistenceTx, *automock.Transactioner) {
   124  	persistTx := &automock.PersistenceTx{}
   125  	persistTx.On("Commit").Return(g.returnedError).Once()
   126  
   127  	transact := &automock.Transactioner{}
   128  	transact.On("Begin").Return(persistTx, nil).Once()
   129  	transact.On("RollbackUnlessCommitted", mock.Anything, persistTx).Return(true).Once()
   130  
   131  	return persistTx, transact
   132  }
   133  
   134  // ThatFailsOnBegin missing godoc
   135  func (g txCtxGenerator) ThatFailsOnBegin() (*automock.PersistenceTx, *automock.Transactioner) {
   136  	persistTx := &automock.PersistenceTx{}
   137  
   138  	transact := &automock.Transactioner{}
   139  	transact.On("Begin").Return(persistTx, g.returnedError).Once()
   140  
   141  	return persistTx, transact
   142  }
   143  
   144  // ThatDoesntStartTransaction missing godoc
   145  func (g txCtxGenerator) ThatDoesntStartTransaction() (*automock.PersistenceTx, *automock.Transactioner) {
   146  	persistTx := &automock.PersistenceTx{}
   147  	transact := &automock.Transactioner{}
   148  
   149  	return persistTx, transact
   150  }