github.com/operator-framework/operator-lifecycle-manager@v0.30.0/pkg/fakes/fake_reconciler.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package fakes
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/operator-framework/api/pkg/operators/v1alpha1"
     8  	"github.com/operator-framework/operator-lifecycle-manager/pkg/controller/registry/reconciler"
     9  	"github.com/sirupsen/logrus"
    10  )
    11  
    12  type FakeRegistryReconciler struct {
    13  	CheckRegistryServerStub        func(*logrus.Entry, *v1alpha1.CatalogSource) (bool, error)
    14  	checkRegistryServerMutex       sync.RWMutex
    15  	checkRegistryServerArgsForCall []struct {
    16  		arg1 *logrus.Entry
    17  		arg2 *v1alpha1.CatalogSource
    18  	}
    19  	checkRegistryServerReturns struct {
    20  		result1 bool
    21  		result2 error
    22  	}
    23  	checkRegistryServerReturnsOnCall map[int]struct {
    24  		result1 bool
    25  		result2 error
    26  	}
    27  	EnsureRegistryServerStub        func(*logrus.Entry, *v1alpha1.CatalogSource) error
    28  	ensureRegistryServerMutex       sync.RWMutex
    29  	ensureRegistryServerArgsForCall []struct {
    30  		arg1 *logrus.Entry
    31  		arg2 *v1alpha1.CatalogSource
    32  	}
    33  	ensureRegistryServerReturns struct {
    34  		result1 error
    35  	}
    36  	ensureRegistryServerReturnsOnCall map[int]struct {
    37  		result1 error
    38  	}
    39  	invocations      map[string][][]interface{}
    40  	invocationsMutex sync.RWMutex
    41  }
    42  
    43  func (fake *FakeRegistryReconciler) CheckRegistryServer(arg1 *logrus.Entry, arg2 *v1alpha1.CatalogSource) (bool, error) {
    44  	fake.checkRegistryServerMutex.Lock()
    45  	ret, specificReturn := fake.checkRegistryServerReturnsOnCall[len(fake.checkRegistryServerArgsForCall)]
    46  	fake.checkRegistryServerArgsForCall = append(fake.checkRegistryServerArgsForCall, struct {
    47  		arg1 *logrus.Entry
    48  		arg2 *v1alpha1.CatalogSource
    49  	}{arg1, arg2})
    50  	stub := fake.CheckRegistryServerStub
    51  	fakeReturns := fake.checkRegistryServerReturns
    52  	fake.recordInvocation("CheckRegistryServer", []interface{}{arg1, arg2})
    53  	fake.checkRegistryServerMutex.Unlock()
    54  	if stub != nil {
    55  		return stub(arg1, arg2)
    56  	}
    57  	if specificReturn {
    58  		return ret.result1, ret.result2
    59  	}
    60  	return fakeReturns.result1, fakeReturns.result2
    61  }
    62  
    63  func (fake *FakeRegistryReconciler) CheckRegistryServerCallCount() int {
    64  	fake.checkRegistryServerMutex.RLock()
    65  	defer fake.checkRegistryServerMutex.RUnlock()
    66  	return len(fake.checkRegistryServerArgsForCall)
    67  }
    68  
    69  func (fake *FakeRegistryReconciler) CheckRegistryServerCalls(stub func(*logrus.Entry, *v1alpha1.CatalogSource) (bool, error)) {
    70  	fake.checkRegistryServerMutex.Lock()
    71  	defer fake.checkRegistryServerMutex.Unlock()
    72  	fake.CheckRegistryServerStub = stub
    73  }
    74  
    75  func (fake *FakeRegistryReconciler) CheckRegistryServerArgsForCall(i int) (*logrus.Entry, *v1alpha1.CatalogSource) {
    76  	fake.checkRegistryServerMutex.RLock()
    77  	defer fake.checkRegistryServerMutex.RUnlock()
    78  	argsForCall := fake.checkRegistryServerArgsForCall[i]
    79  	return argsForCall.arg1, argsForCall.arg2
    80  }
    81  
    82  func (fake *FakeRegistryReconciler) CheckRegistryServerReturns(result1 bool, result2 error) {
    83  	fake.checkRegistryServerMutex.Lock()
    84  	defer fake.checkRegistryServerMutex.Unlock()
    85  	fake.CheckRegistryServerStub = nil
    86  	fake.checkRegistryServerReturns = struct {
    87  		result1 bool
    88  		result2 error
    89  	}{result1, result2}
    90  }
    91  
    92  func (fake *FakeRegistryReconciler) CheckRegistryServerReturnsOnCall(i int, result1 bool, result2 error) {
    93  	fake.checkRegistryServerMutex.Lock()
    94  	defer fake.checkRegistryServerMutex.Unlock()
    95  	fake.CheckRegistryServerStub = nil
    96  	if fake.checkRegistryServerReturnsOnCall == nil {
    97  		fake.checkRegistryServerReturnsOnCall = make(map[int]struct {
    98  			result1 bool
    99  			result2 error
   100  		})
   101  	}
   102  	fake.checkRegistryServerReturnsOnCall[i] = struct {
   103  		result1 bool
   104  		result2 error
   105  	}{result1, result2}
   106  }
   107  
   108  func (fake *FakeRegistryReconciler) EnsureRegistryServer(arg1 *logrus.Entry, arg2 *v1alpha1.CatalogSource) error {
   109  	fake.ensureRegistryServerMutex.Lock()
   110  	ret, specificReturn := fake.ensureRegistryServerReturnsOnCall[len(fake.ensureRegistryServerArgsForCall)]
   111  	fake.ensureRegistryServerArgsForCall = append(fake.ensureRegistryServerArgsForCall, struct {
   112  		arg1 *logrus.Entry
   113  		arg2 *v1alpha1.CatalogSource
   114  	}{arg1, arg2})
   115  	stub := fake.EnsureRegistryServerStub
   116  	fakeReturns := fake.ensureRegistryServerReturns
   117  	fake.recordInvocation("EnsureRegistryServer", []interface{}{arg1, arg2})
   118  	fake.ensureRegistryServerMutex.Unlock()
   119  	if stub != nil {
   120  		return stub(arg1, arg2)
   121  	}
   122  	if specificReturn {
   123  		return ret.result1
   124  	}
   125  	return fakeReturns.result1
   126  }
   127  
   128  func (fake *FakeRegistryReconciler) EnsureRegistryServerCallCount() int {
   129  	fake.ensureRegistryServerMutex.RLock()
   130  	defer fake.ensureRegistryServerMutex.RUnlock()
   131  	return len(fake.ensureRegistryServerArgsForCall)
   132  }
   133  
   134  func (fake *FakeRegistryReconciler) EnsureRegistryServerCalls(stub func(*logrus.Entry, *v1alpha1.CatalogSource) error) {
   135  	fake.ensureRegistryServerMutex.Lock()
   136  	defer fake.ensureRegistryServerMutex.Unlock()
   137  	fake.EnsureRegistryServerStub = stub
   138  }
   139  
   140  func (fake *FakeRegistryReconciler) EnsureRegistryServerArgsForCall(i int) (*logrus.Entry, *v1alpha1.CatalogSource) {
   141  	fake.ensureRegistryServerMutex.RLock()
   142  	defer fake.ensureRegistryServerMutex.RUnlock()
   143  	argsForCall := fake.ensureRegistryServerArgsForCall[i]
   144  	return argsForCall.arg1, argsForCall.arg2
   145  }
   146  
   147  func (fake *FakeRegistryReconciler) EnsureRegistryServerReturns(result1 error) {
   148  	fake.ensureRegistryServerMutex.Lock()
   149  	defer fake.ensureRegistryServerMutex.Unlock()
   150  	fake.EnsureRegistryServerStub = nil
   151  	fake.ensureRegistryServerReturns = struct {
   152  		result1 error
   153  	}{result1}
   154  }
   155  
   156  func (fake *FakeRegistryReconciler) EnsureRegistryServerReturnsOnCall(i int, result1 error) {
   157  	fake.ensureRegistryServerMutex.Lock()
   158  	defer fake.ensureRegistryServerMutex.Unlock()
   159  	fake.EnsureRegistryServerStub = nil
   160  	if fake.ensureRegistryServerReturnsOnCall == nil {
   161  		fake.ensureRegistryServerReturnsOnCall = make(map[int]struct {
   162  			result1 error
   163  		})
   164  	}
   165  	fake.ensureRegistryServerReturnsOnCall[i] = struct {
   166  		result1 error
   167  	}{result1}
   168  }
   169  
   170  func (fake *FakeRegistryReconciler) Invocations() map[string][][]interface{} {
   171  	fake.invocationsMutex.RLock()
   172  	defer fake.invocationsMutex.RUnlock()
   173  	fake.checkRegistryServerMutex.RLock()
   174  	defer fake.checkRegistryServerMutex.RUnlock()
   175  	fake.ensureRegistryServerMutex.RLock()
   176  	defer fake.ensureRegistryServerMutex.RUnlock()
   177  	copiedInvocations := map[string][][]interface{}{}
   178  	for key, value := range fake.invocations {
   179  		copiedInvocations[key] = value
   180  	}
   181  	return copiedInvocations
   182  }
   183  
   184  func (fake *FakeRegistryReconciler) recordInvocation(key string, args []interface{}) {
   185  	fake.invocationsMutex.Lock()
   186  	defer fake.invocationsMutex.Unlock()
   187  	if fake.invocations == nil {
   188  		fake.invocations = map[string][][]interface{}{}
   189  	}
   190  	if fake.invocations[key] == nil {
   191  		fake.invocations[key] = [][]interface{}{}
   192  	}
   193  	fake.invocations[key] = append(fake.invocations[key], args)
   194  }
   195  
   196  var _ reconciler.RegistryReconciler = new(FakeRegistryReconciler)