From b9184ab335bdc426cc442aa333555622e17e6e9d Mon Sep 17 00:00:00 2001 From: Amin Jamali Date: Wed, 12 May 2021 13:41:48 +0000 Subject: [PATCH] Ensure MaxOpenDatabaseConnections is 100 so that we don't exceed the 150 max connection for mysql by default --- cmd/bbs/lrp_convergence_test.go | 1 + controllers/fakes/fake_retirer.go | 8 +- .../fake_lrp_convergence_controller.go | 6 +- .../fake_controllers/fake_task_controller.go | 8 +- db/dbfakes/fake_actual_lrpdb.go | 88 ++--- db/dbfakes/fake_db.go | 312 ++++++++-------- db/dbfakes/fake_desired_lrpdb.go | 48 +-- db/dbfakes/fake_domain_db.go | 16 +- db/dbfakes/fake_encryption_db.go | 24 +- db/dbfakes/fake_evacuation_db.go | 16 +- db/dbfakes/fake_lrpdb.go | 144 ++++---- db/dbfakes/fake_suspect_db.go | 8 +- db/dbfakes/fake_task_db.go | 88 ++--- db/dbfakes/fake_version_db.go | 16 +- .../fakesqldriverfakes/fake_conn.go | 24 +- .../fakesqldriverfakes/fake_driver.go | 8 +- .../fakesqldriverfakes/fake_stmt.go | 32 +- .../fakesqldriverfakes/fake_tx.go | 16 +- .../helpers/helpersfakes/fake_queryable_db.go | 64 ++-- .../monitor/monitorfakes/fake_monitor.go | 48 +-- encryption/encryptionfakes/fake_cryptor.go | 16 +- encryption/encryptionfakes/fake_key.go | 16 +- events/eventfakes/fake_event_source.go | 16 +- events/eventfakes/fake_hub.go | 34 +- events/eventfakes/fake_raw_event_source.go | 16 +- fake_bbs/fake_client.go | 232 ++++++------ fake_bbs/fake_internal_client.go | 344 +++++++++--------- .../guidproviderfakes/fake_guidprovider.go | 8 +- .../fake_actual_lrp_lifecycle_controller.go | 48 +-- .../fake_evacuation_controller.go | 40 +- .../fake_controllers/fake_task_controller.go | 88 ++--- handlers/middleware/fakes/fake_emitter.go | 12 +- .../fakes/fake_lrp_stat_metron_notifier.go | 32 +- .../fakes/fake_task_stat_metron_notifier.go | 38 +- metrics/metricsfakes/fake_dbstats.go | 24 +- migration/migrationfakes/fake_migration.go | 48 +-- .../serviceclientfakes/fake_service_client.go | 24 +- .../fake_task_completion_client.go | 6 +- 38 files changed, 1009 insertions(+), 1008 deletions(-) diff --git a/cmd/bbs/lrp_convergence_test.go b/cmd/bbs/lrp_convergence_test.go index 1ffad50a..ad5299f0 100644 --- a/cmd/bbs/lrp_convergence_test.go +++ b/cmd/bbs/lrp_convergence_test.go @@ -31,6 +31,7 @@ var _ = Describe("Convergence API", func() { BeforeEach(func() { // make the converger more aggressive by running every second bbsConfig.ConvergeRepeatInterval = durationjson.Duration(time.Second) + bbsConfig.MaxOpenDatabaseConnections = 100 bbsRunner = testrunner.New(bbsBinPath, bbsConfig) bbsProcess = ginkgomon.Invoke(bbsRunner) diff --git a/controllers/fakes/fake_retirer.go b/controllers/fakes/fake_retirer.go index 2e5f59f6..3535f557 100644 --- a/controllers/fakes/fake_retirer.go +++ b/controllers/fakes/fake_retirer.go @@ -36,16 +36,16 @@ func (fake *FakeRetirer) RetireActualLRP(arg1 context.Context, arg2 lager.Logger arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.RetireActualLRPStub + fakeReturns := fake.retireActualLRPReturns fake.recordInvocation("RetireActualLRP", []interface{}{arg1, arg2, arg3}) - retireActualLRPStubCopy := fake.RetireActualLRPStub fake.retireActualLRPMutex.Unlock() - if retireActualLRPStubCopy != nil { - return retireActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.retireActualLRPReturns return fakeReturns.result1 } diff --git a/converger/fake_controllers/fake_lrp_convergence_controller.go b/converger/fake_controllers/fake_lrp_convergence_controller.go index 1132093b..08ee6074 100644 --- a/converger/fake_controllers/fake_lrp_convergence_controller.go +++ b/converger/fake_controllers/fake_lrp_convergence_controller.go @@ -26,11 +26,11 @@ func (fake *FakeLrpConvergenceController) ConvergeLRPs(arg1 context.Context, arg arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.ConvergeLRPsStub fake.recordInvocation("ConvergeLRPs", []interface{}{arg1, arg2}) - convergeLRPsStubCopy := fake.ConvergeLRPsStub fake.convergeLRPsMutex.Unlock() - if convergeLRPsStubCopy != nil { - convergeLRPsStubCopy(arg1, arg2) + if stub != nil { + fake.ConvergeLRPsStub(arg1, arg2) } } diff --git a/converger/fake_controllers/fake_task_controller.go b/converger/fake_controllers/fake_task_controller.go index af3e1f80..1a23b811 100644 --- a/converger/fake_controllers/fake_task_controller.go +++ b/converger/fake_controllers/fake_task_controller.go @@ -40,16 +40,16 @@ func (fake *FakeTaskController) ConvergeTasks(arg1 context.Context, arg2 lager.L arg4 time.Duration arg5 time.Duration }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ConvergeTasksStub + fakeReturns := fake.convergeTasksReturns fake.recordInvocation("ConvergeTasks", []interface{}{arg1, arg2, arg3, arg4, arg5}) - convergeTasksStubCopy := fake.ConvergeTasksStub fake.convergeTasksMutex.Unlock() - if convergeTasksStubCopy != nil { - return convergeTasksStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeTasksReturns return fakeReturns.result1 } diff --git a/db/dbfakes/fake_actual_lrpdb.go b/db/dbfakes/fake_actual_lrpdb.go index 525a85b6..187aa758 100644 --- a/db/dbfakes/fake_actual_lrpdb.go +++ b/db/dbfakes/fake_actual_lrpdb.go @@ -213,16 +213,16 @@ func (fake *FakeActualLRPDB) ActualLRPs(arg1 context.Context, arg2 lager.Logger, arg2 lager.Logger arg3 models.ActualLRPFilter }{arg1, arg2, arg3}) + stub := fake.ActualLRPsStub + fakeReturns := fake.actualLRPsReturns fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2, arg3}) - actualLRPsStubCopy := fake.ActualLRPsStub fake.actualLRPsMutex.Unlock() - if actualLRPsStubCopy != nil { - return actualLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -281,16 +281,16 @@ func (fake *FakeActualLRPDB) ChangeActualLRPPresence(arg1 context.Context, arg2 arg4 models.ActualLRP_Presence arg5 models.ActualLRP_Presence }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ChangeActualLRPPresenceStub + fakeReturns := fake.changeActualLRPPresenceReturns fake.recordInvocation("ChangeActualLRPPresence", []interface{}{arg1, arg2, arg3, arg4, arg5}) - changeActualLRPPresenceStubCopy := fake.ChangeActualLRPPresenceStub fake.changeActualLRPPresenceMutex.Unlock() - if changeActualLRPPresenceStubCopy != nil { - return changeActualLRPPresenceStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.changeActualLRPPresenceReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -352,16 +352,16 @@ func (fake *FakeActualLRPDB) ClaimActualLRP(arg1 context.Context, arg2 lager.Log arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ClaimActualLRPStub + fakeReturns := fake.claimActualLRPReturns fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - claimActualLRPStubCopy := fake.ClaimActualLRPStub fake.claimActualLRPMutex.Unlock() - if claimActualLRPStubCopy != nil { - return claimActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.claimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -420,16 +420,16 @@ func (fake *FakeActualLRPDB) CountActualLRPsByState(arg1 context.Context, arg2 l arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountActualLRPsByStateStub + fakeReturns := fake.countActualLRPsByStateReturns fake.recordInvocation("CountActualLRPsByState", []interface{}{arg1, arg2}) - countActualLRPsByStateStubCopy := fake.CountActualLRPsByStateStub fake.countActualLRPsByStateMutex.Unlock() - if countActualLRPsByStateStubCopy != nil { - return countActualLRPsByStateStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5 } - fakeReturns := fake.countActualLRPsByStateReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4, fakeReturns.result5 } @@ -494,16 +494,16 @@ func (fake *FakeActualLRPDB) CountDesiredInstances(arg1 context.Context, arg2 la arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountDesiredInstancesStub + fakeReturns := fake.countDesiredInstancesReturns fake.recordInvocation("CountDesiredInstances", []interface{}{arg1, arg2}) - countDesiredInstancesStubCopy := fake.CountDesiredInstancesStub fake.countDesiredInstancesMutex.Unlock() - if countDesiredInstancesStubCopy != nil { - return countDesiredInstancesStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.countDesiredInstancesReturns return fakeReturns.result1 } @@ -559,16 +559,16 @@ func (fake *FakeActualLRPDB) CrashActualLRP(arg1 context.Context, arg2 lager.Log arg4 *models.ActualLRPInstanceKey arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.CrashActualLRPStub + fakeReturns := fake.crashActualLRPReturns fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - crashActualLRPStubCopy := fake.CrashActualLRPStub fake.crashActualLRPMutex.Unlock() - if crashActualLRPStubCopy != nil { - return crashActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.crashActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -631,16 +631,16 @@ func (fake *FakeActualLRPDB) CreateUnclaimedActualLRP(arg1 context.Context, arg2 arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.CreateUnclaimedActualLRPStub + fakeReturns := fake.createUnclaimedActualLRPReturns fake.recordInvocation("CreateUnclaimedActualLRP", []interface{}{arg1, arg2, arg3}) - createUnclaimedActualLRPStubCopy := fake.CreateUnclaimedActualLRPStub fake.createUnclaimedActualLRPMutex.Unlock() - if createUnclaimedActualLRPStubCopy != nil { - return createUnclaimedActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.createUnclaimedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -698,16 +698,16 @@ func (fake *FakeActualLRPDB) FailActualLRP(arg1 context.Context, arg2 lager.Logg arg3 *models.ActualLRPKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailActualLRPStub + fakeReturns := fake.failActualLRPReturns fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - failActualLRPStubCopy := fake.FailActualLRPStub fake.failActualLRPMutex.Unlock() - if failActualLRPStubCopy != nil { - return failActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.failActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -769,16 +769,16 @@ func (fake *FakeActualLRPDB) RemoveActualLRP(arg1 context.Context, arg2 lager.Lo arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.RemoveActualLRPStub + fakeReturns := fake.removeActualLRPReturns fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - removeActualLRPStubCopy := fake.RemoveActualLRPStub fake.removeActualLRPMutex.Unlock() - if removeActualLRPStubCopy != nil { - return removeActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeActualLRPReturns return fakeReturns.result1 } @@ -834,16 +834,16 @@ func (fake *FakeActualLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Log arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.StartActualLRPStub + fakeReturns := fake.startActualLRPReturns fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - startActualLRPStubCopy := fake.StartActualLRPStub fake.startActualLRPMutex.Unlock() - if startActualLRPStubCopy != nil { - return startActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.startActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -903,16 +903,16 @@ func (fake *FakeActualLRPDB) UnclaimActualLRP(arg1 context.Context, arg2 lager.L arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.UnclaimActualLRPStub + fakeReturns := fake.unclaimActualLRPReturns fake.recordInvocation("UnclaimActualLRP", []interface{}{arg1, arg2, arg3}) - unclaimActualLRPStubCopy := fake.UnclaimActualLRPStub fake.unclaimActualLRPMutex.Unlock() - if unclaimActualLRPStubCopy != nil { - return unclaimActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.unclaimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } diff --git a/db/dbfakes/fake_db.go b/db/dbfakes/fake_db.go index cef2c10f..e782e97e 100644 --- a/db/dbfakes/fake_db.go +++ b/db/dbfakes/fake_db.go @@ -645,16 +645,16 @@ func (fake *FakeDB) ActualLRPs(arg1 context.Context, arg2 lager.Logger, arg3 mod arg2 lager.Logger arg3 models.ActualLRPFilter }{arg1, arg2, arg3}) + stub := fake.ActualLRPsStub + fakeReturns := fake.actualLRPsReturns fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2, arg3}) - actualLRPsStubCopy := fake.ActualLRPsStub fake.actualLRPsMutex.Unlock() - if actualLRPsStubCopy != nil { - return actualLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -711,16 +711,16 @@ func (fake *FakeDB) CancelTask(arg1 context.Context, arg2 lager.Logger, arg3 str arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.CancelTaskStub + fakeReturns := fake.cancelTaskReturns fake.recordInvocation("CancelTask", []interface{}{arg1, arg2, arg3}) - cancelTaskStubCopy := fake.CancelTaskStub fake.cancelTaskMutex.Unlock() - if cancelTaskStubCopy != nil { - return cancelTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.cancelTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -785,16 +785,16 @@ func (fake *FakeDB) ChangeActualLRPPresence(arg1 context.Context, arg2 lager.Log arg4 models.ActualLRP_Presence arg5 models.ActualLRP_Presence }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ChangeActualLRPPresenceStub + fakeReturns := fake.changeActualLRPPresenceReturns fake.recordInvocation("ChangeActualLRPPresence", []interface{}{arg1, arg2, arg3, arg4, arg5}) - changeActualLRPPresenceStubCopy := fake.ChangeActualLRPPresenceStub fake.changeActualLRPPresenceMutex.Unlock() - if changeActualLRPPresenceStubCopy != nil { - return changeActualLRPPresenceStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.changeActualLRPPresenceReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -856,16 +856,16 @@ func (fake *FakeDB) ClaimActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ClaimActualLRPStub + fakeReturns := fake.claimActualLRPReturns fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - claimActualLRPStubCopy := fake.ClaimActualLRPStub fake.claimActualLRPMutex.Unlock() - if claimActualLRPStubCopy != nil { - return claimActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.claimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -929,16 +929,16 @@ func (fake *FakeDB) CompleteTask(arg1 context.Context, arg2 lager.Logger, arg3 s arg6 string arg7 string }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) + stub := fake.CompleteTaskStub + fakeReturns := fake.completeTaskReturns fake.recordInvocation("CompleteTask", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) - completeTaskStubCopy := fake.CompleteTaskStub fake.completeTaskMutex.Unlock() - if completeTaskStubCopy != nil { - return completeTaskStubCopy(arg1, arg2, arg3, arg4, arg5, arg6, arg7) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.completeTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -998,16 +998,16 @@ func (fake *FakeDB) ConvergeLRPs(arg1 context.Context, arg2 lager.Logger, arg3 m arg2 lager.Logger arg3 models.CellSet }{arg1, arg2, arg3}) + stub := fake.ConvergeLRPsStub + fakeReturns := fake.convergeLRPsReturns fake.recordInvocation("ConvergeLRPs", []interface{}{arg1, arg2, arg3}) - convergeLRPsStubCopy := fake.ConvergeLRPsStub fake.convergeLRPsMutex.Unlock() - if convergeLRPsStubCopy != nil { - return convergeLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeLRPsReturns return fakeReturns.result1 } @@ -1064,16 +1064,16 @@ func (fake *FakeDB) ConvergeTasks(arg1 context.Context, arg2 lager.Logger, arg3 arg5 time.Duration arg6 time.Duration }{arg1, arg2, arg3, arg4, arg5, arg6}) + stub := fake.ConvergeTasksStub + fakeReturns := fake.convergeTasksReturns fake.recordInvocation("ConvergeTasks", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) - convergeTasksStubCopy := fake.ConvergeTasksStub fake.convergeTasksMutex.Unlock() - if convergeTasksStubCopy != nil { - return convergeTasksStubCopy(arg1, arg2, arg3, arg4, arg5, arg6) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeTasksReturns return fakeReturns.result1 } @@ -1126,16 +1126,16 @@ func (fake *FakeDB) CountActualLRPsByState(arg1 context.Context, arg2 lager.Logg arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountActualLRPsByStateStub + fakeReturns := fake.countActualLRPsByStateReturns fake.recordInvocation("CountActualLRPsByState", []interface{}{arg1, arg2}) - countActualLRPsByStateStubCopy := fake.CountActualLRPsByStateStub fake.countActualLRPsByStateMutex.Unlock() - if countActualLRPsByStateStubCopy != nil { - return countActualLRPsByStateStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5 } - fakeReturns := fake.countActualLRPsByStateReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4, fakeReturns.result5 } @@ -1200,16 +1200,16 @@ func (fake *FakeDB) CountDesiredInstances(arg1 context.Context, arg2 lager.Logge arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountDesiredInstancesStub + fakeReturns := fake.countDesiredInstancesReturns fake.recordInvocation("CountDesiredInstances", []interface{}{arg1, arg2}) - countDesiredInstancesStubCopy := fake.CountDesiredInstancesStub fake.countDesiredInstancesMutex.Unlock() - if countDesiredInstancesStubCopy != nil { - return countDesiredInstancesStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.countDesiredInstancesReturns return fakeReturns.result1 } @@ -1265,16 +1265,16 @@ func (fake *FakeDB) CrashActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 arg4 *models.ActualLRPInstanceKey arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.CrashActualLRPStub + fakeReturns := fake.crashActualLRPReturns fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - crashActualLRPStubCopy := fake.CrashActualLRPStub fake.crashActualLRPMutex.Unlock() - if crashActualLRPStubCopy != nil { - return crashActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.crashActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -1337,16 +1337,16 @@ func (fake *FakeDB) CreateUnclaimedActualLRP(arg1 context.Context, arg2 lager.Lo arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.CreateUnclaimedActualLRPStub + fakeReturns := fake.createUnclaimedActualLRPReturns fake.recordInvocation("CreateUnclaimedActualLRP", []interface{}{arg1, arg2, arg3}) - createUnclaimedActualLRPStubCopy := fake.CreateUnclaimedActualLRPStub fake.createUnclaimedActualLRPMutex.Unlock() - if createUnclaimedActualLRPStubCopy != nil { - return createUnclaimedActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.createUnclaimedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1403,16 +1403,16 @@ func (fake *FakeDB) DeleteTask(arg1 context.Context, arg2 lager.Logger, arg3 str arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DeleteTaskStub + fakeReturns := fake.deleteTaskReturns fake.recordInvocation("DeleteTask", []interface{}{arg1, arg2, arg3}) - deleteTaskStubCopy := fake.DeleteTaskStub fake.deleteTaskMutex.Unlock() - if deleteTaskStubCopy != nil { - return deleteTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.deleteTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1469,16 +1469,16 @@ func (fake *FakeDB) DesireLRP(arg1 context.Context, arg2 lager.Logger, arg3 *mod arg2 lager.Logger arg3 *models.DesiredLRP }{arg1, arg2, arg3}) + stub := fake.DesireLRPStub + fakeReturns := fake.desireLRPReturns fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2, arg3}) - desireLRPStubCopy := fake.DesireLRPStub fake.desireLRPMutex.Unlock() - if desireLRPStubCopy != nil { - return desireLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireLRPReturns return fakeReturns.result1 } @@ -1534,16 +1534,16 @@ func (fake *FakeDB) DesireTask(arg1 context.Context, arg2 lager.Logger, arg3 *mo arg4 string arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.DesireTaskStub + fakeReturns := fake.desireTaskReturns fake.recordInvocation("DesireTask", []interface{}{arg1, arg2, arg3, arg4, arg5}) - desireTaskStubCopy := fake.DesireTaskStub fake.desireTaskMutex.Unlock() - if desireTaskStubCopy != nil { - return desireTaskStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desireTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1600,16 +1600,16 @@ func (fake *FakeDB) DesiredLRPByProcessGuid(arg1 context.Context, arg2 lager.Log arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DesiredLRPByProcessGuidStub + fakeReturns := fake.desiredLRPByProcessGuidReturns fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2, arg3}) - desiredLRPByProcessGuidStubCopy := fake.DesiredLRPByProcessGuidStub fake.desiredLRPByProcessGuidMutex.Unlock() - if desiredLRPByProcessGuidStubCopy != nil { - return desiredLRPByProcessGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1666,16 +1666,16 @@ func (fake *FakeDB) DesiredLRPSchedulingInfos(arg1 context.Context, arg2 lager.L arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPSchedulingInfosStub + fakeReturns := fake.desiredLRPSchedulingInfosReturns fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2, arg3}) - desiredLRPSchedulingInfosStubCopy := fake.DesiredLRPSchedulingInfosStub fake.desiredLRPSchedulingInfosMutex.Unlock() - if desiredLRPSchedulingInfosStubCopy != nil { - return desiredLRPSchedulingInfosStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPSchedulingInfosReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1732,16 +1732,16 @@ func (fake *FakeDB) DesiredLRPs(arg1 context.Context, arg2 lager.Logger, arg3 mo arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPsStub + fakeReturns := fake.desiredLRPsReturns fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2, arg3}) - desiredLRPsStubCopy := fake.DesiredLRPsStub fake.desiredLRPsMutex.Unlock() - if desiredLRPsStubCopy != nil { - return desiredLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1797,16 +1797,16 @@ func (fake *FakeDB) EncryptionKeyLabel(arg1 context.Context, arg2 lager.Logger) arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.EncryptionKeyLabelStub + fakeReturns := fake.encryptionKeyLabelReturns fake.recordInvocation("EncryptionKeyLabel", []interface{}{arg1, arg2}) - encryptionKeyLabelStubCopy := fake.EncryptionKeyLabelStub fake.encryptionKeyLabelMutex.Unlock() - if encryptionKeyLabelStubCopy != nil { - return encryptionKeyLabelStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.encryptionKeyLabelReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1865,16 +1865,16 @@ func (fake *FakeDB) EvacuateActualLRP(arg1 context.Context, arg2 lager.Logger, a arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.EvacuateActualLRPStub + fakeReturns := fake.evacuateActualLRPReturns fake.recordInvocation("EvacuateActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - evacuateActualLRPStubCopy := fake.EvacuateActualLRPStub fake.evacuateActualLRPMutex.Unlock() - if evacuateActualLRPStubCopy != nil { - return evacuateActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1932,16 +1932,16 @@ func (fake *FakeDB) FailActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 arg3 *models.ActualLRPKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailActualLRPStub + fakeReturns := fake.failActualLRPReturns fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - failActualLRPStubCopy := fake.FailActualLRPStub fake.failActualLRPMutex.Unlock() - if failActualLRPStubCopy != nil { - return failActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.failActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -2002,16 +2002,16 @@ func (fake *FakeDB) FailTask(arg1 context.Context, arg2 lager.Logger, arg3 strin arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailTaskStub + fakeReturns := fake.failTaskReturns fake.recordInvocation("FailTask", []interface{}{arg1, arg2, arg3, arg4}) - failTaskStubCopy := fake.FailTaskStub fake.failTaskMutex.Unlock() - if failTaskStubCopy != nil { - return failTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.failTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -2070,16 +2070,16 @@ func (fake *FakeDB) FreshDomains(arg1 context.Context, arg2 lager.Logger) ([]str arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.FreshDomainsStub + fakeReturns := fake.freshDomainsReturns fake.recordInvocation("FreshDomains", []interface{}{arg1, arg2}) - freshDomainsStubCopy := fake.FreshDomainsStub fake.freshDomainsMutex.Unlock() - if freshDomainsStubCopy != nil { - return freshDomainsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.freshDomainsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2135,16 +2135,16 @@ func (fake *FakeDB) PerformEncryption(arg1 context.Context, arg2 lager.Logger) e arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.PerformEncryptionStub + fakeReturns := fake.performEncryptionReturns fake.recordInvocation("PerformEncryption", []interface{}{arg1, arg2}) - performEncryptionStubCopy := fake.PerformEncryptionStub fake.performEncryptionMutex.Unlock() - if performEncryptionStubCopy != nil { - return performEncryptionStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.performEncryptionReturns return fakeReturns.result1 } @@ -2199,16 +2199,16 @@ func (fake *FakeDB) RejectTask(arg1 context.Context, arg2 lager.Logger, arg3 str arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.RejectTaskStub + fakeReturns := fake.rejectTaskReturns fake.recordInvocation("RejectTask", []interface{}{arg1, arg2, arg3, arg4}) - rejectTaskStubCopy := fake.RejectTaskStub fake.rejectTaskMutex.Unlock() - if rejectTaskStubCopy != nil { - return rejectTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.rejectTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -2270,16 +2270,16 @@ func (fake *FakeDB) RemoveActualLRP(arg1 context.Context, arg2 lager.Logger, arg arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.RemoveActualLRPStub + fakeReturns := fake.removeActualLRPReturns fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - removeActualLRPStubCopy := fake.RemoveActualLRPStub fake.removeActualLRPMutex.Unlock() - if removeActualLRPStubCopy != nil { - return removeActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeActualLRPReturns return fakeReturns.result1 } @@ -2333,16 +2333,16 @@ func (fake *FakeDB) RemoveDesiredLRP(arg1 context.Context, arg2 lager.Logger, ar arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.RemoveDesiredLRPStub + fakeReturns := fake.removeDesiredLRPReturns fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2, arg3}) - removeDesiredLRPStubCopy := fake.RemoveDesiredLRPStub fake.removeDesiredLRPMutex.Unlock() - if removeDesiredLRPStubCopy != nil { - return removeDesiredLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeDesiredLRPReturns return fakeReturns.result1 } @@ -2397,16 +2397,16 @@ func (fake *FakeDB) RemoveEvacuatingActualLRP(arg1 context.Context, arg2 lager.L arg3 *models.ActualLRPKey arg4 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4}) + stub := fake.RemoveEvacuatingActualLRPStub + fakeReturns := fake.removeEvacuatingActualLRPReturns fake.recordInvocation("RemoveEvacuatingActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - removeEvacuatingActualLRPStubCopy := fake.RemoveEvacuatingActualLRPStub fake.removeEvacuatingActualLRPMutex.Unlock() - if removeEvacuatingActualLRPStubCopy != nil { - return removeEvacuatingActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeEvacuatingActualLRPReturns return fakeReturns.result1 } @@ -2460,16 +2460,16 @@ func (fake *FakeDB) RemoveSuspectActualLRP(arg1 context.Context, arg2 lager.Logg arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.RemoveSuspectActualLRPStub + fakeReturns := fake.removeSuspectActualLRPReturns fake.recordInvocation("RemoveSuspectActualLRP", []interface{}{arg1, arg2, arg3}) - removeSuspectActualLRPStubCopy := fake.RemoveSuspectActualLRPStub fake.removeSuspectActualLRPMutex.Unlock() - if removeSuspectActualLRPStubCopy != nil { - return removeSuspectActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.removeSuspectActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2526,16 +2526,16 @@ func (fake *FakeDB) ResolvingTask(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.ResolvingTaskStub + fakeReturns := fake.resolvingTaskReturns fake.recordInvocation("ResolvingTask", []interface{}{arg1, arg2, arg3}) - resolvingTaskStubCopy := fake.ResolvingTaskStub fake.resolvingTaskMutex.Unlock() - if resolvingTaskStubCopy != nil { - return resolvingTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.resolvingTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -2595,16 +2595,16 @@ func (fake *FakeDB) SetEncryptionKeyLabel(arg1 context.Context, arg2 lager.Logge arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.SetEncryptionKeyLabelStub + fakeReturns := fake.setEncryptionKeyLabelReturns fake.recordInvocation("SetEncryptionKeyLabel", []interface{}{arg1, arg2, arg3}) - setEncryptionKeyLabelStubCopy := fake.SetEncryptionKeyLabelStub fake.setEncryptionKeyLabelMutex.Unlock() - if setEncryptionKeyLabelStubCopy != nil { - return setEncryptionKeyLabelStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.setEncryptionKeyLabelReturns return fakeReturns.result1 } @@ -2658,16 +2658,16 @@ func (fake *FakeDB) SetVersion(arg1 context.Context, arg2 lager.Logger, arg3 *mo arg2 lager.Logger arg3 *models.Version }{arg1, arg2, arg3}) + stub := fake.SetVersionStub + fakeReturns := fake.setVersionReturns fake.recordInvocation("SetVersion", []interface{}{arg1, arg2, arg3}) - setVersionStubCopy := fake.SetVersionStub fake.setVersionMutex.Unlock() - if setVersionStubCopy != nil { - return setVersionStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.setVersionReturns return fakeReturns.result1 } @@ -2723,16 +2723,16 @@ func (fake *FakeDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, arg3 arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.StartActualLRPStub + fakeReturns := fake.startActualLRPReturns fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - startActualLRPStubCopy := fake.StartActualLRPStub fake.startActualLRPMutex.Unlock() - if startActualLRPStubCopy != nil { - return startActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.startActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -2793,16 +2793,16 @@ func (fake *FakeDB) StartTask(arg1 context.Context, arg2 lager.Logger, arg3 stri arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.StartTaskStub + fakeReturns := fake.startTaskReturns fake.recordInvocation("StartTask", []interface{}{arg1, arg2, arg3, arg4}) - startTaskStubCopy := fake.StartTaskStub fake.startTaskMutex.Unlock() - if startTaskStubCopy != nil { - return startTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.startTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -2865,16 +2865,16 @@ func (fake *FakeDB) TaskByGuid(arg1 context.Context, arg2 lager.Logger, arg3 str arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.TaskByGuidStub + fakeReturns := fake.taskByGuidReturns fake.recordInvocation("TaskByGuid", []interface{}{arg1, arg2, arg3}) - taskByGuidStubCopy := fake.TaskByGuidStub fake.taskByGuidMutex.Unlock() - if taskByGuidStubCopy != nil { - return taskByGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.taskByGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2931,16 +2931,16 @@ func (fake *FakeDB) Tasks(arg1 context.Context, arg2 lager.Logger, arg3 models.T arg2 lager.Logger arg3 models.TaskFilter }{arg1, arg2, arg3}) + stub := fake.TasksStub + fakeReturns := fake.tasksReturns fake.recordInvocation("Tasks", []interface{}{arg1, arg2, arg3}) - tasksStubCopy := fake.TasksStub fake.tasksMutex.Unlock() - if tasksStubCopy != nil { - return tasksStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2997,16 +2997,16 @@ func (fake *FakeDB) UnclaimActualLRP(arg1 context.Context, arg2 lager.Logger, ar arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.UnclaimActualLRPStub + fakeReturns := fake.unclaimActualLRPReturns fake.recordInvocation("UnclaimActualLRP", []interface{}{arg1, arg2, arg3}) - unclaimActualLRPStubCopy := fake.UnclaimActualLRPStub fake.unclaimActualLRPMutex.Unlock() - if unclaimActualLRPStubCopy != nil { - return unclaimActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.unclaimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -3067,16 +3067,16 @@ func (fake *FakeDB) UpdateDesiredLRP(arg1 context.Context, arg2 lager.Logger, ar arg3 string arg4 *models.DesiredLRPUpdate }{arg1, arg2, arg3, arg4}) + stub := fake.UpdateDesiredLRPStub + fakeReturns := fake.updateDesiredLRPReturns fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3, arg4}) - updateDesiredLRPStubCopy := fake.UpdateDesiredLRPStub fake.updateDesiredLRPMutex.Unlock() - if updateDesiredLRPStubCopy != nil { - return updateDesiredLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.updateDesiredLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -3134,16 +3134,16 @@ func (fake *FakeDB) UpsertDomain(arg1 context.Context, arg2 lager.Logger, arg3 s arg3 string arg4 uint32 }{arg1, arg2, arg3, arg4}) + stub := fake.UpsertDomainStub + fakeReturns := fake.upsertDomainReturns fake.recordInvocation("UpsertDomain", []interface{}{arg1, arg2, arg3, arg4}) - upsertDomainStubCopy := fake.UpsertDomainStub fake.upsertDomainMutex.Unlock() - if upsertDomainStubCopy != nil { - return upsertDomainStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.upsertDomainReturns return fakeReturns.result1 } @@ -3196,16 +3196,16 @@ func (fake *FakeDB) Version(arg1 context.Context, arg2 lager.Logger) (*models.Ve arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.VersionStub + fakeReturns := fake.versionReturns fake.recordInvocation("Version", []interface{}{arg1, arg2}) - versionStubCopy := fake.VersionStub fake.versionMutex.Unlock() - if versionStubCopy != nil { - return versionStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.versionReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/dbfakes/fake_desired_lrpdb.go b/db/dbfakes/fake_desired_lrpdb.go index 39a8bb0d..4fcf880e 100644 --- a/db/dbfakes/fake_desired_lrpdb.go +++ b/db/dbfakes/fake_desired_lrpdb.go @@ -110,16 +110,16 @@ func (fake *FakeDesiredLRPDB) DesireLRP(arg1 context.Context, arg2 lager.Logger, arg2 lager.Logger arg3 *models.DesiredLRP }{arg1, arg2, arg3}) + stub := fake.DesireLRPStub + fakeReturns := fake.desireLRPReturns fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2, arg3}) - desireLRPStubCopy := fake.DesireLRPStub fake.desireLRPMutex.Unlock() - if desireLRPStubCopy != nil { - return desireLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireLRPReturns return fakeReturns.result1 } @@ -173,16 +173,16 @@ func (fake *FakeDesiredLRPDB) DesiredLRPByProcessGuid(arg1 context.Context, arg2 arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DesiredLRPByProcessGuidStub + fakeReturns := fake.desiredLRPByProcessGuidReturns fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2, arg3}) - desiredLRPByProcessGuidStubCopy := fake.DesiredLRPByProcessGuidStub fake.desiredLRPByProcessGuidMutex.Unlock() - if desiredLRPByProcessGuidStubCopy != nil { - return desiredLRPByProcessGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -239,16 +239,16 @@ func (fake *FakeDesiredLRPDB) DesiredLRPSchedulingInfos(arg1 context.Context, ar arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPSchedulingInfosStub + fakeReturns := fake.desiredLRPSchedulingInfosReturns fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2, arg3}) - desiredLRPSchedulingInfosStubCopy := fake.DesiredLRPSchedulingInfosStub fake.desiredLRPSchedulingInfosMutex.Unlock() - if desiredLRPSchedulingInfosStubCopy != nil { - return desiredLRPSchedulingInfosStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPSchedulingInfosReturns return fakeReturns.result1, fakeReturns.result2 } @@ -305,16 +305,16 @@ func (fake *FakeDesiredLRPDB) DesiredLRPs(arg1 context.Context, arg2 lager.Logge arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPsStub + fakeReturns := fake.desiredLRPsReturns fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2, arg3}) - desiredLRPsStubCopy := fake.DesiredLRPsStub fake.desiredLRPsMutex.Unlock() - if desiredLRPsStubCopy != nil { - return desiredLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -371,16 +371,16 @@ func (fake *FakeDesiredLRPDB) RemoveDesiredLRP(arg1 context.Context, arg2 lager. arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.RemoveDesiredLRPStub + fakeReturns := fake.removeDesiredLRPReturns fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2, arg3}) - removeDesiredLRPStubCopy := fake.RemoveDesiredLRPStub fake.removeDesiredLRPMutex.Unlock() - if removeDesiredLRPStubCopy != nil { - return removeDesiredLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeDesiredLRPReturns return fakeReturns.result1 } @@ -435,16 +435,16 @@ func (fake *FakeDesiredLRPDB) UpdateDesiredLRP(arg1 context.Context, arg2 lager. arg3 string arg4 *models.DesiredLRPUpdate }{arg1, arg2, arg3, arg4}) + stub := fake.UpdateDesiredLRPStub + fakeReturns := fake.updateDesiredLRPReturns fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3, arg4}) - updateDesiredLRPStubCopy := fake.UpdateDesiredLRPStub fake.updateDesiredLRPMutex.Unlock() - if updateDesiredLRPStubCopy != nil { - return updateDesiredLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.updateDesiredLRPReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/dbfakes/fake_domain_db.go b/db/dbfakes/fake_domain_db.go index 5e50eb8e..122d1c8b 100644 --- a/db/dbfakes/fake_domain_db.go +++ b/db/dbfakes/fake_domain_db.go @@ -49,16 +49,16 @@ func (fake *FakeDomainDB) FreshDomains(arg1 context.Context, arg2 lager.Logger) arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.FreshDomainsStub + fakeReturns := fake.freshDomainsReturns fake.recordInvocation("FreshDomains", []interface{}{arg1, arg2}) - freshDomainsStubCopy := fake.FreshDomainsStub fake.freshDomainsMutex.Unlock() - if freshDomainsStubCopy != nil { - return freshDomainsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.freshDomainsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -116,16 +116,16 @@ func (fake *FakeDomainDB) UpsertDomain(arg1 context.Context, arg2 lager.Logger, arg3 string arg4 uint32 }{arg1, arg2, arg3, arg4}) + stub := fake.UpsertDomainStub + fakeReturns := fake.upsertDomainReturns fake.recordInvocation("UpsertDomain", []interface{}{arg1, arg2, arg3, arg4}) - upsertDomainStubCopy := fake.UpsertDomainStub fake.upsertDomainMutex.Unlock() - if upsertDomainStubCopy != nil { - return upsertDomainStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.upsertDomainReturns return fakeReturns.result1 } diff --git a/db/dbfakes/fake_encryption_db.go b/db/dbfakes/fake_encryption_db.go index 1e0379a6..79b4ee32 100644 --- a/db/dbfakes/fake_encryption_db.go +++ b/db/dbfakes/fake_encryption_db.go @@ -60,16 +60,16 @@ func (fake *FakeEncryptionDB) EncryptionKeyLabel(arg1 context.Context, arg2 lage arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.EncryptionKeyLabelStub + fakeReturns := fake.encryptionKeyLabelReturns fake.recordInvocation("EncryptionKeyLabel", []interface{}{arg1, arg2}) - encryptionKeyLabelStubCopy := fake.EncryptionKeyLabelStub fake.encryptionKeyLabelMutex.Unlock() - if encryptionKeyLabelStubCopy != nil { - return encryptionKeyLabelStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.encryptionKeyLabelReturns return fakeReturns.result1, fakeReturns.result2 } @@ -125,16 +125,16 @@ func (fake *FakeEncryptionDB) PerformEncryption(arg1 context.Context, arg2 lager arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.PerformEncryptionStub + fakeReturns := fake.performEncryptionReturns fake.recordInvocation("PerformEncryption", []interface{}{arg1, arg2}) - performEncryptionStubCopy := fake.PerformEncryptionStub fake.performEncryptionMutex.Unlock() - if performEncryptionStubCopy != nil { - return performEncryptionStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.performEncryptionReturns return fakeReturns.result1 } @@ -188,16 +188,16 @@ func (fake *FakeEncryptionDB) SetEncryptionKeyLabel(arg1 context.Context, arg2 l arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.SetEncryptionKeyLabelStub + fakeReturns := fake.setEncryptionKeyLabelReturns fake.recordInvocation("SetEncryptionKeyLabel", []interface{}{arg1, arg2, arg3}) - setEncryptionKeyLabelStubCopy := fake.SetEncryptionKeyLabelStub fake.setEncryptionKeyLabelMutex.Unlock() - if setEncryptionKeyLabelStubCopy != nil { - return setEncryptionKeyLabelStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.setEncryptionKeyLabelReturns return fakeReturns.result1 } diff --git a/db/dbfakes/fake_evacuation_db.go b/db/dbfakes/fake_evacuation_db.go index 922dbc0f..59b0f6b8 100644 --- a/db/dbfakes/fake_evacuation_db.go +++ b/db/dbfakes/fake_evacuation_db.go @@ -56,16 +56,16 @@ func (fake *FakeEvacuationDB) EvacuateActualLRP(arg1 context.Context, arg2 lager arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.EvacuateActualLRPStub + fakeReturns := fake.evacuateActualLRPReturns fake.recordInvocation("EvacuateActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - evacuateActualLRPStubCopy := fake.EvacuateActualLRPStub fake.evacuateActualLRPMutex.Unlock() - if evacuateActualLRPStubCopy != nil { - return evacuateActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -123,16 +123,16 @@ func (fake *FakeEvacuationDB) RemoveEvacuatingActualLRP(arg1 context.Context, ar arg3 *models.ActualLRPKey arg4 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4}) + stub := fake.RemoveEvacuatingActualLRPStub + fakeReturns := fake.removeEvacuatingActualLRPReturns fake.recordInvocation("RemoveEvacuatingActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - removeEvacuatingActualLRPStubCopy := fake.RemoveEvacuatingActualLRPStub fake.removeEvacuatingActualLRPMutex.Unlock() - if removeEvacuatingActualLRPStubCopy != nil { - return removeEvacuatingActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeEvacuatingActualLRPReturns return fakeReturns.result1 } diff --git a/db/dbfakes/fake_lrpdb.go b/db/dbfakes/fake_lrpdb.go index 213a2349..2676e2c5 100644 --- a/db/dbfakes/fake_lrpdb.go +++ b/db/dbfakes/fake_lrpdb.go @@ -313,16 +313,16 @@ func (fake *FakeLRPDB) ActualLRPs(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 models.ActualLRPFilter }{arg1, arg2, arg3}) + stub := fake.ActualLRPsStub + fakeReturns := fake.actualLRPsReturns fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2, arg3}) - actualLRPsStubCopy := fake.ActualLRPsStub fake.actualLRPsMutex.Unlock() - if actualLRPsStubCopy != nil { - return actualLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -381,16 +381,16 @@ func (fake *FakeLRPDB) ChangeActualLRPPresence(arg1 context.Context, arg2 lager. arg4 models.ActualLRP_Presence arg5 models.ActualLRP_Presence }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ChangeActualLRPPresenceStub + fakeReturns := fake.changeActualLRPPresenceReturns fake.recordInvocation("ChangeActualLRPPresence", []interface{}{arg1, arg2, arg3, arg4, arg5}) - changeActualLRPPresenceStubCopy := fake.ChangeActualLRPPresenceStub fake.changeActualLRPPresenceMutex.Unlock() - if changeActualLRPPresenceStubCopy != nil { - return changeActualLRPPresenceStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.changeActualLRPPresenceReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -452,16 +452,16 @@ func (fake *FakeLRPDB) ClaimActualLRP(arg1 context.Context, arg2 lager.Logger, a arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ClaimActualLRPStub + fakeReturns := fake.claimActualLRPReturns fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - claimActualLRPStubCopy := fake.ClaimActualLRPStub fake.claimActualLRPMutex.Unlock() - if claimActualLRPStubCopy != nil { - return claimActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.claimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -521,16 +521,16 @@ func (fake *FakeLRPDB) ConvergeLRPs(arg1 context.Context, arg2 lager.Logger, arg arg2 lager.Logger arg3 models.CellSet }{arg1, arg2, arg3}) + stub := fake.ConvergeLRPsStub + fakeReturns := fake.convergeLRPsReturns fake.recordInvocation("ConvergeLRPs", []interface{}{arg1, arg2, arg3}) - convergeLRPsStubCopy := fake.ConvergeLRPsStub fake.convergeLRPsMutex.Unlock() - if convergeLRPsStubCopy != nil { - return convergeLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeLRPsReturns return fakeReturns.result1 } @@ -583,16 +583,16 @@ func (fake *FakeLRPDB) CountActualLRPsByState(arg1 context.Context, arg2 lager.L arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountActualLRPsByStateStub + fakeReturns := fake.countActualLRPsByStateReturns fake.recordInvocation("CountActualLRPsByState", []interface{}{arg1, arg2}) - countActualLRPsByStateStubCopy := fake.CountActualLRPsByStateStub fake.countActualLRPsByStateMutex.Unlock() - if countActualLRPsByStateStubCopy != nil { - return countActualLRPsByStateStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5 } - fakeReturns := fake.countActualLRPsByStateReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4, fakeReturns.result5 } @@ -657,16 +657,16 @@ func (fake *FakeLRPDB) CountDesiredInstances(arg1 context.Context, arg2 lager.Lo arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.CountDesiredInstancesStub + fakeReturns := fake.countDesiredInstancesReturns fake.recordInvocation("CountDesiredInstances", []interface{}{arg1, arg2}) - countDesiredInstancesStubCopy := fake.CountDesiredInstancesStub fake.countDesiredInstancesMutex.Unlock() - if countDesiredInstancesStubCopy != nil { - return countDesiredInstancesStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.countDesiredInstancesReturns return fakeReturns.result1 } @@ -722,16 +722,16 @@ func (fake *FakeLRPDB) CrashActualLRP(arg1 context.Context, arg2 lager.Logger, a arg4 *models.ActualLRPInstanceKey arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.CrashActualLRPStub + fakeReturns := fake.crashActualLRPReturns fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - crashActualLRPStubCopy := fake.CrashActualLRPStub fake.crashActualLRPMutex.Unlock() - if crashActualLRPStubCopy != nil { - return crashActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.crashActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -794,16 +794,16 @@ func (fake *FakeLRPDB) CreateUnclaimedActualLRP(arg1 context.Context, arg2 lager arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.CreateUnclaimedActualLRPStub + fakeReturns := fake.createUnclaimedActualLRPReturns fake.recordInvocation("CreateUnclaimedActualLRP", []interface{}{arg1, arg2, arg3}) - createUnclaimedActualLRPStubCopy := fake.CreateUnclaimedActualLRPStub fake.createUnclaimedActualLRPMutex.Unlock() - if createUnclaimedActualLRPStubCopy != nil { - return createUnclaimedActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.createUnclaimedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -860,16 +860,16 @@ func (fake *FakeLRPDB) DesireLRP(arg1 context.Context, arg2 lager.Logger, arg3 * arg2 lager.Logger arg3 *models.DesiredLRP }{arg1, arg2, arg3}) + stub := fake.DesireLRPStub + fakeReturns := fake.desireLRPReturns fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2, arg3}) - desireLRPStubCopy := fake.DesireLRPStub fake.desireLRPMutex.Unlock() - if desireLRPStubCopy != nil { - return desireLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireLRPReturns return fakeReturns.result1 } @@ -923,16 +923,16 @@ func (fake *FakeLRPDB) DesiredLRPByProcessGuid(arg1 context.Context, arg2 lager. arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DesiredLRPByProcessGuidStub + fakeReturns := fake.desiredLRPByProcessGuidReturns fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2, arg3}) - desiredLRPByProcessGuidStubCopy := fake.DesiredLRPByProcessGuidStub fake.desiredLRPByProcessGuidMutex.Unlock() - if desiredLRPByProcessGuidStubCopy != nil { - return desiredLRPByProcessGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -989,16 +989,16 @@ func (fake *FakeLRPDB) DesiredLRPSchedulingInfos(arg1 context.Context, arg2 lage arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPSchedulingInfosStub + fakeReturns := fake.desiredLRPSchedulingInfosReturns fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2, arg3}) - desiredLRPSchedulingInfosStubCopy := fake.DesiredLRPSchedulingInfosStub fake.desiredLRPSchedulingInfosMutex.Unlock() - if desiredLRPSchedulingInfosStubCopy != nil { - return desiredLRPSchedulingInfosStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPSchedulingInfosReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1055,16 +1055,16 @@ func (fake *FakeLRPDB) DesiredLRPs(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 models.DesiredLRPFilter }{arg1, arg2, arg3}) + stub := fake.DesiredLRPsStub + fakeReturns := fake.desiredLRPsReturns fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2, arg3}) - desiredLRPsStubCopy := fake.DesiredLRPsStub fake.desiredLRPsMutex.Unlock() - if desiredLRPsStubCopy != nil { - return desiredLRPsStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1122,16 +1122,16 @@ func (fake *FakeLRPDB) FailActualLRP(arg1 context.Context, arg2 lager.Logger, ar arg3 *models.ActualLRPKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailActualLRPStub + fakeReturns := fake.failActualLRPReturns fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - failActualLRPStubCopy := fake.FailActualLRPStub fake.failActualLRPMutex.Unlock() - if failActualLRPStubCopy != nil { - return failActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.failActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -1193,16 +1193,16 @@ func (fake *FakeLRPDB) RemoveActualLRP(arg1 context.Context, arg2 lager.Logger, arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.RemoveActualLRPStub + fakeReturns := fake.removeActualLRPReturns fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - removeActualLRPStubCopy := fake.RemoveActualLRPStub fake.removeActualLRPMutex.Unlock() - if removeActualLRPStubCopy != nil { - return removeActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeActualLRPReturns return fakeReturns.result1 } @@ -1256,16 +1256,16 @@ func (fake *FakeLRPDB) RemoveDesiredLRP(arg1 context.Context, arg2 lager.Logger, arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.RemoveDesiredLRPStub + fakeReturns := fake.removeDesiredLRPReturns fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2, arg3}) - removeDesiredLRPStubCopy := fake.RemoveDesiredLRPStub fake.removeDesiredLRPMutex.Unlock() - if removeDesiredLRPStubCopy != nil { - return removeDesiredLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeDesiredLRPReturns return fakeReturns.result1 } @@ -1321,16 +1321,16 @@ func (fake *FakeLRPDB) StartActualLRP(arg1 context.Context, arg2 lager.Logger, a arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.StartActualLRPStub + fakeReturns := fake.startActualLRPReturns fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - startActualLRPStubCopy := fake.StartActualLRPStub fake.startActualLRPMutex.Unlock() - if startActualLRPStubCopy != nil { - return startActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.startActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -1390,16 +1390,16 @@ func (fake *FakeLRPDB) UnclaimActualLRP(arg1 context.Context, arg2 lager.Logger, arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.UnclaimActualLRPStub + fakeReturns := fake.unclaimActualLRPReturns fake.recordInvocation("UnclaimActualLRP", []interface{}{arg1, arg2, arg3}) - unclaimActualLRPStubCopy := fake.UnclaimActualLRPStub fake.unclaimActualLRPMutex.Unlock() - if unclaimActualLRPStubCopy != nil { - return unclaimActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.unclaimActualLRPReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -1460,16 +1460,16 @@ func (fake *FakeLRPDB) UpdateDesiredLRP(arg1 context.Context, arg2 lager.Logger, arg3 string arg4 *models.DesiredLRPUpdate }{arg1, arg2, arg3, arg4}) + stub := fake.UpdateDesiredLRPStub + fakeReturns := fake.updateDesiredLRPReturns fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3, arg4}) - updateDesiredLRPStubCopy := fake.UpdateDesiredLRPStub fake.updateDesiredLRPMutex.Unlock() - if updateDesiredLRPStubCopy != nil { - return updateDesiredLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.updateDesiredLRPReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/dbfakes/fake_suspect_db.go b/db/dbfakes/fake_suspect_db.go index 206f76f0..1c5eea65 100644 --- a/db/dbfakes/fake_suspect_db.go +++ b/db/dbfakes/fake_suspect_db.go @@ -38,16 +38,16 @@ func (fake *FakeSuspectDB) RemoveSuspectActualLRP(arg1 context.Context, arg2 lag arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.RemoveSuspectActualLRPStub + fakeReturns := fake.removeSuspectActualLRPReturns fake.recordInvocation("RemoveSuspectActualLRP", []interface{}{arg1, arg2, arg3}) - removeSuspectActualLRPStubCopy := fake.RemoveSuspectActualLRPStub fake.removeSuspectActualLRPMutex.Unlock() - if removeSuspectActualLRPStubCopy != nil { - return removeSuspectActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.removeSuspectActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/dbfakes/fake_task_db.go b/db/dbfakes/fake_task_db.go index 4bfe32ed..b0516714 100644 --- a/db/dbfakes/fake_task_db.go +++ b/db/dbfakes/fake_task_db.go @@ -215,16 +215,16 @@ func (fake *FakeTaskDB) CancelTask(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.CancelTaskStub + fakeReturns := fake.cancelTaskReturns fake.recordInvocation("CancelTask", []interface{}{arg1, arg2, arg3}) - cancelTaskStubCopy := fake.CancelTaskStub fake.cancelTaskMutex.Unlock() - if cancelTaskStubCopy != nil { - return cancelTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.cancelTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -291,16 +291,16 @@ func (fake *FakeTaskDB) CompleteTask(arg1 context.Context, arg2 lager.Logger, ar arg6 string arg7 string }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) + stub := fake.CompleteTaskStub + fakeReturns := fake.completeTaskReturns fake.recordInvocation("CompleteTask", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) - completeTaskStubCopy := fake.CompleteTaskStub fake.completeTaskMutex.Unlock() - if completeTaskStubCopy != nil { - return completeTaskStubCopy(arg1, arg2, arg3, arg4, arg5, arg6, arg7) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.completeTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -363,16 +363,16 @@ func (fake *FakeTaskDB) ConvergeTasks(arg1 context.Context, arg2 lager.Logger, a arg5 time.Duration arg6 time.Duration }{arg1, arg2, arg3, arg4, arg5, arg6}) + stub := fake.ConvergeTasksStub + fakeReturns := fake.convergeTasksReturns fake.recordInvocation("ConvergeTasks", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) - convergeTasksStubCopy := fake.ConvergeTasksStub fake.convergeTasksMutex.Unlock() - if convergeTasksStubCopy != nil { - return convergeTasksStubCopy(arg1, arg2, arg3, arg4, arg5, arg6) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeTasksReturns return fakeReturns.result1 } @@ -426,16 +426,16 @@ func (fake *FakeTaskDB) DeleteTask(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DeleteTaskStub + fakeReturns := fake.deleteTaskReturns fake.recordInvocation("DeleteTask", []interface{}{arg1, arg2, arg3}) - deleteTaskStubCopy := fake.DeleteTaskStub fake.deleteTaskMutex.Unlock() - if deleteTaskStubCopy != nil { - return deleteTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.deleteTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -494,16 +494,16 @@ func (fake *FakeTaskDB) DesireTask(arg1 context.Context, arg2 lager.Logger, arg3 arg4 string arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.DesireTaskStub + fakeReturns := fake.desireTaskReturns fake.recordInvocation("DesireTask", []interface{}{arg1, arg2, arg3, arg4, arg5}) - desireTaskStubCopy := fake.DesireTaskStub fake.desireTaskMutex.Unlock() - if desireTaskStubCopy != nil { - return desireTaskStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desireTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -561,16 +561,16 @@ func (fake *FakeTaskDB) FailTask(arg1 context.Context, arg2 lager.Logger, arg3 s arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailTaskStub + fakeReturns := fake.failTaskReturns fake.recordInvocation("FailTask", []interface{}{arg1, arg2, arg3, arg4}) - failTaskStubCopy := fake.FailTaskStub fake.failTaskMutex.Unlock() - if failTaskStubCopy != nil { - return failTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.failTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -631,16 +631,16 @@ func (fake *FakeTaskDB) RejectTask(arg1 context.Context, arg2 lager.Logger, arg3 arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.RejectTaskStub + fakeReturns := fake.rejectTaskReturns fake.recordInvocation("RejectTask", []interface{}{arg1, arg2, arg3, arg4}) - rejectTaskStubCopy := fake.RejectTaskStub fake.rejectTaskMutex.Unlock() - if rejectTaskStubCopy != nil { - return rejectTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.rejectTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -700,16 +700,16 @@ func (fake *FakeTaskDB) ResolvingTask(arg1 context.Context, arg2 lager.Logger, a arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.ResolvingTaskStub + fakeReturns := fake.resolvingTaskReturns fake.recordInvocation("ResolvingTask", []interface{}{arg1, arg2, arg3}) - resolvingTaskStubCopy := fake.ResolvingTaskStub fake.resolvingTaskMutex.Unlock() - if resolvingTaskStubCopy != nil { - return resolvingTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2, ret.result3 } - fakeReturns := fake.resolvingTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 } @@ -770,16 +770,16 @@ func (fake *FakeTaskDB) StartTask(arg1 context.Context, arg2 lager.Logger, arg3 arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.StartTaskStub + fakeReturns := fake.startTaskReturns fake.recordInvocation("StartTask", []interface{}{arg1, arg2, arg3, arg4}) - startTaskStubCopy := fake.StartTaskStub fake.startTaskMutex.Unlock() - if startTaskStubCopy != nil { - return startTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2, ret.result3, ret.result4 } - fakeReturns := fake.startTaskReturns return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4 } @@ -842,16 +842,16 @@ func (fake *FakeTaskDB) TaskByGuid(arg1 context.Context, arg2 lager.Logger, arg3 arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.TaskByGuidStub + fakeReturns := fake.taskByGuidReturns fake.recordInvocation("TaskByGuid", []interface{}{arg1, arg2, arg3}) - taskByGuidStubCopy := fake.TaskByGuidStub fake.taskByGuidMutex.Unlock() - if taskByGuidStubCopy != nil { - return taskByGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.taskByGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -908,16 +908,16 @@ func (fake *FakeTaskDB) Tasks(arg1 context.Context, arg2 lager.Logger, arg3 mode arg2 lager.Logger arg3 models.TaskFilter }{arg1, arg2, arg3}) + stub := fake.TasksStub + fakeReturns := fake.tasksReturns fake.recordInvocation("Tasks", []interface{}{arg1, arg2, arg3}) - tasksStubCopy := fake.TasksStub fake.tasksMutex.Unlock() - if tasksStubCopy != nil { - return tasksStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/dbfakes/fake_version_db.go b/db/dbfakes/fake_version_db.go index 1c70609b..8c8b22e7 100644 --- a/db/dbfakes/fake_version_db.go +++ b/db/dbfakes/fake_version_db.go @@ -50,16 +50,16 @@ func (fake *FakeVersionDB) SetVersion(arg1 context.Context, arg2 lager.Logger, a arg2 lager.Logger arg3 *models.Version }{arg1, arg2, arg3}) + stub := fake.SetVersionStub + fakeReturns := fake.setVersionReturns fake.recordInvocation("SetVersion", []interface{}{arg1, arg2, arg3}) - setVersionStubCopy := fake.SetVersionStub fake.setVersionMutex.Unlock() - if setVersionStubCopy != nil { - return setVersionStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.setVersionReturns return fakeReturns.result1 } @@ -112,16 +112,16 @@ func (fake *FakeVersionDB) Version(arg1 context.Context, arg2 lager.Logger) (*mo arg1 context.Context arg2 lager.Logger }{arg1, arg2}) + stub := fake.VersionStub + fakeReturns := fake.versionReturns fake.recordInvocation("Version", []interface{}{arg1, arg2}) - versionStubCopy := fake.VersionStub fake.versionMutex.Unlock() - if versionStubCopy != nil { - return versionStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.versionReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_conn.go b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_conn.go index 5a4cd059..5711e4f9 100644 --- a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_conn.go +++ b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_conn.go @@ -53,16 +53,16 @@ func (fake *FakeConn) Begin() (driver.Tx, error) { ret, specificReturn := fake.beginReturnsOnCall[len(fake.beginArgsForCall)] fake.beginArgsForCall = append(fake.beginArgsForCall, struct { }{}) + stub := fake.BeginStub + fakeReturns := fake.beginReturns fake.recordInvocation("Begin", []interface{}{}) - beginStubCopy := fake.BeginStub fake.beginMutex.Unlock() - if beginStubCopy != nil { - return beginStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.beginReturns return fakeReturns.result1, fakeReturns.result2 } @@ -109,16 +109,16 @@ func (fake *FakeConn) Close() error { ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] fake.closeArgsForCall = append(fake.closeArgsForCall, struct { }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns fake.recordInvocation("Close", []interface{}{}) - closeStubCopy := fake.CloseStub fake.closeMutex.Unlock() - if closeStubCopy != nil { - return closeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.closeReturns return fakeReturns.result1 } @@ -163,16 +163,16 @@ func (fake *FakeConn) Prepare(arg1 string) (driver.Stmt, error) { fake.prepareArgsForCall = append(fake.prepareArgsForCall, struct { arg1 string }{arg1}) + stub := fake.PrepareStub + fakeReturns := fake.prepareReturns fake.recordInvocation("Prepare", []interface{}{arg1}) - prepareStubCopy := fake.PrepareStub fake.prepareMutex.Unlock() - if prepareStubCopy != nil { - return prepareStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.prepareReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_driver.go b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_driver.go index 4dcc7c1b..31856a0a 100644 --- a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_driver.go +++ b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_driver.go @@ -32,16 +32,16 @@ func (fake *FakeDriver) Open(arg1 string) (driver.Conn, error) { fake.openArgsForCall = append(fake.openArgsForCall, struct { arg1 string }{arg1}) + stub := fake.OpenStub + fakeReturns := fake.openReturns fake.recordInvocation("Open", []interface{}{arg1}) - openStubCopy := fake.OpenStub fake.openMutex.Unlock() - if openStubCopy != nil { - return openStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.openReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_stmt.go b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_stmt.go index d7afe11d..01bc4978 100644 --- a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_stmt.go +++ b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_stmt.go @@ -64,16 +64,16 @@ func (fake *FakeStmt) Close() error { ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] fake.closeArgsForCall = append(fake.closeArgsForCall, struct { }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns fake.recordInvocation("Close", []interface{}{}) - closeStubCopy := fake.CloseStub fake.closeMutex.Unlock() - if closeStubCopy != nil { - return closeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.closeReturns return fakeReturns.result1 } @@ -123,16 +123,16 @@ func (fake *FakeStmt) Exec(arg1 []driver.Value) (driver.Result, error) { fake.execArgsForCall = append(fake.execArgsForCall, struct { arg1 []driver.Value }{arg1Copy}) + stub := fake.ExecStub + fakeReturns := fake.execReturns fake.recordInvocation("Exec", []interface{}{arg1Copy}) - execStubCopy := fake.ExecStub fake.execMutex.Unlock() - if execStubCopy != nil { - return execStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.execReturns return fakeReturns.result1, fakeReturns.result2 } @@ -186,16 +186,16 @@ func (fake *FakeStmt) NumInput() int { ret, specificReturn := fake.numInputReturnsOnCall[len(fake.numInputArgsForCall)] fake.numInputArgsForCall = append(fake.numInputArgsForCall, struct { }{}) + stub := fake.NumInputStub + fakeReturns := fake.numInputReturns fake.recordInvocation("NumInput", []interface{}{}) - numInputStubCopy := fake.NumInputStub fake.numInputMutex.Unlock() - if numInputStubCopy != nil { - return numInputStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.numInputReturns return fakeReturns.result1 } @@ -245,16 +245,16 @@ func (fake *FakeStmt) Query(arg1 []driver.Value) (driver.Rows, error) { fake.queryArgsForCall = append(fake.queryArgsForCall, struct { arg1 []driver.Value }{arg1Copy}) + stub := fake.QueryStub + fakeReturns := fake.queryReturns fake.recordInvocation("Query", []interface{}{arg1Copy}) - queryStubCopy := fake.QueryStub fake.queryMutex.Unlock() - if queryStubCopy != nil { - return queryStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.queryReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_tx.go b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_tx.go index 31fec491..f88a5e56 100644 --- a/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_tx.go +++ b/db/sqldb/fakesqldriver/fakesqldriverfakes/fake_tx.go @@ -37,16 +37,16 @@ func (fake *FakeTx) Commit() error { ret, specificReturn := fake.commitReturnsOnCall[len(fake.commitArgsForCall)] fake.commitArgsForCall = append(fake.commitArgsForCall, struct { }{}) + stub := fake.CommitStub + fakeReturns := fake.commitReturns fake.recordInvocation("Commit", []interface{}{}) - commitStubCopy := fake.CommitStub fake.commitMutex.Unlock() - if commitStubCopy != nil { - return commitStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.commitReturns return fakeReturns.result1 } @@ -90,16 +90,16 @@ func (fake *FakeTx) Rollback() error { ret, specificReturn := fake.rollbackReturnsOnCall[len(fake.rollbackArgsForCall)] fake.rollbackArgsForCall = append(fake.rollbackArgsForCall, struct { }{}) + stub := fake.RollbackStub + fakeReturns := fake.rollbackReturns fake.recordInvocation("Rollback", []interface{}{}) - rollbackStubCopy := fake.RollbackStub fake.rollbackMutex.Unlock() - if rollbackStubCopy != nil { - return rollbackStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.rollbackReturns return fakeReturns.result1 } diff --git a/db/sqldb/helpers/helpersfakes/fake_queryable_db.go b/db/sqldb/helpers/helpersfakes/fake_queryable_db.go index 7d8b8c91..f9efad53 100644 --- a/db/sqldb/helpers/helpersfakes/fake_queryable_db.go +++ b/db/sqldb/helpers/helpersfakes/fake_queryable_db.go @@ -123,16 +123,16 @@ func (fake *FakeQueryableDB) BeginTx(arg1 context.Context, arg2 *sql.TxOptions) arg1 context.Context arg2 *sql.TxOptions }{arg1, arg2}) + stub := fake.BeginTxStub + fakeReturns := fake.beginTxReturns fake.recordInvocation("BeginTx", []interface{}{arg1, arg2}) - beginTxStubCopy := fake.BeginTxStub fake.beginTxMutex.Unlock() - if beginTxStubCopy != nil { - return beginTxStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.beginTxReturns return fakeReturns.result1, fakeReturns.result2 } @@ -189,16 +189,16 @@ func (fake *FakeQueryableDB) ExecContext(arg1 context.Context, arg2 string, arg3 arg2 string arg3 []interface{} }{arg1, arg2, arg3}) + stub := fake.ExecContextStub + fakeReturns := fake.execContextReturns fake.recordInvocation("ExecContext", []interface{}{arg1, arg2, arg3}) - execContextStubCopy := fake.ExecContextStub fake.execContextMutex.Unlock() - if execContextStubCopy != nil { - return execContextStubCopy(arg1, arg2, arg3...) + if stub != nil { + return stub(arg1, arg2, arg3...) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.execContextReturns return fakeReturns.result1, fakeReturns.result2 } @@ -252,16 +252,16 @@ func (fake *FakeQueryableDB) OpenConnections() int { ret, specificReturn := fake.openConnectionsReturnsOnCall[len(fake.openConnectionsArgsForCall)] fake.openConnectionsArgsForCall = append(fake.openConnectionsArgsForCall, struct { }{}) + stub := fake.OpenConnectionsStub + fakeReturns := fake.openConnectionsReturns fake.recordInvocation("OpenConnections", []interface{}{}) - openConnectionsStubCopy := fake.OpenConnectionsStub fake.openConnectionsMutex.Unlock() - if openConnectionsStubCopy != nil { - return openConnectionsStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.openConnectionsReturns return fakeReturns.result1 } @@ -307,16 +307,16 @@ func (fake *FakeQueryableDB) PrepareContext(arg1 context.Context, arg2 string) ( arg1 context.Context arg2 string }{arg1, arg2}) + stub := fake.PrepareContextStub + fakeReturns := fake.prepareContextReturns fake.recordInvocation("PrepareContext", []interface{}{arg1, arg2}) - prepareContextStubCopy := fake.PrepareContextStub fake.prepareContextMutex.Unlock() - if prepareContextStubCopy != nil { - return prepareContextStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.prepareContextReturns return fakeReturns.result1, fakeReturns.result2 } @@ -373,16 +373,16 @@ func (fake *FakeQueryableDB) QueryContext(arg1 context.Context, arg2 string, arg arg2 string arg3 []interface{} }{arg1, arg2, arg3}) + stub := fake.QueryContextStub + fakeReturns := fake.queryContextReturns fake.recordInvocation("QueryContext", []interface{}{arg1, arg2, arg3}) - queryContextStubCopy := fake.QueryContextStub fake.queryContextMutex.Unlock() - if queryContextStubCopy != nil { - return queryContextStubCopy(arg1, arg2, arg3...) + if stub != nil { + return stub(arg1, arg2, arg3...) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.queryContextReturns return fakeReturns.result1, fakeReturns.result2 } @@ -439,16 +439,16 @@ func (fake *FakeQueryableDB) QueryRowContext(arg1 context.Context, arg2 string, arg2 string arg3 []interface{} }{arg1, arg2, arg3}) + stub := fake.QueryRowContextStub + fakeReturns := fake.queryRowContextReturns fake.recordInvocation("QueryRowContext", []interface{}{arg1, arg2, arg3}) - queryRowContextStubCopy := fake.QueryRowContextStub fake.queryRowContextMutex.Unlock() - if queryRowContextStubCopy != nil { - return queryRowContextStubCopy(arg1, arg2, arg3...) + if stub != nil { + return stub(arg1, arg2, arg3...) } if specificReturn { return ret.result1 } - fakeReturns := fake.queryRowContextReturns return fakeReturns.result1 } @@ -499,16 +499,16 @@ func (fake *FakeQueryableDB) WaitCount() int64 { ret, specificReturn := fake.waitCountReturnsOnCall[len(fake.waitCountArgsForCall)] fake.waitCountArgsForCall = append(fake.waitCountArgsForCall, struct { }{}) + stub := fake.WaitCountStub + fakeReturns := fake.waitCountReturns fake.recordInvocation("WaitCount", []interface{}{}) - waitCountStubCopy := fake.WaitCountStub fake.waitCountMutex.Unlock() - if waitCountStubCopy != nil { - return waitCountStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.waitCountReturns return fakeReturns.result1 } @@ -552,16 +552,16 @@ func (fake *FakeQueryableDB) WaitDuration() time.Duration { ret, specificReturn := fake.waitDurationReturnsOnCall[len(fake.waitDurationArgsForCall)] fake.waitDurationArgsForCall = append(fake.waitDurationArgsForCall, struct { }{}) + stub := fake.WaitDurationStub + fakeReturns := fake.waitDurationReturns fake.recordInvocation("WaitDuration", []interface{}{}) - waitDurationStubCopy := fake.WaitDurationStub fake.waitDurationMutex.Unlock() - if waitDurationStubCopy != nil { - return waitDurationStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.waitDurationReturns return fakeReturns.result1 } diff --git a/db/sqldb/helpers/monitor/monitorfakes/fake_monitor.go b/db/sqldb/helpers/monitor/monitorfakes/fake_monitor.go index b0b1799a..d6691c7a 100644 --- a/db/sqldb/helpers/monitor/monitorfakes/fake_monitor.go +++ b/db/sqldb/helpers/monitor/monitorfakes/fake_monitor.go @@ -79,16 +79,16 @@ func (fake *FakeMonitor) Failed() int64 { ret, specificReturn := fake.failedReturnsOnCall[len(fake.failedArgsForCall)] fake.failedArgsForCall = append(fake.failedArgsForCall, struct { }{}) + stub := fake.FailedStub + fakeReturns := fake.failedReturns fake.recordInvocation("Failed", []interface{}{}) - failedStubCopy := fake.FailedStub fake.failedMutex.Unlock() - if failedStubCopy != nil { - return failedStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.failedReturns return fakeReturns.result1 } @@ -133,16 +133,16 @@ func (fake *FakeMonitor) Monitor(arg1 func() error) error { fake.monitorArgsForCall = append(fake.monitorArgsForCall, struct { arg1 func() error }{arg1}) + stub := fake.MonitorStub + fakeReturns := fake.monitorReturns fake.recordInvocation("Monitor", []interface{}{arg1}) - monitorStubCopy := fake.MonitorStub fake.monitorMutex.Unlock() - if monitorStubCopy != nil { - return monitorStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1 } - fakeReturns := fake.monitorReturns return fakeReturns.result1 } @@ -193,16 +193,16 @@ func (fake *FakeMonitor) ReadAndResetDurationMax() time.Duration { ret, specificReturn := fake.readAndResetDurationMaxReturnsOnCall[len(fake.readAndResetDurationMaxArgsForCall)] fake.readAndResetDurationMaxArgsForCall = append(fake.readAndResetDurationMaxArgsForCall, struct { }{}) + stub := fake.ReadAndResetDurationMaxStub + fakeReturns := fake.readAndResetDurationMaxReturns fake.recordInvocation("ReadAndResetDurationMax", []interface{}{}) - readAndResetDurationMaxStubCopy := fake.ReadAndResetDurationMaxStub fake.readAndResetDurationMaxMutex.Unlock() - if readAndResetDurationMaxStubCopy != nil { - return readAndResetDurationMaxStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.readAndResetDurationMaxReturns return fakeReturns.result1 } @@ -246,16 +246,16 @@ func (fake *FakeMonitor) ReadAndResetInFlightMax() int64 { ret, specificReturn := fake.readAndResetInFlightMaxReturnsOnCall[len(fake.readAndResetInFlightMaxArgsForCall)] fake.readAndResetInFlightMaxArgsForCall = append(fake.readAndResetInFlightMaxArgsForCall, struct { }{}) + stub := fake.ReadAndResetInFlightMaxStub + fakeReturns := fake.readAndResetInFlightMaxReturns fake.recordInvocation("ReadAndResetInFlightMax", []interface{}{}) - readAndResetInFlightMaxStubCopy := fake.ReadAndResetInFlightMaxStub fake.readAndResetInFlightMaxMutex.Unlock() - if readAndResetInFlightMaxStubCopy != nil { - return readAndResetInFlightMaxStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.readAndResetInFlightMaxReturns return fakeReturns.result1 } @@ -299,16 +299,16 @@ func (fake *FakeMonitor) Succeeded() int64 { ret, specificReturn := fake.succeededReturnsOnCall[len(fake.succeededArgsForCall)] fake.succeededArgsForCall = append(fake.succeededArgsForCall, struct { }{}) + stub := fake.SucceededStub + fakeReturns := fake.succeededReturns fake.recordInvocation("Succeeded", []interface{}{}) - succeededStubCopy := fake.SucceededStub fake.succeededMutex.Unlock() - if succeededStubCopy != nil { - return succeededStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.succeededReturns return fakeReturns.result1 } @@ -352,16 +352,16 @@ func (fake *FakeMonitor) Total() int64 { ret, specificReturn := fake.totalReturnsOnCall[len(fake.totalArgsForCall)] fake.totalArgsForCall = append(fake.totalArgsForCall, struct { }{}) + stub := fake.TotalStub + fakeReturns := fake.totalReturns fake.recordInvocation("Total", []interface{}{}) - totalStubCopy := fake.TotalStub fake.totalMutex.Unlock() - if totalStubCopy != nil { - return totalStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.totalReturns return fakeReturns.result1 } diff --git a/encryption/encryptionfakes/fake_cryptor.go b/encryption/encryptionfakes/fake_cryptor.go index 8a89e7ff..912d0b7b 100644 --- a/encryption/encryptionfakes/fake_cryptor.go +++ b/encryption/encryptionfakes/fake_cryptor.go @@ -44,16 +44,16 @@ func (fake *FakeCryptor) Decrypt(arg1 encryption.Encrypted) ([]byte, error) { fake.decryptArgsForCall = append(fake.decryptArgsForCall, struct { arg1 encryption.Encrypted }{arg1}) + stub := fake.DecryptStub + fakeReturns := fake.decryptReturns fake.recordInvocation("Decrypt", []interface{}{arg1}) - decryptStubCopy := fake.DecryptStub fake.decryptMutex.Unlock() - if decryptStubCopy != nil { - return decryptStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.decryptReturns return fakeReturns.result1, fakeReturns.result2 } @@ -113,16 +113,16 @@ func (fake *FakeCryptor) Encrypt(arg1 []byte) (encryption.Encrypted, error) { fake.encryptArgsForCall = append(fake.encryptArgsForCall, struct { arg1 []byte }{arg1Copy}) + stub := fake.EncryptStub + fakeReturns := fake.encryptReturns fake.recordInvocation("Encrypt", []interface{}{arg1Copy}) - encryptStubCopy := fake.EncryptStub fake.encryptMutex.Unlock() - if encryptStubCopy != nil { - return encryptStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.encryptReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/encryption/encryptionfakes/fake_key.go b/encryption/encryptionfakes/fake_key.go index 48258563..24e32283 100644 --- a/encryption/encryptionfakes/fake_key.go +++ b/encryption/encryptionfakes/fake_key.go @@ -38,16 +38,16 @@ func (fake *FakeKey) Block() cipher.Block { ret, specificReturn := fake.blockReturnsOnCall[len(fake.blockArgsForCall)] fake.blockArgsForCall = append(fake.blockArgsForCall, struct { }{}) + stub := fake.BlockStub + fakeReturns := fake.blockReturns fake.recordInvocation("Block", []interface{}{}) - blockStubCopy := fake.BlockStub fake.blockMutex.Unlock() - if blockStubCopy != nil { - return blockStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.blockReturns return fakeReturns.result1 } @@ -91,16 +91,16 @@ func (fake *FakeKey) Label() string { ret, specificReturn := fake.labelReturnsOnCall[len(fake.labelArgsForCall)] fake.labelArgsForCall = append(fake.labelArgsForCall, struct { }{}) + stub := fake.LabelStub + fakeReturns := fake.labelReturns fake.recordInvocation("Label", []interface{}{}) - labelStubCopy := fake.LabelStub fake.labelMutex.Unlock() - if labelStubCopy != nil { - return labelStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.labelReturns return fakeReturns.result1 } diff --git a/events/eventfakes/fake_event_source.go b/events/eventfakes/fake_event_source.go index a5eb551e..bbc370d4 100644 --- a/events/eventfakes/fake_event_source.go +++ b/events/eventfakes/fake_event_source.go @@ -40,16 +40,16 @@ func (fake *FakeEventSource) Close() error { ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] fake.closeArgsForCall = append(fake.closeArgsForCall, struct { }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns fake.recordInvocation("Close", []interface{}{}) - closeStubCopy := fake.CloseStub fake.closeMutex.Unlock() - if closeStubCopy != nil { - return closeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.closeReturns return fakeReturns.result1 } @@ -93,16 +93,16 @@ func (fake *FakeEventSource) Next() (models.Event, error) { ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)] fake.nextArgsForCall = append(fake.nextArgsForCall, struct { }{}) + stub := fake.NextStub + fakeReturns := fake.nextReturns fake.recordInvocation("Next", []interface{}{}) - nextStubCopy := fake.NextStub fake.nextMutex.Unlock() - if nextStubCopy != nil { - return nextStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.nextReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/events/eventfakes/fake_hub.go b/events/eventfakes/fake_hub.go index bcf046df..7c9c4efc 100644 --- a/events/eventfakes/fake_hub.go +++ b/events/eventfakes/fake_hub.go @@ -54,16 +54,16 @@ func (fake *FakeHub) Close() error { ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] fake.closeArgsForCall = append(fake.closeArgsForCall, struct { }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns fake.recordInvocation("Close", []interface{}{}) - closeStubCopy := fake.CloseStub fake.closeMutex.Unlock() - if closeStubCopy != nil { - return closeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.closeReturns return fakeReturns.result1 } @@ -107,11 +107,11 @@ func (fake *FakeHub) Emit(arg1 models.Event) { fake.emitArgsForCall = append(fake.emitArgsForCall, struct { arg1 models.Event }{arg1}) + stub := fake.EmitStub fake.recordInvocation("Emit", []interface{}{arg1}) - emitStubCopy := fake.EmitStub fake.emitMutex.Unlock() - if emitStubCopy != nil { - emitStubCopy(arg1) + if stub != nil { + fake.EmitStub(arg1) } } @@ -139,11 +139,11 @@ func (fake *FakeHub) RegisterCallback(arg1 func(count int)) { fake.registerCallbackArgsForCall = append(fake.registerCallbackArgsForCall, struct { arg1 func(count int) }{arg1}) + stub := fake.RegisterCallbackStub fake.recordInvocation("RegisterCallback", []interface{}{arg1}) - registerCallbackStubCopy := fake.RegisterCallbackStub fake.registerCallbackMutex.Unlock() - if registerCallbackStubCopy != nil { - registerCallbackStubCopy(arg1) + if stub != nil { + fake.RegisterCallbackStub(arg1) } } @@ -171,16 +171,16 @@ func (fake *FakeHub) Subscribe() (events.EventSource, error) { ret, specificReturn := fake.subscribeReturnsOnCall[len(fake.subscribeArgsForCall)] fake.subscribeArgsForCall = append(fake.subscribeArgsForCall, struct { }{}) + stub := fake.SubscribeStub + fakeReturns := fake.subscribeReturns fake.recordInvocation("Subscribe", []interface{}{}) - subscribeStubCopy := fake.SubscribeStub fake.subscribeMutex.Unlock() - if subscribeStubCopy != nil { - return subscribeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeReturns return fakeReturns.result1, fakeReturns.result2 } @@ -226,11 +226,11 @@ func (fake *FakeHub) UnregisterCallback() { fake.unregisterCallbackMutex.Lock() fake.unregisterCallbackArgsForCall = append(fake.unregisterCallbackArgsForCall, struct { }{}) + stub := fake.UnregisterCallbackStub fake.recordInvocation("UnregisterCallback", []interface{}{}) - unregisterCallbackStubCopy := fake.UnregisterCallbackStub fake.unregisterCallbackMutex.Unlock() - if unregisterCallbackStubCopy != nil { - unregisterCallbackStubCopy() + if stub != nil { + fake.UnregisterCallbackStub() } } diff --git a/events/eventfakes/fake_raw_event_source.go b/events/eventfakes/fake_raw_event_source.go index 489fcfe6..0504f5ea 100644 --- a/events/eventfakes/fake_raw_event_source.go +++ b/events/eventfakes/fake_raw_event_source.go @@ -40,16 +40,16 @@ func (fake *FakeRawEventSource) Close() error { ret, specificReturn := fake.closeReturnsOnCall[len(fake.closeArgsForCall)] fake.closeArgsForCall = append(fake.closeArgsForCall, struct { }{}) + stub := fake.CloseStub + fakeReturns := fake.closeReturns fake.recordInvocation("Close", []interface{}{}) - closeStubCopy := fake.CloseStub fake.closeMutex.Unlock() - if closeStubCopy != nil { - return closeStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.closeReturns return fakeReturns.result1 } @@ -93,16 +93,16 @@ func (fake *FakeRawEventSource) Next() (sse.Event, error) { ret, specificReturn := fake.nextReturnsOnCall[len(fake.nextArgsForCall)] fake.nextArgsForCall = append(fake.nextArgsForCall, struct { }{}) + stub := fake.NextStub + fakeReturns := fake.nextReturns fake.recordInvocation("Next", []interface{}{}) - nextStubCopy := fake.NextStub fake.nextMutex.Unlock() - if nextStubCopy != nil { - return nextStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.nextReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/fake_bbs/fake_client.go b/fake_bbs/fake_client.go index 07b50f26..17c30211 100644 --- a/fake_bbs/fake_client.go +++ b/fake_bbs/fake_client.go @@ -408,16 +408,16 @@ func (fake *FakeClient) ActualLRPGroupByProcessGuidAndIndex(arg1 lager.Logger, a arg2 string arg3 int }{arg1, arg2, arg3}) + stub := fake.ActualLRPGroupByProcessGuidAndIndexStub + fakeReturns := fake.actualLRPGroupByProcessGuidAndIndexReturns fake.recordInvocation("ActualLRPGroupByProcessGuidAndIndex", []interface{}{arg1, arg2, arg3}) - actualLRPGroupByProcessGuidAndIndexStubCopy := fake.ActualLRPGroupByProcessGuidAndIndexStub fake.actualLRPGroupByProcessGuidAndIndexMutex.Unlock() - if actualLRPGroupByProcessGuidAndIndexStubCopy != nil { - return actualLRPGroupByProcessGuidAndIndexStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupByProcessGuidAndIndexReturns return fakeReturns.result1, fakeReturns.result2 } @@ -473,16 +473,16 @@ func (fake *FakeClient) ActualLRPGroups(arg1 lager.Logger, arg2 models.ActualLRP arg1 lager.Logger arg2 models.ActualLRPFilter }{arg1, arg2}) + stub := fake.ActualLRPGroupsStub + fakeReturns := fake.actualLRPGroupsReturns fake.recordInvocation("ActualLRPGroups", []interface{}{arg1, arg2}) - actualLRPGroupsStubCopy := fake.ActualLRPGroupsStub fake.actualLRPGroupsMutex.Unlock() - if actualLRPGroupsStubCopy != nil { - return actualLRPGroupsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -538,16 +538,16 @@ func (fake *FakeClient) ActualLRPGroupsByProcessGuid(arg1 lager.Logger, arg2 str arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.ActualLRPGroupsByProcessGuidStub + fakeReturns := fake.actualLRPGroupsByProcessGuidReturns fake.recordInvocation("ActualLRPGroupsByProcessGuid", []interface{}{arg1, arg2}) - actualLRPGroupsByProcessGuidStubCopy := fake.ActualLRPGroupsByProcessGuidStub fake.actualLRPGroupsByProcessGuidMutex.Unlock() - if actualLRPGroupsByProcessGuidStubCopy != nil { - return actualLRPGroupsByProcessGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupsByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -603,16 +603,16 @@ func (fake *FakeClient) ActualLRPs(arg1 lager.Logger, arg2 models.ActualLRPFilte arg1 lager.Logger arg2 models.ActualLRPFilter }{arg1, arg2}) + stub := fake.ActualLRPsStub + fakeReturns := fake.actualLRPsReturns fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2}) - actualLRPsStubCopy := fake.ActualLRPsStub fake.actualLRPsMutex.Unlock() - if actualLRPsStubCopy != nil { - return actualLRPsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -668,16 +668,16 @@ func (fake *FakeClient) CancelTask(arg1 lager.Logger, arg2 string) error { arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.CancelTaskStub + fakeReturns := fake.cancelTaskReturns fake.recordInvocation("CancelTask", []interface{}{arg1, arg2}) - cancelTaskStubCopy := fake.CancelTaskStub fake.cancelTaskMutex.Unlock() - if cancelTaskStubCopy != nil { - return cancelTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.cancelTaskReturns return fakeReturns.result1 } @@ -729,16 +729,16 @@ func (fake *FakeClient) Cells(arg1 lager.Logger) ([]*models.CellPresence, error) fake.cellsArgsForCall = append(fake.cellsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.CellsStub + fakeReturns := fake.cellsReturns fake.recordInvocation("Cells", []interface{}{arg1}) - cellsStubCopy := fake.CellsStub fake.cellsMutex.Unlock() - if cellsStubCopy != nil { - return cellsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.cellsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -794,16 +794,16 @@ func (fake *FakeClient) DeleteTask(arg1 lager.Logger, arg2 string) error { arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.DeleteTaskStub + fakeReturns := fake.deleteTaskReturns fake.recordInvocation("DeleteTask", []interface{}{arg1, arg2}) - deleteTaskStubCopy := fake.DeleteTaskStub fake.deleteTaskMutex.Unlock() - if deleteTaskStubCopy != nil { - return deleteTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.deleteTaskReturns return fakeReturns.result1 } @@ -856,16 +856,16 @@ func (fake *FakeClient) DesireLRP(arg1 lager.Logger, arg2 *models.DesiredLRP) er arg1 lager.Logger arg2 *models.DesiredLRP }{arg1, arg2}) + stub := fake.DesireLRPStub + fakeReturns := fake.desireLRPReturns fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2}) - desireLRPStubCopy := fake.DesireLRPStub fake.desireLRPMutex.Unlock() - if desireLRPStubCopy != nil { - return desireLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireLRPReturns return fakeReturns.result1 } @@ -920,16 +920,16 @@ func (fake *FakeClient) DesireTask(arg1 lager.Logger, arg2 string, arg3 string, arg3 string arg4 *models.TaskDefinition }{arg1, arg2, arg3, arg4}) + stub := fake.DesireTaskStub + fakeReturns := fake.desireTaskReturns fake.recordInvocation("DesireTask", []interface{}{arg1, arg2, arg3, arg4}) - desireTaskStubCopy := fake.DesireTaskStub fake.desireTaskMutex.Unlock() - if desireTaskStubCopy != nil { - return desireTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireTaskReturns return fakeReturns.result1 } @@ -982,16 +982,16 @@ func (fake *FakeClient) DesiredLRPByProcessGuid(arg1 lager.Logger, arg2 string) arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.DesiredLRPByProcessGuidStub + fakeReturns := fake.desiredLRPByProcessGuidReturns fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2}) - desiredLRPByProcessGuidStubCopy := fake.DesiredLRPByProcessGuidStub fake.desiredLRPByProcessGuidMutex.Unlock() - if desiredLRPByProcessGuidStubCopy != nil { - return desiredLRPByProcessGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1047,16 +1047,16 @@ func (fake *FakeClient) DesiredLRPSchedulingInfos(arg1 lager.Logger, arg2 models arg1 lager.Logger arg2 models.DesiredLRPFilter }{arg1, arg2}) + stub := fake.DesiredLRPSchedulingInfosStub + fakeReturns := fake.desiredLRPSchedulingInfosReturns fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2}) - desiredLRPSchedulingInfosStubCopy := fake.DesiredLRPSchedulingInfosStub fake.desiredLRPSchedulingInfosMutex.Unlock() - if desiredLRPSchedulingInfosStubCopy != nil { - return desiredLRPSchedulingInfosStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPSchedulingInfosReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1112,16 +1112,16 @@ func (fake *FakeClient) DesiredLRPs(arg1 lager.Logger, arg2 models.DesiredLRPFil arg1 lager.Logger arg2 models.DesiredLRPFilter }{arg1, arg2}) + stub := fake.DesiredLRPsStub + fakeReturns := fake.desiredLRPsReturns fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2}) - desiredLRPsStubCopy := fake.DesiredLRPsStub fake.desiredLRPsMutex.Unlock() - if desiredLRPsStubCopy != nil { - return desiredLRPsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1176,16 +1176,16 @@ func (fake *FakeClient) Domains(arg1 lager.Logger) ([]string, error) { fake.domainsArgsForCall = append(fake.domainsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.DomainsStub + fakeReturns := fake.domainsReturns fake.recordInvocation("Domains", []interface{}{arg1}) - domainsStubCopy := fake.DomainsStub fake.domainsMutex.Unlock() - if domainsStubCopy != nil { - return domainsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.domainsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1240,16 +1240,16 @@ func (fake *FakeClient) Ping(arg1 lager.Logger) bool { fake.pingArgsForCall = append(fake.pingArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.PingStub + fakeReturns := fake.pingReturns fake.recordInvocation("Ping", []interface{}{arg1}) - pingStubCopy := fake.PingStub fake.pingMutex.Unlock() - if pingStubCopy != nil { - return pingStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1 } - fakeReturns := fake.pingReturns return fakeReturns.result1 } @@ -1302,16 +1302,16 @@ func (fake *FakeClient) RemoveDesiredLRP(arg1 lager.Logger, arg2 string) error { arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.RemoveDesiredLRPStub + fakeReturns := fake.removeDesiredLRPReturns fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2}) - removeDesiredLRPStubCopy := fake.RemoveDesiredLRPStub fake.removeDesiredLRPMutex.Unlock() - if removeDesiredLRPStubCopy != nil { - return removeDesiredLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeDesiredLRPReturns return fakeReturns.result1 } @@ -1364,16 +1364,16 @@ func (fake *FakeClient) ResolvingTask(arg1 lager.Logger, arg2 string) error { arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.ResolvingTaskStub + fakeReturns := fake.resolvingTaskReturns fake.recordInvocation("ResolvingTask", []interface{}{arg1, arg2}) - resolvingTaskStubCopy := fake.ResolvingTaskStub fake.resolvingTaskMutex.Unlock() - if resolvingTaskStubCopy != nil { - return resolvingTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.resolvingTaskReturns return fakeReturns.result1 } @@ -1426,16 +1426,16 @@ func (fake *FakeClient) RetireActualLRP(arg1 lager.Logger, arg2 *models.ActualLR arg1 lager.Logger arg2 *models.ActualLRPKey }{arg1, arg2}) + stub := fake.RetireActualLRPStub + fakeReturns := fake.retireActualLRPReturns fake.recordInvocation("RetireActualLRP", []interface{}{arg1, arg2}) - retireActualLRPStubCopy := fake.RetireActualLRPStub fake.retireActualLRPMutex.Unlock() - if retireActualLRPStubCopy != nil { - return retireActualLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.retireActualLRPReturns return fakeReturns.result1 } @@ -1487,16 +1487,16 @@ func (fake *FakeClient) SubscribeToEvents(arg1 lager.Logger) (events.EventSource fake.subscribeToEventsArgsForCall = append(fake.subscribeToEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToEventsStub + fakeReturns := fake.subscribeToEventsReturns fake.recordInvocation("SubscribeToEvents", []interface{}{arg1}) - subscribeToEventsStubCopy := fake.SubscribeToEventsStub fake.subscribeToEventsMutex.Unlock() - if subscribeToEventsStubCopy != nil { - return subscribeToEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1552,16 +1552,16 @@ func (fake *FakeClient) SubscribeToEventsByCellID(arg1 lager.Logger, arg2 string arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.SubscribeToEventsByCellIDStub + fakeReturns := fake.subscribeToEventsByCellIDReturns fake.recordInvocation("SubscribeToEventsByCellID", []interface{}{arg1, arg2}) - subscribeToEventsByCellIDStubCopy := fake.SubscribeToEventsByCellIDStub fake.subscribeToEventsByCellIDMutex.Unlock() - if subscribeToEventsByCellIDStubCopy != nil { - return subscribeToEventsByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToEventsByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1616,16 +1616,16 @@ func (fake *FakeClient) SubscribeToInstanceEvents(arg1 lager.Logger) (events.Eve fake.subscribeToInstanceEventsArgsForCall = append(fake.subscribeToInstanceEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToInstanceEventsStub + fakeReturns := fake.subscribeToInstanceEventsReturns fake.recordInvocation("SubscribeToInstanceEvents", []interface{}{arg1}) - subscribeToInstanceEventsStubCopy := fake.SubscribeToInstanceEventsStub fake.subscribeToInstanceEventsMutex.Unlock() - if subscribeToInstanceEventsStubCopy != nil { - return subscribeToInstanceEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToInstanceEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1681,16 +1681,16 @@ func (fake *FakeClient) SubscribeToInstanceEventsByCellID(arg1 lager.Logger, arg arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.SubscribeToInstanceEventsByCellIDStub + fakeReturns := fake.subscribeToInstanceEventsByCellIDReturns fake.recordInvocation("SubscribeToInstanceEventsByCellID", []interface{}{arg1, arg2}) - subscribeToInstanceEventsByCellIDStubCopy := fake.SubscribeToInstanceEventsByCellIDStub fake.subscribeToInstanceEventsByCellIDMutex.Unlock() - if subscribeToInstanceEventsByCellIDStubCopy != nil { - return subscribeToInstanceEventsByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToInstanceEventsByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1745,16 +1745,16 @@ func (fake *FakeClient) SubscribeToTaskEvents(arg1 lager.Logger) (events.EventSo fake.subscribeToTaskEventsArgsForCall = append(fake.subscribeToTaskEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToTaskEventsStub + fakeReturns := fake.subscribeToTaskEventsReturns fake.recordInvocation("SubscribeToTaskEvents", []interface{}{arg1}) - subscribeToTaskEventsStubCopy := fake.SubscribeToTaskEventsStub fake.subscribeToTaskEventsMutex.Unlock() - if subscribeToTaskEventsStubCopy != nil { - return subscribeToTaskEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToTaskEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1810,16 +1810,16 @@ func (fake *FakeClient) TaskByGuid(arg1 lager.Logger, arg2 string) (*models.Task arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TaskByGuidStub + fakeReturns := fake.taskByGuidReturns fake.recordInvocation("TaskByGuid", []interface{}{arg1, arg2}) - taskByGuidStubCopy := fake.TaskByGuidStub fake.taskByGuidMutex.Unlock() - if taskByGuidStubCopy != nil { - return taskByGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.taskByGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1874,16 +1874,16 @@ func (fake *FakeClient) Tasks(arg1 lager.Logger) ([]*models.Task, error) { fake.tasksArgsForCall = append(fake.tasksArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.TasksStub + fakeReturns := fake.tasksReturns fake.recordInvocation("Tasks", []interface{}{arg1}) - tasksStubCopy := fake.TasksStub fake.tasksMutex.Unlock() - if tasksStubCopy != nil { - return tasksStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1939,16 +1939,16 @@ func (fake *FakeClient) TasksByCellID(arg1 lager.Logger, arg2 string) ([]*models arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TasksByCellIDStub + fakeReturns := fake.tasksByCellIDReturns fake.recordInvocation("TasksByCellID", []interface{}{arg1, arg2}) - tasksByCellIDStubCopy := fake.TasksByCellIDStub fake.tasksByCellIDMutex.Unlock() - if tasksByCellIDStubCopy != nil { - return tasksByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2004,16 +2004,16 @@ func (fake *FakeClient) TasksByDomain(arg1 lager.Logger, arg2 string) ([]*models arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TasksByDomainStub + fakeReturns := fake.tasksByDomainReturns fake.recordInvocation("TasksByDomain", []interface{}{arg1, arg2}) - tasksByDomainStubCopy := fake.TasksByDomainStub fake.tasksByDomainMutex.Unlock() - if tasksByDomainStubCopy != nil { - return tasksByDomainStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksByDomainReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2069,16 +2069,16 @@ func (fake *FakeClient) TasksWithFilter(arg1 lager.Logger, arg2 models.TaskFilte arg1 lager.Logger arg2 models.TaskFilter }{arg1, arg2}) + stub := fake.TasksWithFilterStub + fakeReturns := fake.tasksWithFilterReturns fake.recordInvocation("TasksWithFilter", []interface{}{arg1, arg2}) - tasksWithFilterStubCopy := fake.TasksWithFilterStub fake.tasksWithFilterMutex.Unlock() - if tasksWithFilterStubCopy != nil { - return tasksWithFilterStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksWithFilterReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2135,16 +2135,16 @@ func (fake *FakeClient) UpdateDesiredLRP(arg1 lager.Logger, arg2 string, arg3 *m arg2 string arg3 *models.DesiredLRPUpdate }{arg1, arg2, arg3}) + stub := fake.UpdateDesiredLRPStub + fakeReturns := fake.updateDesiredLRPReturns fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3}) - updateDesiredLRPStubCopy := fake.UpdateDesiredLRPStub fake.updateDesiredLRPMutex.Unlock() - if updateDesiredLRPStubCopy != nil { - return updateDesiredLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.updateDesiredLRPReturns return fakeReturns.result1 } @@ -2198,16 +2198,16 @@ func (fake *FakeClient) UpsertDomain(arg1 lager.Logger, arg2 string, arg3 time.D arg2 string arg3 time.Duration }{arg1, arg2, arg3}) + stub := fake.UpsertDomainStub + fakeReturns := fake.upsertDomainReturns fake.recordInvocation("UpsertDomain", []interface{}{arg1, arg2, arg3}) - upsertDomainStubCopy := fake.UpsertDomainStub fake.upsertDomainMutex.Unlock() - if upsertDomainStubCopy != nil { - return upsertDomainStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.upsertDomainReturns return fakeReturns.result1 } diff --git a/fake_bbs/fake_internal_client.go b/fake_bbs/fake_internal_client.go index b5a7d291..4c887f47 100644 --- a/fake_bbs/fake_internal_client.go +++ b/fake_bbs/fake_internal_client.go @@ -607,16 +607,16 @@ func (fake *FakeInternalClient) ActualLRPGroupByProcessGuidAndIndex(arg1 lager.L arg2 string arg3 int }{arg1, arg2, arg3}) + stub := fake.ActualLRPGroupByProcessGuidAndIndexStub + fakeReturns := fake.actualLRPGroupByProcessGuidAndIndexReturns fake.recordInvocation("ActualLRPGroupByProcessGuidAndIndex", []interface{}{arg1, arg2, arg3}) - actualLRPGroupByProcessGuidAndIndexStubCopy := fake.ActualLRPGroupByProcessGuidAndIndexStub fake.actualLRPGroupByProcessGuidAndIndexMutex.Unlock() - if actualLRPGroupByProcessGuidAndIndexStubCopy != nil { - return actualLRPGroupByProcessGuidAndIndexStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupByProcessGuidAndIndexReturns return fakeReturns.result1, fakeReturns.result2 } @@ -672,16 +672,16 @@ func (fake *FakeInternalClient) ActualLRPGroups(arg1 lager.Logger, arg2 models.A arg1 lager.Logger arg2 models.ActualLRPFilter }{arg1, arg2}) + stub := fake.ActualLRPGroupsStub + fakeReturns := fake.actualLRPGroupsReturns fake.recordInvocation("ActualLRPGroups", []interface{}{arg1, arg2}) - actualLRPGroupsStubCopy := fake.ActualLRPGroupsStub fake.actualLRPGroupsMutex.Unlock() - if actualLRPGroupsStubCopy != nil { - return actualLRPGroupsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -737,16 +737,16 @@ func (fake *FakeInternalClient) ActualLRPGroupsByProcessGuid(arg1 lager.Logger, arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.ActualLRPGroupsByProcessGuidStub + fakeReturns := fake.actualLRPGroupsByProcessGuidReturns fake.recordInvocation("ActualLRPGroupsByProcessGuid", []interface{}{arg1, arg2}) - actualLRPGroupsByProcessGuidStubCopy := fake.ActualLRPGroupsByProcessGuidStub fake.actualLRPGroupsByProcessGuidMutex.Unlock() - if actualLRPGroupsByProcessGuidStubCopy != nil { - return actualLRPGroupsByProcessGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPGroupsByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -802,16 +802,16 @@ func (fake *FakeInternalClient) ActualLRPs(arg1 lager.Logger, arg2 models.Actual arg1 lager.Logger arg2 models.ActualLRPFilter }{arg1, arg2}) + stub := fake.ActualLRPsStub + fakeReturns := fake.actualLRPsReturns fake.recordInvocation("ActualLRPs", []interface{}{arg1, arg2}) - actualLRPsStubCopy := fake.ActualLRPsStub fake.actualLRPsMutex.Unlock() - if actualLRPsStubCopy != nil { - return actualLRPsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.actualLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -867,16 +867,16 @@ func (fake *FakeInternalClient) CancelTask(arg1 lager.Logger, arg2 string) error arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.CancelTaskStub + fakeReturns := fake.cancelTaskReturns fake.recordInvocation("CancelTask", []interface{}{arg1, arg2}) - cancelTaskStubCopy := fake.CancelTaskStub fake.cancelTaskMutex.Unlock() - if cancelTaskStubCopy != nil { - return cancelTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.cancelTaskReturns return fakeReturns.result1 } @@ -928,16 +928,16 @@ func (fake *FakeInternalClient) Cells(arg1 lager.Logger) ([]*models.CellPresence fake.cellsArgsForCall = append(fake.cellsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.CellsStub + fakeReturns := fake.cellsReturns fake.recordInvocation("Cells", []interface{}{arg1}) - cellsStubCopy := fake.CellsStub fake.cellsMutex.Unlock() - if cellsStubCopy != nil { - return cellsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.cellsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -994,16 +994,16 @@ func (fake *FakeInternalClient) ClaimActualLRP(arg1 lager.Logger, arg2 *models.A arg2 *models.ActualLRPKey arg3 *models.ActualLRPInstanceKey }{arg1, arg2, arg3}) + stub := fake.ClaimActualLRPStub + fakeReturns := fake.claimActualLRPReturns fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3}) - claimActualLRPStubCopy := fake.ClaimActualLRPStub fake.claimActualLRPMutex.Unlock() - if claimActualLRPStubCopy != nil { - return claimActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.claimActualLRPReturns return fakeReturns.result1 } @@ -1060,16 +1060,16 @@ func (fake *FakeInternalClient) CompleteTask(arg1 lager.Logger, arg2 string, arg arg5 string arg6 string }{arg1, arg2, arg3, arg4, arg5, arg6}) + stub := fake.CompleteTaskStub + fakeReturns := fake.completeTaskReturns fake.recordInvocation("CompleteTask", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) - completeTaskStubCopy := fake.CompleteTaskStub fake.completeTaskMutex.Unlock() - if completeTaskStubCopy != nil { - return completeTaskStubCopy(arg1, arg2, arg3, arg4, arg5, arg6) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) } if specificReturn { return ret.result1 } - fakeReturns := fake.completeTaskReturns return fakeReturns.result1 } @@ -1124,16 +1124,16 @@ func (fake *FakeInternalClient) CrashActualLRP(arg1 lager.Logger, arg2 *models.A arg3 *models.ActualLRPInstanceKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.CrashActualLRPStub + fakeReturns := fake.crashActualLRPReturns fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - crashActualLRPStubCopy := fake.CrashActualLRPStub fake.crashActualLRPMutex.Unlock() - if crashActualLRPStubCopy != nil { - return crashActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.crashActualLRPReturns return fakeReturns.result1 } @@ -1186,16 +1186,16 @@ func (fake *FakeInternalClient) DeleteTask(arg1 lager.Logger, arg2 string) error arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.DeleteTaskStub + fakeReturns := fake.deleteTaskReturns fake.recordInvocation("DeleteTask", []interface{}{arg1, arg2}) - deleteTaskStubCopy := fake.DeleteTaskStub fake.deleteTaskMutex.Unlock() - if deleteTaskStubCopy != nil { - return deleteTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.deleteTaskReturns return fakeReturns.result1 } @@ -1248,16 +1248,16 @@ func (fake *FakeInternalClient) DesireLRP(arg1 lager.Logger, arg2 *models.Desire arg1 lager.Logger arg2 *models.DesiredLRP }{arg1, arg2}) + stub := fake.DesireLRPStub + fakeReturns := fake.desireLRPReturns fake.recordInvocation("DesireLRP", []interface{}{arg1, arg2}) - desireLRPStubCopy := fake.DesireLRPStub fake.desireLRPMutex.Unlock() - if desireLRPStubCopy != nil { - return desireLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireLRPReturns return fakeReturns.result1 } @@ -1312,16 +1312,16 @@ func (fake *FakeInternalClient) DesireTask(arg1 lager.Logger, arg2 string, arg3 arg3 string arg4 *models.TaskDefinition }{arg1, arg2, arg3, arg4}) + stub := fake.DesireTaskStub + fakeReturns := fake.desireTaskReturns fake.recordInvocation("DesireTask", []interface{}{arg1, arg2, arg3, arg4}) - desireTaskStubCopy := fake.DesireTaskStub fake.desireTaskMutex.Unlock() - if desireTaskStubCopy != nil { - return desireTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireTaskReturns return fakeReturns.result1 } @@ -1374,16 +1374,16 @@ func (fake *FakeInternalClient) DesiredLRPByProcessGuid(arg1 lager.Logger, arg2 arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.DesiredLRPByProcessGuidStub + fakeReturns := fake.desiredLRPByProcessGuidReturns fake.recordInvocation("DesiredLRPByProcessGuid", []interface{}{arg1, arg2}) - desiredLRPByProcessGuidStubCopy := fake.DesiredLRPByProcessGuidStub fake.desiredLRPByProcessGuidMutex.Unlock() - if desiredLRPByProcessGuidStubCopy != nil { - return desiredLRPByProcessGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPByProcessGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1439,16 +1439,16 @@ func (fake *FakeInternalClient) DesiredLRPSchedulingInfos(arg1 lager.Logger, arg arg1 lager.Logger arg2 models.DesiredLRPFilter }{arg1, arg2}) + stub := fake.DesiredLRPSchedulingInfosStub + fakeReturns := fake.desiredLRPSchedulingInfosReturns fake.recordInvocation("DesiredLRPSchedulingInfos", []interface{}{arg1, arg2}) - desiredLRPSchedulingInfosStubCopy := fake.DesiredLRPSchedulingInfosStub fake.desiredLRPSchedulingInfosMutex.Unlock() - if desiredLRPSchedulingInfosStubCopy != nil { - return desiredLRPSchedulingInfosStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPSchedulingInfosReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1504,16 +1504,16 @@ func (fake *FakeInternalClient) DesiredLRPs(arg1 lager.Logger, arg2 models.Desir arg1 lager.Logger arg2 models.DesiredLRPFilter }{arg1, arg2}) + stub := fake.DesiredLRPsStub + fakeReturns := fake.desiredLRPsReturns fake.recordInvocation("DesiredLRPs", []interface{}{arg1, arg2}) - desiredLRPsStubCopy := fake.DesiredLRPsStub fake.desiredLRPsMutex.Unlock() - if desiredLRPsStubCopy != nil { - return desiredLRPsStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.desiredLRPsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1568,16 +1568,16 @@ func (fake *FakeInternalClient) Domains(arg1 lager.Logger) ([]string, error) { fake.domainsArgsForCall = append(fake.domainsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.DomainsStub + fakeReturns := fake.domainsReturns fake.recordInvocation("Domains", []interface{}{arg1}) - domainsStubCopy := fake.DomainsStub fake.domainsMutex.Unlock() - if domainsStubCopy != nil { - return domainsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.domainsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1634,16 +1634,16 @@ func (fake *FakeInternalClient) EvacuateClaimedActualLRP(arg1 lager.Logger, arg2 arg2 *models.ActualLRPKey arg3 *models.ActualLRPInstanceKey }{arg1, arg2, arg3}) + stub := fake.EvacuateClaimedActualLRPStub + fakeReturns := fake.evacuateClaimedActualLRPReturns fake.recordInvocation("EvacuateClaimedActualLRP", []interface{}{arg1, arg2, arg3}) - evacuateClaimedActualLRPStubCopy := fake.EvacuateClaimedActualLRPStub fake.evacuateClaimedActualLRPMutex.Unlock() - if evacuateClaimedActualLRPStubCopy != nil { - return evacuateClaimedActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateClaimedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1701,16 +1701,16 @@ func (fake *FakeInternalClient) EvacuateCrashedActualLRP(arg1 lager.Logger, arg2 arg3 *models.ActualLRPInstanceKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.EvacuateCrashedActualLRPStub + fakeReturns := fake.evacuateCrashedActualLRPReturns fake.recordInvocation("EvacuateCrashedActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - evacuateCrashedActualLRPStubCopy := fake.EvacuateCrashedActualLRPStub fake.evacuateCrashedActualLRPMutex.Unlock() - if evacuateCrashedActualLRPStubCopy != nil { - return evacuateCrashedActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateCrashedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1768,16 +1768,16 @@ func (fake *FakeInternalClient) EvacuateRunningActualLRP(arg1 lager.Logger, arg2 arg3 *models.ActualLRPInstanceKey arg4 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4}) + stub := fake.EvacuateRunningActualLRPStub + fakeReturns := fake.evacuateRunningActualLRPReturns fake.recordInvocation("EvacuateRunningActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - evacuateRunningActualLRPStubCopy := fake.EvacuateRunningActualLRPStub fake.evacuateRunningActualLRPMutex.Unlock() - if evacuateRunningActualLRPStubCopy != nil { - return evacuateRunningActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateRunningActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1834,16 +1834,16 @@ func (fake *FakeInternalClient) EvacuateStoppedActualLRP(arg1 lager.Logger, arg2 arg2 *models.ActualLRPKey arg3 *models.ActualLRPInstanceKey }{arg1, arg2, arg3}) + stub := fake.EvacuateStoppedActualLRPStub + fakeReturns := fake.evacuateStoppedActualLRPReturns fake.recordInvocation("EvacuateStoppedActualLRP", []interface{}{arg1, arg2, arg3}) - evacuateStoppedActualLRPStubCopy := fake.EvacuateStoppedActualLRPStub fake.evacuateStoppedActualLRPMutex.Unlock() - if evacuateStoppedActualLRPStubCopy != nil { - return evacuateStoppedActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateStoppedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -1900,16 +1900,16 @@ func (fake *FakeInternalClient) FailActualLRP(arg1 lager.Logger, arg2 *models.Ac arg2 *models.ActualLRPKey arg3 string }{arg1, arg2, arg3}) + stub := fake.FailActualLRPStub + fakeReturns := fake.failActualLRPReturns fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3}) - failActualLRPStubCopy := fake.FailActualLRPStub fake.failActualLRPMutex.Unlock() - if failActualLRPStubCopy != nil { - return failActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.failActualLRPReturns return fakeReturns.result1 } @@ -1963,16 +1963,16 @@ func (fake *FakeInternalClient) FailTask(arg1 lager.Logger, arg2 string, arg3 st arg2 string arg3 string }{arg1, arg2, arg3}) + stub := fake.FailTaskStub + fakeReturns := fake.failTaskReturns fake.recordInvocation("FailTask", []interface{}{arg1, arg2, arg3}) - failTaskStubCopy := fake.FailTaskStub fake.failTaskMutex.Unlock() - if failTaskStubCopy != nil { - return failTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.failTaskReturns return fakeReturns.result1 } @@ -2024,16 +2024,16 @@ func (fake *FakeInternalClient) Ping(arg1 lager.Logger) bool { fake.pingArgsForCall = append(fake.pingArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.PingStub + fakeReturns := fake.pingReturns fake.recordInvocation("Ping", []interface{}{arg1}) - pingStubCopy := fake.PingStub fake.pingMutex.Unlock() - if pingStubCopy != nil { - return pingStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1 } - fakeReturns := fake.pingReturns return fakeReturns.result1 } @@ -2087,16 +2087,16 @@ func (fake *FakeInternalClient) RejectTask(arg1 lager.Logger, arg2 string, arg3 arg2 string arg3 string }{arg1, arg2, arg3}) + stub := fake.RejectTaskStub + fakeReturns := fake.rejectTaskReturns fake.recordInvocation("RejectTask", []interface{}{arg1, arg2, arg3}) - rejectTaskStubCopy := fake.RejectTaskStub fake.rejectTaskMutex.Unlock() - if rejectTaskStubCopy != nil { - return rejectTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.rejectTaskReturns return fakeReturns.result1 } @@ -2150,16 +2150,16 @@ func (fake *FakeInternalClient) RemoveActualLRP(arg1 lager.Logger, arg2 *models. arg2 *models.ActualLRPKey arg3 *models.ActualLRPInstanceKey }{arg1, arg2, arg3}) + stub := fake.RemoveActualLRPStub + fakeReturns := fake.removeActualLRPReturns fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3}) - removeActualLRPStubCopy := fake.RemoveActualLRPStub fake.removeActualLRPMutex.Unlock() - if removeActualLRPStubCopy != nil { - return removeActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeActualLRPReturns return fakeReturns.result1 } @@ -2212,16 +2212,16 @@ func (fake *FakeInternalClient) RemoveDesiredLRP(arg1 lager.Logger, arg2 string) arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.RemoveDesiredLRPStub + fakeReturns := fake.removeDesiredLRPReturns fake.recordInvocation("RemoveDesiredLRP", []interface{}{arg1, arg2}) - removeDesiredLRPStubCopy := fake.RemoveDesiredLRPStub fake.removeDesiredLRPMutex.Unlock() - if removeDesiredLRPStubCopy != nil { - return removeDesiredLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeDesiredLRPReturns return fakeReturns.result1 } @@ -2275,16 +2275,16 @@ func (fake *FakeInternalClient) RemoveEvacuatingActualLRP(arg1 lager.Logger, arg arg2 *models.ActualLRPKey arg3 *models.ActualLRPInstanceKey }{arg1, arg2, arg3}) + stub := fake.RemoveEvacuatingActualLRPStub + fakeReturns := fake.removeEvacuatingActualLRPReturns fake.recordInvocation("RemoveEvacuatingActualLRP", []interface{}{arg1, arg2, arg3}) - removeEvacuatingActualLRPStubCopy := fake.RemoveEvacuatingActualLRPStub fake.removeEvacuatingActualLRPMutex.Unlock() - if removeEvacuatingActualLRPStubCopy != nil { - return removeEvacuatingActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeEvacuatingActualLRPReturns return fakeReturns.result1 } @@ -2337,16 +2337,16 @@ func (fake *FakeInternalClient) ResolvingTask(arg1 lager.Logger, arg2 string) er arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.ResolvingTaskStub + fakeReturns := fake.resolvingTaskReturns fake.recordInvocation("ResolvingTask", []interface{}{arg1, arg2}) - resolvingTaskStubCopy := fake.ResolvingTaskStub fake.resolvingTaskMutex.Unlock() - if resolvingTaskStubCopy != nil { - return resolvingTaskStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.resolvingTaskReturns return fakeReturns.result1 } @@ -2399,16 +2399,16 @@ func (fake *FakeInternalClient) RetireActualLRP(arg1 lager.Logger, arg2 *models. arg1 lager.Logger arg2 *models.ActualLRPKey }{arg1, arg2}) + stub := fake.RetireActualLRPStub + fakeReturns := fake.retireActualLRPReturns fake.recordInvocation("RetireActualLRP", []interface{}{arg1, arg2}) - retireActualLRPStubCopy := fake.RetireActualLRPStub fake.retireActualLRPMutex.Unlock() - if retireActualLRPStubCopy != nil { - return retireActualLRPStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.retireActualLRPReturns return fakeReturns.result1 } @@ -2463,16 +2463,16 @@ func (fake *FakeInternalClient) StartActualLRP(arg1 lager.Logger, arg2 *models.A arg3 *models.ActualLRPInstanceKey arg4 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4}) + stub := fake.StartActualLRPStub + fakeReturns := fake.startActualLRPReturns fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - startActualLRPStubCopy := fake.StartActualLRPStub fake.startActualLRPMutex.Unlock() - if startActualLRPStubCopy != nil { - return startActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.startActualLRPReturns return fakeReturns.result1 } @@ -2526,16 +2526,16 @@ func (fake *FakeInternalClient) StartTask(arg1 lager.Logger, arg2 string, arg3 s arg2 string arg3 string }{arg1, arg2, arg3}) + stub := fake.StartTaskStub + fakeReturns := fake.startTaskReturns fake.recordInvocation("StartTask", []interface{}{arg1, arg2, arg3}) - startTaskStubCopy := fake.StartTaskStub fake.startTaskMutex.Unlock() - if startTaskStubCopy != nil { - return startTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.startTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2590,16 +2590,16 @@ func (fake *FakeInternalClient) SubscribeToEvents(arg1 lager.Logger) (events.Eve fake.subscribeToEventsArgsForCall = append(fake.subscribeToEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToEventsStub + fakeReturns := fake.subscribeToEventsReturns fake.recordInvocation("SubscribeToEvents", []interface{}{arg1}) - subscribeToEventsStubCopy := fake.SubscribeToEventsStub fake.subscribeToEventsMutex.Unlock() - if subscribeToEventsStubCopy != nil { - return subscribeToEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2655,16 +2655,16 @@ func (fake *FakeInternalClient) SubscribeToEventsByCellID(arg1 lager.Logger, arg arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.SubscribeToEventsByCellIDStub + fakeReturns := fake.subscribeToEventsByCellIDReturns fake.recordInvocation("SubscribeToEventsByCellID", []interface{}{arg1, arg2}) - subscribeToEventsByCellIDStubCopy := fake.SubscribeToEventsByCellIDStub fake.subscribeToEventsByCellIDMutex.Unlock() - if subscribeToEventsByCellIDStubCopy != nil { - return subscribeToEventsByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToEventsByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2719,16 +2719,16 @@ func (fake *FakeInternalClient) SubscribeToInstanceEvents(arg1 lager.Logger) (ev fake.subscribeToInstanceEventsArgsForCall = append(fake.subscribeToInstanceEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToInstanceEventsStub + fakeReturns := fake.subscribeToInstanceEventsReturns fake.recordInvocation("SubscribeToInstanceEvents", []interface{}{arg1}) - subscribeToInstanceEventsStubCopy := fake.SubscribeToInstanceEventsStub fake.subscribeToInstanceEventsMutex.Unlock() - if subscribeToInstanceEventsStubCopy != nil { - return subscribeToInstanceEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToInstanceEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2784,16 +2784,16 @@ func (fake *FakeInternalClient) SubscribeToInstanceEventsByCellID(arg1 lager.Log arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.SubscribeToInstanceEventsByCellIDStub + fakeReturns := fake.subscribeToInstanceEventsByCellIDReturns fake.recordInvocation("SubscribeToInstanceEventsByCellID", []interface{}{arg1, arg2}) - subscribeToInstanceEventsByCellIDStubCopy := fake.SubscribeToInstanceEventsByCellIDStub fake.subscribeToInstanceEventsByCellIDMutex.Unlock() - if subscribeToInstanceEventsByCellIDStubCopy != nil { - return subscribeToInstanceEventsByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToInstanceEventsByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2848,16 +2848,16 @@ func (fake *FakeInternalClient) SubscribeToTaskEvents(arg1 lager.Logger) (events fake.subscribeToTaskEventsArgsForCall = append(fake.subscribeToTaskEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.SubscribeToTaskEventsStub + fakeReturns := fake.subscribeToTaskEventsReturns fake.recordInvocation("SubscribeToTaskEvents", []interface{}{arg1}) - subscribeToTaskEventsStubCopy := fake.SubscribeToTaskEventsStub fake.subscribeToTaskEventsMutex.Unlock() - if subscribeToTaskEventsStubCopy != nil { - return subscribeToTaskEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.subscribeToTaskEventsReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2913,16 +2913,16 @@ func (fake *FakeInternalClient) TaskByGuid(arg1 lager.Logger, arg2 string) (*mod arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TaskByGuidStub + fakeReturns := fake.taskByGuidReturns fake.recordInvocation("TaskByGuid", []interface{}{arg1, arg2}) - taskByGuidStubCopy := fake.TaskByGuidStub fake.taskByGuidMutex.Unlock() - if taskByGuidStubCopy != nil { - return taskByGuidStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.taskByGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -2977,16 +2977,16 @@ func (fake *FakeInternalClient) Tasks(arg1 lager.Logger) ([]*models.Task, error) fake.tasksArgsForCall = append(fake.tasksArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.TasksStub + fakeReturns := fake.tasksReturns fake.recordInvocation("Tasks", []interface{}{arg1}) - tasksStubCopy := fake.TasksStub fake.tasksMutex.Unlock() - if tasksStubCopy != nil { - return tasksStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksReturns return fakeReturns.result1, fakeReturns.result2 } @@ -3042,16 +3042,16 @@ func (fake *FakeInternalClient) TasksByCellID(arg1 lager.Logger, arg2 string) ([ arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TasksByCellIDStub + fakeReturns := fake.tasksByCellIDReturns fake.recordInvocation("TasksByCellID", []interface{}{arg1, arg2}) - tasksByCellIDStubCopy := fake.TasksByCellIDStub fake.tasksByCellIDMutex.Unlock() - if tasksByCellIDStubCopy != nil { - return tasksByCellIDStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksByCellIDReturns return fakeReturns.result1, fakeReturns.result2 } @@ -3107,16 +3107,16 @@ func (fake *FakeInternalClient) TasksByDomain(arg1 lager.Logger, arg2 string) ([ arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.TasksByDomainStub + fakeReturns := fake.tasksByDomainReturns fake.recordInvocation("TasksByDomain", []interface{}{arg1, arg2}) - tasksByDomainStubCopy := fake.TasksByDomainStub fake.tasksByDomainMutex.Unlock() - if tasksByDomainStubCopy != nil { - return tasksByDomainStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksByDomainReturns return fakeReturns.result1, fakeReturns.result2 } @@ -3172,16 +3172,16 @@ func (fake *FakeInternalClient) TasksWithFilter(arg1 lager.Logger, arg2 models.T arg1 lager.Logger arg2 models.TaskFilter }{arg1, arg2}) + stub := fake.TasksWithFilterStub + fakeReturns := fake.tasksWithFilterReturns fake.recordInvocation("TasksWithFilter", []interface{}{arg1, arg2}) - tasksWithFilterStubCopy := fake.TasksWithFilterStub fake.tasksWithFilterMutex.Unlock() - if tasksWithFilterStubCopy != nil { - return tasksWithFilterStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksWithFilterReturns return fakeReturns.result1, fakeReturns.result2 } @@ -3238,16 +3238,16 @@ func (fake *FakeInternalClient) UpdateDesiredLRP(arg1 lager.Logger, arg2 string, arg2 string arg3 *models.DesiredLRPUpdate }{arg1, arg2, arg3}) + stub := fake.UpdateDesiredLRPStub + fakeReturns := fake.updateDesiredLRPReturns fake.recordInvocation("UpdateDesiredLRP", []interface{}{arg1, arg2, arg3}) - updateDesiredLRPStubCopy := fake.UpdateDesiredLRPStub fake.updateDesiredLRPMutex.Unlock() - if updateDesiredLRPStubCopy != nil { - return updateDesiredLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.updateDesiredLRPReturns return fakeReturns.result1 } @@ -3301,16 +3301,16 @@ func (fake *FakeInternalClient) UpsertDomain(arg1 lager.Logger, arg2 string, arg arg2 string arg3 time.Duration }{arg1, arg2, arg3}) + stub := fake.UpsertDomainStub + fakeReturns := fake.upsertDomainReturns fake.recordInvocation("UpsertDomain", []interface{}{arg1, arg2, arg3}) - upsertDomainStubCopy := fake.UpsertDomainStub fake.upsertDomainMutex.Unlock() - if upsertDomainStubCopy != nil { - return upsertDomainStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.upsertDomainReturns return fakeReturns.result1 } diff --git a/guidprovider/guidproviderfakes/fake_guidprovider.go b/guidprovider/guidproviderfakes/fake_guidprovider.go index ad24ac63..59a5de63 100644 --- a/guidprovider/guidproviderfakes/fake_guidprovider.go +++ b/guidprovider/guidproviderfakes/fake_guidprovider.go @@ -29,16 +29,16 @@ func (fake *FakeGUIDProvider) NextGUID() (string, error) { ret, specificReturn := fake.nextGUIDReturnsOnCall[len(fake.nextGUIDArgsForCall)] fake.nextGUIDArgsForCall = append(fake.nextGUIDArgsForCall, struct { }{}) + stub := fake.NextGUIDStub + fakeReturns := fake.nextGUIDReturns fake.recordInvocation("NextGUID", []interface{}{}) - nextGUIDStubCopy := fake.NextGUIDStub fake.nextGUIDMutex.Unlock() - if nextGUIDStubCopy != nil { - return nextGUIDStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.nextGUIDReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/handlers/fake_controllers/fake_actual_lrp_lifecycle_controller.go b/handlers/fake_controllers/fake_actual_lrp_lifecycle_controller.go index 86d2c2ef..5d24ca65 100644 --- a/handlers/fake_controllers/fake_actual_lrp_lifecycle_controller.go +++ b/handlers/fake_controllers/fake_actual_lrp_lifecycle_controller.go @@ -112,16 +112,16 @@ func (fake *FakeActualLRPLifecycleController) ClaimActualLRP(arg1 context.Contex arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ClaimActualLRPStub + fakeReturns := fake.claimActualLRPReturns fake.recordInvocation("ClaimActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - claimActualLRPStubCopy := fake.ClaimActualLRPStub fake.claimActualLRPMutex.Unlock() - if claimActualLRPStubCopy != nil { - return claimActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.claimActualLRPReturns return fakeReturns.result1 } @@ -177,16 +177,16 @@ func (fake *FakeActualLRPLifecycleController) CrashActualLRP(arg1 context.Contex arg4 *models.ActualLRPInstanceKey arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.CrashActualLRPStub + fakeReturns := fake.crashActualLRPReturns fake.recordInvocation("CrashActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - crashActualLRPStubCopy := fake.CrashActualLRPStub fake.crashActualLRPMutex.Unlock() - if crashActualLRPStubCopy != nil { - return crashActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.crashActualLRPReturns return fakeReturns.result1 } @@ -241,16 +241,16 @@ func (fake *FakeActualLRPLifecycleController) FailActualLRP(arg1 context.Context arg3 *models.ActualLRPKey arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailActualLRPStub + fakeReturns := fake.failActualLRPReturns fake.recordInvocation("FailActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - failActualLRPStubCopy := fake.FailActualLRPStub fake.failActualLRPMutex.Unlock() - if failActualLRPStubCopy != nil { - return failActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.failActualLRPReturns return fakeReturns.result1 } @@ -306,16 +306,16 @@ func (fake *FakeActualLRPLifecycleController) RemoveActualLRP(arg1 context.Conte arg4 int32 arg5 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.RemoveActualLRPStub + fakeReturns := fake.removeActualLRPReturns fake.recordInvocation("RemoveActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - removeActualLRPStubCopy := fake.RemoveActualLRPStub fake.removeActualLRPMutex.Unlock() - if removeActualLRPStubCopy != nil { - return removeActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeActualLRPReturns return fakeReturns.result1 } @@ -369,16 +369,16 @@ func (fake *FakeActualLRPLifecycleController) RetireActualLRP(arg1 context.Conte arg2 lager.Logger arg3 *models.ActualLRPKey }{arg1, arg2, arg3}) + stub := fake.RetireActualLRPStub + fakeReturns := fake.retireActualLRPReturns fake.recordInvocation("RetireActualLRP", []interface{}{arg1, arg2, arg3}) - retireActualLRPStubCopy := fake.RetireActualLRPStub fake.retireActualLRPMutex.Unlock() - if retireActualLRPStubCopy != nil { - return retireActualLRPStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.retireActualLRPReturns return fakeReturns.result1 } @@ -434,16 +434,16 @@ func (fake *FakeActualLRPLifecycleController) StartActualLRP(arg1 context.Contex arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.StartActualLRPStub + fakeReturns := fake.startActualLRPReturns fake.recordInvocation("StartActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - startActualLRPStubCopy := fake.StartActualLRPStub fake.startActualLRPMutex.Unlock() - if startActualLRPStubCopy != nil { - return startActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.startActualLRPReturns return fakeReturns.result1 } diff --git a/handlers/fake_controllers/fake_evacuation_controller.go b/handlers/fake_controllers/fake_evacuation_controller.go index 42a866a3..a60ed95e 100644 --- a/handlers/fake_controllers/fake_evacuation_controller.go +++ b/handlers/fake_controllers/fake_evacuation_controller.go @@ -100,16 +100,16 @@ func (fake *FakeEvacuationController) EvacuateClaimedActualLRP(arg1 context.Cont arg3 *models.ActualLRPKey arg4 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4}) + stub := fake.EvacuateClaimedActualLRPStub + fakeReturns := fake.evacuateClaimedActualLRPReturns fake.recordInvocation("EvacuateClaimedActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - evacuateClaimedActualLRPStubCopy := fake.EvacuateClaimedActualLRPStub fake.evacuateClaimedActualLRPMutex.Unlock() - if evacuateClaimedActualLRPStubCopy != nil { - return evacuateClaimedActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateClaimedActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -168,16 +168,16 @@ func (fake *FakeEvacuationController) EvacuateCrashedActualLRP(arg1 context.Cont arg4 *models.ActualLRPInstanceKey arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.EvacuateCrashedActualLRPStub + fakeReturns := fake.evacuateCrashedActualLRPReturns fake.recordInvocation("EvacuateCrashedActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - evacuateCrashedActualLRPStubCopy := fake.EvacuateCrashedActualLRPStub fake.evacuateCrashedActualLRPMutex.Unlock() - if evacuateCrashedActualLRPStubCopy != nil { - return evacuateCrashedActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.evacuateCrashedActualLRPReturns return fakeReturns.result1 } @@ -233,16 +233,16 @@ func (fake *FakeEvacuationController) EvacuateRunningActualLRP(arg1 context.Cont arg4 *models.ActualLRPInstanceKey arg5 *models.ActualLRPNetInfo }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.EvacuateRunningActualLRPStub + fakeReturns := fake.evacuateRunningActualLRPReturns fake.recordInvocation("EvacuateRunningActualLRP", []interface{}{arg1, arg2, arg3, arg4, arg5}) - evacuateRunningActualLRPStubCopy := fake.EvacuateRunningActualLRPStub fake.evacuateRunningActualLRPMutex.Unlock() - if evacuateRunningActualLRPStubCopy != nil { - return evacuateRunningActualLRPStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.evacuateRunningActualLRPReturns return fakeReturns.result1, fakeReturns.result2 } @@ -300,16 +300,16 @@ func (fake *FakeEvacuationController) EvacuateStoppedActualLRP(arg1 context.Cont arg3 *models.ActualLRPKey arg4 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4}) + stub := fake.EvacuateStoppedActualLRPStub + fakeReturns := fake.evacuateStoppedActualLRPReturns fake.recordInvocation("EvacuateStoppedActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - evacuateStoppedActualLRPStubCopy := fake.EvacuateStoppedActualLRPStub fake.evacuateStoppedActualLRPMutex.Unlock() - if evacuateStoppedActualLRPStubCopy != nil { - return evacuateStoppedActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.evacuateStoppedActualLRPReturns return fakeReturns.result1 } @@ -364,16 +364,16 @@ func (fake *FakeEvacuationController) RemoveEvacuatingActualLRP(arg1 context.Con arg3 *models.ActualLRPKey arg4 *models.ActualLRPInstanceKey }{arg1, arg2, arg3, arg4}) + stub := fake.RemoveEvacuatingActualLRPStub + fakeReturns := fake.removeEvacuatingActualLRPReturns fake.recordInvocation("RemoveEvacuatingActualLRP", []interface{}{arg1, arg2, arg3, arg4}) - removeEvacuatingActualLRPStubCopy := fake.RemoveEvacuatingActualLRPStub fake.removeEvacuatingActualLRPMutex.Unlock() - if removeEvacuatingActualLRPStubCopy != nil { - return removeEvacuatingActualLRPStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.removeEvacuatingActualLRPReturns return fakeReturns.result1 } diff --git a/handlers/fake_controllers/fake_task_controller.go b/handlers/fake_controllers/fake_task_controller.go index 1c7b9d7f..8731b507 100644 --- a/handlers/fake_controllers/fake_task_controller.go +++ b/handlers/fake_controllers/fake_task_controller.go @@ -185,16 +185,16 @@ func (fake *FakeTaskController) CancelTask(arg1 context.Context, arg2 lager.Logg arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.CancelTaskStub + fakeReturns := fake.cancelTaskReturns fake.recordInvocation("CancelTask", []interface{}{arg1, arg2, arg3}) - cancelTaskStubCopy := fake.CancelTaskStub fake.cancelTaskMutex.Unlock() - if cancelTaskStubCopy != nil { - return cancelTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.cancelTaskReturns return fakeReturns.result1 } @@ -252,16 +252,16 @@ func (fake *FakeTaskController) CompleteTask(arg1 context.Context, arg2 lager.Lo arg6 string arg7 string }{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) + stub := fake.CompleteTaskStub + fakeReturns := fake.completeTaskReturns fake.recordInvocation("CompleteTask", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7}) - completeTaskStubCopy := fake.CompleteTaskStub fake.completeTaskMutex.Unlock() - if completeTaskStubCopy != nil { - return completeTaskStubCopy(arg1, arg2, arg3, arg4, arg5, arg6, arg7) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7) } if specificReturn { return ret.result1 } - fakeReturns := fake.completeTaskReturns return fakeReturns.result1 } @@ -317,16 +317,16 @@ func (fake *FakeTaskController) ConvergeTasks(arg1 context.Context, arg2 lager.L arg4 time.Duration arg5 time.Duration }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.ConvergeTasksStub + fakeReturns := fake.convergeTasksReturns fake.recordInvocation("ConvergeTasks", []interface{}{arg1, arg2, arg3, arg4, arg5}) - convergeTasksStubCopy := fake.ConvergeTasksStub fake.convergeTasksMutex.Unlock() - if convergeTasksStubCopy != nil { - return convergeTasksStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.convergeTasksReturns return fakeReturns.result1 } @@ -380,16 +380,16 @@ func (fake *FakeTaskController) DeleteTask(arg1 context.Context, arg2 lager.Logg arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.DeleteTaskStub + fakeReturns := fake.deleteTaskReturns fake.recordInvocation("DeleteTask", []interface{}{arg1, arg2, arg3}) - deleteTaskStubCopy := fake.DeleteTaskStub fake.deleteTaskMutex.Unlock() - if deleteTaskStubCopy != nil { - return deleteTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.deleteTaskReturns return fakeReturns.result1 } @@ -445,16 +445,16 @@ func (fake *FakeTaskController) DesireTask(arg1 context.Context, arg2 lager.Logg arg4 string arg5 string }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.DesireTaskStub + fakeReturns := fake.desireTaskReturns fake.recordInvocation("DesireTask", []interface{}{arg1, arg2, arg3, arg4, arg5}) - desireTaskStubCopy := fake.DesireTaskStub fake.desireTaskMutex.Unlock() - if desireTaskStubCopy != nil { - return desireTaskStubCopy(arg1, arg2, arg3, arg4, arg5) + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) } if specificReturn { return ret.result1 } - fakeReturns := fake.desireTaskReturns return fakeReturns.result1 } @@ -509,16 +509,16 @@ func (fake *FakeTaskController) FailTask(arg1 context.Context, arg2 lager.Logger arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.FailTaskStub + fakeReturns := fake.failTaskReturns fake.recordInvocation("FailTask", []interface{}{arg1, arg2, arg3, arg4}) - failTaskStubCopy := fake.FailTaskStub fake.failTaskMutex.Unlock() - if failTaskStubCopy != nil { - return failTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.failTaskReturns return fakeReturns.result1 } @@ -573,16 +573,16 @@ func (fake *FakeTaskController) RejectTask(arg1 context.Context, arg2 lager.Logg arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.RejectTaskStub + fakeReturns := fake.rejectTaskReturns fake.recordInvocation("RejectTask", []interface{}{arg1, arg2, arg3, arg4}) - rejectTaskStubCopy := fake.RejectTaskStub fake.rejectTaskMutex.Unlock() - if rejectTaskStubCopy != nil { - return rejectTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1 } - fakeReturns := fake.rejectTaskReturns return fakeReturns.result1 } @@ -636,16 +636,16 @@ func (fake *FakeTaskController) ResolvingTask(arg1 context.Context, arg2 lager.L arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.ResolvingTaskStub + fakeReturns := fake.resolvingTaskReturns fake.recordInvocation("ResolvingTask", []interface{}{arg1, arg2, arg3}) - resolvingTaskStubCopy := fake.ResolvingTaskStub fake.resolvingTaskMutex.Unlock() - if resolvingTaskStubCopy != nil { - return resolvingTaskStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1 } - fakeReturns := fake.resolvingTaskReturns return fakeReturns.result1 } @@ -700,16 +700,16 @@ func (fake *FakeTaskController) StartTask(arg1 context.Context, arg2 lager.Logge arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.StartTaskStub + fakeReturns := fake.startTaskReturns fake.recordInvocation("StartTask", []interface{}{arg1, arg2, arg3, arg4}) - startTaskStubCopy := fake.StartTaskStub fake.startTaskMutex.Unlock() - if startTaskStubCopy != nil { - return startTaskStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.startTaskReturns return fakeReturns.result1, fakeReturns.result2 } @@ -766,16 +766,16 @@ func (fake *FakeTaskController) TaskByGuid(arg1 context.Context, arg2 lager.Logg arg2 lager.Logger arg3 string }{arg1, arg2, arg3}) + stub := fake.TaskByGuidStub + fakeReturns := fake.taskByGuidReturns fake.recordInvocation("TaskByGuid", []interface{}{arg1, arg2, arg3}) - taskByGuidStubCopy := fake.TaskByGuidStub fake.taskByGuidMutex.Unlock() - if taskByGuidStubCopy != nil { - return taskByGuidStubCopy(arg1, arg2, arg3) + if stub != nil { + return stub(arg1, arg2, arg3) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.taskByGuidReturns return fakeReturns.result1, fakeReturns.result2 } @@ -833,16 +833,16 @@ func (fake *FakeTaskController) Tasks(arg1 context.Context, arg2 lager.Logger, a arg3 string arg4 string }{arg1, arg2, arg3, arg4}) + stub := fake.TasksStub + fakeReturns := fake.tasksReturns fake.recordInvocation("Tasks", []interface{}{arg1, arg2, arg3, arg4}) - tasksStubCopy := fake.TasksStub fake.tasksMutex.Unlock() - if tasksStubCopy != nil { - return tasksStubCopy(arg1, arg2, arg3, arg4) + if stub != nil { + return stub(arg1, arg2, arg3, arg4) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.tasksReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/handlers/middleware/fakes/fake_emitter.go b/handlers/middleware/fakes/fake_emitter.go index 7d5b1fff..d49ec7fa 100644 --- a/handlers/middleware/fakes/fake_emitter.go +++ b/handlers/middleware/fakes/fake_emitter.go @@ -28,11 +28,11 @@ func (fake *FakeEmitter) IncrementRequestCounter(arg1 int) { fake.incrementRequestCounterArgsForCall = append(fake.incrementRequestCounterArgsForCall, struct { arg1 int }{arg1}) + stub := fake.IncrementRequestCounterStub fake.recordInvocation("IncrementRequestCounter", []interface{}{arg1}) - incrementRequestCounterStubCopy := fake.IncrementRequestCounterStub fake.incrementRequestCounterMutex.Unlock() - if incrementRequestCounterStubCopy != nil { - incrementRequestCounterStubCopy(arg1) + if stub != nil { + fake.IncrementRequestCounterStub(arg1) } } @@ -60,11 +60,11 @@ func (fake *FakeEmitter) UpdateLatency(arg1 time.Duration) { fake.updateLatencyArgsForCall = append(fake.updateLatencyArgsForCall, struct { arg1 time.Duration }{arg1}) + stub := fake.UpdateLatencyStub fake.recordInvocation("UpdateLatency", []interface{}{arg1}) - updateLatencyStubCopy := fake.UpdateLatencyStub fake.updateLatencyMutex.Unlock() - if updateLatencyStubCopy != nil { - updateLatencyStubCopy(arg1) + if stub != nil { + fake.UpdateLatencyStub(arg1) } } diff --git a/metrics/fakes/fake_lrp_stat_metron_notifier.go b/metrics/fakes/fake_lrp_stat_metron_notifier.go index deee7a79..1b437773 100644 --- a/metrics/fakes/fake_lrp_stat_metron_notifier.go +++ b/metrics/fakes/fake_lrp_stat_metron_notifier.go @@ -62,11 +62,11 @@ func (fake *FakeLRPStatMetronNotifier) RecordCellCounts(arg1 int, arg2 int) { arg1 int arg2 int }{arg1, arg2}) + stub := fake.RecordCellCountsStub fake.recordInvocation("RecordCellCounts", []interface{}{arg1, arg2}) - recordCellCountsStubCopy := fake.RecordCellCountsStub fake.recordCellCountsMutex.Unlock() - if recordCellCountsStubCopy != nil { - recordCellCountsStubCopy(arg1, arg2) + if stub != nil { + fake.RecordCellCountsStub(arg1, arg2) } } @@ -94,11 +94,11 @@ func (fake *FakeLRPStatMetronNotifier) RecordConvergenceDuration(arg1 time.Durat fake.recordConvergenceDurationArgsForCall = append(fake.recordConvergenceDurationArgsForCall, struct { arg1 time.Duration }{arg1}) + stub := fake.RecordConvergenceDurationStub fake.recordInvocation("RecordConvergenceDuration", []interface{}{arg1}) - recordConvergenceDurationStubCopy := fake.RecordConvergenceDurationStub fake.recordConvergenceDurationMutex.Unlock() - if recordConvergenceDurationStubCopy != nil { - recordConvergenceDurationStubCopy(arg1) + if stub != nil { + fake.RecordConvergenceDurationStub(arg1) } } @@ -131,11 +131,11 @@ func (fake *FakeLRPStatMetronNotifier) RecordFreshDomains(arg1 []string) { fake.recordFreshDomainsArgsForCall = append(fake.recordFreshDomainsArgsForCall, struct { arg1 []string }{arg1Copy}) + stub := fake.RecordFreshDomainsStub fake.recordInvocation("RecordFreshDomains", []interface{}{arg1Copy}) - recordFreshDomainsStubCopy := fake.RecordFreshDomainsStub fake.recordFreshDomainsMutex.Unlock() - if recordFreshDomainsStubCopy != nil { - recordFreshDomainsStubCopy(arg1) + if stub != nil { + fake.RecordFreshDomainsStub(arg1) } } @@ -172,11 +172,11 @@ func (fake *FakeLRPStatMetronNotifier) RecordLRPCounts(arg1 int, arg2 int, arg3 arg9 int arg10 int }{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10}) + stub := fake.RecordLRPCountsStub fake.recordInvocation("RecordLRPCounts", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10}) - recordLRPCountsStubCopy := fake.RecordLRPCountsStub fake.recordLRPCountsMutex.Unlock() - if recordLRPCountsStubCopy != nil { - recordLRPCountsStubCopy(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) + if stub != nil { + fake.RecordLRPCountsStub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) } } @@ -206,16 +206,16 @@ func (fake *FakeLRPStatMetronNotifier) Run(arg1 <-chan os.Signal, arg2 chan<- st arg1 <-chan os.Signal arg2 chan<- struct{} }{arg1, arg2}) + stub := fake.RunStub + fakeReturns := fake.runReturns fake.recordInvocation("Run", []interface{}{arg1, arg2}) - runStubCopy := fake.RunStub fake.runMutex.Unlock() - if runStubCopy != nil { - return runStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.runReturns return fakeReturns.result1 } diff --git a/metrics/fakes/fake_task_stat_metron_notifier.go b/metrics/fakes/fake_task_stat_metron_notifier.go index 60821a3d..e9cdb821 100644 --- a/metrics/fakes/fake_task_stat_metron_notifier.go +++ b/metrics/fakes/fake_task_stat_metron_notifier.go @@ -61,11 +61,11 @@ func (fake *FakeTaskStatMetronNotifier) RecordConvergenceDuration(arg1 time.Dura fake.recordConvergenceDurationArgsForCall = append(fake.recordConvergenceDurationArgsForCall, struct { arg1 time.Duration }{arg1}) + stub := fake.RecordConvergenceDurationStub fake.recordInvocation("RecordConvergenceDuration", []interface{}{arg1}) - recordConvergenceDurationStubCopy := fake.RecordConvergenceDurationStub fake.recordConvergenceDurationMutex.Unlock() - if recordConvergenceDurationStubCopy != nil { - recordConvergenceDurationStubCopy(arg1) + if stub != nil { + fake.RecordConvergenceDurationStub(arg1) } } @@ -98,11 +98,11 @@ func (fake *FakeTaskStatMetronNotifier) RecordTaskCounts(arg1 int, arg2 int, arg arg5 uint64 arg6 uint64 }{arg1, arg2, arg3, arg4, arg5, arg6}) + stub := fake.RecordTaskCountsStub fake.recordInvocation("RecordTaskCounts", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) - recordTaskCountsStubCopy := fake.RecordTaskCountsStub fake.recordTaskCountsMutex.Unlock() - if recordTaskCountsStubCopy != nil { - recordTaskCountsStubCopy(arg1, arg2, arg3, arg4, arg5, arg6) + if stub != nil { + fake.RecordTaskCountsStub(arg1, arg2, arg3, arg4, arg5, arg6) } } @@ -130,11 +130,11 @@ func (fake *FakeTaskStatMetronNotifier) RecordTaskFailed(arg1 string) { fake.recordTaskFailedArgsForCall = append(fake.recordTaskFailedArgsForCall, struct { arg1 string }{arg1}) + stub := fake.RecordTaskFailedStub fake.recordInvocation("RecordTaskFailed", []interface{}{arg1}) - recordTaskFailedStubCopy := fake.RecordTaskFailedStub fake.recordTaskFailedMutex.Unlock() - if recordTaskFailedStubCopy != nil { - recordTaskFailedStubCopy(arg1) + if stub != nil { + fake.RecordTaskFailedStub(arg1) } } @@ -162,11 +162,11 @@ func (fake *FakeTaskStatMetronNotifier) RecordTaskStarted(arg1 string) { fake.recordTaskStartedArgsForCall = append(fake.recordTaskStartedArgsForCall, struct { arg1 string }{arg1}) + stub := fake.RecordTaskStartedStub fake.recordInvocation("RecordTaskStarted", []interface{}{arg1}) - recordTaskStartedStubCopy := fake.RecordTaskStartedStub fake.recordTaskStartedMutex.Unlock() - if recordTaskStartedStubCopy != nil { - recordTaskStartedStubCopy(arg1) + if stub != nil { + fake.RecordTaskStartedStub(arg1) } } @@ -194,11 +194,11 @@ func (fake *FakeTaskStatMetronNotifier) RecordTaskSucceeded(arg1 string) { fake.recordTaskSucceededArgsForCall = append(fake.recordTaskSucceededArgsForCall, struct { arg1 string }{arg1}) + stub := fake.RecordTaskSucceededStub fake.recordInvocation("RecordTaskSucceeded", []interface{}{arg1}) - recordTaskSucceededStubCopy := fake.RecordTaskSucceededStub fake.recordTaskSucceededMutex.Unlock() - if recordTaskSucceededStubCopy != nil { - recordTaskSucceededStubCopy(arg1) + if stub != nil { + fake.RecordTaskSucceededStub(arg1) } } @@ -228,16 +228,16 @@ func (fake *FakeTaskStatMetronNotifier) Run(arg1 <-chan os.Signal, arg2 chan<- s arg1 <-chan os.Signal arg2 chan<- struct{} }{arg1, arg2}) + stub := fake.RunStub + fakeReturns := fake.runReturns fake.recordInvocation("Run", []interface{}{arg1, arg2}) - runStubCopy := fake.RunStub fake.runMutex.Unlock() - if runStubCopy != nil { - return runStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1 } - fakeReturns := fake.runReturns return fakeReturns.result1 } diff --git a/metrics/metricsfakes/fake_dbstats.go b/metrics/metricsfakes/fake_dbstats.go index 94115f84..017295cd 100644 --- a/metrics/metricsfakes/fake_dbstats.go +++ b/metrics/metricsfakes/fake_dbstats.go @@ -48,16 +48,16 @@ func (fake *FakeDBStats) OpenConnections() int { ret, specificReturn := fake.openConnectionsReturnsOnCall[len(fake.openConnectionsArgsForCall)] fake.openConnectionsArgsForCall = append(fake.openConnectionsArgsForCall, struct { }{}) + stub := fake.OpenConnectionsStub + fakeReturns := fake.openConnectionsReturns fake.recordInvocation("OpenConnections", []interface{}{}) - openConnectionsStubCopy := fake.OpenConnectionsStub fake.openConnectionsMutex.Unlock() - if openConnectionsStubCopy != nil { - return openConnectionsStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.openConnectionsReturns return fakeReturns.result1 } @@ -101,16 +101,16 @@ func (fake *FakeDBStats) WaitCount() int64 { ret, specificReturn := fake.waitCountReturnsOnCall[len(fake.waitCountArgsForCall)] fake.waitCountArgsForCall = append(fake.waitCountArgsForCall, struct { }{}) + stub := fake.WaitCountStub + fakeReturns := fake.waitCountReturns fake.recordInvocation("WaitCount", []interface{}{}) - waitCountStubCopy := fake.WaitCountStub fake.waitCountMutex.Unlock() - if waitCountStubCopy != nil { - return waitCountStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.waitCountReturns return fakeReturns.result1 } @@ -154,16 +154,16 @@ func (fake *FakeDBStats) WaitDuration() time.Duration { ret, specificReturn := fake.waitDurationReturnsOnCall[len(fake.waitDurationArgsForCall)] fake.waitDurationArgsForCall = append(fake.waitDurationArgsForCall, struct { }{}) + stub := fake.WaitDurationStub + fakeReturns := fake.waitDurationReturns fake.recordInvocation("WaitDuration", []interface{}{}) - waitDurationStubCopy := fake.WaitDurationStub fake.waitDurationMutex.Unlock() - if waitDurationStubCopy != nil { - return waitDurationStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.waitDurationReturns return fakeReturns.result1 } diff --git a/migration/migrationfakes/fake_migration.go b/migration/migrationfakes/fake_migration.go index 5fc77ea5..650ede98 100644 --- a/migration/migrationfakes/fake_migration.go +++ b/migration/migrationfakes/fake_migration.go @@ -72,11 +72,11 @@ func (fake *FakeMigration) SetClock(arg1 clock.Clock) { fake.setClockArgsForCall = append(fake.setClockArgsForCall, struct { arg1 clock.Clock }{arg1}) + stub := fake.SetClockStub fake.recordInvocation("SetClock", []interface{}{arg1}) - setClockStubCopy := fake.SetClockStub fake.setClockMutex.Unlock() - if setClockStubCopy != nil { - setClockStubCopy(arg1) + if stub != nil { + fake.SetClockStub(arg1) } } @@ -104,11 +104,11 @@ func (fake *FakeMigration) SetCryptor(arg1 encryption.Cryptor) { fake.setCryptorArgsForCall = append(fake.setCryptorArgsForCall, struct { arg1 encryption.Cryptor }{arg1}) + stub := fake.SetCryptorStub fake.recordInvocation("SetCryptor", []interface{}{arg1}) - setCryptorStubCopy := fake.SetCryptorStub fake.setCryptorMutex.Unlock() - if setCryptorStubCopy != nil { - setCryptorStubCopy(arg1) + if stub != nil { + fake.SetCryptorStub(arg1) } } @@ -136,11 +136,11 @@ func (fake *FakeMigration) SetDBFlavor(arg1 string) { fake.setDBFlavorArgsForCall = append(fake.setDBFlavorArgsForCall, struct { arg1 string }{arg1}) + stub := fake.SetDBFlavorStub fake.recordInvocation("SetDBFlavor", []interface{}{arg1}) - setDBFlavorStubCopy := fake.SetDBFlavorStub fake.setDBFlavorMutex.Unlock() - if setDBFlavorStubCopy != nil { - setDBFlavorStubCopy(arg1) + if stub != nil { + fake.SetDBFlavorStub(arg1) } } @@ -168,11 +168,11 @@ func (fake *FakeMigration) SetRawSQLDB(arg1 *sql.DB) { fake.setRawSQLDBArgsForCall = append(fake.setRawSQLDBArgsForCall, struct { arg1 *sql.DB }{arg1}) + stub := fake.SetRawSQLDBStub fake.recordInvocation("SetRawSQLDB", []interface{}{arg1}) - setRawSQLDBStubCopy := fake.SetRawSQLDBStub fake.setRawSQLDBMutex.Unlock() - if setRawSQLDBStubCopy != nil { - setRawSQLDBStubCopy(arg1) + if stub != nil { + fake.SetRawSQLDBStub(arg1) } } @@ -200,16 +200,16 @@ func (fake *FakeMigration) String() string { ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)] fake.stringArgsForCall = append(fake.stringArgsForCall, struct { }{}) + stub := fake.StringStub + fakeReturns := fake.stringReturns fake.recordInvocation("String", []interface{}{}) - stringStubCopy := fake.StringStub fake.stringMutex.Unlock() - if stringStubCopy != nil { - return stringStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.stringReturns return fakeReturns.result1 } @@ -254,16 +254,16 @@ func (fake *FakeMigration) Up(arg1 lager.Logger) error { fake.upArgsForCall = append(fake.upArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.UpStub + fakeReturns := fake.upReturns fake.recordInvocation("Up", []interface{}{arg1}) - upStubCopy := fake.UpStub fake.upMutex.Unlock() - if upStubCopy != nil { - return upStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1 } - fakeReturns := fake.upReturns return fakeReturns.result1 } @@ -314,16 +314,16 @@ func (fake *FakeMigration) Version() int64 { ret, specificReturn := fake.versionReturnsOnCall[len(fake.versionArgsForCall)] fake.versionArgsForCall = append(fake.versionArgsForCall, struct { }{}) + stub := fake.VersionStub + fakeReturns := fake.versionReturns fake.recordInvocation("Version", []interface{}{}) - versionStubCopy := fake.VersionStub fake.versionMutex.Unlock() - if versionStubCopy != nil { - return versionStubCopy() + if stub != nil { + return stub() } if specificReturn { return ret.result1 } - fakeReturns := fake.versionReturns return fakeReturns.result1 } diff --git a/serviceclient/serviceclientfakes/fake_service_client.go b/serviceclient/serviceclientfakes/fake_service_client.go index dc851ca9..20ca0745 100644 --- a/serviceclient/serviceclientfakes/fake_service_client.go +++ b/serviceclient/serviceclientfakes/fake_service_client.go @@ -59,16 +59,16 @@ func (fake *FakeServiceClient) CellById(arg1 lager.Logger, arg2 string) (*models arg1 lager.Logger arg2 string }{arg1, arg2}) + stub := fake.CellByIdStub + fakeReturns := fake.cellByIdReturns fake.recordInvocation("CellById", []interface{}{arg1, arg2}) - cellByIdStubCopy := fake.CellByIdStub fake.cellByIdMutex.Unlock() - if cellByIdStubCopy != nil { - return cellByIdStubCopy(arg1, arg2) + if stub != nil { + return stub(arg1, arg2) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.cellByIdReturns return fakeReturns.result1, fakeReturns.result2 } @@ -123,16 +123,16 @@ func (fake *FakeServiceClient) CellEvents(arg1 lager.Logger) <-chan models.CellE fake.cellEventsArgsForCall = append(fake.cellEventsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.CellEventsStub + fakeReturns := fake.cellEventsReturns fake.recordInvocation("CellEvents", []interface{}{arg1}) - cellEventsStubCopy := fake.CellEventsStub fake.cellEventsMutex.Unlock() - if cellEventsStubCopy != nil { - return cellEventsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1 } - fakeReturns := fake.cellEventsReturns return fakeReturns.result1 } @@ -184,16 +184,16 @@ func (fake *FakeServiceClient) Cells(arg1 lager.Logger) (models.CellSet, error) fake.cellsArgsForCall = append(fake.cellsArgsForCall, struct { arg1 lager.Logger }{arg1}) + stub := fake.CellsStub + fakeReturns := fake.cellsReturns fake.recordInvocation("Cells", []interface{}{arg1}) - cellsStubCopy := fake.CellsStub fake.cellsMutex.Unlock() - if cellsStubCopy != nil { - return cellsStubCopy(arg1) + if stub != nil { + return stub(arg1) } if specificReturn { return ret.result1, ret.result2 } - fakeReturns := fake.cellsReturns return fakeReturns.result1, fakeReturns.result2 } diff --git a/taskworkpool/taskworkpoolfakes/fake_task_completion_client.go b/taskworkpool/taskworkpoolfakes/fake_task_completion_client.go index a72dffe5..dd54f40c 100644 --- a/taskworkpool/taskworkpoolfakes/fake_task_completion_client.go +++ b/taskworkpool/taskworkpoolfakes/fake_task_completion_client.go @@ -29,11 +29,11 @@ func (fake *FakeTaskCompletionClient) Submit(arg1 db.TaskDB, arg2 events.Hub, ar arg2 events.Hub arg3 *models.Task }{arg1, arg2, arg3}) + stub := fake.SubmitStub fake.recordInvocation("Submit", []interface{}{arg1, arg2, arg3}) - submitStubCopy := fake.SubmitStub fake.submitMutex.Unlock() - if submitStubCopy != nil { - submitStubCopy(arg1, arg2, arg3) + if stub != nil { + fake.SubmitStub(arg1, arg2, arg3) } }