github.com/IBM-Blockchain/fabric-operator@v1.0.4/pkg/action/mocks/deploymentreset.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package mocks
     3  
     4  import (
     5  	"sync"
     6  
     7  	"github.com/IBM-Blockchain/fabric-operator/pkg/action"
     8  	v1 "k8s.io/api/apps/v1"
     9  	v1a "k8s.io/apimachinery/pkg/apis/meta/v1"
    10  	"k8s.io/apimachinery/pkg/runtime"
    11  	"sigs.k8s.io/controller-runtime/pkg/client"
    12  )
    13  
    14  type DeploymentReset struct {
    15  	DeploymentStatusStub        func(v1a.Object) (v1.DeploymentStatus, error)
    16  	deploymentStatusMutex       sync.RWMutex
    17  	deploymentStatusArgsForCall []struct {
    18  		arg1 v1a.Object
    19  	}
    20  	deploymentStatusReturns struct {
    21  		result1 v1.DeploymentStatus
    22  		result2 error
    23  	}
    24  	deploymentStatusReturnsOnCall map[int]struct {
    25  		result1 v1.DeploymentStatus
    26  		result2 error
    27  	}
    28  	GetStub        func(v1a.Object) (client.Object, error)
    29  	getMutex       sync.RWMutex
    30  	getArgsForCall []struct {
    31  		arg1 v1a.Object
    32  	}
    33  	getReturns struct {
    34  		result1 client.Object
    35  		result2 error
    36  	}
    37  	getReturnsOnCall map[int]struct {
    38  		result1 client.Object
    39  		result2 error
    40  	}
    41  	GetSchemeStub        func() *runtime.Scheme
    42  	getSchemeMutex       sync.RWMutex
    43  	getSchemeArgsForCall []struct {
    44  	}
    45  	getSchemeReturns struct {
    46  		result1 *runtime.Scheme
    47  	}
    48  	getSchemeReturnsOnCall map[int]struct {
    49  		result1 *runtime.Scheme
    50  	}
    51  	invocations      map[string][][]interface{}
    52  	invocationsMutex sync.RWMutex
    53  }
    54  
    55  func (fake *DeploymentReset) DeploymentStatus(arg1 v1a.Object) (v1.DeploymentStatus, error) {
    56  	fake.deploymentStatusMutex.Lock()
    57  	ret, specificReturn := fake.deploymentStatusReturnsOnCall[len(fake.deploymentStatusArgsForCall)]
    58  	fake.deploymentStatusArgsForCall = append(fake.deploymentStatusArgsForCall, struct {
    59  		arg1 v1a.Object
    60  	}{arg1})
    61  	stub := fake.DeploymentStatusStub
    62  	fakeReturns := fake.deploymentStatusReturns
    63  	fake.recordInvocation("DeploymentStatus", []interface{}{arg1})
    64  	fake.deploymentStatusMutex.Unlock()
    65  	if stub != nil {
    66  		return stub(arg1)
    67  	}
    68  	if specificReturn {
    69  		return ret.result1, ret.result2
    70  	}
    71  	return fakeReturns.result1, fakeReturns.result2
    72  }
    73  
    74  func (fake *DeploymentReset) DeploymentStatusCallCount() int {
    75  	fake.deploymentStatusMutex.RLock()
    76  	defer fake.deploymentStatusMutex.RUnlock()
    77  	return len(fake.deploymentStatusArgsForCall)
    78  }
    79  
    80  func (fake *DeploymentReset) DeploymentStatusCalls(stub func(v1a.Object) (v1.DeploymentStatus, error)) {
    81  	fake.deploymentStatusMutex.Lock()
    82  	defer fake.deploymentStatusMutex.Unlock()
    83  	fake.DeploymentStatusStub = stub
    84  }
    85  
    86  func (fake *DeploymentReset) DeploymentStatusArgsForCall(i int) v1a.Object {
    87  	fake.deploymentStatusMutex.RLock()
    88  	defer fake.deploymentStatusMutex.RUnlock()
    89  	argsForCall := fake.deploymentStatusArgsForCall[i]
    90  	return argsForCall.arg1
    91  }
    92  
    93  func (fake *DeploymentReset) DeploymentStatusReturns(result1 v1.DeploymentStatus, result2 error) {
    94  	fake.deploymentStatusMutex.Lock()
    95  	defer fake.deploymentStatusMutex.Unlock()
    96  	fake.DeploymentStatusStub = nil
    97  	fake.deploymentStatusReturns = struct {
    98  		result1 v1.DeploymentStatus
    99  		result2 error
   100  	}{result1, result2}
   101  }
   102  
   103  func (fake *DeploymentReset) DeploymentStatusReturnsOnCall(i int, result1 v1.DeploymentStatus, result2 error) {
   104  	fake.deploymentStatusMutex.Lock()
   105  	defer fake.deploymentStatusMutex.Unlock()
   106  	fake.DeploymentStatusStub = nil
   107  	if fake.deploymentStatusReturnsOnCall == nil {
   108  		fake.deploymentStatusReturnsOnCall = make(map[int]struct {
   109  			result1 v1.DeploymentStatus
   110  			result2 error
   111  		})
   112  	}
   113  	fake.deploymentStatusReturnsOnCall[i] = struct {
   114  		result1 v1.DeploymentStatus
   115  		result2 error
   116  	}{result1, result2}
   117  }
   118  
   119  func (fake *DeploymentReset) Get(arg1 v1a.Object) (client.Object, error) {
   120  	fake.getMutex.Lock()
   121  	ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)]
   122  	fake.getArgsForCall = append(fake.getArgsForCall, struct {
   123  		arg1 v1a.Object
   124  	}{arg1})
   125  	stub := fake.GetStub
   126  	fakeReturns := fake.getReturns
   127  	fake.recordInvocation("Get", []interface{}{arg1})
   128  	fake.getMutex.Unlock()
   129  	if stub != nil {
   130  		return stub(arg1)
   131  	}
   132  	if specificReturn {
   133  		return ret.result1, ret.result2
   134  	}
   135  	return fakeReturns.result1, fakeReturns.result2
   136  }
   137  
   138  func (fake *DeploymentReset) GetCallCount() int {
   139  	fake.getMutex.RLock()
   140  	defer fake.getMutex.RUnlock()
   141  	return len(fake.getArgsForCall)
   142  }
   143  
   144  func (fake *DeploymentReset) GetCalls(stub func(v1a.Object) (client.Object, error)) {
   145  	fake.getMutex.Lock()
   146  	defer fake.getMutex.Unlock()
   147  	fake.GetStub = stub
   148  }
   149  
   150  func (fake *DeploymentReset) GetArgsForCall(i int) v1a.Object {
   151  	fake.getMutex.RLock()
   152  	defer fake.getMutex.RUnlock()
   153  	argsForCall := fake.getArgsForCall[i]
   154  	return argsForCall.arg1
   155  }
   156  
   157  func (fake *DeploymentReset) GetReturns(result1 client.Object, result2 error) {
   158  	fake.getMutex.Lock()
   159  	defer fake.getMutex.Unlock()
   160  	fake.GetStub = nil
   161  	fake.getReturns = struct {
   162  		result1 client.Object
   163  		result2 error
   164  	}{result1, result2}
   165  }
   166  
   167  func (fake *DeploymentReset) GetReturnsOnCall(i int, result1 client.Object, result2 error) {
   168  	fake.getMutex.Lock()
   169  	defer fake.getMutex.Unlock()
   170  	fake.GetStub = nil
   171  	if fake.getReturnsOnCall == nil {
   172  		fake.getReturnsOnCall = make(map[int]struct {
   173  			result1 client.Object
   174  			result2 error
   175  		})
   176  	}
   177  	fake.getReturnsOnCall[i] = struct {
   178  		result1 client.Object
   179  		result2 error
   180  	}{result1, result2}
   181  }
   182  
   183  func (fake *DeploymentReset) GetScheme() *runtime.Scheme {
   184  	fake.getSchemeMutex.Lock()
   185  	ret, specificReturn := fake.getSchemeReturnsOnCall[len(fake.getSchemeArgsForCall)]
   186  	fake.getSchemeArgsForCall = append(fake.getSchemeArgsForCall, struct {
   187  	}{})
   188  	stub := fake.GetSchemeStub
   189  	fakeReturns := fake.getSchemeReturns
   190  	fake.recordInvocation("GetScheme", []interface{}{})
   191  	fake.getSchemeMutex.Unlock()
   192  	if stub != nil {
   193  		return stub()
   194  	}
   195  	if specificReturn {
   196  		return ret.result1
   197  	}
   198  	return fakeReturns.result1
   199  }
   200  
   201  func (fake *DeploymentReset) GetSchemeCallCount() int {
   202  	fake.getSchemeMutex.RLock()
   203  	defer fake.getSchemeMutex.RUnlock()
   204  	return len(fake.getSchemeArgsForCall)
   205  }
   206  
   207  func (fake *DeploymentReset) GetSchemeCalls(stub func() *runtime.Scheme) {
   208  	fake.getSchemeMutex.Lock()
   209  	defer fake.getSchemeMutex.Unlock()
   210  	fake.GetSchemeStub = stub
   211  }
   212  
   213  func (fake *DeploymentReset) GetSchemeReturns(result1 *runtime.Scheme) {
   214  	fake.getSchemeMutex.Lock()
   215  	defer fake.getSchemeMutex.Unlock()
   216  	fake.GetSchemeStub = nil
   217  	fake.getSchemeReturns = struct {
   218  		result1 *runtime.Scheme
   219  	}{result1}
   220  }
   221  
   222  func (fake *DeploymentReset) GetSchemeReturnsOnCall(i int, result1 *runtime.Scheme) {
   223  	fake.getSchemeMutex.Lock()
   224  	defer fake.getSchemeMutex.Unlock()
   225  	fake.GetSchemeStub = nil
   226  	if fake.getSchemeReturnsOnCall == nil {
   227  		fake.getSchemeReturnsOnCall = make(map[int]struct {
   228  			result1 *runtime.Scheme
   229  		})
   230  	}
   231  	fake.getSchemeReturnsOnCall[i] = struct {
   232  		result1 *runtime.Scheme
   233  	}{result1}
   234  }
   235  
   236  func (fake *DeploymentReset) Invocations() map[string][][]interface{} {
   237  	fake.invocationsMutex.RLock()
   238  	defer fake.invocationsMutex.RUnlock()
   239  	fake.deploymentStatusMutex.RLock()
   240  	defer fake.deploymentStatusMutex.RUnlock()
   241  	fake.getMutex.RLock()
   242  	defer fake.getMutex.RUnlock()
   243  	fake.getSchemeMutex.RLock()
   244  	defer fake.getSchemeMutex.RUnlock()
   245  	copiedInvocations := map[string][][]interface{}{}
   246  	for key, value := range fake.invocations {
   247  		copiedInvocations[key] = value
   248  	}
   249  	return copiedInvocations
   250  }
   251  
   252  func (fake *DeploymentReset) recordInvocation(key string, args []interface{}) {
   253  	fake.invocationsMutex.Lock()
   254  	defer fake.invocationsMutex.Unlock()
   255  	if fake.invocations == nil {
   256  		fake.invocations = map[string][][]interface{}{}
   257  	}
   258  	if fake.invocations[key] == nil {
   259  		fake.invocations[key] = [][]interface{}{}
   260  	}
   261  	fake.invocations[key] = append(fake.invocations[key], args)
   262  }
   263  
   264  var _ action.DeploymentReset = new(DeploymentReset)