github.com/IBM-Blockchain/fabric-operator@v1.0.4/pkg/offering/base/ca/mocks/update.go (about)

     1  // Code generated by counterfeiter. DO NOT EDIT.
     2  package mocks
     3  
     4  import (
     5  	"sync"
     6  
     7  	baseca "github.com/IBM-Blockchain/fabric-operator/pkg/offering/base/ca"
     8  )
     9  
    10  type Update struct {
    11  	CACryptoCreatedStub        func() bool
    12  	cACryptoCreatedMutex       sync.RWMutex
    13  	cACryptoCreatedArgsForCall []struct {
    14  	}
    15  	cACryptoCreatedReturns struct {
    16  		result1 bool
    17  	}
    18  	cACryptoCreatedReturnsOnCall map[int]struct {
    19  		result1 bool
    20  	}
    21  	CACryptoUpdatedStub        func() bool
    22  	cACryptoUpdatedMutex       sync.RWMutex
    23  	cACryptoUpdatedArgsForCall []struct {
    24  	}
    25  	cACryptoUpdatedReturns struct {
    26  		result1 bool
    27  	}
    28  	cACryptoUpdatedReturnsOnCall map[int]struct {
    29  		result1 bool
    30  	}
    31  	CAOverridesUpdatedStub        func() bool
    32  	cAOverridesUpdatedMutex       sync.RWMutex
    33  	cAOverridesUpdatedArgsForCall []struct {
    34  	}
    35  	cAOverridesUpdatedReturns struct {
    36  		result1 bool
    37  	}
    38  	cAOverridesUpdatedReturnsOnCall map[int]struct {
    39  		result1 bool
    40  	}
    41  	CATagUpdatedStub        func() bool
    42  	cATagUpdatedMutex       sync.RWMutex
    43  	cATagUpdatedArgsForCall []struct {
    44  	}
    45  	cATagUpdatedReturns struct {
    46  		result1 bool
    47  	}
    48  	cATagUpdatedReturnsOnCall map[int]struct {
    49  		result1 bool
    50  	}
    51  	ConfigOverridesUpdatedStub        func() bool
    52  	configOverridesUpdatedMutex       sync.RWMutex
    53  	configOverridesUpdatedArgsForCall []struct {
    54  	}
    55  	configOverridesUpdatedReturns struct {
    56  		result1 bool
    57  	}
    58  	configOverridesUpdatedReturnsOnCall map[int]struct {
    59  		result1 bool
    60  	}
    61  	FabricVersionUpdatedStub        func() bool
    62  	fabricVersionUpdatedMutex       sync.RWMutex
    63  	fabricVersionUpdatedArgsForCall []struct {
    64  	}
    65  	fabricVersionUpdatedReturns struct {
    66  		result1 bool
    67  	}
    68  	fabricVersionUpdatedReturnsOnCall map[int]struct {
    69  		result1 bool
    70  	}
    71  	ImagesUpdatedStub        func() bool
    72  	imagesUpdatedMutex       sync.RWMutex
    73  	imagesUpdatedArgsForCall []struct {
    74  	}
    75  	imagesUpdatedReturns struct {
    76  		result1 bool
    77  	}
    78  	imagesUpdatedReturnsOnCall map[int]struct {
    79  		result1 bool
    80  	}
    81  	RenewTLSCertStub        func() bool
    82  	renewTLSCertMutex       sync.RWMutex
    83  	renewTLSCertArgsForCall []struct {
    84  	}
    85  	renewTLSCertReturns struct {
    86  		result1 bool
    87  	}
    88  	renewTLSCertReturnsOnCall map[int]struct {
    89  		result1 bool
    90  	}
    91  	RestartNeededStub        func() bool
    92  	restartNeededMutex       sync.RWMutex
    93  	restartNeededArgsForCall []struct {
    94  	}
    95  	restartNeededReturns struct {
    96  		result1 bool
    97  	}
    98  	restartNeededReturnsOnCall map[int]struct {
    99  		result1 bool
   100  	}
   101  	SpecUpdatedStub        func() bool
   102  	specUpdatedMutex       sync.RWMutex
   103  	specUpdatedArgsForCall []struct {
   104  	}
   105  	specUpdatedReturns struct {
   106  		result1 bool
   107  	}
   108  	specUpdatedReturnsOnCall map[int]struct {
   109  		result1 bool
   110  	}
   111  	TLSCAOverridesUpdatedStub        func() bool
   112  	tLSCAOverridesUpdatedMutex       sync.RWMutex
   113  	tLSCAOverridesUpdatedArgsForCall []struct {
   114  	}
   115  	tLSCAOverridesUpdatedReturns struct {
   116  		result1 bool
   117  	}
   118  	tLSCAOverridesUpdatedReturnsOnCall map[int]struct {
   119  		result1 bool
   120  	}
   121  	invocations      map[string][][]interface{}
   122  	invocationsMutex sync.RWMutex
   123  }
   124  
   125  func (fake *Update) CACryptoCreated() bool {
   126  	fake.cACryptoCreatedMutex.Lock()
   127  	ret, specificReturn := fake.cACryptoCreatedReturnsOnCall[len(fake.cACryptoCreatedArgsForCall)]
   128  	fake.cACryptoCreatedArgsForCall = append(fake.cACryptoCreatedArgsForCall, struct {
   129  	}{})
   130  	stub := fake.CACryptoCreatedStub
   131  	fakeReturns := fake.cACryptoCreatedReturns
   132  	fake.recordInvocation("CACryptoCreated", []interface{}{})
   133  	fake.cACryptoCreatedMutex.Unlock()
   134  	if stub != nil {
   135  		return stub()
   136  	}
   137  	if specificReturn {
   138  		return ret.result1
   139  	}
   140  	return fakeReturns.result1
   141  }
   142  
   143  func (fake *Update) CACryptoCreatedCallCount() int {
   144  	fake.cACryptoCreatedMutex.RLock()
   145  	defer fake.cACryptoCreatedMutex.RUnlock()
   146  	return len(fake.cACryptoCreatedArgsForCall)
   147  }
   148  
   149  func (fake *Update) CACryptoCreatedCalls(stub func() bool) {
   150  	fake.cACryptoCreatedMutex.Lock()
   151  	defer fake.cACryptoCreatedMutex.Unlock()
   152  	fake.CACryptoCreatedStub = stub
   153  }
   154  
   155  func (fake *Update) CACryptoCreatedReturns(result1 bool) {
   156  	fake.cACryptoCreatedMutex.Lock()
   157  	defer fake.cACryptoCreatedMutex.Unlock()
   158  	fake.CACryptoCreatedStub = nil
   159  	fake.cACryptoCreatedReturns = struct {
   160  		result1 bool
   161  	}{result1}
   162  }
   163  
   164  func (fake *Update) CACryptoCreatedReturnsOnCall(i int, result1 bool) {
   165  	fake.cACryptoCreatedMutex.Lock()
   166  	defer fake.cACryptoCreatedMutex.Unlock()
   167  	fake.CACryptoCreatedStub = nil
   168  	if fake.cACryptoCreatedReturnsOnCall == nil {
   169  		fake.cACryptoCreatedReturnsOnCall = make(map[int]struct {
   170  			result1 bool
   171  		})
   172  	}
   173  	fake.cACryptoCreatedReturnsOnCall[i] = struct {
   174  		result1 bool
   175  	}{result1}
   176  }
   177  
   178  func (fake *Update) CACryptoUpdated() bool {
   179  	fake.cACryptoUpdatedMutex.Lock()
   180  	ret, specificReturn := fake.cACryptoUpdatedReturnsOnCall[len(fake.cACryptoUpdatedArgsForCall)]
   181  	fake.cACryptoUpdatedArgsForCall = append(fake.cACryptoUpdatedArgsForCall, struct {
   182  	}{})
   183  	stub := fake.CACryptoUpdatedStub
   184  	fakeReturns := fake.cACryptoUpdatedReturns
   185  	fake.recordInvocation("CACryptoUpdated", []interface{}{})
   186  	fake.cACryptoUpdatedMutex.Unlock()
   187  	if stub != nil {
   188  		return stub()
   189  	}
   190  	if specificReturn {
   191  		return ret.result1
   192  	}
   193  	return fakeReturns.result1
   194  }
   195  
   196  func (fake *Update) CACryptoUpdatedCallCount() int {
   197  	fake.cACryptoUpdatedMutex.RLock()
   198  	defer fake.cACryptoUpdatedMutex.RUnlock()
   199  	return len(fake.cACryptoUpdatedArgsForCall)
   200  }
   201  
   202  func (fake *Update) CACryptoUpdatedCalls(stub func() bool) {
   203  	fake.cACryptoUpdatedMutex.Lock()
   204  	defer fake.cACryptoUpdatedMutex.Unlock()
   205  	fake.CACryptoUpdatedStub = stub
   206  }
   207  
   208  func (fake *Update) CACryptoUpdatedReturns(result1 bool) {
   209  	fake.cACryptoUpdatedMutex.Lock()
   210  	defer fake.cACryptoUpdatedMutex.Unlock()
   211  	fake.CACryptoUpdatedStub = nil
   212  	fake.cACryptoUpdatedReturns = struct {
   213  		result1 bool
   214  	}{result1}
   215  }
   216  
   217  func (fake *Update) CACryptoUpdatedReturnsOnCall(i int, result1 bool) {
   218  	fake.cACryptoUpdatedMutex.Lock()
   219  	defer fake.cACryptoUpdatedMutex.Unlock()
   220  	fake.CACryptoUpdatedStub = nil
   221  	if fake.cACryptoUpdatedReturnsOnCall == nil {
   222  		fake.cACryptoUpdatedReturnsOnCall = make(map[int]struct {
   223  			result1 bool
   224  		})
   225  	}
   226  	fake.cACryptoUpdatedReturnsOnCall[i] = struct {
   227  		result1 bool
   228  	}{result1}
   229  }
   230  
   231  func (fake *Update) CAOverridesUpdated() bool {
   232  	fake.cAOverridesUpdatedMutex.Lock()
   233  	ret, specificReturn := fake.cAOverridesUpdatedReturnsOnCall[len(fake.cAOverridesUpdatedArgsForCall)]
   234  	fake.cAOverridesUpdatedArgsForCall = append(fake.cAOverridesUpdatedArgsForCall, struct {
   235  	}{})
   236  	stub := fake.CAOverridesUpdatedStub
   237  	fakeReturns := fake.cAOverridesUpdatedReturns
   238  	fake.recordInvocation("CAOverridesUpdated", []interface{}{})
   239  	fake.cAOverridesUpdatedMutex.Unlock()
   240  	if stub != nil {
   241  		return stub()
   242  	}
   243  	if specificReturn {
   244  		return ret.result1
   245  	}
   246  	return fakeReturns.result1
   247  }
   248  
   249  func (fake *Update) CAOverridesUpdatedCallCount() int {
   250  	fake.cAOverridesUpdatedMutex.RLock()
   251  	defer fake.cAOverridesUpdatedMutex.RUnlock()
   252  	return len(fake.cAOverridesUpdatedArgsForCall)
   253  }
   254  
   255  func (fake *Update) CAOverridesUpdatedCalls(stub func() bool) {
   256  	fake.cAOverridesUpdatedMutex.Lock()
   257  	defer fake.cAOverridesUpdatedMutex.Unlock()
   258  	fake.CAOverridesUpdatedStub = stub
   259  }
   260  
   261  func (fake *Update) CAOverridesUpdatedReturns(result1 bool) {
   262  	fake.cAOverridesUpdatedMutex.Lock()
   263  	defer fake.cAOverridesUpdatedMutex.Unlock()
   264  	fake.CAOverridesUpdatedStub = nil
   265  	fake.cAOverridesUpdatedReturns = struct {
   266  		result1 bool
   267  	}{result1}
   268  }
   269  
   270  func (fake *Update) CAOverridesUpdatedReturnsOnCall(i int, result1 bool) {
   271  	fake.cAOverridesUpdatedMutex.Lock()
   272  	defer fake.cAOverridesUpdatedMutex.Unlock()
   273  	fake.CAOverridesUpdatedStub = nil
   274  	if fake.cAOverridesUpdatedReturnsOnCall == nil {
   275  		fake.cAOverridesUpdatedReturnsOnCall = make(map[int]struct {
   276  			result1 bool
   277  		})
   278  	}
   279  	fake.cAOverridesUpdatedReturnsOnCall[i] = struct {
   280  		result1 bool
   281  	}{result1}
   282  }
   283  
   284  func (fake *Update) CATagUpdated() bool {
   285  	fake.cATagUpdatedMutex.Lock()
   286  	ret, specificReturn := fake.cATagUpdatedReturnsOnCall[len(fake.cATagUpdatedArgsForCall)]
   287  	fake.cATagUpdatedArgsForCall = append(fake.cATagUpdatedArgsForCall, struct {
   288  	}{})
   289  	stub := fake.CATagUpdatedStub
   290  	fakeReturns := fake.cATagUpdatedReturns
   291  	fake.recordInvocation("CATagUpdated", []interface{}{})
   292  	fake.cATagUpdatedMutex.Unlock()
   293  	if stub != nil {
   294  		return stub()
   295  	}
   296  	if specificReturn {
   297  		return ret.result1
   298  	}
   299  	return fakeReturns.result1
   300  }
   301  
   302  func (fake *Update) CATagUpdatedCallCount() int {
   303  	fake.cATagUpdatedMutex.RLock()
   304  	defer fake.cATagUpdatedMutex.RUnlock()
   305  	return len(fake.cATagUpdatedArgsForCall)
   306  }
   307  
   308  func (fake *Update) CATagUpdatedCalls(stub func() bool) {
   309  	fake.cATagUpdatedMutex.Lock()
   310  	defer fake.cATagUpdatedMutex.Unlock()
   311  	fake.CATagUpdatedStub = stub
   312  }
   313  
   314  func (fake *Update) CATagUpdatedReturns(result1 bool) {
   315  	fake.cATagUpdatedMutex.Lock()
   316  	defer fake.cATagUpdatedMutex.Unlock()
   317  	fake.CATagUpdatedStub = nil
   318  	fake.cATagUpdatedReturns = struct {
   319  		result1 bool
   320  	}{result1}
   321  }
   322  
   323  func (fake *Update) CATagUpdatedReturnsOnCall(i int, result1 bool) {
   324  	fake.cATagUpdatedMutex.Lock()
   325  	defer fake.cATagUpdatedMutex.Unlock()
   326  	fake.CATagUpdatedStub = nil
   327  	if fake.cATagUpdatedReturnsOnCall == nil {
   328  		fake.cATagUpdatedReturnsOnCall = make(map[int]struct {
   329  			result1 bool
   330  		})
   331  	}
   332  	fake.cATagUpdatedReturnsOnCall[i] = struct {
   333  		result1 bool
   334  	}{result1}
   335  }
   336  
   337  func (fake *Update) ConfigOverridesUpdated() bool {
   338  	fake.configOverridesUpdatedMutex.Lock()
   339  	ret, specificReturn := fake.configOverridesUpdatedReturnsOnCall[len(fake.configOverridesUpdatedArgsForCall)]
   340  	fake.configOverridesUpdatedArgsForCall = append(fake.configOverridesUpdatedArgsForCall, struct {
   341  	}{})
   342  	stub := fake.ConfigOverridesUpdatedStub
   343  	fakeReturns := fake.configOverridesUpdatedReturns
   344  	fake.recordInvocation("ConfigOverridesUpdated", []interface{}{})
   345  	fake.configOverridesUpdatedMutex.Unlock()
   346  	if stub != nil {
   347  		return stub()
   348  	}
   349  	if specificReturn {
   350  		return ret.result1
   351  	}
   352  	return fakeReturns.result1
   353  }
   354  
   355  func (fake *Update) ConfigOverridesUpdatedCallCount() int {
   356  	fake.configOverridesUpdatedMutex.RLock()
   357  	defer fake.configOverridesUpdatedMutex.RUnlock()
   358  	return len(fake.configOverridesUpdatedArgsForCall)
   359  }
   360  
   361  func (fake *Update) ConfigOverridesUpdatedCalls(stub func() bool) {
   362  	fake.configOverridesUpdatedMutex.Lock()
   363  	defer fake.configOverridesUpdatedMutex.Unlock()
   364  	fake.ConfigOverridesUpdatedStub = stub
   365  }
   366  
   367  func (fake *Update) ConfigOverridesUpdatedReturns(result1 bool) {
   368  	fake.configOverridesUpdatedMutex.Lock()
   369  	defer fake.configOverridesUpdatedMutex.Unlock()
   370  	fake.ConfigOverridesUpdatedStub = nil
   371  	fake.configOverridesUpdatedReturns = struct {
   372  		result1 bool
   373  	}{result1}
   374  }
   375  
   376  func (fake *Update) ConfigOverridesUpdatedReturnsOnCall(i int, result1 bool) {
   377  	fake.configOverridesUpdatedMutex.Lock()
   378  	defer fake.configOverridesUpdatedMutex.Unlock()
   379  	fake.ConfigOverridesUpdatedStub = nil
   380  	if fake.configOverridesUpdatedReturnsOnCall == nil {
   381  		fake.configOverridesUpdatedReturnsOnCall = make(map[int]struct {
   382  			result1 bool
   383  		})
   384  	}
   385  	fake.configOverridesUpdatedReturnsOnCall[i] = struct {
   386  		result1 bool
   387  	}{result1}
   388  }
   389  
   390  func (fake *Update) FabricVersionUpdated() bool {
   391  	fake.fabricVersionUpdatedMutex.Lock()
   392  	ret, specificReturn := fake.fabricVersionUpdatedReturnsOnCall[len(fake.fabricVersionUpdatedArgsForCall)]
   393  	fake.fabricVersionUpdatedArgsForCall = append(fake.fabricVersionUpdatedArgsForCall, struct {
   394  	}{})
   395  	stub := fake.FabricVersionUpdatedStub
   396  	fakeReturns := fake.fabricVersionUpdatedReturns
   397  	fake.recordInvocation("FabricVersionUpdated", []interface{}{})
   398  	fake.fabricVersionUpdatedMutex.Unlock()
   399  	if stub != nil {
   400  		return stub()
   401  	}
   402  	if specificReturn {
   403  		return ret.result1
   404  	}
   405  	return fakeReturns.result1
   406  }
   407  
   408  func (fake *Update) FabricVersionUpdatedCallCount() int {
   409  	fake.fabricVersionUpdatedMutex.RLock()
   410  	defer fake.fabricVersionUpdatedMutex.RUnlock()
   411  	return len(fake.fabricVersionUpdatedArgsForCall)
   412  }
   413  
   414  func (fake *Update) FabricVersionUpdatedCalls(stub func() bool) {
   415  	fake.fabricVersionUpdatedMutex.Lock()
   416  	defer fake.fabricVersionUpdatedMutex.Unlock()
   417  	fake.FabricVersionUpdatedStub = stub
   418  }
   419  
   420  func (fake *Update) FabricVersionUpdatedReturns(result1 bool) {
   421  	fake.fabricVersionUpdatedMutex.Lock()
   422  	defer fake.fabricVersionUpdatedMutex.Unlock()
   423  	fake.FabricVersionUpdatedStub = nil
   424  	fake.fabricVersionUpdatedReturns = struct {
   425  		result1 bool
   426  	}{result1}
   427  }
   428  
   429  func (fake *Update) FabricVersionUpdatedReturnsOnCall(i int, result1 bool) {
   430  	fake.fabricVersionUpdatedMutex.Lock()
   431  	defer fake.fabricVersionUpdatedMutex.Unlock()
   432  	fake.FabricVersionUpdatedStub = nil
   433  	if fake.fabricVersionUpdatedReturnsOnCall == nil {
   434  		fake.fabricVersionUpdatedReturnsOnCall = make(map[int]struct {
   435  			result1 bool
   436  		})
   437  	}
   438  	fake.fabricVersionUpdatedReturnsOnCall[i] = struct {
   439  		result1 bool
   440  	}{result1}
   441  }
   442  
   443  func (fake *Update) ImagesUpdated() bool {
   444  	fake.imagesUpdatedMutex.Lock()
   445  	ret, specificReturn := fake.imagesUpdatedReturnsOnCall[len(fake.imagesUpdatedArgsForCall)]
   446  	fake.imagesUpdatedArgsForCall = append(fake.imagesUpdatedArgsForCall, struct {
   447  	}{})
   448  	stub := fake.ImagesUpdatedStub
   449  	fakeReturns := fake.imagesUpdatedReturns
   450  	fake.recordInvocation("ImagesUpdated", []interface{}{})
   451  	fake.imagesUpdatedMutex.Unlock()
   452  	if stub != nil {
   453  		return stub()
   454  	}
   455  	if specificReturn {
   456  		return ret.result1
   457  	}
   458  	return fakeReturns.result1
   459  }
   460  
   461  func (fake *Update) ImagesUpdatedCallCount() int {
   462  	fake.imagesUpdatedMutex.RLock()
   463  	defer fake.imagesUpdatedMutex.RUnlock()
   464  	return len(fake.imagesUpdatedArgsForCall)
   465  }
   466  
   467  func (fake *Update) ImagesUpdatedCalls(stub func() bool) {
   468  	fake.imagesUpdatedMutex.Lock()
   469  	defer fake.imagesUpdatedMutex.Unlock()
   470  	fake.ImagesUpdatedStub = stub
   471  }
   472  
   473  func (fake *Update) ImagesUpdatedReturns(result1 bool) {
   474  	fake.imagesUpdatedMutex.Lock()
   475  	defer fake.imagesUpdatedMutex.Unlock()
   476  	fake.ImagesUpdatedStub = nil
   477  	fake.imagesUpdatedReturns = struct {
   478  		result1 bool
   479  	}{result1}
   480  }
   481  
   482  func (fake *Update) ImagesUpdatedReturnsOnCall(i int, result1 bool) {
   483  	fake.imagesUpdatedMutex.Lock()
   484  	defer fake.imagesUpdatedMutex.Unlock()
   485  	fake.ImagesUpdatedStub = nil
   486  	if fake.imagesUpdatedReturnsOnCall == nil {
   487  		fake.imagesUpdatedReturnsOnCall = make(map[int]struct {
   488  			result1 bool
   489  		})
   490  	}
   491  	fake.imagesUpdatedReturnsOnCall[i] = struct {
   492  		result1 bool
   493  	}{result1}
   494  }
   495  
   496  func (fake *Update) RenewTLSCert() bool {
   497  	fake.renewTLSCertMutex.Lock()
   498  	ret, specificReturn := fake.renewTLSCertReturnsOnCall[len(fake.renewTLSCertArgsForCall)]
   499  	fake.renewTLSCertArgsForCall = append(fake.renewTLSCertArgsForCall, struct {
   500  	}{})
   501  	stub := fake.RenewTLSCertStub
   502  	fakeReturns := fake.renewTLSCertReturns
   503  	fake.recordInvocation("RenewTLSCert", []interface{}{})
   504  	fake.renewTLSCertMutex.Unlock()
   505  	if stub != nil {
   506  		return stub()
   507  	}
   508  	if specificReturn {
   509  		return ret.result1
   510  	}
   511  	return fakeReturns.result1
   512  }
   513  
   514  func (fake *Update) RenewTLSCertCallCount() int {
   515  	fake.renewTLSCertMutex.RLock()
   516  	defer fake.renewTLSCertMutex.RUnlock()
   517  	return len(fake.renewTLSCertArgsForCall)
   518  }
   519  
   520  func (fake *Update) RenewTLSCertCalls(stub func() bool) {
   521  	fake.renewTLSCertMutex.Lock()
   522  	defer fake.renewTLSCertMutex.Unlock()
   523  	fake.RenewTLSCertStub = stub
   524  }
   525  
   526  func (fake *Update) RenewTLSCertReturns(result1 bool) {
   527  	fake.renewTLSCertMutex.Lock()
   528  	defer fake.renewTLSCertMutex.Unlock()
   529  	fake.RenewTLSCertStub = nil
   530  	fake.renewTLSCertReturns = struct {
   531  		result1 bool
   532  	}{result1}
   533  }
   534  
   535  func (fake *Update) RenewTLSCertReturnsOnCall(i int, result1 bool) {
   536  	fake.renewTLSCertMutex.Lock()
   537  	defer fake.renewTLSCertMutex.Unlock()
   538  	fake.RenewTLSCertStub = nil
   539  	if fake.renewTLSCertReturnsOnCall == nil {
   540  		fake.renewTLSCertReturnsOnCall = make(map[int]struct {
   541  			result1 bool
   542  		})
   543  	}
   544  	fake.renewTLSCertReturnsOnCall[i] = struct {
   545  		result1 bool
   546  	}{result1}
   547  }
   548  
   549  func (fake *Update) RestartNeeded() bool {
   550  	fake.restartNeededMutex.Lock()
   551  	ret, specificReturn := fake.restartNeededReturnsOnCall[len(fake.restartNeededArgsForCall)]
   552  	fake.restartNeededArgsForCall = append(fake.restartNeededArgsForCall, struct {
   553  	}{})
   554  	stub := fake.RestartNeededStub
   555  	fakeReturns := fake.restartNeededReturns
   556  	fake.recordInvocation("RestartNeeded", []interface{}{})
   557  	fake.restartNeededMutex.Unlock()
   558  	if stub != nil {
   559  		return stub()
   560  	}
   561  	if specificReturn {
   562  		return ret.result1
   563  	}
   564  	return fakeReturns.result1
   565  }
   566  
   567  func (fake *Update) RestartNeededCallCount() int {
   568  	fake.restartNeededMutex.RLock()
   569  	defer fake.restartNeededMutex.RUnlock()
   570  	return len(fake.restartNeededArgsForCall)
   571  }
   572  
   573  func (fake *Update) RestartNeededCalls(stub func() bool) {
   574  	fake.restartNeededMutex.Lock()
   575  	defer fake.restartNeededMutex.Unlock()
   576  	fake.RestartNeededStub = stub
   577  }
   578  
   579  func (fake *Update) RestartNeededReturns(result1 bool) {
   580  	fake.restartNeededMutex.Lock()
   581  	defer fake.restartNeededMutex.Unlock()
   582  	fake.RestartNeededStub = nil
   583  	fake.restartNeededReturns = struct {
   584  		result1 bool
   585  	}{result1}
   586  }
   587  
   588  func (fake *Update) RestartNeededReturnsOnCall(i int, result1 bool) {
   589  	fake.restartNeededMutex.Lock()
   590  	defer fake.restartNeededMutex.Unlock()
   591  	fake.RestartNeededStub = nil
   592  	if fake.restartNeededReturnsOnCall == nil {
   593  		fake.restartNeededReturnsOnCall = make(map[int]struct {
   594  			result1 bool
   595  		})
   596  	}
   597  	fake.restartNeededReturnsOnCall[i] = struct {
   598  		result1 bool
   599  	}{result1}
   600  }
   601  
   602  func (fake *Update) SpecUpdated() bool {
   603  	fake.specUpdatedMutex.Lock()
   604  	ret, specificReturn := fake.specUpdatedReturnsOnCall[len(fake.specUpdatedArgsForCall)]
   605  	fake.specUpdatedArgsForCall = append(fake.specUpdatedArgsForCall, struct {
   606  	}{})
   607  	stub := fake.SpecUpdatedStub
   608  	fakeReturns := fake.specUpdatedReturns
   609  	fake.recordInvocation("SpecUpdated", []interface{}{})
   610  	fake.specUpdatedMutex.Unlock()
   611  	if stub != nil {
   612  		return stub()
   613  	}
   614  	if specificReturn {
   615  		return ret.result1
   616  	}
   617  	return fakeReturns.result1
   618  }
   619  
   620  func (fake *Update) SpecUpdatedCallCount() int {
   621  	fake.specUpdatedMutex.RLock()
   622  	defer fake.specUpdatedMutex.RUnlock()
   623  	return len(fake.specUpdatedArgsForCall)
   624  }
   625  
   626  func (fake *Update) SpecUpdatedCalls(stub func() bool) {
   627  	fake.specUpdatedMutex.Lock()
   628  	defer fake.specUpdatedMutex.Unlock()
   629  	fake.SpecUpdatedStub = stub
   630  }
   631  
   632  func (fake *Update) SpecUpdatedReturns(result1 bool) {
   633  	fake.specUpdatedMutex.Lock()
   634  	defer fake.specUpdatedMutex.Unlock()
   635  	fake.SpecUpdatedStub = nil
   636  	fake.specUpdatedReturns = struct {
   637  		result1 bool
   638  	}{result1}
   639  }
   640  
   641  func (fake *Update) SpecUpdatedReturnsOnCall(i int, result1 bool) {
   642  	fake.specUpdatedMutex.Lock()
   643  	defer fake.specUpdatedMutex.Unlock()
   644  	fake.SpecUpdatedStub = nil
   645  	if fake.specUpdatedReturnsOnCall == nil {
   646  		fake.specUpdatedReturnsOnCall = make(map[int]struct {
   647  			result1 bool
   648  		})
   649  	}
   650  	fake.specUpdatedReturnsOnCall[i] = struct {
   651  		result1 bool
   652  	}{result1}
   653  }
   654  
   655  func (fake *Update) TLSCAOverridesUpdated() bool {
   656  	fake.tLSCAOverridesUpdatedMutex.Lock()
   657  	ret, specificReturn := fake.tLSCAOverridesUpdatedReturnsOnCall[len(fake.tLSCAOverridesUpdatedArgsForCall)]
   658  	fake.tLSCAOverridesUpdatedArgsForCall = append(fake.tLSCAOverridesUpdatedArgsForCall, struct {
   659  	}{})
   660  	stub := fake.TLSCAOverridesUpdatedStub
   661  	fakeReturns := fake.tLSCAOverridesUpdatedReturns
   662  	fake.recordInvocation("TLSCAOverridesUpdated", []interface{}{})
   663  	fake.tLSCAOverridesUpdatedMutex.Unlock()
   664  	if stub != nil {
   665  		return stub()
   666  	}
   667  	if specificReturn {
   668  		return ret.result1
   669  	}
   670  	return fakeReturns.result1
   671  }
   672  
   673  func (fake *Update) TLSCAOverridesUpdatedCallCount() int {
   674  	fake.tLSCAOverridesUpdatedMutex.RLock()
   675  	defer fake.tLSCAOverridesUpdatedMutex.RUnlock()
   676  	return len(fake.tLSCAOverridesUpdatedArgsForCall)
   677  }
   678  
   679  func (fake *Update) TLSCAOverridesUpdatedCalls(stub func() bool) {
   680  	fake.tLSCAOverridesUpdatedMutex.Lock()
   681  	defer fake.tLSCAOverridesUpdatedMutex.Unlock()
   682  	fake.TLSCAOverridesUpdatedStub = stub
   683  }
   684  
   685  func (fake *Update) TLSCAOverridesUpdatedReturns(result1 bool) {
   686  	fake.tLSCAOverridesUpdatedMutex.Lock()
   687  	defer fake.tLSCAOverridesUpdatedMutex.Unlock()
   688  	fake.TLSCAOverridesUpdatedStub = nil
   689  	fake.tLSCAOverridesUpdatedReturns = struct {
   690  		result1 bool
   691  	}{result1}
   692  }
   693  
   694  func (fake *Update) TLSCAOverridesUpdatedReturnsOnCall(i int, result1 bool) {
   695  	fake.tLSCAOverridesUpdatedMutex.Lock()
   696  	defer fake.tLSCAOverridesUpdatedMutex.Unlock()
   697  	fake.TLSCAOverridesUpdatedStub = nil
   698  	if fake.tLSCAOverridesUpdatedReturnsOnCall == nil {
   699  		fake.tLSCAOverridesUpdatedReturnsOnCall = make(map[int]struct {
   700  			result1 bool
   701  		})
   702  	}
   703  	fake.tLSCAOverridesUpdatedReturnsOnCall[i] = struct {
   704  		result1 bool
   705  	}{result1}
   706  }
   707  
   708  func (fake *Update) Invocations() map[string][][]interface{} {
   709  	fake.invocationsMutex.RLock()
   710  	defer fake.invocationsMutex.RUnlock()
   711  	fake.cACryptoCreatedMutex.RLock()
   712  	defer fake.cACryptoCreatedMutex.RUnlock()
   713  	fake.cACryptoUpdatedMutex.RLock()
   714  	defer fake.cACryptoUpdatedMutex.RUnlock()
   715  	fake.cAOverridesUpdatedMutex.RLock()
   716  	defer fake.cAOverridesUpdatedMutex.RUnlock()
   717  	fake.cATagUpdatedMutex.RLock()
   718  	defer fake.cATagUpdatedMutex.RUnlock()
   719  	fake.configOverridesUpdatedMutex.RLock()
   720  	defer fake.configOverridesUpdatedMutex.RUnlock()
   721  	fake.fabricVersionUpdatedMutex.RLock()
   722  	defer fake.fabricVersionUpdatedMutex.RUnlock()
   723  	fake.imagesUpdatedMutex.RLock()
   724  	defer fake.imagesUpdatedMutex.RUnlock()
   725  	fake.renewTLSCertMutex.RLock()
   726  	defer fake.renewTLSCertMutex.RUnlock()
   727  	fake.restartNeededMutex.RLock()
   728  	defer fake.restartNeededMutex.RUnlock()
   729  	fake.specUpdatedMutex.RLock()
   730  	defer fake.specUpdatedMutex.RUnlock()
   731  	fake.tLSCAOverridesUpdatedMutex.RLock()
   732  	defer fake.tLSCAOverridesUpdatedMutex.RUnlock()
   733  	copiedInvocations := map[string][][]interface{}{}
   734  	for key, value := range fake.invocations {
   735  		copiedInvocations[key] = value
   736  	}
   737  	return copiedInvocations
   738  }
   739  
   740  func (fake *Update) recordInvocation(key string, args []interface{}) {
   741  	fake.invocationsMutex.Lock()
   742  	defer fake.invocationsMutex.Unlock()
   743  	if fake.invocations == nil {
   744  		fake.invocations = map[string][][]interface{}{}
   745  	}
   746  	if fake.invocations[key] == nil {
   747  		fake.invocations[key] = [][]interface{}{}
   748  	}
   749  	fake.invocations[key] = append(fake.invocations[key], args)
   750  }
   751  
   752  var _ baseca.Update = new(Update)