github.com/tw-bc-group/fabric-ca-gm@v0.0.0-20201218004200-3b690512bd5a/lib/mocks/operations_server.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mocks 3 4 import ( 5 sync "sync" 6 7 healthz "github.com/hyperledger/fabric-lib-go/healthz" 8 metrics "github.com/tw-bc-group/fabric-gm/common/metrics" 9 ) 10 11 type OperationsServer struct { 12 AddrStub func() string 13 addrMutex sync.RWMutex 14 addrArgsForCall []struct { 15 } 16 addrReturns struct { 17 result1 string 18 } 19 addrReturnsOnCall map[int]struct { 20 result1 string 21 } 22 NewCounterStub func(metrics.CounterOpts) metrics.Counter 23 newCounterMutex sync.RWMutex 24 newCounterArgsForCall []struct { 25 arg1 metrics.CounterOpts 26 } 27 newCounterReturns struct { 28 result1 metrics.Counter 29 } 30 newCounterReturnsOnCall map[int]struct { 31 result1 metrics.Counter 32 } 33 NewGaugeStub func(metrics.GaugeOpts) metrics.Gauge 34 newGaugeMutex sync.RWMutex 35 newGaugeArgsForCall []struct { 36 arg1 metrics.GaugeOpts 37 } 38 newGaugeReturns struct { 39 result1 metrics.Gauge 40 } 41 newGaugeReturnsOnCall map[int]struct { 42 result1 metrics.Gauge 43 } 44 NewHistogramStub func(metrics.HistogramOpts) metrics.Histogram 45 newHistogramMutex sync.RWMutex 46 newHistogramArgsForCall []struct { 47 arg1 metrics.HistogramOpts 48 } 49 newHistogramReturns struct { 50 result1 metrics.Histogram 51 } 52 newHistogramReturnsOnCall map[int]struct { 53 result1 metrics.Histogram 54 } 55 RegisterCheckerStub func(string, healthz.HealthChecker) error 56 registerCheckerMutex sync.RWMutex 57 registerCheckerArgsForCall []struct { 58 arg1 string 59 arg2 healthz.HealthChecker 60 } 61 registerCheckerReturns struct { 62 result1 error 63 } 64 registerCheckerReturnsOnCall map[int]struct { 65 result1 error 66 } 67 StartStub func() error 68 startMutex sync.RWMutex 69 startArgsForCall []struct { 70 } 71 startReturns struct { 72 result1 error 73 } 74 startReturnsOnCall map[int]struct { 75 result1 error 76 } 77 StopStub func() error 78 stopMutex sync.RWMutex 79 stopArgsForCall []struct { 80 } 81 stopReturns struct { 82 result1 error 83 } 84 stopReturnsOnCall map[int]struct { 85 result1 error 86 } 87 invocations map[string][][]interface{} 88 invocationsMutex sync.RWMutex 89 } 90 91 func (fake *OperationsServer) Addr() string { 92 fake.addrMutex.Lock() 93 ret, specificReturn := fake.addrReturnsOnCall[len(fake.addrArgsForCall)] 94 fake.addrArgsForCall = append(fake.addrArgsForCall, struct { 95 }{}) 96 fake.recordInvocation("Addr", []interface{}{}) 97 fake.addrMutex.Unlock() 98 if fake.AddrStub != nil { 99 return fake.AddrStub() 100 } 101 if specificReturn { 102 return ret.result1 103 } 104 fakeReturns := fake.addrReturns 105 return fakeReturns.result1 106 } 107 108 func (fake *OperationsServer) AddrCallCount() int { 109 fake.addrMutex.RLock() 110 defer fake.addrMutex.RUnlock() 111 return len(fake.addrArgsForCall) 112 } 113 114 func (fake *OperationsServer) AddrCalls(stub func() string) { 115 fake.addrMutex.Lock() 116 defer fake.addrMutex.Unlock() 117 fake.AddrStub = stub 118 } 119 120 func (fake *OperationsServer) AddrReturns(result1 string) { 121 fake.addrMutex.Lock() 122 defer fake.addrMutex.Unlock() 123 fake.AddrStub = nil 124 fake.addrReturns = struct { 125 result1 string 126 }{result1} 127 } 128 129 func (fake *OperationsServer) AddrReturnsOnCall(i int, result1 string) { 130 fake.addrMutex.Lock() 131 defer fake.addrMutex.Unlock() 132 fake.AddrStub = nil 133 if fake.addrReturnsOnCall == nil { 134 fake.addrReturnsOnCall = make(map[int]struct { 135 result1 string 136 }) 137 } 138 fake.addrReturnsOnCall[i] = struct { 139 result1 string 140 }{result1} 141 } 142 143 func (fake *OperationsServer) NewCounter(arg1 metrics.CounterOpts) metrics.Counter { 144 fake.newCounterMutex.Lock() 145 ret, specificReturn := fake.newCounterReturnsOnCall[len(fake.newCounterArgsForCall)] 146 fake.newCounterArgsForCall = append(fake.newCounterArgsForCall, struct { 147 arg1 metrics.CounterOpts 148 }{arg1}) 149 fake.recordInvocation("NewCounter", []interface{}{arg1}) 150 fake.newCounterMutex.Unlock() 151 if fake.NewCounterStub != nil { 152 return fake.NewCounterStub(arg1) 153 } 154 if specificReturn { 155 return ret.result1 156 } 157 fakeReturns := fake.newCounterReturns 158 return fakeReturns.result1 159 } 160 161 func (fake *OperationsServer) NewCounterCallCount() int { 162 fake.newCounterMutex.RLock() 163 defer fake.newCounterMutex.RUnlock() 164 return len(fake.newCounterArgsForCall) 165 } 166 167 func (fake *OperationsServer) NewCounterCalls(stub func(metrics.CounterOpts) metrics.Counter) { 168 fake.newCounterMutex.Lock() 169 defer fake.newCounterMutex.Unlock() 170 fake.NewCounterStub = stub 171 } 172 173 func (fake *OperationsServer) NewCounterArgsForCall(i int) metrics.CounterOpts { 174 fake.newCounterMutex.RLock() 175 defer fake.newCounterMutex.RUnlock() 176 argsForCall := fake.newCounterArgsForCall[i] 177 return argsForCall.arg1 178 } 179 180 func (fake *OperationsServer) NewCounterReturns(result1 metrics.Counter) { 181 fake.newCounterMutex.Lock() 182 defer fake.newCounterMutex.Unlock() 183 fake.NewCounterStub = nil 184 fake.newCounterReturns = struct { 185 result1 metrics.Counter 186 }{result1} 187 } 188 189 func (fake *OperationsServer) NewCounterReturnsOnCall(i int, result1 metrics.Counter) { 190 fake.newCounterMutex.Lock() 191 defer fake.newCounterMutex.Unlock() 192 fake.NewCounterStub = nil 193 if fake.newCounterReturnsOnCall == nil { 194 fake.newCounterReturnsOnCall = make(map[int]struct { 195 result1 metrics.Counter 196 }) 197 } 198 fake.newCounterReturnsOnCall[i] = struct { 199 result1 metrics.Counter 200 }{result1} 201 } 202 203 func (fake *OperationsServer) NewGauge(arg1 metrics.GaugeOpts) metrics.Gauge { 204 fake.newGaugeMutex.Lock() 205 ret, specificReturn := fake.newGaugeReturnsOnCall[len(fake.newGaugeArgsForCall)] 206 fake.newGaugeArgsForCall = append(fake.newGaugeArgsForCall, struct { 207 arg1 metrics.GaugeOpts 208 }{arg1}) 209 fake.recordInvocation("NewGauge", []interface{}{arg1}) 210 fake.newGaugeMutex.Unlock() 211 if fake.NewGaugeStub != nil { 212 return fake.NewGaugeStub(arg1) 213 } 214 if specificReturn { 215 return ret.result1 216 } 217 fakeReturns := fake.newGaugeReturns 218 return fakeReturns.result1 219 } 220 221 func (fake *OperationsServer) NewGaugeCallCount() int { 222 fake.newGaugeMutex.RLock() 223 defer fake.newGaugeMutex.RUnlock() 224 return len(fake.newGaugeArgsForCall) 225 } 226 227 func (fake *OperationsServer) NewGaugeCalls(stub func(metrics.GaugeOpts) metrics.Gauge) { 228 fake.newGaugeMutex.Lock() 229 defer fake.newGaugeMutex.Unlock() 230 fake.NewGaugeStub = stub 231 } 232 233 func (fake *OperationsServer) NewGaugeArgsForCall(i int) metrics.GaugeOpts { 234 fake.newGaugeMutex.RLock() 235 defer fake.newGaugeMutex.RUnlock() 236 argsForCall := fake.newGaugeArgsForCall[i] 237 return argsForCall.arg1 238 } 239 240 func (fake *OperationsServer) NewGaugeReturns(result1 metrics.Gauge) { 241 fake.newGaugeMutex.Lock() 242 defer fake.newGaugeMutex.Unlock() 243 fake.NewGaugeStub = nil 244 fake.newGaugeReturns = struct { 245 result1 metrics.Gauge 246 }{result1} 247 } 248 249 func (fake *OperationsServer) NewGaugeReturnsOnCall(i int, result1 metrics.Gauge) { 250 fake.newGaugeMutex.Lock() 251 defer fake.newGaugeMutex.Unlock() 252 fake.NewGaugeStub = nil 253 if fake.newGaugeReturnsOnCall == nil { 254 fake.newGaugeReturnsOnCall = make(map[int]struct { 255 result1 metrics.Gauge 256 }) 257 } 258 fake.newGaugeReturnsOnCall[i] = struct { 259 result1 metrics.Gauge 260 }{result1} 261 } 262 263 func (fake *OperationsServer) NewHistogram(arg1 metrics.HistogramOpts) metrics.Histogram { 264 fake.newHistogramMutex.Lock() 265 ret, specificReturn := fake.newHistogramReturnsOnCall[len(fake.newHistogramArgsForCall)] 266 fake.newHistogramArgsForCall = append(fake.newHistogramArgsForCall, struct { 267 arg1 metrics.HistogramOpts 268 }{arg1}) 269 fake.recordInvocation("NewHistogram", []interface{}{arg1}) 270 fake.newHistogramMutex.Unlock() 271 if fake.NewHistogramStub != nil { 272 return fake.NewHistogramStub(arg1) 273 } 274 if specificReturn { 275 return ret.result1 276 } 277 fakeReturns := fake.newHistogramReturns 278 return fakeReturns.result1 279 } 280 281 func (fake *OperationsServer) NewHistogramCallCount() int { 282 fake.newHistogramMutex.RLock() 283 defer fake.newHistogramMutex.RUnlock() 284 return len(fake.newHistogramArgsForCall) 285 } 286 287 func (fake *OperationsServer) NewHistogramCalls(stub func(metrics.HistogramOpts) metrics.Histogram) { 288 fake.newHistogramMutex.Lock() 289 defer fake.newHistogramMutex.Unlock() 290 fake.NewHistogramStub = stub 291 } 292 293 func (fake *OperationsServer) NewHistogramArgsForCall(i int) metrics.HistogramOpts { 294 fake.newHistogramMutex.RLock() 295 defer fake.newHistogramMutex.RUnlock() 296 argsForCall := fake.newHistogramArgsForCall[i] 297 return argsForCall.arg1 298 } 299 300 func (fake *OperationsServer) NewHistogramReturns(result1 metrics.Histogram) { 301 fake.newHistogramMutex.Lock() 302 defer fake.newHistogramMutex.Unlock() 303 fake.NewHistogramStub = nil 304 fake.newHistogramReturns = struct { 305 result1 metrics.Histogram 306 }{result1} 307 } 308 309 func (fake *OperationsServer) NewHistogramReturnsOnCall(i int, result1 metrics.Histogram) { 310 fake.newHistogramMutex.Lock() 311 defer fake.newHistogramMutex.Unlock() 312 fake.NewHistogramStub = nil 313 if fake.newHistogramReturnsOnCall == nil { 314 fake.newHistogramReturnsOnCall = make(map[int]struct { 315 result1 metrics.Histogram 316 }) 317 } 318 fake.newHistogramReturnsOnCall[i] = struct { 319 result1 metrics.Histogram 320 }{result1} 321 } 322 323 func (fake *OperationsServer) RegisterChecker(arg1 string, arg2 healthz.HealthChecker) error { 324 fake.registerCheckerMutex.Lock() 325 ret, specificReturn := fake.registerCheckerReturnsOnCall[len(fake.registerCheckerArgsForCall)] 326 fake.registerCheckerArgsForCall = append(fake.registerCheckerArgsForCall, struct { 327 arg1 string 328 arg2 healthz.HealthChecker 329 }{arg1, arg2}) 330 fake.recordInvocation("RegisterChecker", []interface{}{arg1, arg2}) 331 fake.registerCheckerMutex.Unlock() 332 if fake.RegisterCheckerStub != nil { 333 return fake.RegisterCheckerStub(arg1, arg2) 334 } 335 if specificReturn { 336 return ret.result1 337 } 338 fakeReturns := fake.registerCheckerReturns 339 return fakeReturns.result1 340 } 341 342 func (fake *OperationsServer) RegisterCheckerCallCount() int { 343 fake.registerCheckerMutex.RLock() 344 defer fake.registerCheckerMutex.RUnlock() 345 return len(fake.registerCheckerArgsForCall) 346 } 347 348 func (fake *OperationsServer) RegisterCheckerCalls(stub func(string, healthz.HealthChecker) error) { 349 fake.registerCheckerMutex.Lock() 350 defer fake.registerCheckerMutex.Unlock() 351 fake.RegisterCheckerStub = stub 352 } 353 354 func (fake *OperationsServer) RegisterCheckerArgsForCall(i int) (string, healthz.HealthChecker) { 355 fake.registerCheckerMutex.RLock() 356 defer fake.registerCheckerMutex.RUnlock() 357 argsForCall := fake.registerCheckerArgsForCall[i] 358 return argsForCall.arg1, argsForCall.arg2 359 } 360 361 func (fake *OperationsServer) RegisterCheckerReturns(result1 error) { 362 fake.registerCheckerMutex.Lock() 363 defer fake.registerCheckerMutex.Unlock() 364 fake.RegisterCheckerStub = nil 365 fake.registerCheckerReturns = struct { 366 result1 error 367 }{result1} 368 } 369 370 func (fake *OperationsServer) RegisterCheckerReturnsOnCall(i int, result1 error) { 371 fake.registerCheckerMutex.Lock() 372 defer fake.registerCheckerMutex.Unlock() 373 fake.RegisterCheckerStub = nil 374 if fake.registerCheckerReturnsOnCall == nil { 375 fake.registerCheckerReturnsOnCall = make(map[int]struct { 376 result1 error 377 }) 378 } 379 fake.registerCheckerReturnsOnCall[i] = struct { 380 result1 error 381 }{result1} 382 } 383 384 func (fake *OperationsServer) Start() error { 385 fake.startMutex.Lock() 386 ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)] 387 fake.startArgsForCall = append(fake.startArgsForCall, struct { 388 }{}) 389 fake.recordInvocation("Start", []interface{}{}) 390 fake.startMutex.Unlock() 391 if fake.StartStub != nil { 392 return fake.StartStub() 393 } 394 if specificReturn { 395 return ret.result1 396 } 397 fakeReturns := fake.startReturns 398 return fakeReturns.result1 399 } 400 401 func (fake *OperationsServer) StartCallCount() int { 402 fake.startMutex.RLock() 403 defer fake.startMutex.RUnlock() 404 return len(fake.startArgsForCall) 405 } 406 407 func (fake *OperationsServer) StartCalls(stub func() error) { 408 fake.startMutex.Lock() 409 defer fake.startMutex.Unlock() 410 fake.StartStub = stub 411 } 412 413 func (fake *OperationsServer) StartReturns(result1 error) { 414 fake.startMutex.Lock() 415 defer fake.startMutex.Unlock() 416 fake.StartStub = nil 417 fake.startReturns = struct { 418 result1 error 419 }{result1} 420 } 421 422 func (fake *OperationsServer) StartReturnsOnCall(i int, result1 error) { 423 fake.startMutex.Lock() 424 defer fake.startMutex.Unlock() 425 fake.StartStub = nil 426 if fake.startReturnsOnCall == nil { 427 fake.startReturnsOnCall = make(map[int]struct { 428 result1 error 429 }) 430 } 431 fake.startReturnsOnCall[i] = struct { 432 result1 error 433 }{result1} 434 } 435 436 func (fake *OperationsServer) Stop() error { 437 fake.stopMutex.Lock() 438 ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] 439 fake.stopArgsForCall = append(fake.stopArgsForCall, struct { 440 }{}) 441 fake.recordInvocation("Stop", []interface{}{}) 442 fake.stopMutex.Unlock() 443 if fake.StopStub != nil { 444 return fake.StopStub() 445 } 446 if specificReturn { 447 return ret.result1 448 } 449 fakeReturns := fake.stopReturns 450 return fakeReturns.result1 451 } 452 453 func (fake *OperationsServer) StopCallCount() int { 454 fake.stopMutex.RLock() 455 defer fake.stopMutex.RUnlock() 456 return len(fake.stopArgsForCall) 457 } 458 459 func (fake *OperationsServer) StopCalls(stub func() error) { 460 fake.stopMutex.Lock() 461 defer fake.stopMutex.Unlock() 462 fake.StopStub = stub 463 } 464 465 func (fake *OperationsServer) StopReturns(result1 error) { 466 fake.stopMutex.Lock() 467 defer fake.stopMutex.Unlock() 468 fake.StopStub = nil 469 fake.stopReturns = struct { 470 result1 error 471 }{result1} 472 } 473 474 func (fake *OperationsServer) StopReturnsOnCall(i int, result1 error) { 475 fake.stopMutex.Lock() 476 defer fake.stopMutex.Unlock() 477 fake.StopStub = nil 478 if fake.stopReturnsOnCall == nil { 479 fake.stopReturnsOnCall = make(map[int]struct { 480 result1 error 481 }) 482 } 483 fake.stopReturnsOnCall[i] = struct { 484 result1 error 485 }{result1} 486 } 487 488 func (fake *OperationsServer) Invocations() map[string][][]interface{} { 489 fake.invocationsMutex.RLock() 490 defer fake.invocationsMutex.RUnlock() 491 fake.addrMutex.RLock() 492 defer fake.addrMutex.RUnlock() 493 fake.newCounterMutex.RLock() 494 defer fake.newCounterMutex.RUnlock() 495 fake.newGaugeMutex.RLock() 496 defer fake.newGaugeMutex.RUnlock() 497 fake.newHistogramMutex.RLock() 498 defer fake.newHistogramMutex.RUnlock() 499 fake.registerCheckerMutex.RLock() 500 defer fake.registerCheckerMutex.RUnlock() 501 fake.startMutex.RLock() 502 defer fake.startMutex.RUnlock() 503 fake.stopMutex.RLock() 504 defer fake.stopMutex.RUnlock() 505 copiedInvocations := map[string][][]interface{}{} 506 for key, value := range fake.invocations { 507 copiedInvocations[key] = value 508 } 509 return copiedInvocations 510 } 511 512 func (fake *OperationsServer) recordInvocation(key string, args []interface{}) { 513 fake.invocationsMutex.Lock() 514 defer fake.invocationsMutex.Unlock() 515 if fake.invocations == nil { 516 fake.invocations = map[string][][]interface{}{} 517 } 518 if fake.invocations[key] == nil { 519 fake.invocations[key] = [][]interface{}{} 520 } 521 fake.invocations[key] = append(fake.invocations[key], args) 522 }