From b8da6acbffa5a9a06dbfff4c651925015c243103 Mon Sep 17 00:00:00 2001 From: aram price Date: Thu, 20 Aug 2026 15:08:13 -0700 Subject: [PATCH 01/13] Replace gomock with counterfeiter --- .../agentclientfakes/fake_agent_client.go | 1500 +++++++++++++++++ agentclient/generate.go | 5 + agentclient/mocks/mocks.go | 325 ---- blobstore/blobstore.go | 4 + blobstore/blobstore_factory.go | 2 + blobstore/blobstorefakes/fake_blobstore.go | 191 +++ blobstore/blobstorefakes/fake_factory.go | 117 ++ blobstore/mocks/mocks.go | 104 -- cloud/cloud.go | 4 + cloud/cloudfakes/fake_cloud.go | 1015 +++++++++++ cloud/cloudfakes/fake_factory.go | 119 ++ cloud/factory.go | 2 + cloud/mocks/mocks.go | 263 --- cmd/cmdfakes/fake_agent_client_factory.go | 119 ++ cmd/cmdfakes/fake_deployment_deleter.go | 112 ++ cmd/cmdfakes/fake_deployment_state_manager.go | 184 ++ cmd/create_env_test.go | 208 +-- cmd/delete_env_test.go | 30 +- cmd/deployment_deleter.go | 2 + cmd/deployment_deleter_test.go | 210 ++- cmd/deployment_state_manager.go | 2 + cmd/deployment_state_manager_test.go | 90 +- cmd/log_in.go | 1 + cmd/logs_test.go | 175 +- cmd/mocks/gomock_gomega_wrapper.go | 29 - cmd/mocks/mocks.go | 100 -- cmd/scp_test.go | 63 +- cmd/ssh_test.go | 88 +- cmd/start_env_test.go | 26 +- cmd/stop_env_test.go | 30 +- cmd/suite_test.go | 25 +- .../fake_legacy_deployment_state_migrator.go | 114 ++ config/legacy_deployment_state_migrator.go | 4 + config/mocks/mocks.go | 49 - cpi/release/installer_test.go | 71 +- cpi/release/mocks/mocks.go | 41 - deployment/deployer.go | 2 + deployment/deployer_test.go | 64 +- deployment/deployment.go | 4 + deployment/deployment_test.go | 308 ++-- deployment/deploymentfakes/fake_deployer.go | 139 ++ deployment/deploymentfakes/fake_deployment.go | 261 +++ deployment/deploymentfakes/fake_factory.go | 131 ++ deployment/deploymentfakes/fake_manager.go | 183 ++ .../deploymentfakes/fake_manager_factory.go | 116 ++ deployment/disk/disk.go | 4 + deployment/disk/diskfakes/fake_disk.go | 243 +++ deployment/disk/diskfakes/fake_manager.go | 326 ++++ deployment/disk/manager.go | 2 + deployment/disk/mocks/mocks.go | 163 -- deployment/factory.go | 2 + deployment/instance/instance.go | 4 + deployment/instance/instance_test.go | 50 +- .../instance/instancefakes/fake_instance.go | 694 ++++++++ .../instance/instancefakes/fake_manager.go | 285 ++++ deployment/instance/manager.go | 2 + deployment/instance/manager_test.go | 42 +- deployment/instance/mocks/mocks.go | 236 --- deployment/instance/state/builder.go | 2 + deployment/instance/state/builder_factory.go | 4 + deployment/instance/state/builder_test.go | 94 +- deployment/instance/state/mocks/mocks.go | 200 --- .../state/remote_package_compiler_test.go | 70 +- deployment/instance/state/state.go | 2 + .../instance/state/statefakes/fake_builder.go | 206 +++ .../state/statefakes/fake_builder_factory.go | 113 ++ .../instance/state/statefakes/fake_state.go | 353 ++++ deployment/manager.go | 2 + deployment/manager_factory.go | 2 + deployment/manager_test.go | 116 +- deployment/mocks/mocks.go | 251 --- deployment/release/job_resolver.go | 4 + deployment/release/job_resolver_test.go | 25 +- deployment/release/mocks/mocks.go | 50 - .../release/releasefakes/fake_job_resolver.go | 117 ++ deployment/vm/manager_factory.go | 2 + deployment/vm/mocks/mocks.go | 51 - deployment/vm/vmfakes/fake_manager_factory.go | 113 ++ go.mod | 1 - go.sum | 25 - installation/installation.go | 4 + .../installationfakes/fake_installation.go | 163 ++ .../installationfakes/fake_installer.go | 190 +++ .../fake_installer_factory.go | 109 ++ .../installationfakes/fake_job_renderer.go | 126 ++ .../installationfakes/fake_job_resolver.go | 116 ++ .../fake_package_compiler.go | 123 ++ .../installationfakes/fake_uninstaller.go | 109 ++ installation/installer.go | 2 + installation/installer_factory.go | 2 + installation/installer_test.go | 57 +- installation/job_renderer.go | 2 + installation/job_renderer_test.go | 38 +- installation/job_resolver.go | 2 + installation/job_resolver_test.go | 26 +- installation/mocks/mocks.go | 306 ---- installation/package_compiler.go | 2 + installation/package_compiler_test.go | 32 +- installation/pkg/compiler_test.go | 113 +- installation/tarball/mocks/mocks.go | 51 - installation/tarball/provider.go | 4 + .../tarball/tarballfakes/fake_provider.go | 117 ++ installation/uninstaller.go | 2 + integration/create_env_test.go | 693 ++++---- release/interfaces.go | 4 + release/mocks/mocks.go | 128 -- release/releasefakes/fake_extractor.go | 114 ++ release/releasefakes/fake_manager.go | 277 +++ state/job/dependency_compiler.go | 4 + state/job/dependency_compiler_test.go | 109 +- .../job/jobfakes/fake_dependency_compiler.go | 123 ++ state/job/mocks/mocks.go | 52 - state/pkg/compiled_package_repo.go | 2 + state/pkg/compiler_interface.go | 4 + state/pkg/mocks/mocks.go | 105 -- .../pkgfakes/fake_compiled_package_repo.go | 194 +++ state/pkg/pkgfakes/fake_compiler.go | 120 ++ stemcell/manager.go | 6 + stemcell/mockfakes/fake_manager.go | 325 ++++ stemcell/mocks/mocks.go | 188 --- .../stemcellfakes/fake_manager_factory.go | 25 +- templatescompiler/job_list_renderer.go | 2 + templatescompiler/job_list_renderer_test.go | 54 +- templatescompiler/job_renderer.go | 4 + templatescompiler/mocks/mocks.go | 371 ---- templatescompiler/rendered_job.go | 2 + templatescompiler/rendered_job_list.go | 2 + .../rendered_job_list_archive.go | 2 + .../rendered_job_list_archive_test.go | 17 +- .../rendered_job_list_compressor.go | 2 + .../fake_job_list_renderer.go | 131 ++ .../fake_job_renderer.go | 126 ++ .../fake_rendered_job.go | 255 +++ .../fake_rendered_job_list.go | 228 +++ .../fake_rendered_job_list_archive.go | 317 ++++ .../fake_rendered_job_list_compressor.go | 114 ++ test_support/mocks/mocks.go | 46 - testutils/mocks/mocks.go | 37 - tools/tools.go | 1 - .../v2/agentclient/http/mocks/mocks.go | 50 - vendor/github.com/golang/mock/AUTHORS | 12 - vendor/github.com/golang/mock/CONTRIBUTORS | 37 - vendor/github.com/golang/mock/LICENSE | 202 --- vendor/github.com/golang/mock/gomock/call.go | 445 ----- .../github.com/golang/mock/gomock/callset.go | 113 -- .../golang/mock/gomock/controller.go | 336 ---- .../github.com/golang/mock/gomock/matchers.go | 341 ---- .../golang/mock/mockgen/model/model.go | 495 ------ vendor/modules.txt | 5 - 149 files changed, 11614 insertions(+), 6790 deletions(-) create mode 100644 agentclient/agentclientfakes/fake_agent_client.go create mode 100644 agentclient/generate.go delete mode 100644 agentclient/mocks/mocks.go create mode 100644 blobstore/blobstorefakes/fake_blobstore.go create mode 100644 blobstore/blobstorefakes/fake_factory.go delete mode 100644 blobstore/mocks/mocks.go create mode 100644 cloud/cloudfakes/fake_cloud.go create mode 100644 cloud/cloudfakes/fake_factory.go delete mode 100644 cloud/mocks/mocks.go create mode 100644 cmd/cmdfakes/fake_agent_client_factory.go create mode 100644 cmd/cmdfakes/fake_deployment_deleter.go create mode 100644 cmd/cmdfakes/fake_deployment_state_manager.go delete mode 100644 cmd/mocks/gomock_gomega_wrapper.go delete mode 100644 cmd/mocks/mocks.go create mode 100644 config/configfakes/fake_legacy_deployment_state_migrator.go delete mode 100644 config/mocks/mocks.go delete mode 100644 cpi/release/mocks/mocks.go create mode 100644 deployment/deploymentfakes/fake_deployer.go create mode 100644 deployment/deploymentfakes/fake_deployment.go create mode 100644 deployment/deploymentfakes/fake_factory.go create mode 100644 deployment/deploymentfakes/fake_manager.go create mode 100644 deployment/deploymentfakes/fake_manager_factory.go create mode 100644 deployment/disk/diskfakes/fake_disk.go create mode 100644 deployment/disk/diskfakes/fake_manager.go delete mode 100644 deployment/disk/mocks/mocks.go create mode 100644 deployment/instance/instancefakes/fake_instance.go create mode 100644 deployment/instance/instancefakes/fake_manager.go delete mode 100644 deployment/instance/mocks/mocks.go delete mode 100644 deployment/instance/state/mocks/mocks.go create mode 100644 deployment/instance/state/statefakes/fake_builder.go create mode 100644 deployment/instance/state/statefakes/fake_builder_factory.go create mode 100644 deployment/instance/state/statefakes/fake_state.go delete mode 100644 deployment/mocks/mocks.go delete mode 100644 deployment/release/mocks/mocks.go create mode 100644 deployment/release/releasefakes/fake_job_resolver.go delete mode 100644 deployment/vm/mocks/mocks.go create mode 100644 deployment/vm/vmfakes/fake_manager_factory.go create mode 100644 installation/installationfakes/fake_installation.go create mode 100644 installation/installationfakes/fake_installer.go create mode 100644 installation/installationfakes/fake_installer_factory.go create mode 100644 installation/installationfakes/fake_job_renderer.go create mode 100644 installation/installationfakes/fake_job_resolver.go create mode 100644 installation/installationfakes/fake_package_compiler.go create mode 100644 installation/installationfakes/fake_uninstaller.go delete mode 100644 installation/mocks/mocks.go delete mode 100644 installation/tarball/mocks/mocks.go create mode 100644 installation/tarball/tarballfakes/fake_provider.go delete mode 100644 release/mocks/mocks.go create mode 100644 release/releasefakes/fake_extractor.go create mode 100644 release/releasefakes/fake_manager.go create mode 100644 state/job/jobfakes/fake_dependency_compiler.go delete mode 100644 state/job/mocks/mocks.go delete mode 100644 state/pkg/mocks/mocks.go create mode 100644 state/pkg/pkgfakes/fake_compiled_package_repo.go create mode 100644 state/pkg/pkgfakes/fake_compiler.go create mode 100644 stemcell/mockfakes/fake_manager.go delete mode 100644 stemcell/mocks/mocks.go delete mode 100644 templatescompiler/mocks/mocks.go create mode 100644 templatescompiler/templatescompilerfakes/fake_job_list_renderer.go create mode 100644 templatescompiler/templatescompilerfakes/fake_job_renderer.go create mode 100644 templatescompiler/templatescompilerfakes/fake_rendered_job.go create mode 100644 templatescompiler/templatescompilerfakes/fake_rendered_job_list.go create mode 100644 templatescompiler/templatescompilerfakes/fake_rendered_job_list_archive.go create mode 100644 templatescompiler/templatescompilerfakes/fake_rendered_job_list_compressor.go delete mode 100644 test_support/mocks/mocks.go delete mode 100644 testutils/mocks/mocks.go delete mode 100644 vendor/github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks/mocks.go delete mode 100644 vendor/github.com/golang/mock/AUTHORS delete mode 100644 vendor/github.com/golang/mock/CONTRIBUTORS delete mode 100644 vendor/github.com/golang/mock/LICENSE delete mode 100644 vendor/github.com/golang/mock/gomock/call.go delete mode 100644 vendor/github.com/golang/mock/gomock/callset.go delete mode 100644 vendor/github.com/golang/mock/gomock/controller.go delete mode 100644 vendor/github.com/golang/mock/gomock/matchers.go delete mode 100644 vendor/github.com/golang/mock/mockgen/model/model.go diff --git a/agentclient/agentclientfakes/fake_agent_client.go b/agentclient/agentclientfakes/fake_agent_client.go new file mode 100644 index 0000000000..ef803ae042 --- /dev/null +++ b/agentclient/agentclientfakes/fake_agent_client.go @@ -0,0 +1,1500 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package agentclientfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" +) + +type FakeAgentClient struct { + AddPersistentDiskStub func(string, interface{}) error + addPersistentDiskMutex sync.RWMutex + addPersistentDiskArgsForCall []struct { + arg1 string + arg2 interface{} + } + addPersistentDiskReturns struct { + result1 error + } + addPersistentDiskReturnsOnCall map[int]struct { + result1 error + } + ApplyStub func(applyspec.ApplySpec) error + applyMutex sync.RWMutex + applyArgsForCall []struct { + arg1 applyspec.ApplySpec + } + applyReturns struct { + result1 error + } + applyReturnsOnCall map[int]struct { + result1 error + } + BundleLogsStub func(string, string, []string) (agentclient.BundleLogsResult, error) + bundleLogsMutex sync.RWMutex + bundleLogsArgsForCall []struct { + arg1 string + arg2 string + arg3 []string + } + bundleLogsReturns struct { + result1 agentclient.BundleLogsResult + result2 error + } + bundleLogsReturnsOnCall map[int]struct { + result1 agentclient.BundleLogsResult + result2 error + } + CleanUpSSHStub func(string) (agentclient.SSHResult, error) + cleanUpSSHMutex sync.RWMutex + cleanUpSSHArgsForCall []struct { + arg1 string + } + cleanUpSSHReturns struct { + result1 agentclient.SSHResult + result2 error + } + cleanUpSSHReturnsOnCall map[int]struct { + result1 agentclient.SSHResult + result2 error + } + CompilePackageStub func(agentclient.BlobRef, []agentclient.BlobRef) (agentclient.BlobRef, error) + compilePackageMutex sync.RWMutex + compilePackageArgsForCall []struct { + arg1 agentclient.BlobRef + arg2 []agentclient.BlobRef + } + compilePackageReturns struct { + result1 agentclient.BlobRef + result2 error + } + compilePackageReturnsOnCall map[int]struct { + result1 agentclient.BlobRef + result2 error + } + DeleteARPEntriesStub func([]string) error + deleteARPEntriesMutex sync.RWMutex + deleteARPEntriesArgsForCall []struct { + arg1 []string + } + deleteARPEntriesReturns struct { + result1 error + } + deleteARPEntriesReturnsOnCall map[int]struct { + result1 error + } + DrainStub func(string) (int64, error) + drainMutex sync.RWMutex + drainArgsForCall []struct { + arg1 string + } + drainReturns struct { + result1 int64 + result2 error + } + drainReturnsOnCall map[int]struct { + result1 int64 + result2 error + } + GetStateStub func() (agentclient.AgentState, error) + getStateMutex sync.RWMutex + getStateArgsForCall []struct { + } + getStateReturns struct { + result1 agentclient.AgentState + result2 error + } + getStateReturnsOnCall map[int]struct { + result1 agentclient.AgentState + result2 error + } + ListDiskStub func() ([]string, error) + listDiskMutex sync.RWMutex + listDiskArgsForCall []struct { + } + listDiskReturns struct { + result1 []string + result2 error + } + listDiskReturnsOnCall map[int]struct { + result1 []string + result2 error + } + MigrateDiskStub func() error + migrateDiskMutex sync.RWMutex + migrateDiskArgsForCall []struct { + } + migrateDiskReturns struct { + result1 error + } + migrateDiskReturnsOnCall map[int]struct { + result1 error + } + MountDiskStub func(string) error + mountDiskMutex sync.RWMutex + mountDiskArgsForCall []struct { + arg1 string + } + mountDiskReturns struct { + result1 error + } + mountDiskReturnsOnCall map[int]struct { + result1 error + } + PingStub func() (string, error) + pingMutex sync.RWMutex + pingArgsForCall []struct { + } + pingReturns struct { + result1 string + result2 error + } + pingReturnsOnCall map[int]struct { + result1 string + result2 error + } + RemoveFileStub func(string) error + removeFileMutex sync.RWMutex + removeFileArgsForCall []struct { + arg1 string + } + removeFileReturns struct { + result1 error + } + removeFileReturnsOnCall map[int]struct { + result1 error + } + RemovePersistentDiskStub func(string) error + removePersistentDiskMutex sync.RWMutex + removePersistentDiskArgsForCall []struct { + arg1 string + } + removePersistentDiskReturns struct { + result1 error + } + removePersistentDiskReturnsOnCall map[int]struct { + result1 error + } + RunScriptStub func(string, map[string]interface{}) error + runScriptMutex sync.RWMutex + runScriptArgsForCall []struct { + arg1 string + arg2 map[string]interface{} + } + runScriptReturns struct { + result1 error + } + runScriptReturnsOnCall map[int]struct { + result1 error + } + SetUpSSHStub func(string, string) (agentclient.SSHResult, error) + setUpSSHMutex sync.RWMutex + setUpSSHArgsForCall []struct { + arg1 string + arg2 string + } + setUpSSHReturns struct { + result1 agentclient.SSHResult + result2 error + } + setUpSSHReturnsOnCall map[int]struct { + result1 agentclient.SSHResult + result2 error + } + StartStub func() error + startMutex sync.RWMutex + startArgsForCall []struct { + } + startReturns struct { + result1 error + } + startReturnsOnCall map[int]struct { + result1 error + } + StopStub func() error + stopMutex sync.RWMutex + stopArgsForCall []struct { + } + stopReturns struct { + result1 error + } + stopReturnsOnCall map[int]struct { + result1 error + } + SyncDNSStub func(string, string, uint64) (string, error) + syncDNSMutex sync.RWMutex + syncDNSArgsForCall []struct { + arg1 string + arg2 string + arg3 uint64 + } + syncDNSReturns struct { + result1 string + result2 error + } + syncDNSReturnsOnCall map[int]struct { + result1 string + result2 error + } + UnmountDiskStub func(string) error + unmountDiskMutex sync.RWMutex + unmountDiskArgsForCall []struct { + arg1 string + } + unmountDiskReturns struct { + result1 error + } + unmountDiskReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeAgentClient) AddPersistentDisk(arg1 string, arg2 interface{}) error { + fake.addPersistentDiskMutex.Lock() + ret, specificReturn := fake.addPersistentDiskReturnsOnCall[len(fake.addPersistentDiskArgsForCall)] + fake.addPersistentDiskArgsForCall = append(fake.addPersistentDiskArgsForCall, struct { + arg1 string + arg2 interface{} + }{arg1, arg2}) + stub := fake.AddPersistentDiskStub + fakeReturns := fake.addPersistentDiskReturns + fake.recordInvocation("AddPersistentDisk", []interface{}{arg1, arg2}) + fake.addPersistentDiskMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) AddPersistentDiskCallCount() int { + fake.addPersistentDiskMutex.RLock() + defer fake.addPersistentDiskMutex.RUnlock() + return len(fake.addPersistentDiskArgsForCall) +} + +func (fake *FakeAgentClient) AddPersistentDiskCalls(stub func(string, interface{}) error) { + fake.addPersistentDiskMutex.Lock() + defer fake.addPersistentDiskMutex.Unlock() + fake.AddPersistentDiskStub = stub +} + +func (fake *FakeAgentClient) AddPersistentDiskArgsForCall(i int) (string, interface{}) { + fake.addPersistentDiskMutex.RLock() + defer fake.addPersistentDiskMutex.RUnlock() + argsForCall := fake.addPersistentDiskArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeAgentClient) AddPersistentDiskReturns(result1 error) { + fake.addPersistentDiskMutex.Lock() + defer fake.addPersistentDiskMutex.Unlock() + fake.AddPersistentDiskStub = nil + fake.addPersistentDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) AddPersistentDiskReturnsOnCall(i int, result1 error) { + fake.addPersistentDiskMutex.Lock() + defer fake.addPersistentDiskMutex.Unlock() + fake.AddPersistentDiskStub = nil + if fake.addPersistentDiskReturnsOnCall == nil { + fake.addPersistentDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.addPersistentDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) Apply(arg1 applyspec.ApplySpec) error { + fake.applyMutex.Lock() + ret, specificReturn := fake.applyReturnsOnCall[len(fake.applyArgsForCall)] + fake.applyArgsForCall = append(fake.applyArgsForCall, struct { + arg1 applyspec.ApplySpec + }{arg1}) + stub := fake.ApplyStub + fakeReturns := fake.applyReturns + fake.recordInvocation("Apply", []interface{}{arg1}) + fake.applyMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) ApplyCallCount() int { + fake.applyMutex.RLock() + defer fake.applyMutex.RUnlock() + return len(fake.applyArgsForCall) +} + +func (fake *FakeAgentClient) ApplyCalls(stub func(applyspec.ApplySpec) error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = stub +} + +func (fake *FakeAgentClient) ApplyArgsForCall(i int) applyspec.ApplySpec { + fake.applyMutex.RLock() + defer fake.applyMutex.RUnlock() + argsForCall := fake.applyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) ApplyReturns(result1 error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = nil + fake.applyReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) ApplyReturnsOnCall(i int, result1 error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = nil + if fake.applyReturnsOnCall == nil { + fake.applyReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.applyReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) BundleLogs(arg1 string, arg2 string, arg3 []string) (agentclient.BundleLogsResult, error) { + var arg3Copy []string + if arg3 != nil { + arg3Copy = make([]string, len(arg3)) + copy(arg3Copy, arg3) + } + fake.bundleLogsMutex.Lock() + ret, specificReturn := fake.bundleLogsReturnsOnCall[len(fake.bundleLogsArgsForCall)] + fake.bundleLogsArgsForCall = append(fake.bundleLogsArgsForCall, struct { + arg1 string + arg2 string + arg3 []string + }{arg1, arg2, arg3Copy}) + stub := fake.BundleLogsStub + fakeReturns := fake.bundleLogsReturns + fake.recordInvocation("BundleLogs", []interface{}{arg1, arg2, arg3Copy}) + fake.bundleLogsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) BundleLogsCallCount() int { + fake.bundleLogsMutex.RLock() + defer fake.bundleLogsMutex.RUnlock() + return len(fake.bundleLogsArgsForCall) +} + +func (fake *FakeAgentClient) BundleLogsCalls(stub func(string, string, []string) (agentclient.BundleLogsResult, error)) { + fake.bundleLogsMutex.Lock() + defer fake.bundleLogsMutex.Unlock() + fake.BundleLogsStub = stub +} + +func (fake *FakeAgentClient) BundleLogsArgsForCall(i int) (string, string, []string) { + fake.bundleLogsMutex.RLock() + defer fake.bundleLogsMutex.RUnlock() + argsForCall := fake.bundleLogsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeAgentClient) BundleLogsReturns(result1 agentclient.BundleLogsResult, result2 error) { + fake.bundleLogsMutex.Lock() + defer fake.bundleLogsMutex.Unlock() + fake.BundleLogsStub = nil + fake.bundleLogsReturns = struct { + result1 agentclient.BundleLogsResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) BundleLogsReturnsOnCall(i int, result1 agentclient.BundleLogsResult, result2 error) { + fake.bundleLogsMutex.Lock() + defer fake.bundleLogsMutex.Unlock() + fake.BundleLogsStub = nil + if fake.bundleLogsReturnsOnCall == nil { + fake.bundleLogsReturnsOnCall = make(map[int]struct { + result1 agentclient.BundleLogsResult + result2 error + }) + } + fake.bundleLogsReturnsOnCall[i] = struct { + result1 agentclient.BundleLogsResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) CleanUpSSH(arg1 string) (agentclient.SSHResult, error) { + fake.cleanUpSSHMutex.Lock() + ret, specificReturn := fake.cleanUpSSHReturnsOnCall[len(fake.cleanUpSSHArgsForCall)] + fake.cleanUpSSHArgsForCall = append(fake.cleanUpSSHArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.CleanUpSSHStub + fakeReturns := fake.cleanUpSSHReturns + fake.recordInvocation("CleanUpSSH", []interface{}{arg1}) + fake.cleanUpSSHMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) CleanUpSSHCallCount() int { + fake.cleanUpSSHMutex.RLock() + defer fake.cleanUpSSHMutex.RUnlock() + return len(fake.cleanUpSSHArgsForCall) +} + +func (fake *FakeAgentClient) CleanUpSSHCalls(stub func(string) (agentclient.SSHResult, error)) { + fake.cleanUpSSHMutex.Lock() + defer fake.cleanUpSSHMutex.Unlock() + fake.CleanUpSSHStub = stub +} + +func (fake *FakeAgentClient) CleanUpSSHArgsForCall(i int) string { + fake.cleanUpSSHMutex.RLock() + defer fake.cleanUpSSHMutex.RUnlock() + argsForCall := fake.cleanUpSSHArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) CleanUpSSHReturns(result1 agentclient.SSHResult, result2 error) { + fake.cleanUpSSHMutex.Lock() + defer fake.cleanUpSSHMutex.Unlock() + fake.CleanUpSSHStub = nil + fake.cleanUpSSHReturns = struct { + result1 agentclient.SSHResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) CleanUpSSHReturnsOnCall(i int, result1 agentclient.SSHResult, result2 error) { + fake.cleanUpSSHMutex.Lock() + defer fake.cleanUpSSHMutex.Unlock() + fake.CleanUpSSHStub = nil + if fake.cleanUpSSHReturnsOnCall == nil { + fake.cleanUpSSHReturnsOnCall = make(map[int]struct { + result1 agentclient.SSHResult + result2 error + }) + } + fake.cleanUpSSHReturnsOnCall[i] = struct { + result1 agentclient.SSHResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) CompilePackage(arg1 agentclient.BlobRef, arg2 []agentclient.BlobRef) (agentclient.BlobRef, error) { + var arg2Copy []agentclient.BlobRef + if arg2 != nil { + arg2Copy = make([]agentclient.BlobRef, len(arg2)) + copy(arg2Copy, arg2) + } + fake.compilePackageMutex.Lock() + ret, specificReturn := fake.compilePackageReturnsOnCall[len(fake.compilePackageArgsForCall)] + fake.compilePackageArgsForCall = append(fake.compilePackageArgsForCall, struct { + arg1 agentclient.BlobRef + arg2 []agentclient.BlobRef + }{arg1, arg2Copy}) + stub := fake.CompilePackageStub + fakeReturns := fake.compilePackageReturns + fake.recordInvocation("CompilePackage", []interface{}{arg1, arg2Copy}) + fake.compilePackageMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) CompilePackageCallCount() int { + fake.compilePackageMutex.RLock() + defer fake.compilePackageMutex.RUnlock() + return len(fake.compilePackageArgsForCall) +} + +func (fake *FakeAgentClient) CompilePackageCalls(stub func(agentclient.BlobRef, []agentclient.BlobRef) (agentclient.BlobRef, error)) { + fake.compilePackageMutex.Lock() + defer fake.compilePackageMutex.Unlock() + fake.CompilePackageStub = stub +} + +func (fake *FakeAgentClient) CompilePackageArgsForCall(i int) (agentclient.BlobRef, []agentclient.BlobRef) { + fake.compilePackageMutex.RLock() + defer fake.compilePackageMutex.RUnlock() + argsForCall := fake.compilePackageArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeAgentClient) CompilePackageReturns(result1 agentclient.BlobRef, result2 error) { + fake.compilePackageMutex.Lock() + defer fake.compilePackageMutex.Unlock() + fake.CompilePackageStub = nil + fake.compilePackageReturns = struct { + result1 agentclient.BlobRef + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) CompilePackageReturnsOnCall(i int, result1 agentclient.BlobRef, result2 error) { + fake.compilePackageMutex.Lock() + defer fake.compilePackageMutex.Unlock() + fake.CompilePackageStub = nil + if fake.compilePackageReturnsOnCall == nil { + fake.compilePackageReturnsOnCall = make(map[int]struct { + result1 agentclient.BlobRef + result2 error + }) + } + fake.compilePackageReturnsOnCall[i] = struct { + result1 agentclient.BlobRef + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) DeleteARPEntries(arg1 []string) error { + var arg1Copy []string + if arg1 != nil { + arg1Copy = make([]string, len(arg1)) + copy(arg1Copy, arg1) + } + fake.deleteARPEntriesMutex.Lock() + ret, specificReturn := fake.deleteARPEntriesReturnsOnCall[len(fake.deleteARPEntriesArgsForCall)] + fake.deleteARPEntriesArgsForCall = append(fake.deleteARPEntriesArgsForCall, struct { + arg1 []string + }{arg1Copy}) + stub := fake.DeleteARPEntriesStub + fakeReturns := fake.deleteARPEntriesReturns + fake.recordInvocation("DeleteARPEntries", []interface{}{arg1Copy}) + fake.deleteARPEntriesMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) DeleteARPEntriesCallCount() int { + fake.deleteARPEntriesMutex.RLock() + defer fake.deleteARPEntriesMutex.RUnlock() + return len(fake.deleteARPEntriesArgsForCall) +} + +func (fake *FakeAgentClient) DeleteARPEntriesCalls(stub func([]string) error) { + fake.deleteARPEntriesMutex.Lock() + defer fake.deleteARPEntriesMutex.Unlock() + fake.DeleteARPEntriesStub = stub +} + +func (fake *FakeAgentClient) DeleteARPEntriesArgsForCall(i int) []string { + fake.deleteARPEntriesMutex.RLock() + defer fake.deleteARPEntriesMutex.RUnlock() + argsForCall := fake.deleteARPEntriesArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) DeleteARPEntriesReturns(result1 error) { + fake.deleteARPEntriesMutex.Lock() + defer fake.deleteARPEntriesMutex.Unlock() + fake.DeleteARPEntriesStub = nil + fake.deleteARPEntriesReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) DeleteARPEntriesReturnsOnCall(i int, result1 error) { + fake.deleteARPEntriesMutex.Lock() + defer fake.deleteARPEntriesMutex.Unlock() + fake.DeleteARPEntriesStub = nil + if fake.deleteARPEntriesReturnsOnCall == nil { + fake.deleteARPEntriesReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteARPEntriesReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) Drain(arg1 string) (int64, error) { + fake.drainMutex.Lock() + ret, specificReturn := fake.drainReturnsOnCall[len(fake.drainArgsForCall)] + fake.drainArgsForCall = append(fake.drainArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DrainStub + fakeReturns := fake.drainReturns + fake.recordInvocation("Drain", []interface{}{arg1}) + fake.drainMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) DrainCallCount() int { + fake.drainMutex.RLock() + defer fake.drainMutex.RUnlock() + return len(fake.drainArgsForCall) +} + +func (fake *FakeAgentClient) DrainCalls(stub func(string) (int64, error)) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = stub +} + +func (fake *FakeAgentClient) DrainArgsForCall(i int) string { + fake.drainMutex.RLock() + defer fake.drainMutex.RUnlock() + argsForCall := fake.drainArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) DrainReturns(result1 int64, result2 error) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = nil + fake.drainReturns = struct { + result1 int64 + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) DrainReturnsOnCall(i int, result1 int64, result2 error) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = nil + if fake.drainReturnsOnCall == nil { + fake.drainReturnsOnCall = make(map[int]struct { + result1 int64 + result2 error + }) + } + fake.drainReturnsOnCall[i] = struct { + result1 int64 + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) GetState() (agentclient.AgentState, error) { + fake.getStateMutex.Lock() + ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] + fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { + }{}) + stub := fake.GetStateStub + fakeReturns := fake.getStateReturns + fake.recordInvocation("GetState", []interface{}{}) + fake.getStateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) GetStateCallCount() int { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + return len(fake.getStateArgsForCall) +} + +func (fake *FakeAgentClient) GetStateCalls(stub func() (agentclient.AgentState, error)) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = stub +} + +func (fake *FakeAgentClient) GetStateReturns(result1 agentclient.AgentState, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + fake.getStateReturns = struct { + result1 agentclient.AgentState + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) GetStateReturnsOnCall(i int, result1 agentclient.AgentState, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + if fake.getStateReturnsOnCall == nil { + fake.getStateReturnsOnCall = make(map[int]struct { + result1 agentclient.AgentState + result2 error + }) + } + fake.getStateReturnsOnCall[i] = struct { + result1 agentclient.AgentState + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) ListDisk() ([]string, error) { + fake.listDiskMutex.Lock() + ret, specificReturn := fake.listDiskReturnsOnCall[len(fake.listDiskArgsForCall)] + fake.listDiskArgsForCall = append(fake.listDiskArgsForCall, struct { + }{}) + stub := fake.ListDiskStub + fakeReturns := fake.listDiskReturns + fake.recordInvocation("ListDisk", []interface{}{}) + fake.listDiskMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) ListDiskCallCount() int { + fake.listDiskMutex.RLock() + defer fake.listDiskMutex.RUnlock() + return len(fake.listDiskArgsForCall) +} + +func (fake *FakeAgentClient) ListDiskCalls(stub func() ([]string, error)) { + fake.listDiskMutex.Lock() + defer fake.listDiskMutex.Unlock() + fake.ListDiskStub = stub +} + +func (fake *FakeAgentClient) ListDiskReturns(result1 []string, result2 error) { + fake.listDiskMutex.Lock() + defer fake.listDiskMutex.Unlock() + fake.ListDiskStub = nil + fake.listDiskReturns = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) ListDiskReturnsOnCall(i int, result1 []string, result2 error) { + fake.listDiskMutex.Lock() + defer fake.listDiskMutex.Unlock() + fake.ListDiskStub = nil + if fake.listDiskReturnsOnCall == nil { + fake.listDiskReturnsOnCall = make(map[int]struct { + result1 []string + result2 error + }) + } + fake.listDiskReturnsOnCall[i] = struct { + result1 []string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) MigrateDisk() error { + fake.migrateDiskMutex.Lock() + ret, specificReturn := fake.migrateDiskReturnsOnCall[len(fake.migrateDiskArgsForCall)] + fake.migrateDiskArgsForCall = append(fake.migrateDiskArgsForCall, struct { + }{}) + stub := fake.MigrateDiskStub + fakeReturns := fake.migrateDiskReturns + fake.recordInvocation("MigrateDisk", []interface{}{}) + fake.migrateDiskMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) MigrateDiskCallCount() int { + fake.migrateDiskMutex.RLock() + defer fake.migrateDiskMutex.RUnlock() + return len(fake.migrateDiskArgsForCall) +} + +func (fake *FakeAgentClient) MigrateDiskCalls(stub func() error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = stub +} + +func (fake *FakeAgentClient) MigrateDiskReturns(result1 error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = nil + fake.migrateDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) MigrateDiskReturnsOnCall(i int, result1 error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = nil + if fake.migrateDiskReturnsOnCall == nil { + fake.migrateDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.migrateDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) MountDisk(arg1 string) error { + fake.mountDiskMutex.Lock() + ret, specificReturn := fake.mountDiskReturnsOnCall[len(fake.mountDiskArgsForCall)] + fake.mountDiskArgsForCall = append(fake.mountDiskArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.MountDiskStub + fakeReturns := fake.mountDiskReturns + fake.recordInvocation("MountDisk", []interface{}{arg1}) + fake.mountDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) MountDiskCallCount() int { + fake.mountDiskMutex.RLock() + defer fake.mountDiskMutex.RUnlock() + return len(fake.mountDiskArgsForCall) +} + +func (fake *FakeAgentClient) MountDiskCalls(stub func(string) error) { + fake.mountDiskMutex.Lock() + defer fake.mountDiskMutex.Unlock() + fake.MountDiskStub = stub +} + +func (fake *FakeAgentClient) MountDiskArgsForCall(i int) string { + fake.mountDiskMutex.RLock() + defer fake.mountDiskMutex.RUnlock() + argsForCall := fake.mountDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) MountDiskReturns(result1 error) { + fake.mountDiskMutex.Lock() + defer fake.mountDiskMutex.Unlock() + fake.MountDiskStub = nil + fake.mountDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) MountDiskReturnsOnCall(i int, result1 error) { + fake.mountDiskMutex.Lock() + defer fake.mountDiskMutex.Unlock() + fake.MountDiskStub = nil + if fake.mountDiskReturnsOnCall == nil { + fake.mountDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.mountDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) Ping() (string, error) { + fake.pingMutex.Lock() + ret, specificReturn := fake.pingReturnsOnCall[len(fake.pingArgsForCall)] + fake.pingArgsForCall = append(fake.pingArgsForCall, struct { + }{}) + stub := fake.PingStub + fakeReturns := fake.pingReturns + fake.recordInvocation("Ping", []interface{}{}) + fake.pingMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) PingCallCount() int { + fake.pingMutex.RLock() + defer fake.pingMutex.RUnlock() + return len(fake.pingArgsForCall) +} + +func (fake *FakeAgentClient) PingCalls(stub func() (string, error)) { + fake.pingMutex.Lock() + defer fake.pingMutex.Unlock() + fake.PingStub = stub +} + +func (fake *FakeAgentClient) PingReturns(result1 string, result2 error) { + fake.pingMutex.Lock() + defer fake.pingMutex.Unlock() + fake.PingStub = nil + fake.pingReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) PingReturnsOnCall(i int, result1 string, result2 error) { + fake.pingMutex.Lock() + defer fake.pingMutex.Unlock() + fake.PingStub = nil + if fake.pingReturnsOnCall == nil { + fake.pingReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.pingReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) RemoveFile(arg1 string) error { + fake.removeFileMutex.Lock() + ret, specificReturn := fake.removeFileReturnsOnCall[len(fake.removeFileArgsForCall)] + fake.removeFileArgsForCall = append(fake.removeFileArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.RemoveFileStub + fakeReturns := fake.removeFileReturns + fake.recordInvocation("RemoveFile", []interface{}{arg1}) + fake.removeFileMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) RemoveFileCallCount() int { + fake.removeFileMutex.RLock() + defer fake.removeFileMutex.RUnlock() + return len(fake.removeFileArgsForCall) +} + +func (fake *FakeAgentClient) RemoveFileCalls(stub func(string) error) { + fake.removeFileMutex.Lock() + defer fake.removeFileMutex.Unlock() + fake.RemoveFileStub = stub +} + +func (fake *FakeAgentClient) RemoveFileArgsForCall(i int) string { + fake.removeFileMutex.RLock() + defer fake.removeFileMutex.RUnlock() + argsForCall := fake.removeFileArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) RemoveFileReturns(result1 error) { + fake.removeFileMutex.Lock() + defer fake.removeFileMutex.Unlock() + fake.RemoveFileStub = nil + fake.removeFileReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) RemoveFileReturnsOnCall(i int, result1 error) { + fake.removeFileMutex.Lock() + defer fake.removeFileMutex.Unlock() + fake.RemoveFileStub = nil + if fake.removeFileReturnsOnCall == nil { + fake.removeFileReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.removeFileReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) RemovePersistentDisk(arg1 string) error { + fake.removePersistentDiskMutex.Lock() + ret, specificReturn := fake.removePersistentDiskReturnsOnCall[len(fake.removePersistentDiskArgsForCall)] + fake.removePersistentDiskArgsForCall = append(fake.removePersistentDiskArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.RemovePersistentDiskStub + fakeReturns := fake.removePersistentDiskReturns + fake.recordInvocation("RemovePersistentDisk", []interface{}{arg1}) + fake.removePersistentDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) RemovePersistentDiskCallCount() int { + fake.removePersistentDiskMutex.RLock() + defer fake.removePersistentDiskMutex.RUnlock() + return len(fake.removePersistentDiskArgsForCall) +} + +func (fake *FakeAgentClient) RemovePersistentDiskCalls(stub func(string) error) { + fake.removePersistentDiskMutex.Lock() + defer fake.removePersistentDiskMutex.Unlock() + fake.RemovePersistentDiskStub = stub +} + +func (fake *FakeAgentClient) RemovePersistentDiskArgsForCall(i int) string { + fake.removePersistentDiskMutex.RLock() + defer fake.removePersistentDiskMutex.RUnlock() + argsForCall := fake.removePersistentDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) RemovePersistentDiskReturns(result1 error) { + fake.removePersistentDiskMutex.Lock() + defer fake.removePersistentDiskMutex.Unlock() + fake.RemovePersistentDiskStub = nil + fake.removePersistentDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) RemovePersistentDiskReturnsOnCall(i int, result1 error) { + fake.removePersistentDiskMutex.Lock() + defer fake.removePersistentDiskMutex.Unlock() + fake.RemovePersistentDiskStub = nil + if fake.removePersistentDiskReturnsOnCall == nil { + fake.removePersistentDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.removePersistentDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) RunScript(arg1 string, arg2 map[string]interface{}) error { + fake.runScriptMutex.Lock() + ret, specificReturn := fake.runScriptReturnsOnCall[len(fake.runScriptArgsForCall)] + fake.runScriptArgsForCall = append(fake.runScriptArgsForCall, struct { + arg1 string + arg2 map[string]interface{} + }{arg1, arg2}) + stub := fake.RunScriptStub + fakeReturns := fake.runScriptReturns + fake.recordInvocation("RunScript", []interface{}{arg1, arg2}) + fake.runScriptMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) RunScriptCallCount() int { + fake.runScriptMutex.RLock() + defer fake.runScriptMutex.RUnlock() + return len(fake.runScriptArgsForCall) +} + +func (fake *FakeAgentClient) RunScriptCalls(stub func(string, map[string]interface{}) error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = stub +} + +func (fake *FakeAgentClient) RunScriptArgsForCall(i int) (string, map[string]interface{}) { + fake.runScriptMutex.RLock() + defer fake.runScriptMutex.RUnlock() + argsForCall := fake.runScriptArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeAgentClient) RunScriptReturns(result1 error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = nil + fake.runScriptReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) RunScriptReturnsOnCall(i int, result1 error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = nil + if fake.runScriptReturnsOnCall == nil { + fake.runScriptReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.runScriptReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) SetUpSSH(arg1 string, arg2 string) (agentclient.SSHResult, error) { + fake.setUpSSHMutex.Lock() + ret, specificReturn := fake.setUpSSHReturnsOnCall[len(fake.setUpSSHArgsForCall)] + fake.setUpSSHArgsForCall = append(fake.setUpSSHArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.SetUpSSHStub + fakeReturns := fake.setUpSSHReturns + fake.recordInvocation("SetUpSSH", []interface{}{arg1, arg2}) + fake.setUpSSHMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) SetUpSSHCallCount() int { + fake.setUpSSHMutex.RLock() + defer fake.setUpSSHMutex.RUnlock() + return len(fake.setUpSSHArgsForCall) +} + +func (fake *FakeAgentClient) SetUpSSHCalls(stub func(string, string) (agentclient.SSHResult, error)) { + fake.setUpSSHMutex.Lock() + defer fake.setUpSSHMutex.Unlock() + fake.SetUpSSHStub = stub +} + +func (fake *FakeAgentClient) SetUpSSHArgsForCall(i int) (string, string) { + fake.setUpSSHMutex.RLock() + defer fake.setUpSSHMutex.RUnlock() + argsForCall := fake.setUpSSHArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeAgentClient) SetUpSSHReturns(result1 agentclient.SSHResult, result2 error) { + fake.setUpSSHMutex.Lock() + defer fake.setUpSSHMutex.Unlock() + fake.SetUpSSHStub = nil + fake.setUpSSHReturns = struct { + result1 agentclient.SSHResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) SetUpSSHReturnsOnCall(i int, result1 agentclient.SSHResult, result2 error) { + fake.setUpSSHMutex.Lock() + defer fake.setUpSSHMutex.Unlock() + fake.SetUpSSHStub = nil + if fake.setUpSSHReturnsOnCall == nil { + fake.setUpSSHReturnsOnCall = make(map[int]struct { + result1 agentclient.SSHResult + result2 error + }) + } + fake.setUpSSHReturnsOnCall[i] = struct { + result1 agentclient.SSHResult + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) Start() error { + fake.startMutex.Lock() + ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)] + fake.startArgsForCall = append(fake.startArgsForCall, struct { + }{}) + stub := fake.StartStub + fakeReturns := fake.startReturns + fake.recordInvocation("Start", []interface{}{}) + fake.startMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeAgentClient) StartCalls(stub func() error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + +func (fake *FakeAgentClient) StartReturns(result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + fake.startReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) StartReturnsOnCall(i int, result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + if fake.startReturnsOnCall == nil { + fake.startReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.startReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) Stop() error { + fake.stopMutex.Lock() + ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] + fake.stopArgsForCall = append(fake.stopArgsForCall, struct { + }{}) + stub := fake.StopStub + fakeReturns := fake.stopReturns + fake.recordInvocation("Stop", []interface{}{}) + fake.stopMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) StopCallCount() int { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + return len(fake.stopArgsForCall) +} + +func (fake *FakeAgentClient) StopCalls(stub func() error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = stub +} + +func (fake *FakeAgentClient) StopReturns(result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + fake.stopReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) StopReturnsOnCall(i int, result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + if fake.stopReturnsOnCall == nil { + fake.stopReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.stopReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) SyncDNS(arg1 string, arg2 string, arg3 uint64) (string, error) { + fake.syncDNSMutex.Lock() + ret, specificReturn := fake.syncDNSReturnsOnCall[len(fake.syncDNSArgsForCall)] + fake.syncDNSArgsForCall = append(fake.syncDNSArgsForCall, struct { + arg1 string + arg2 string + arg3 uint64 + }{arg1, arg2, arg3}) + stub := fake.SyncDNSStub + fakeReturns := fake.syncDNSReturns + fake.recordInvocation("SyncDNS", []interface{}{arg1, arg2, arg3}) + fake.syncDNSMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClient) SyncDNSCallCount() int { + fake.syncDNSMutex.RLock() + defer fake.syncDNSMutex.RUnlock() + return len(fake.syncDNSArgsForCall) +} + +func (fake *FakeAgentClient) SyncDNSCalls(stub func(string, string, uint64) (string, error)) { + fake.syncDNSMutex.Lock() + defer fake.syncDNSMutex.Unlock() + fake.SyncDNSStub = stub +} + +func (fake *FakeAgentClient) SyncDNSArgsForCall(i int) (string, string, uint64) { + fake.syncDNSMutex.RLock() + defer fake.syncDNSMutex.RUnlock() + argsForCall := fake.syncDNSArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeAgentClient) SyncDNSReturns(result1 string, result2 error) { + fake.syncDNSMutex.Lock() + defer fake.syncDNSMutex.Unlock() + fake.SyncDNSStub = nil + fake.syncDNSReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) SyncDNSReturnsOnCall(i int, result1 string, result2 error) { + fake.syncDNSMutex.Lock() + defer fake.syncDNSMutex.Unlock() + fake.SyncDNSStub = nil + if fake.syncDNSReturnsOnCall == nil { + fake.syncDNSReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.syncDNSReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClient) UnmountDisk(arg1 string) error { + fake.unmountDiskMutex.Lock() + ret, specificReturn := fake.unmountDiskReturnsOnCall[len(fake.unmountDiskArgsForCall)] + fake.unmountDiskArgsForCall = append(fake.unmountDiskArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.UnmountDiskStub + fakeReturns := fake.unmountDiskReturns + fake.recordInvocation("UnmountDisk", []interface{}{arg1}) + fake.unmountDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeAgentClient) UnmountDiskCallCount() int { + fake.unmountDiskMutex.RLock() + defer fake.unmountDiskMutex.RUnlock() + return len(fake.unmountDiskArgsForCall) +} + +func (fake *FakeAgentClient) UnmountDiskCalls(stub func(string) error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = stub +} + +func (fake *FakeAgentClient) UnmountDiskArgsForCall(i int) string { + fake.unmountDiskMutex.RLock() + defer fake.unmountDiskMutex.RUnlock() + argsForCall := fake.unmountDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeAgentClient) UnmountDiskReturns(result1 error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = nil + fake.unmountDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) UnmountDiskReturnsOnCall(i int, result1 error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = nil + if fake.unmountDiskReturnsOnCall == nil { + fake.unmountDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.unmountDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeAgentClient) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeAgentClient) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ agentclient.AgentClient = new(FakeAgentClient) diff --git a/agentclient/generate.go b/agentclient/generate.go new file mode 100644 index 0000000000..b231e9eb32 --- /dev/null +++ b/agentclient/generate.go @@ -0,0 +1,5 @@ +package agentclient + +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate github.com/cloudfoundry/bosh-agent/v2/agentclient.AgentClient diff --git a/agentclient/mocks/mocks.go b/agentclient/mocks/mocks.go deleted file mode 100644 index 6763f8818d..0000000000 --- a/agentclient/mocks/mocks.go +++ /dev/null @@ -1,325 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-agent/agentclient (interfaces: AgentClient) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - agentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - applyspec "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - gomock "github.com/golang/mock/gomock" -) - -// MockAgentClient is a mock of AgentClient interface. -type MockAgentClient struct { - ctrl *gomock.Controller - recorder *MockAgentClientMockRecorder -} - -// MockAgentClientMockRecorder is the mock recorder for MockAgentClient. -type MockAgentClientMockRecorder struct { - mock *MockAgentClient -} - -// NewMockAgentClient creates a new mock instance. -func NewMockAgentClient(ctrl *gomock.Controller) *MockAgentClient { - mock := &MockAgentClient{ctrl: ctrl} - mock.recorder = &MockAgentClientMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockAgentClient) EXPECT() *MockAgentClientMockRecorder { - return m.recorder -} - -// AddPersistentDisk mocks base method. -func (m *MockAgentClient) AddPersistentDisk(arg0 string, arg1 interface{}) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddPersistentDisk", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// AddPersistentDisk indicates an expected call of AddPersistentDisk. -func (mr *MockAgentClientMockRecorder) AddPersistentDisk(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPersistentDisk", reflect.TypeOf((*MockAgentClient)(nil).AddPersistentDisk), arg0, arg1) -} - -// Apply mocks base method. -func (m *MockAgentClient) Apply(arg0 applyspec.ApplySpec) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Apply", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// Apply indicates an expected call of Apply. -func (mr *MockAgentClientMockRecorder) Apply(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Apply", reflect.TypeOf((*MockAgentClient)(nil).Apply), arg0) -} - -// BundleLogs mocks base method. -func (m *MockAgentClient) BundleLogs(arg0, arg1 string, arg2 []string) (agentclient.BundleLogsResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BundleLogs", arg0, arg1, arg2) - ret0, _ := ret[0].(agentclient.BundleLogsResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BundleLogs indicates an expected call of BundleLogs. -func (mr *MockAgentClientMockRecorder) BundleLogs(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleLogs", reflect.TypeOf((*MockAgentClient)(nil).BundleLogs), arg0, arg1, arg2) -} - -// CleanUpSSH mocks base method. -func (m *MockAgentClient) CleanUpSSH(arg0 string) (agentclient.SSHResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CleanUpSSH", arg0) - ret0, _ := ret[0].(agentclient.SSHResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CleanUpSSH indicates an expected call of CleanUpSSH. -func (mr *MockAgentClientMockRecorder) CleanUpSSH(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CleanUpSSH", reflect.TypeOf((*MockAgentClient)(nil).CleanUpSSH), arg0) -} - -// CompilePackage mocks base method. -func (m *MockAgentClient) CompilePackage(arg0 agentclient.BlobRef, arg1 []agentclient.BlobRef) (agentclient.BlobRef, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CompilePackage", arg0, arg1) - ret0, _ := ret[0].(agentclient.BlobRef) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CompilePackage indicates an expected call of CompilePackage. -func (mr *MockAgentClientMockRecorder) CompilePackage(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompilePackage", reflect.TypeOf((*MockAgentClient)(nil).CompilePackage), arg0, arg1) -} - -// DeleteARPEntries mocks base method. -func (m *MockAgentClient) DeleteARPEntries(arg0 []string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteARPEntries", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteARPEntries indicates an expected call of DeleteARPEntries. -func (mr *MockAgentClientMockRecorder) DeleteARPEntries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteARPEntries", reflect.TypeOf((*MockAgentClient)(nil).DeleteARPEntries), arg0) -} - -// Drain mocks base method. -func (m *MockAgentClient) Drain(arg0 string) (int64, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Drain", arg0) - ret0, _ := ret[0].(int64) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Drain indicates an expected call of Drain. -func (mr *MockAgentClientMockRecorder) Drain(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Drain", reflect.TypeOf((*MockAgentClient)(nil).Drain), arg0) -} - -// GetState mocks base method. -func (m *MockAgentClient) GetState() (agentclient.AgentState, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetState") - ret0, _ := ret[0].(agentclient.AgentState) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetState indicates an expected call of GetState. -func (mr *MockAgentClientMockRecorder) GetState() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetState", reflect.TypeOf((*MockAgentClient)(nil).GetState)) -} - -// ListDisk mocks base method. -func (m *MockAgentClient) ListDisk() ([]string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListDisk") - ret0, _ := ret[0].([]string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListDisk indicates an expected call of ListDisk. -func (mr *MockAgentClientMockRecorder) ListDisk() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDisk", reflect.TypeOf((*MockAgentClient)(nil).ListDisk)) -} - -// MigrateDisk mocks base method. -func (m *MockAgentClient) MigrateDisk() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MigrateDisk") - ret0, _ := ret[0].(error) - return ret0 -} - -// MigrateDisk indicates an expected call of MigrateDisk. -func (mr *MockAgentClientMockRecorder) MigrateDisk() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateDisk", reflect.TypeOf((*MockAgentClient)(nil).MigrateDisk)) -} - -// MountDisk mocks base method. -func (m *MockAgentClient) MountDisk(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MountDisk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// MountDisk indicates an expected call of MountDisk. -func (mr *MockAgentClientMockRecorder) MountDisk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MountDisk", reflect.TypeOf((*MockAgentClient)(nil).MountDisk), arg0) -} - -// Ping mocks base method. -func (m *MockAgentClient) Ping() (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Ping") - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Ping indicates an expected call of Ping. -func (mr *MockAgentClientMockRecorder) Ping() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockAgentClient)(nil).Ping)) -} - -// RemoveFile mocks base method. -func (m *MockAgentClient) RemoveFile(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveFile", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// RemoveFile indicates an expected call of RemoveFile. -func (mr *MockAgentClientMockRecorder) RemoveFile(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveFile", reflect.TypeOf((*MockAgentClient)(nil).RemoveFile), arg0) -} - -// RemovePersistentDisk mocks base method. -func (m *MockAgentClient) RemovePersistentDisk(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemovePersistentDisk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// RemovePersistentDisk indicates an expected call of RemovePersistentDisk. -func (mr *MockAgentClientMockRecorder) RemovePersistentDisk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePersistentDisk", reflect.TypeOf((*MockAgentClient)(nil).RemovePersistentDisk), arg0) -} - -// RunScript mocks base method. -func (m *MockAgentClient) RunScript(arg0 string, arg1 map[string]interface{}) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunScript", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// RunScript indicates an expected call of RunScript. -func (mr *MockAgentClientMockRecorder) RunScript(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScript", reflect.TypeOf((*MockAgentClient)(nil).RunScript), arg0, arg1) -} - -// SetUpSSH mocks base method. -func (m *MockAgentClient) SetUpSSH(arg0, arg1 string) (agentclient.SSHResult, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetUpSSH", arg0, arg1) - ret0, _ := ret[0].(agentclient.SSHResult) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetUpSSH indicates an expected call of SetUpSSH. -func (mr *MockAgentClientMockRecorder) SetUpSSH(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpSSH", reflect.TypeOf((*MockAgentClient)(nil).SetUpSSH), arg0, arg1) -} - -// Start mocks base method. -func (m *MockAgentClient) Start() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Start") - ret0, _ := ret[0].(error) - return ret0 -} - -// Start indicates an expected call of Start. -func (mr *MockAgentClientMockRecorder) Start() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockAgentClient)(nil).Start)) -} - -// Stop mocks base method. -func (m *MockAgentClient) Stop() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stop") - ret0, _ := ret[0].(error) - return ret0 -} - -// Stop indicates an expected call of Stop. -func (mr *MockAgentClientMockRecorder) Stop() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockAgentClient)(nil).Stop)) -} - -// SyncDNS mocks base method. -func (m *MockAgentClient) SyncDNS(arg0, arg1 string, arg2 uint64) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SyncDNS", arg0, arg1, arg2) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SyncDNS indicates an expected call of SyncDNS. -func (mr *MockAgentClientMockRecorder) SyncDNS(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncDNS", reflect.TypeOf((*MockAgentClient)(nil).SyncDNS), arg0, arg1, arg2) -} - -// UnmountDisk mocks base method. -func (m *MockAgentClient) UnmountDisk(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnmountDisk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// UnmountDisk indicates an expected call of UnmountDisk. -func (mr *MockAgentClientMockRecorder) UnmountDisk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmountDisk", reflect.TypeOf((*MockAgentClient)(nil).UnmountDisk), arg0) -} diff --git a/blobstore/blobstore.go b/blobstore/blobstore.go index a8f9e4d71b..623f4a91f9 100644 --- a/blobstore/blobstore.go +++ b/blobstore/blobstore.go @@ -10,6 +10,10 @@ import ( boshuuid "github.com/cloudfoundry/bosh-utils/uuid" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Blobstore + type Blobstore interface { Get(blobID string) (LocalBlob, error) Add(sourcePath string) (blobID string, err error) diff --git a/blobstore/blobstore_factory.go b/blobstore/blobstore_factory.go index 1641fede0b..5d14a379d4 100644 --- a/blobstore/blobstore_factory.go +++ b/blobstore/blobstore_factory.go @@ -13,6 +13,8 @@ import ( boshuuid "github.com/cloudfoundry/bosh-utils/uuid" ) +//counterfeiter:generate . Factory + type Factory interface { Create(string, *http.Client) (Blobstore, error) } diff --git a/blobstore/blobstorefakes/fake_blobstore.go b/blobstore/blobstorefakes/fake_blobstore.go new file mode 100644 index 0000000000..953cfdd9f7 --- /dev/null +++ b/blobstore/blobstorefakes/fake_blobstore.go @@ -0,0 +1,191 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package blobstorefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/blobstore" +) + +type FakeBlobstore struct { + AddStub func(string) (string, error) + addMutex sync.RWMutex + addArgsForCall []struct { + arg1 string + } + addReturns struct { + result1 string + result2 error + } + addReturnsOnCall map[int]struct { + result1 string + result2 error + } + GetStub func(string) (blobstore.LocalBlob, error) + getMutex sync.RWMutex + getArgsForCall []struct { + arg1 string + } + getReturns struct { + result1 blobstore.LocalBlob + result2 error + } + getReturnsOnCall map[int]struct { + result1 blobstore.LocalBlob + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeBlobstore) Add(arg1 string) (string, error) { + fake.addMutex.Lock() + ret, specificReturn := fake.addReturnsOnCall[len(fake.addArgsForCall)] + fake.addArgsForCall = append(fake.addArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.AddStub + fakeReturns := fake.addReturns + fake.recordInvocation("Add", []interface{}{arg1}) + fake.addMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeBlobstore) AddCallCount() int { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + return len(fake.addArgsForCall) +} + +func (fake *FakeBlobstore) AddCalls(stub func(string) (string, error)) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = stub +} + +func (fake *FakeBlobstore) AddArgsForCall(i int) string { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + argsForCall := fake.addArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeBlobstore) AddReturns(result1 string, result2 error) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = nil + fake.addReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeBlobstore) AddReturnsOnCall(i int, result1 string, result2 error) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = nil + if fake.addReturnsOnCall == nil { + fake.addReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.addReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeBlobstore) Get(arg1 string) (blobstore.LocalBlob, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.GetStub + fakeReturns := fake.getReturns + fake.recordInvocation("Get", []interface{}{arg1}) + fake.getMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeBlobstore) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeBlobstore) GetCalls(stub func(string) (blobstore.LocalBlob, error)) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = stub +} + +func (fake *FakeBlobstore) GetArgsForCall(i int) string { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + argsForCall := fake.getArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeBlobstore) GetReturns(result1 blobstore.LocalBlob, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + fake.getReturns = struct { + result1 blobstore.LocalBlob + result2 error + }{result1, result2} +} + +func (fake *FakeBlobstore) GetReturnsOnCall(i int, result1 blobstore.LocalBlob, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 blobstore.LocalBlob + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 blobstore.LocalBlob + result2 error + }{result1, result2} +} + +func (fake *FakeBlobstore) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeBlobstore) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ blobstore.Blobstore = new(FakeBlobstore) diff --git a/blobstore/blobstorefakes/fake_factory.go b/blobstore/blobstorefakes/fake_factory.go new file mode 100644 index 0000000000..5fbb3340ac --- /dev/null +++ b/blobstore/blobstorefakes/fake_factory.go @@ -0,0 +1,117 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package blobstorefakes + +import ( + "net/http" + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/blobstore" +) + +type FakeFactory struct { + CreateStub func(string, *http.Client) (blobstore.Blobstore, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 string + arg2 *http.Client + } + createReturns struct { + result1 blobstore.Blobstore + result2 error + } + createReturnsOnCall map[int]struct { + result1 blobstore.Blobstore + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeFactory) Create(arg1 string, arg2 *http.Client) (blobstore.Blobstore, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 string + arg2 *http.Client + }{arg1, arg2}) + stub := fake.CreateStub + fakeReturns := fake.createReturns + fake.recordInvocation("Create", []interface{}{arg1, arg2}) + fake.createMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeFactory) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeFactory) CreateCalls(stub func(string, *http.Client) (blobstore.Blobstore, error)) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = stub +} + +func (fake *FakeFactory) CreateArgsForCall(i int) (string, *http.Client) { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + argsForCall := fake.createArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeFactory) CreateReturns(result1 blobstore.Blobstore, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + fake.createReturns = struct { + result1 blobstore.Blobstore + result2 error + }{result1, result2} +} + +func (fake *FakeFactory) CreateReturnsOnCall(i int, result1 blobstore.Blobstore, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 blobstore.Blobstore + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 blobstore.Blobstore + result2 error + }{result1, result2} +} + +func (fake *FakeFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ blobstore.Factory = new(FakeFactory) diff --git a/blobstore/mocks/mocks.go b/blobstore/mocks/mocks.go deleted file mode 100644 index 0748d9180c..0000000000 --- a/blobstore/mocks/mocks.go +++ /dev/null @@ -1,104 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/blobstore (interfaces: Factory,Blobstore) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - http "net/http" - reflect "reflect" - - blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore" - gomock "github.com/golang/mock/gomock" -) - -// MockFactory is a mock of Factory interface. -type MockFactory struct { - ctrl *gomock.Controller - recorder *MockFactoryMockRecorder -} - -// MockFactoryMockRecorder is the mock recorder for MockFactory. -type MockFactoryMockRecorder struct { - mock *MockFactory -} - -// NewMockFactory creates a new mock instance. -func NewMockFactory(ctrl *gomock.Controller) *MockFactory { - mock := &MockFactory{ctrl: ctrl} - mock.recorder = &MockFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { - return m.recorder -} - -// Create mocks base method. -func (m *MockFactory) Create(arg0 string, arg1 *http.Client) (blobstore.Blobstore, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) - ret0, _ := ret[0].(blobstore.Blobstore) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Create indicates an expected call of Create. -func (mr *MockFactoryMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockFactory)(nil).Create), arg0, arg1) -} - -// MockBlobstore is a mock of Blobstore interface. -type MockBlobstore struct { - ctrl *gomock.Controller - recorder *MockBlobstoreMockRecorder -} - -// MockBlobstoreMockRecorder is the mock recorder for MockBlobstore. -type MockBlobstoreMockRecorder struct { - mock *MockBlobstore -} - -// NewMockBlobstore creates a new mock instance. -func NewMockBlobstore(ctrl *gomock.Controller) *MockBlobstore { - mock := &MockBlobstore{ctrl: ctrl} - mock.recorder = &MockBlobstoreMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockBlobstore) EXPECT() *MockBlobstoreMockRecorder { - return m.recorder -} - -// Add mocks base method. -func (m *MockBlobstore) Add(arg0 string) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Add", arg0) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Add indicates an expected call of Add. -func (mr *MockBlobstoreMockRecorder) Add(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockBlobstore)(nil).Add), arg0) -} - -// Get mocks base method. -func (m *MockBlobstore) Get(arg0 string) (blobstore.LocalBlob, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0) - ret0, _ := ret[0].(blobstore.LocalBlob) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Get indicates an expected call of Get. -func (mr *MockBlobstoreMockRecorder) Get(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockBlobstore)(nil).Get), arg0) -} diff --git a/cloud/cloud.go b/cloud/cloud.go index cb62799f25..ca9e5cf565 100644 --- a/cloud/cloud.go +++ b/cloud/cloud.go @@ -15,6 +15,10 @@ const MaxCpiApiVersionSupported = 2 const StemcellNoRegistryAsOfVersion = 2 const DefaultCPIVersion = 1 +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Cloud + type Cloud interface { CreateStemcell(imagePath string, cloudProperties biproperty.Map) (stemcellCID string, err error) DeleteStemcell(stemcellCID string) error diff --git a/cloud/cloudfakes/fake_cloud.go b/cloud/cloudfakes/fake_cloud.go new file mode 100644 index 0000000000..f2a69027ca --- /dev/null +++ b/cloud/cloudfakes/fake_cloud.go @@ -0,0 +1,1015 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cloudfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-utils/property" +) + +type FakeCloud struct { + AttachDiskStub func(string, string) (interface{}, error) + attachDiskMutex sync.RWMutex + attachDiskArgsForCall []struct { + arg1 string + arg2 string + } + attachDiskReturns struct { + result1 interface{} + result2 error + } + attachDiskReturnsOnCall map[int]struct { + result1 interface{} + result2 error + } + CreateDiskStub func(int, property.Map, string) (string, error) + createDiskMutex sync.RWMutex + createDiskArgsForCall []struct { + arg1 int + arg2 property.Map + arg3 string + } + createDiskReturns struct { + result1 string + result2 error + } + createDiskReturnsOnCall map[int]struct { + result1 string + result2 error + } + CreateStemcellStub func(string, property.Map) (string, error) + createStemcellMutex sync.RWMutex + createStemcellArgsForCall []struct { + arg1 string + arg2 property.Map + } + createStemcellReturns struct { + result1 string + result2 error + } + createStemcellReturnsOnCall map[int]struct { + result1 string + result2 error + } + CreateVMStub func(string, string, property.Map, []string, map[string]property.Map, property.Map) (string, error) + createVMMutex sync.RWMutex + createVMArgsForCall []struct { + arg1 string + arg2 string + arg3 property.Map + arg4 []string + arg5 map[string]property.Map + arg6 property.Map + } + createVMReturns struct { + result1 string + result2 error + } + createVMReturnsOnCall map[int]struct { + result1 string + result2 error + } + DeleteDiskStub func(string) error + deleteDiskMutex sync.RWMutex + deleteDiskArgsForCall []struct { + arg1 string + } + deleteDiskReturns struct { + result1 error + } + deleteDiskReturnsOnCall map[int]struct { + result1 error + } + DeleteStemcellStub func(string) error + deleteStemcellMutex sync.RWMutex + deleteStemcellArgsForCall []struct { + arg1 string + } + deleteStemcellReturns struct { + result1 error + } + deleteStemcellReturnsOnCall map[int]struct { + result1 error + } + DeleteVMStub func(string) error + deleteVMMutex sync.RWMutex + deleteVMArgsForCall []struct { + arg1 string + } + deleteVMReturns struct { + result1 error + } + deleteVMReturnsOnCall map[int]struct { + result1 error + } + DetachDiskStub func(string, string) error + detachDiskMutex sync.RWMutex + detachDiskArgsForCall []struct { + arg1 string + arg2 string + } + detachDiskReturns struct { + result1 error + } + detachDiskReturnsOnCall map[int]struct { + result1 error + } + HasVMStub func(string) (bool, error) + hasVMMutex sync.RWMutex + hasVMArgsForCall []struct { + arg1 string + } + hasVMReturns struct { + result1 bool + result2 error + } + hasVMReturnsOnCall map[int]struct { + result1 bool + result2 error + } + InfoStub func() (cloud.CpiInfo, error) + infoMutex sync.RWMutex + infoArgsForCall []struct { + } + infoReturns struct { + result1 cloud.CpiInfo + result2 error + } + infoReturnsOnCall map[int]struct { + result1 cloud.CpiInfo + result2 error + } + SetDiskMetadataStub func(string, cloud.DiskMetadata) error + setDiskMetadataMutex sync.RWMutex + setDiskMetadataArgsForCall []struct { + arg1 string + arg2 cloud.DiskMetadata + } + setDiskMetadataReturns struct { + result1 error + } + setDiskMetadataReturnsOnCall map[int]struct { + result1 error + } + SetVMMetadataStub func(string, cloud.VMMetadata) error + setVMMetadataMutex sync.RWMutex + setVMMetadataArgsForCall []struct { + arg1 string + arg2 cloud.VMMetadata + } + setVMMetadataReturns struct { + result1 error + } + setVMMetadataReturnsOnCall map[int]struct { + result1 error + } + StringStub func() string + stringMutex sync.RWMutex + stringArgsForCall []struct { + } + stringReturns struct { + result1 string + } + stringReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeCloud) AttachDisk(arg1 string, arg2 string) (interface{}, error) { + fake.attachDiskMutex.Lock() + ret, specificReturn := fake.attachDiskReturnsOnCall[len(fake.attachDiskArgsForCall)] + fake.attachDiskArgsForCall = append(fake.attachDiskArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.AttachDiskStub + fakeReturns := fake.attachDiskReturns + fake.recordInvocation("AttachDisk", []interface{}{arg1, arg2}) + fake.attachDiskMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) AttachDiskCallCount() int { + fake.attachDiskMutex.RLock() + defer fake.attachDiskMutex.RUnlock() + return len(fake.attachDiskArgsForCall) +} + +func (fake *FakeCloud) AttachDiskCalls(stub func(string, string) (interface{}, error)) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = stub +} + +func (fake *FakeCloud) AttachDiskArgsForCall(i int) (string, string) { + fake.attachDiskMutex.RLock() + defer fake.attachDiskMutex.RUnlock() + argsForCall := fake.attachDiskArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCloud) AttachDiskReturns(result1 interface{}, result2 error) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = nil + fake.attachDiskReturns = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) AttachDiskReturnsOnCall(i int, result1 interface{}, result2 error) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = nil + if fake.attachDiskReturnsOnCall == nil { + fake.attachDiskReturnsOnCall = make(map[int]struct { + result1 interface{} + result2 error + }) + } + fake.attachDiskReturnsOnCall[i] = struct { + result1 interface{} + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateDisk(arg1 int, arg2 property.Map, arg3 string) (string, error) { + fake.createDiskMutex.Lock() + ret, specificReturn := fake.createDiskReturnsOnCall[len(fake.createDiskArgsForCall)] + fake.createDiskArgsForCall = append(fake.createDiskArgsForCall, struct { + arg1 int + arg2 property.Map + arg3 string + }{arg1, arg2, arg3}) + stub := fake.CreateDiskStub + fakeReturns := fake.createDiskReturns + fake.recordInvocation("CreateDisk", []interface{}{arg1, arg2, arg3}) + fake.createDiskMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) CreateDiskCallCount() int { + fake.createDiskMutex.RLock() + defer fake.createDiskMutex.RUnlock() + return len(fake.createDiskArgsForCall) +} + +func (fake *FakeCloud) CreateDiskCalls(stub func(int, property.Map, string) (string, error)) { + fake.createDiskMutex.Lock() + defer fake.createDiskMutex.Unlock() + fake.CreateDiskStub = stub +} + +func (fake *FakeCloud) CreateDiskArgsForCall(i int) (int, property.Map, string) { + fake.createDiskMutex.RLock() + defer fake.createDiskMutex.RUnlock() + argsForCall := fake.createDiskArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeCloud) CreateDiskReturns(result1 string, result2 error) { + fake.createDiskMutex.Lock() + defer fake.createDiskMutex.Unlock() + fake.CreateDiskStub = nil + fake.createDiskReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateDiskReturnsOnCall(i int, result1 string, result2 error) { + fake.createDiskMutex.Lock() + defer fake.createDiskMutex.Unlock() + fake.CreateDiskStub = nil + if fake.createDiskReturnsOnCall == nil { + fake.createDiskReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.createDiskReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateStemcell(arg1 string, arg2 property.Map) (string, error) { + fake.createStemcellMutex.Lock() + ret, specificReturn := fake.createStemcellReturnsOnCall[len(fake.createStemcellArgsForCall)] + fake.createStemcellArgsForCall = append(fake.createStemcellArgsForCall, struct { + arg1 string + arg2 property.Map + }{arg1, arg2}) + stub := fake.CreateStemcellStub + fakeReturns := fake.createStemcellReturns + fake.recordInvocation("CreateStemcell", []interface{}{arg1, arg2}) + fake.createStemcellMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) CreateStemcellCallCount() int { + fake.createStemcellMutex.RLock() + defer fake.createStemcellMutex.RUnlock() + return len(fake.createStemcellArgsForCall) +} + +func (fake *FakeCloud) CreateStemcellCalls(stub func(string, property.Map) (string, error)) { + fake.createStemcellMutex.Lock() + defer fake.createStemcellMutex.Unlock() + fake.CreateStemcellStub = stub +} + +func (fake *FakeCloud) CreateStemcellArgsForCall(i int) (string, property.Map) { + fake.createStemcellMutex.RLock() + defer fake.createStemcellMutex.RUnlock() + argsForCall := fake.createStemcellArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCloud) CreateStemcellReturns(result1 string, result2 error) { + fake.createStemcellMutex.Lock() + defer fake.createStemcellMutex.Unlock() + fake.CreateStemcellStub = nil + fake.createStemcellReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateStemcellReturnsOnCall(i int, result1 string, result2 error) { + fake.createStemcellMutex.Lock() + defer fake.createStemcellMutex.Unlock() + fake.CreateStemcellStub = nil + if fake.createStemcellReturnsOnCall == nil { + fake.createStemcellReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.createStemcellReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateVM(arg1 string, arg2 string, arg3 property.Map, arg4 []string, arg5 map[string]property.Map, arg6 property.Map) (string, error) { + var arg4Copy []string + if arg4 != nil { + arg4Copy = make([]string, len(arg4)) + copy(arg4Copy, arg4) + } + fake.createVMMutex.Lock() + ret, specificReturn := fake.createVMReturnsOnCall[len(fake.createVMArgsForCall)] + fake.createVMArgsForCall = append(fake.createVMArgsForCall, struct { + arg1 string + arg2 string + arg3 property.Map + arg4 []string + arg5 map[string]property.Map + arg6 property.Map + }{arg1, arg2, arg3, arg4Copy, arg5, arg6}) + stub := fake.CreateVMStub + fakeReturns := fake.createVMReturns + fake.recordInvocation("CreateVM", []interface{}{arg1, arg2, arg3, arg4Copy, arg5, arg6}) + fake.createVMMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) CreateVMCallCount() int { + fake.createVMMutex.RLock() + defer fake.createVMMutex.RUnlock() + return len(fake.createVMArgsForCall) +} + +func (fake *FakeCloud) CreateVMCalls(stub func(string, string, property.Map, []string, map[string]property.Map, property.Map) (string, error)) { + fake.createVMMutex.Lock() + defer fake.createVMMutex.Unlock() + fake.CreateVMStub = stub +} + +func (fake *FakeCloud) CreateVMArgsForCall(i int) (string, string, property.Map, []string, map[string]property.Map, property.Map) { + fake.createVMMutex.RLock() + defer fake.createVMMutex.RUnlock() + argsForCall := fake.createVMArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *FakeCloud) CreateVMReturns(result1 string, result2 error) { + fake.createVMMutex.Lock() + defer fake.createVMMutex.Unlock() + fake.CreateVMStub = nil + fake.createVMReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) CreateVMReturnsOnCall(i int, result1 string, result2 error) { + fake.createVMMutex.Lock() + defer fake.createVMMutex.Unlock() + fake.CreateVMStub = nil + if fake.createVMReturnsOnCall == nil { + fake.createVMReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.createVMReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) DeleteDisk(arg1 string) error { + fake.deleteDiskMutex.Lock() + ret, specificReturn := fake.deleteDiskReturnsOnCall[len(fake.deleteDiskArgsForCall)] + fake.deleteDiskArgsForCall = append(fake.deleteDiskArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DeleteDiskStub + fakeReturns := fake.deleteDiskReturns + fake.recordInvocation("DeleteDisk", []interface{}{arg1}) + fake.deleteDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) DeleteDiskCallCount() int { + fake.deleteDiskMutex.RLock() + defer fake.deleteDiskMutex.RUnlock() + return len(fake.deleteDiskArgsForCall) +} + +func (fake *FakeCloud) DeleteDiskCalls(stub func(string) error) { + fake.deleteDiskMutex.Lock() + defer fake.deleteDiskMutex.Unlock() + fake.DeleteDiskStub = stub +} + +func (fake *FakeCloud) DeleteDiskArgsForCall(i int) string { + fake.deleteDiskMutex.RLock() + defer fake.deleteDiskMutex.RUnlock() + argsForCall := fake.deleteDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloud) DeleteDiskReturns(result1 error) { + fake.deleteDiskMutex.Lock() + defer fake.deleteDiskMutex.Unlock() + fake.DeleteDiskStub = nil + fake.deleteDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DeleteDiskReturnsOnCall(i int, result1 error) { + fake.deleteDiskMutex.Lock() + defer fake.deleteDiskMutex.Unlock() + fake.DeleteDiskStub = nil + if fake.deleteDiskReturnsOnCall == nil { + fake.deleteDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DeleteStemcell(arg1 string) error { + fake.deleteStemcellMutex.Lock() + ret, specificReturn := fake.deleteStemcellReturnsOnCall[len(fake.deleteStemcellArgsForCall)] + fake.deleteStemcellArgsForCall = append(fake.deleteStemcellArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DeleteStemcellStub + fakeReturns := fake.deleteStemcellReturns + fake.recordInvocation("DeleteStemcell", []interface{}{arg1}) + fake.deleteStemcellMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) DeleteStemcellCallCount() int { + fake.deleteStemcellMutex.RLock() + defer fake.deleteStemcellMutex.RUnlock() + return len(fake.deleteStemcellArgsForCall) +} + +func (fake *FakeCloud) DeleteStemcellCalls(stub func(string) error) { + fake.deleteStemcellMutex.Lock() + defer fake.deleteStemcellMutex.Unlock() + fake.DeleteStemcellStub = stub +} + +func (fake *FakeCloud) DeleteStemcellArgsForCall(i int) string { + fake.deleteStemcellMutex.RLock() + defer fake.deleteStemcellMutex.RUnlock() + argsForCall := fake.deleteStemcellArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloud) DeleteStemcellReturns(result1 error) { + fake.deleteStemcellMutex.Lock() + defer fake.deleteStemcellMutex.Unlock() + fake.DeleteStemcellStub = nil + fake.deleteStemcellReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DeleteStemcellReturnsOnCall(i int, result1 error) { + fake.deleteStemcellMutex.Lock() + defer fake.deleteStemcellMutex.Unlock() + fake.DeleteStemcellStub = nil + if fake.deleteStemcellReturnsOnCall == nil { + fake.deleteStemcellReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteStemcellReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DeleteVM(arg1 string) error { + fake.deleteVMMutex.Lock() + ret, specificReturn := fake.deleteVMReturnsOnCall[len(fake.deleteVMArgsForCall)] + fake.deleteVMArgsForCall = append(fake.deleteVMArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.DeleteVMStub + fakeReturns := fake.deleteVMReturns + fake.recordInvocation("DeleteVM", []interface{}{arg1}) + fake.deleteVMMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) DeleteVMCallCount() int { + fake.deleteVMMutex.RLock() + defer fake.deleteVMMutex.RUnlock() + return len(fake.deleteVMArgsForCall) +} + +func (fake *FakeCloud) DeleteVMCalls(stub func(string) error) { + fake.deleteVMMutex.Lock() + defer fake.deleteVMMutex.Unlock() + fake.DeleteVMStub = stub +} + +func (fake *FakeCloud) DeleteVMArgsForCall(i int) string { + fake.deleteVMMutex.RLock() + defer fake.deleteVMMutex.RUnlock() + argsForCall := fake.deleteVMArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloud) DeleteVMReturns(result1 error) { + fake.deleteVMMutex.Lock() + defer fake.deleteVMMutex.Unlock() + fake.DeleteVMStub = nil + fake.deleteVMReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DeleteVMReturnsOnCall(i int, result1 error) { + fake.deleteVMMutex.Lock() + defer fake.deleteVMMutex.Unlock() + fake.DeleteVMStub = nil + if fake.deleteVMReturnsOnCall == nil { + fake.deleteVMReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteVMReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DetachDisk(arg1 string, arg2 string) error { + fake.detachDiskMutex.Lock() + ret, specificReturn := fake.detachDiskReturnsOnCall[len(fake.detachDiskArgsForCall)] + fake.detachDiskArgsForCall = append(fake.detachDiskArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.DetachDiskStub + fakeReturns := fake.detachDiskReturns + fake.recordInvocation("DetachDisk", []interface{}{arg1, arg2}) + fake.detachDiskMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) DetachDiskCallCount() int { + fake.detachDiskMutex.RLock() + defer fake.detachDiskMutex.RUnlock() + return len(fake.detachDiskArgsForCall) +} + +func (fake *FakeCloud) DetachDiskCalls(stub func(string, string) error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = stub +} + +func (fake *FakeCloud) DetachDiskArgsForCall(i int) (string, string) { + fake.detachDiskMutex.RLock() + defer fake.detachDiskMutex.RUnlock() + argsForCall := fake.detachDiskArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCloud) DetachDiskReturns(result1 error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = nil + fake.detachDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) DetachDiskReturnsOnCall(i int, result1 error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = nil + if fake.detachDiskReturnsOnCall == nil { + fake.detachDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.detachDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) HasVM(arg1 string) (bool, error) { + fake.hasVMMutex.Lock() + ret, specificReturn := fake.hasVMReturnsOnCall[len(fake.hasVMArgsForCall)] + fake.hasVMArgsForCall = append(fake.hasVMArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.HasVMStub + fakeReturns := fake.hasVMReturns + fake.recordInvocation("HasVM", []interface{}{arg1}) + fake.hasVMMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) HasVMCallCount() int { + fake.hasVMMutex.RLock() + defer fake.hasVMMutex.RUnlock() + return len(fake.hasVMArgsForCall) +} + +func (fake *FakeCloud) HasVMCalls(stub func(string) (bool, error)) { + fake.hasVMMutex.Lock() + defer fake.hasVMMutex.Unlock() + fake.HasVMStub = stub +} + +func (fake *FakeCloud) HasVMArgsForCall(i int) string { + fake.hasVMMutex.RLock() + defer fake.hasVMMutex.RUnlock() + argsForCall := fake.hasVMArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCloud) HasVMReturns(result1 bool, result2 error) { + fake.hasVMMutex.Lock() + defer fake.hasVMMutex.Unlock() + fake.HasVMStub = nil + fake.hasVMReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) HasVMReturnsOnCall(i int, result1 bool, result2 error) { + fake.hasVMMutex.Lock() + defer fake.hasVMMutex.Unlock() + fake.HasVMStub = nil + if fake.hasVMReturnsOnCall == nil { + fake.hasVMReturnsOnCall = make(map[int]struct { + result1 bool + result2 error + }) + } + fake.hasVMReturnsOnCall[i] = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) Info() (cloud.CpiInfo, error) { + fake.infoMutex.Lock() + ret, specificReturn := fake.infoReturnsOnCall[len(fake.infoArgsForCall)] + fake.infoArgsForCall = append(fake.infoArgsForCall, struct { + }{}) + stub := fake.InfoStub + fakeReturns := fake.infoReturns + fake.recordInvocation("Info", []interface{}{}) + fake.infoMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCloud) InfoCallCount() int { + fake.infoMutex.RLock() + defer fake.infoMutex.RUnlock() + return len(fake.infoArgsForCall) +} + +func (fake *FakeCloud) InfoCalls(stub func() (cloud.CpiInfo, error)) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = stub +} + +func (fake *FakeCloud) InfoReturns(result1 cloud.CpiInfo, result2 error) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = nil + fake.infoReturns = struct { + result1 cloud.CpiInfo + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) InfoReturnsOnCall(i int, result1 cloud.CpiInfo, result2 error) { + fake.infoMutex.Lock() + defer fake.infoMutex.Unlock() + fake.InfoStub = nil + if fake.infoReturnsOnCall == nil { + fake.infoReturnsOnCall = make(map[int]struct { + result1 cloud.CpiInfo + result2 error + }) + } + fake.infoReturnsOnCall[i] = struct { + result1 cloud.CpiInfo + result2 error + }{result1, result2} +} + +func (fake *FakeCloud) SetDiskMetadata(arg1 string, arg2 cloud.DiskMetadata) error { + fake.setDiskMetadataMutex.Lock() + ret, specificReturn := fake.setDiskMetadataReturnsOnCall[len(fake.setDiskMetadataArgsForCall)] + fake.setDiskMetadataArgsForCall = append(fake.setDiskMetadataArgsForCall, struct { + arg1 string + arg2 cloud.DiskMetadata + }{arg1, arg2}) + stub := fake.SetDiskMetadataStub + fakeReturns := fake.setDiskMetadataReturns + fake.recordInvocation("SetDiskMetadata", []interface{}{arg1, arg2}) + fake.setDiskMetadataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) SetDiskMetadataCallCount() int { + fake.setDiskMetadataMutex.RLock() + defer fake.setDiskMetadataMutex.RUnlock() + return len(fake.setDiskMetadataArgsForCall) +} + +func (fake *FakeCloud) SetDiskMetadataCalls(stub func(string, cloud.DiskMetadata) error) { + fake.setDiskMetadataMutex.Lock() + defer fake.setDiskMetadataMutex.Unlock() + fake.SetDiskMetadataStub = stub +} + +func (fake *FakeCloud) SetDiskMetadataArgsForCall(i int) (string, cloud.DiskMetadata) { + fake.setDiskMetadataMutex.RLock() + defer fake.setDiskMetadataMutex.RUnlock() + argsForCall := fake.setDiskMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCloud) SetDiskMetadataReturns(result1 error) { + fake.setDiskMetadataMutex.Lock() + defer fake.setDiskMetadataMutex.Unlock() + fake.SetDiskMetadataStub = nil + fake.setDiskMetadataReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) SetDiskMetadataReturnsOnCall(i int, result1 error) { + fake.setDiskMetadataMutex.Lock() + defer fake.setDiskMetadataMutex.Unlock() + fake.SetDiskMetadataStub = nil + if fake.setDiskMetadataReturnsOnCall == nil { + fake.setDiskMetadataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setDiskMetadataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) SetVMMetadata(arg1 string, arg2 cloud.VMMetadata) error { + fake.setVMMetadataMutex.Lock() + ret, specificReturn := fake.setVMMetadataReturnsOnCall[len(fake.setVMMetadataArgsForCall)] + fake.setVMMetadataArgsForCall = append(fake.setVMMetadataArgsForCall, struct { + arg1 string + arg2 cloud.VMMetadata + }{arg1, arg2}) + stub := fake.SetVMMetadataStub + fakeReturns := fake.setVMMetadataReturns + fake.recordInvocation("SetVMMetadata", []interface{}{arg1, arg2}) + fake.setVMMetadataMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) SetVMMetadataCallCount() int { + fake.setVMMetadataMutex.RLock() + defer fake.setVMMetadataMutex.RUnlock() + return len(fake.setVMMetadataArgsForCall) +} + +func (fake *FakeCloud) SetVMMetadataCalls(stub func(string, cloud.VMMetadata) error) { + fake.setVMMetadataMutex.Lock() + defer fake.setVMMetadataMutex.Unlock() + fake.SetVMMetadataStub = stub +} + +func (fake *FakeCloud) SetVMMetadataArgsForCall(i int) (string, cloud.VMMetadata) { + fake.setVMMetadataMutex.RLock() + defer fake.setVMMetadataMutex.RUnlock() + argsForCall := fake.setVMMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCloud) SetVMMetadataReturns(result1 error) { + fake.setVMMetadataMutex.Lock() + defer fake.setVMMetadataMutex.Unlock() + fake.SetVMMetadataStub = nil + fake.setVMMetadataReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) SetVMMetadataReturnsOnCall(i int, result1 error) { + fake.setVMMetadataMutex.Lock() + defer fake.setVMMetadataMutex.Unlock() + fake.SetVMMetadataStub = nil + if fake.setVMMetadataReturnsOnCall == nil { + fake.setVMMetadataReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.setVMMetadataReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCloud) String() string { + fake.stringMutex.Lock() + ret, specificReturn := fake.stringReturnsOnCall[len(fake.stringArgsForCall)] + fake.stringArgsForCall = append(fake.stringArgsForCall, struct { + }{}) + stub := fake.StringStub + fakeReturns := fake.stringReturns + fake.recordInvocation("String", []interface{}{}) + fake.stringMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCloud) StringCallCount() int { + fake.stringMutex.RLock() + defer fake.stringMutex.RUnlock() + return len(fake.stringArgsForCall) +} + +func (fake *FakeCloud) StringCalls(stub func() string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = stub +} + +func (fake *FakeCloud) StringReturns(result1 string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = nil + fake.stringReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeCloud) StringReturnsOnCall(i int, result1 string) { + fake.stringMutex.Lock() + defer fake.stringMutex.Unlock() + fake.StringStub = nil + if fake.stringReturnsOnCall == nil { + fake.stringReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.stringReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeCloud) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeCloud) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ cloud.Cloud = new(FakeCloud) diff --git a/cloud/cloudfakes/fake_factory.go b/cloud/cloudfakes/fake_factory.go new file mode 100644 index 0000000000..55197aabb1 --- /dev/null +++ b/cloud/cloudfakes/fake_factory.go @@ -0,0 +1,119 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cloudfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/installation" +) + +type FakeFactory struct { + NewCloudStub func(installation.Installation, string, int) (cloud.Cloud, error) + newCloudMutex sync.RWMutex + newCloudArgsForCall []struct { + arg1 installation.Installation + arg2 string + arg3 int + } + newCloudReturns struct { + result1 cloud.Cloud + result2 error + } + newCloudReturnsOnCall map[int]struct { + result1 cloud.Cloud + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeFactory) NewCloud(arg1 installation.Installation, arg2 string, arg3 int) (cloud.Cloud, error) { + fake.newCloudMutex.Lock() + ret, specificReturn := fake.newCloudReturnsOnCall[len(fake.newCloudArgsForCall)] + fake.newCloudArgsForCall = append(fake.newCloudArgsForCall, struct { + arg1 installation.Installation + arg2 string + arg3 int + }{arg1, arg2, arg3}) + stub := fake.NewCloudStub + fakeReturns := fake.newCloudReturns + fake.recordInvocation("NewCloud", []interface{}{arg1, arg2, arg3}) + fake.newCloudMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeFactory) NewCloudCallCount() int { + fake.newCloudMutex.RLock() + defer fake.newCloudMutex.RUnlock() + return len(fake.newCloudArgsForCall) +} + +func (fake *FakeFactory) NewCloudCalls(stub func(installation.Installation, string, int) (cloud.Cloud, error)) { + fake.newCloudMutex.Lock() + defer fake.newCloudMutex.Unlock() + fake.NewCloudStub = stub +} + +func (fake *FakeFactory) NewCloudArgsForCall(i int) (installation.Installation, string, int) { + fake.newCloudMutex.RLock() + defer fake.newCloudMutex.RUnlock() + argsForCall := fake.newCloudArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeFactory) NewCloudReturns(result1 cloud.Cloud, result2 error) { + fake.newCloudMutex.Lock() + defer fake.newCloudMutex.Unlock() + fake.NewCloudStub = nil + fake.newCloudReturns = struct { + result1 cloud.Cloud + result2 error + }{result1, result2} +} + +func (fake *FakeFactory) NewCloudReturnsOnCall(i int, result1 cloud.Cloud, result2 error) { + fake.newCloudMutex.Lock() + defer fake.newCloudMutex.Unlock() + fake.NewCloudStub = nil + if fake.newCloudReturnsOnCall == nil { + fake.newCloudReturnsOnCall = make(map[int]struct { + result1 cloud.Cloud + result2 error + }) + } + fake.newCloudReturnsOnCall[i] = struct { + result1 cloud.Cloud + result2 error + }{result1, result2} +} + +func (fake *FakeFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ cloud.Factory = new(FakeFactory) diff --git a/cloud/factory.go b/cloud/factory.go index 562352e393..1c11fb7dcf 100644 --- a/cloud/factory.go +++ b/cloud/factory.go @@ -8,6 +8,8 @@ import ( biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" ) +//counterfeiter:generate . Factory + type Factory interface { NewCloud(installation biinstall.Installation, directorID string, stemcellApiVersion int) (Cloud, error) } diff --git a/cloud/mocks/mocks.go b/cloud/mocks/mocks.go deleted file mode 100644 index d64fef8810..0000000000 --- a/cloud/mocks/mocks.go +++ /dev/null @@ -1,263 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/cloud (interfaces: Cloud,Factory) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - cloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - installation "github.com/cloudfoundry/bosh-cli/v7/installation" - property "github.com/cloudfoundry/bosh-utils/property" - gomock "github.com/golang/mock/gomock" -) - -// MockCloud is a mock of Cloud interface. -type MockCloud struct { - ctrl *gomock.Controller - recorder *MockCloudMockRecorder -} - -// MockCloudMockRecorder is the mock recorder for MockCloud. -type MockCloudMockRecorder struct { - mock *MockCloud -} - -// NewMockCloud creates a new mock instance. -func NewMockCloud(ctrl *gomock.Controller) *MockCloud { - mock := &MockCloud{ctrl: ctrl} - mock.recorder = &MockCloudMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCloud) EXPECT() *MockCloudMockRecorder { - return m.recorder -} - -// AttachDisk mocks base method. -func (m *MockCloud) AttachDisk(arg0, arg1 string) (interface{}, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachDisk", arg0, arg1) - ret0, _ := ret[0].(interface{}) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachDisk indicates an expected call of AttachDisk. -func (mr *MockCloudMockRecorder) AttachDisk(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachDisk", reflect.TypeOf((*MockCloud)(nil).AttachDisk), arg0, arg1) -} - -// CreateDisk mocks base method. -func (m *MockCloud) CreateDisk(arg0 int, arg1 property.Map, arg2 string) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDisk", arg0, arg1, arg2) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDisk indicates an expected call of CreateDisk. -func (mr *MockCloudMockRecorder) CreateDisk(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDisk", reflect.TypeOf((*MockCloud)(nil).CreateDisk), arg0, arg1, arg2) -} - -// CreateStemcell mocks base method. -func (m *MockCloud) CreateStemcell(arg0 string, arg1 property.Map) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateStemcell", arg0, arg1) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateStemcell indicates an expected call of CreateStemcell. -func (mr *MockCloudMockRecorder) CreateStemcell(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStemcell", reflect.TypeOf((*MockCloud)(nil).CreateStemcell), arg0, arg1) -} - -// CreateVM mocks base method. -func (m *MockCloud) CreateVM(arg0, arg1 string, arg2 property.Map, arg3 []string, arg4 map[string]property.Map, arg5 property.Map) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVM", arg0, arg1, arg2, arg3, arg4, arg5) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVM indicates an expected call of CreateVM. -func (mr *MockCloudMockRecorder) CreateVM(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVM", reflect.TypeOf((*MockCloud)(nil).CreateVM), arg0, arg1, arg2, arg3, arg4, arg5) -} - -// DeleteDisk mocks base method. -func (m *MockCloud) DeleteDisk(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDisk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteDisk indicates an expected call of DeleteDisk. -func (mr *MockCloudMockRecorder) DeleteDisk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDisk", reflect.TypeOf((*MockCloud)(nil).DeleteDisk), arg0) -} - -// DeleteStemcell mocks base method. -func (m *MockCloud) DeleteStemcell(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteStemcell", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteStemcell indicates an expected call of DeleteStemcell. -func (mr *MockCloudMockRecorder) DeleteStemcell(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteStemcell", reflect.TypeOf((*MockCloud)(nil).DeleteStemcell), arg0) -} - -// DeleteVM mocks base method. -func (m *MockCloud) DeleteVM(arg0 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVM", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteVM indicates an expected call of DeleteVM. -func (mr *MockCloudMockRecorder) DeleteVM(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVM", reflect.TypeOf((*MockCloud)(nil).DeleteVM), arg0) -} - -// DetachDisk mocks base method. -func (m *MockCloud) DetachDisk(arg0, arg1 string) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachDisk", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DetachDisk indicates an expected call of DetachDisk. -func (mr *MockCloudMockRecorder) DetachDisk(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockCloud)(nil).DetachDisk), arg0, arg1) -} - -// HasVM mocks base method. -func (m *MockCloud) HasVM(arg0 string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "HasVM", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// HasVM indicates an expected call of HasVM. -func (mr *MockCloudMockRecorder) HasVM(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasVM", reflect.TypeOf((*MockCloud)(nil).HasVM), arg0) -} - -// Info mocks base method. -func (m *MockCloud) Info() (cloud.CpiInfo, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Info") - ret0, _ := ret[0].(cloud.CpiInfo) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Info indicates an expected call of Info. -func (mr *MockCloudMockRecorder) Info() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockCloud)(nil).Info)) -} - -// SetDiskMetadata mocks base method. -func (m *MockCloud) SetDiskMetadata(arg0 string, arg1 cloud.DiskMetadata) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetDiskMetadata", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetDiskMetadata indicates an expected call of SetDiskMetadata. -func (mr *MockCloudMockRecorder) SetDiskMetadata(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDiskMetadata", reflect.TypeOf((*MockCloud)(nil).SetDiskMetadata), arg0, arg1) -} - -// SetVMMetadata mocks base method. -func (m *MockCloud) SetVMMetadata(arg0 string, arg1 cloud.VMMetadata) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetVMMetadata", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// SetVMMetadata indicates an expected call of SetVMMetadata. -func (mr *MockCloudMockRecorder) SetVMMetadata(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVMMetadata", reflect.TypeOf((*MockCloud)(nil).SetVMMetadata), arg0, arg1) -} - -// String mocks base method. -func (m *MockCloud) String() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "String") - ret0, _ := ret[0].(string) - return ret0 -} - -// String indicates an expected call of String. -func (mr *MockCloudMockRecorder) String() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockCloud)(nil).String)) -} - -// MockFactory is a mock of Factory interface. -type MockFactory struct { - ctrl *gomock.Controller - recorder *MockFactoryMockRecorder -} - -// MockFactoryMockRecorder is the mock recorder for MockFactory. -type MockFactoryMockRecorder struct { - mock *MockFactory -} - -// NewMockFactory creates a new mock instance. -func NewMockFactory(ctrl *gomock.Controller) *MockFactory { - mock := &MockFactory{ctrl: ctrl} - mock.recorder = &MockFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { - return m.recorder -} - -// NewCloud mocks base method. -func (m *MockFactory) NewCloud(arg0 installation.Installation, arg1 string, arg2 int) (cloud.Cloud, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewCloud", arg0, arg1, arg2) - ret0, _ := ret[0].(cloud.Cloud) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// NewCloud indicates an expected call of NewCloud. -func (mr *MockFactoryMockRecorder) NewCloud(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCloud", reflect.TypeOf((*MockFactory)(nil).NewCloud), arg0, arg1, arg2) -} diff --git a/cmd/cmdfakes/fake_agent_client_factory.go b/cmd/cmdfakes/fake_agent_client_factory.go new file mode 100644 index 0000000000..1b098a240c --- /dev/null +++ b/cmd/cmdfakes/fake_agent_client_factory.go @@ -0,0 +1,119 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cmdfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-agent/v2/agentclient/http" +) + +type FakeAgentClientFactory struct { + NewAgentClientStub func(string, string, string) (agentclient.AgentClient, error) + newAgentClientMutex sync.RWMutex + newAgentClientArgsForCall []struct { + arg1 string + arg2 string + arg3 string + } + newAgentClientReturns struct { + result1 agentclient.AgentClient + result2 error + } + newAgentClientReturnsOnCall map[int]struct { + result1 agentclient.AgentClient + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeAgentClientFactory) NewAgentClient(arg1 string, arg2 string, arg3 string) (agentclient.AgentClient, error) { + fake.newAgentClientMutex.Lock() + ret, specificReturn := fake.newAgentClientReturnsOnCall[len(fake.newAgentClientArgsForCall)] + fake.newAgentClientArgsForCall = append(fake.newAgentClientArgsForCall, struct { + arg1 string + arg2 string + arg3 string + }{arg1, arg2, arg3}) + stub := fake.NewAgentClientStub + fakeReturns := fake.newAgentClientReturns + fake.recordInvocation("NewAgentClient", []interface{}{arg1, arg2, arg3}) + fake.newAgentClientMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeAgentClientFactory) NewAgentClientCallCount() int { + fake.newAgentClientMutex.RLock() + defer fake.newAgentClientMutex.RUnlock() + return len(fake.newAgentClientArgsForCall) +} + +func (fake *FakeAgentClientFactory) NewAgentClientCalls(stub func(string, string, string) (agentclient.AgentClient, error)) { + fake.newAgentClientMutex.Lock() + defer fake.newAgentClientMutex.Unlock() + fake.NewAgentClientStub = stub +} + +func (fake *FakeAgentClientFactory) NewAgentClientArgsForCall(i int) (string, string, string) { + fake.newAgentClientMutex.RLock() + defer fake.newAgentClientMutex.RUnlock() + argsForCall := fake.newAgentClientArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeAgentClientFactory) NewAgentClientReturns(result1 agentclient.AgentClient, result2 error) { + fake.newAgentClientMutex.Lock() + defer fake.newAgentClientMutex.Unlock() + fake.NewAgentClientStub = nil + fake.newAgentClientReturns = struct { + result1 agentclient.AgentClient + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClientFactory) NewAgentClientReturnsOnCall(i int, result1 agentclient.AgentClient, result2 error) { + fake.newAgentClientMutex.Lock() + defer fake.newAgentClientMutex.Unlock() + fake.NewAgentClientStub = nil + if fake.newAgentClientReturnsOnCall == nil { + fake.newAgentClientReturnsOnCall = make(map[int]struct { + result1 agentclient.AgentClient + result2 error + }) + } + fake.newAgentClientReturnsOnCall[i] = struct { + result1 agentclient.AgentClient + result2 error + }{result1, result2} +} + +func (fake *FakeAgentClientFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeAgentClientFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ http.AgentClientFactory = new(FakeAgentClientFactory) diff --git a/cmd/cmdfakes/fake_deployment_deleter.go b/cmd/cmdfakes/fake_deployment_deleter.go new file mode 100644 index 0000000000..ed09b03eed --- /dev/null +++ b/cmd/cmdfakes/fake_deployment_deleter.go @@ -0,0 +1,112 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cmdfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cmd" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDeploymentDeleter struct { + DeleteDeploymentStub func(bool, ui.Stage) error + deleteDeploymentMutex sync.RWMutex + deleteDeploymentArgsForCall []struct { + arg1 bool + arg2 ui.Stage + } + deleteDeploymentReturns struct { + result1 error + } + deleteDeploymentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDeploymentDeleter) DeleteDeployment(arg1 bool, arg2 ui.Stage) error { + fake.deleteDeploymentMutex.Lock() + ret, specificReturn := fake.deleteDeploymentReturnsOnCall[len(fake.deleteDeploymentArgsForCall)] + fake.deleteDeploymentArgsForCall = append(fake.deleteDeploymentArgsForCall, struct { + arg1 bool + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.DeleteDeploymentStub + fakeReturns := fake.deleteDeploymentReturns + fake.recordInvocation("DeleteDeployment", []interface{}{arg1, arg2}) + fake.deleteDeploymentMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeploymentDeleter) DeleteDeploymentCallCount() int { + fake.deleteDeploymentMutex.RLock() + defer fake.deleteDeploymentMutex.RUnlock() + return len(fake.deleteDeploymentArgsForCall) +} + +func (fake *FakeDeploymentDeleter) DeleteDeploymentCalls(stub func(bool, ui.Stage) error) { + fake.deleteDeploymentMutex.Lock() + defer fake.deleteDeploymentMutex.Unlock() + fake.DeleteDeploymentStub = stub +} + +func (fake *FakeDeploymentDeleter) DeleteDeploymentArgsForCall(i int) (bool, ui.Stage) { + fake.deleteDeploymentMutex.RLock() + defer fake.deleteDeploymentMutex.RUnlock() + argsForCall := fake.deleteDeploymentArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDeploymentDeleter) DeleteDeploymentReturns(result1 error) { + fake.deleteDeploymentMutex.Lock() + defer fake.deleteDeploymentMutex.Unlock() + fake.DeleteDeploymentStub = nil + fake.deleteDeploymentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentDeleter) DeleteDeploymentReturnsOnCall(i int, result1 error) { + fake.deleteDeploymentMutex.Lock() + defer fake.deleteDeploymentMutex.Unlock() + fake.DeleteDeploymentStub = nil + if fake.deleteDeploymentReturnsOnCall == nil { + fake.deleteDeploymentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteDeploymentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentDeleter) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDeploymentDeleter) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ cmd.DeploymentDeleter = new(FakeDeploymentDeleter) diff --git a/cmd/cmdfakes/fake_deployment_state_manager.go b/cmd/cmdfakes/fake_deployment_state_manager.go new file mode 100644 index 0000000000..5801f40f24 --- /dev/null +++ b/cmd/cmdfakes/fake_deployment_state_manager.go @@ -0,0 +1,184 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cmdfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cmd" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDeploymentStateManager struct { + StartDeploymentStub func(ui.Stage) error + startDeploymentMutex sync.RWMutex + startDeploymentArgsForCall []struct { + arg1 ui.Stage + } + startDeploymentReturns struct { + result1 error + } + startDeploymentReturnsOnCall map[int]struct { + result1 error + } + StopDeploymentStub func(bool, ui.Stage) error + stopDeploymentMutex sync.RWMutex + stopDeploymentArgsForCall []struct { + arg1 bool + arg2 ui.Stage + } + stopDeploymentReturns struct { + result1 error + } + stopDeploymentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDeploymentStateManager) StartDeployment(arg1 ui.Stage) error { + fake.startDeploymentMutex.Lock() + ret, specificReturn := fake.startDeploymentReturnsOnCall[len(fake.startDeploymentArgsForCall)] + fake.startDeploymentArgsForCall = append(fake.startDeploymentArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.StartDeploymentStub + fakeReturns := fake.startDeploymentReturns + fake.recordInvocation("StartDeployment", []interface{}{arg1}) + fake.startDeploymentMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeploymentStateManager) StartDeploymentCallCount() int { + fake.startDeploymentMutex.RLock() + defer fake.startDeploymentMutex.RUnlock() + return len(fake.startDeploymentArgsForCall) +} + +func (fake *FakeDeploymentStateManager) StartDeploymentCalls(stub func(ui.Stage) error) { + fake.startDeploymentMutex.Lock() + defer fake.startDeploymentMutex.Unlock() + fake.StartDeploymentStub = stub +} + +func (fake *FakeDeploymentStateManager) StartDeploymentArgsForCall(i int) ui.Stage { + fake.startDeploymentMutex.RLock() + defer fake.startDeploymentMutex.RUnlock() + argsForCall := fake.startDeploymentArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDeploymentStateManager) StartDeploymentReturns(result1 error) { + fake.startDeploymentMutex.Lock() + defer fake.startDeploymentMutex.Unlock() + fake.StartDeploymentStub = nil + fake.startDeploymentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentStateManager) StartDeploymentReturnsOnCall(i int, result1 error) { + fake.startDeploymentMutex.Lock() + defer fake.startDeploymentMutex.Unlock() + fake.StartDeploymentStub = nil + if fake.startDeploymentReturnsOnCall == nil { + fake.startDeploymentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.startDeploymentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentStateManager) StopDeployment(arg1 bool, arg2 ui.Stage) error { + fake.stopDeploymentMutex.Lock() + ret, specificReturn := fake.stopDeploymentReturnsOnCall[len(fake.stopDeploymentArgsForCall)] + fake.stopDeploymentArgsForCall = append(fake.stopDeploymentArgsForCall, struct { + arg1 bool + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.StopDeploymentStub + fakeReturns := fake.stopDeploymentReturns + fake.recordInvocation("StopDeployment", []interface{}{arg1, arg2}) + fake.stopDeploymentMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeploymentStateManager) StopDeploymentCallCount() int { + fake.stopDeploymentMutex.RLock() + defer fake.stopDeploymentMutex.RUnlock() + return len(fake.stopDeploymentArgsForCall) +} + +func (fake *FakeDeploymentStateManager) StopDeploymentCalls(stub func(bool, ui.Stage) error) { + fake.stopDeploymentMutex.Lock() + defer fake.stopDeploymentMutex.Unlock() + fake.StopDeploymentStub = stub +} + +func (fake *FakeDeploymentStateManager) StopDeploymentArgsForCall(i int) (bool, ui.Stage) { + fake.stopDeploymentMutex.RLock() + defer fake.stopDeploymentMutex.RUnlock() + argsForCall := fake.stopDeploymentArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDeploymentStateManager) StopDeploymentReturns(result1 error) { + fake.stopDeploymentMutex.Lock() + defer fake.stopDeploymentMutex.Unlock() + fake.StopDeploymentStub = nil + fake.stopDeploymentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentStateManager) StopDeploymentReturnsOnCall(i int, result1 error) { + fake.stopDeploymentMutex.Lock() + defer fake.stopDeploymentMutex.Unlock() + fake.StopDeploymentStub = nil + if fake.stopDeploymentReturnsOnCall == nil { + fake.stopDeploymentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.stopDeploymentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentStateManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDeploymentStateManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ cmd.DeploymentStateManager = new(FakeDeploymentStateManager) diff --git a/cmd/create_env_test.go b/cmd/create_env_test.go index 00b1a70a48..5a94fd5b67 100644 --- a/cmd/create_env_test.go +++ b/cmd/create_env_test.go @@ -7,40 +7,41 @@ import ( "path/filepath" "regexp" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/onsi/gomega/gbytes" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mockblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + biblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - mockcloud "github.com/cloudfoundry/bosh-cli/v7/cloud/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - mockconfig "github.com/cloudfoundry/bosh-cli/v7/config/mocks" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bicpirel "github.com/cloudfoundry/bosh-cli/v7/cpi/release" "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/deployment/deploymentfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" fakebideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest/manifestfakes" - mockdeployment "github.com/cloudfoundry/bosh-cli/v7/deployment/mocks" bidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template" fakebidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template/templatefakes" + bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" - mockvm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" fakebiinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest/fakes" - mockinstall "github.com/cloudfoundry/bosh-cli/v7/installation/mocks" bitarball "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" boshrel "github.com/cloudfoundry/bosh-cli/v7/release" boshjob "github.com/cloudfoundry/bosh-cli/v7/release/job" @@ -50,26 +51,13 @@ import ( birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" fakebirelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/fakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - mockstemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/mocks" + "github.com/cloudfoundry/bosh-cli/v7/stemcell/mockfakes" fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" boshui "github.com/cloudfoundry/bosh-cli/v7/ui" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("CreateEnvCmd", func() { - var mockCtrl *gomock.Controller - var mockCloudCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - mockCloudCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - mockCloudCtrl.Finish() - }) - Describe("Run", func() { const ( directorID = "generated-director-uuid" @@ -84,34 +72,34 @@ var _ = Describe("CreateEnvCmd", func() { userInterface boshui.UI manifestSHA string - mockDeployer *mockdeployment.MockDeployer - mockInstaller *mockinstall.MockInstaller - mockInstallerFactory *mockinstall.MockInstallerFactory + mockDeployer *deploymentfakes.FakeDeployer + mockInstaller *installationfakes.FakeInstaller + mockInstallerFactory *installationfakes.FakeInstallerFactory releaseReader *fakebirel.FakeReader releaseManager biinstall.ReleaseManager - mockAgentClient *mockagentclient.MockAgentClient - mockAgentClientFactory *mockhttpagent.MockAgentClientFactory - mockCloudFactory *mockcloud.MockFactory - mockCloud *mockcloud.MockCloud + mockAgentClient *agentclientfakes.FakeAgentClient + mockAgentClientFactory *cmdfakes.FakeAgentClientFactory + mockCloudFactory *cloudfakes.FakeFactory + mockCloud *cloudfakes.FakeCloud cpiRelease *fakebirel.FakeRelease logger boshlog.Logger - mockBlobstoreFactory *mockblobstore.MockFactory - mockBlobstore *mockblobstore.MockBlobstore + mockBlobstoreFactory *blobstorefakes.FakeFactory + mockBlobstore *blobstorefakes.FakeBlobstore - mockVMManagerFactory *mockvm.MockManagerFactory + mockVMManagerFactory *vmfakes.FakeManagerFactory fakeVMManager *fakebivm.FakeManager fakeStemcellExtractor *fakebistemcell.FakeExtractor - mockStemcellManager *mockstemcell.MockManager + mockStemcellManager *mockfakes.FakeManager fakeStemcellManagerFactory *fakebistemcell.FakeManagerFactory fakeReleaseSetParser *fakebirelsetmanifest.FakeParser fakeInstallationParser *fakebiinstallmanifest.FakeParser fakeDeploymentParser *fakebideplmanifest.FakeParser fakeDeploymentTemplateFactory *fakebidepltpl.FakeDeploymentTemplateFactory - mockLegacyDeploymentStateMigrator *mockconfig.MockLegacyDeploymentStateMigrator + mockLegacyDeploymentStateMigrator *configfakes.FakeLegacyDeploymentStateMigrator setupDeploymentStateService biconfig.DeploymentStateService fakeDeploymentValidator *fakebideplmanifest.FakeValidator @@ -128,8 +116,6 @@ var _ = Describe("CreateEnvCmd", func() { cpiApiVersion int extractedStemcell bistemcell.ExtractedStemcell - expectDeploy *gomock.Call - releaseSetManifest birelsetmanifest.Manifest template bidepltpl.DeploymentTemplate boshDeploymentManifest bideplmanifest.Manifest @@ -141,12 +127,6 @@ var _ = Describe("CreateEnvCmd", func() { expectedSkipDrain bool - expectLegacyMigrate *gomock.Call - expectStemcellUpload *gomock.Call - expectStemcellDeleteUnused *gomock.Call - expectInstall *gomock.Call - expectNewCloud *gomock.Call - expectedDeployError error ) @@ -168,29 +148,29 @@ var _ = Describe("CreateEnvCmd", func() { err := fs.WriteFileString(deploymentManifestPath, "") Expect(err).ToNot(HaveOccurred()) - mockDeployer = mockdeployment.NewMockDeployer(mockCtrl) - mockInstaller = mockinstall.NewMockInstaller(mockCtrl) - mockInstallerFactory = mockinstall.NewMockInstallerFactory(mockCtrl) + mockDeployer = &deploymentfakes.FakeDeployer{} + mockInstaller = &installationfakes.FakeInstaller{} + mockInstallerFactory = &installationfakes.FakeInstallerFactory{} releaseReader = &fakebirel.FakeReader{} releaseManager = biinstall.NewReleaseManager(logger) - mockAgentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) - mockAgentClient = mockagentclient.NewMockAgentClient(mockCtrl) - mockAgentClientFactory.EXPECT().NewAgentClient(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockAgentClient, nil).AnyTimes() + mockAgentClientFactory = &cmdfakes.FakeAgentClientFactory{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} + mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) - mockCloudFactory = mockcloud.NewMockFactory(mockCtrl) + mockCloudFactory = &cloudfakes.FakeFactory{} - mockBlobstoreFactory = mockblobstore.NewMockFactory(mockCtrl) - mockBlobstore = mockblobstore.NewMockBlobstore(mockCtrl) - mockBlobstoreFactory.EXPECT().Create(mbusURL, SecureTLSClientMatcher()).Return(mockBlobstore, nil).AnyTimes() + mockBlobstoreFactory = &blobstorefakes.FakeFactory{} + mockBlobstore = &blobstorefakes.FakeBlobstore{} + mockBlobstoreFactory.CreateReturns(mockBlobstore, nil) - mockVMManagerFactory = mockvm.NewMockManagerFactory(mockCtrl) + mockVMManagerFactory = &vmfakes.FakeManagerFactory{} fakeVMManager = fakebivm.NewFakeManager() - mockVMManagerFactory.EXPECT().NewManager(gomock.Any(), mockAgentClient).Return(fakeVMManager).AnyTimes() + mockVMManagerFactory.NewManagerReturns(fakeVMManager) fakeStemcellExtractor = fakebistemcell.NewFakeExtractor() - mockStemcellManager = mockstemcell.NewMockManager(mockCtrl) + mockStemcellManager = &mockfakes.FakeManager{} fakeStemcellManagerFactory = fakebistemcell.NewFakeManagerFactory() fakeReleaseSetParser = fakebirelsetmanifest.NewFakeParser() @@ -198,7 +178,7 @@ var _ = Describe("CreateEnvCmd", func() { fakeDeploymentParser = &fakebideplmanifest.FakeParser{} fakeDeploymentTemplateFactory = &fakebidepltpl.FakeDeploymentTemplateFactory{} - mockLegacyDeploymentStateMigrator = mockconfig.NewMockLegacyDeploymentStateMigrator(mockCtrl) + mockLegacyDeploymentStateMigrator = &configfakes.FakeLegacyDeploymentStateMigrator{} configUUIDGenerator = &fakeuuid.FakeGenerator{} configUUIDGenerator.GeneratedUUID = directorID @@ -380,7 +360,7 @@ var _ = Describe("CreateEnvCmd", func() { command = cmd.NewCreateEnvCmd(userInterface, doGet) - expectLegacyMigrate = mockLegacyDeploymentStateMigrator.EXPECT().MigrateIfExists(filepath.Join("/", "path", "to", "bosh-deployments.yml")).AnyTimes() + mockLegacyDeploymentStateMigrator.MigrateIfExistsReturns(false, nil) extractedStemcell = bistemcell.NewExtractedStemcell( bistemcell.Manifest{ @@ -400,17 +380,17 @@ var _ = Describe("CreateEnvCmd", func() { cloudStemcell = fakebistemcell.NewFakeCloudStemcell( "fake-stemcell-cid", "fake-stemcell-name", "fake-stemcell-version", stemcellApiVersion) - mockCloud = mockcloud.NewMockCloud(mockCloudCtrl) - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil).AnyTimes() - mockCloud.EXPECT().String().AnyTimes() + mockCloud = &cloudfakes.FakeCloud{} + mockCloud.InfoReturns(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil) + mockCloud.StringReturns("") fakeStemcellExtractor.SetExtractBehavior(stemcellTarballPath, extractedStemcell, nil) fakeStemcellManagerFactory.SetNewManagerBehavior(mockCloud, mockStemcellManager) - expectStemcellUpload = mockStemcellManager.EXPECT().Upload(extractedStemcell, fakeStage).Return(cloudStemcell, nil).AnyTimes() + mockStemcellManager.UploadReturns(cloudStemcell, nil) - expectStemcellDeleteUnused = mockStemcellManager.EXPECT().DeleteUnused(fakeStage).AnyTimes() + mockStemcellManager.DeleteUnusedReturns(nil) fakeReleaseSetParser.ParseManifest = releaseSetManifest template := bidepltpl.NewDeploymentTemplate([]byte("--- {\"test\":true}")) @@ -428,30 +408,23 @@ var _ = Describe("CreateEnvCmd", func() { filepath.Join(target.JobsPath(), "fake-cpi-release-job-name"), ) - mockInstallerFactory.EXPECT().NewInstaller(target).Return(mockInstaller).AnyTimes() + mockInstallerFactory.NewInstallerReturns(mockInstaller) installation := biinstall.NewInstallation(target, []biinstall.InstalledJob{installedJob}, installationManifest) - expectInstall = mockInstaller.EXPECT().Install(installationManifest, gomock.Any()).Do(func(_ interface{}, stage boshui.Stage) { + mockInstaller.InstallStub = func(_ biinstallmanifest.Manifest, stage boshui.Stage) (biinstall.Installation, error) { Expect(fakeStage.SubStages).To(ContainElement(stage)) - }).Return(installation, nil).AnyTimes() - mockInstaller.EXPECT().Cleanup(installation).AnyTimes() - - expectDeploy = mockDeployer.EXPECT().Deploy( - mockCloud, - boshDeploymentManifest, - cloudStemcell, - fakeVMManager, - mockBlobstore, - expectedSkipDrain, - gomock.Any(), - gomock.Any(), - ).Do(func(_, _, _, _, _, _ interface{}, _ interface{}, stage boshui.Stage) { + return installation, nil + } + mockInstaller.CleanupReturns(nil) + + mockDeployer.DeployStub = func(_ bicloud.Cloud, _ bideplmanifest.Manifest, _ bistemcell.CloudStemcell, _ bivm.Manager, _ biblobstore.Blobstore, _ bool, _ []string, stage boshui.Stage) (deployment.Deployment, error) { Expect(fakeStage.SubStages).To(ContainElement(stage)) - }).Return(nil, expectedDeployError).AnyTimes() + return nil, expectedDeployError + } - expectNewCloud = mockCloudFactory.EXPECT().NewCloud(installation, directorID, stemcellApiVersion).Return(mockCloud, nil).AnyTimes() + mockCloudFactory.NewCloudReturns(mockCloud, nil) }) Describe("prints the deployment manifest and state file", func() { @@ -489,22 +462,22 @@ var _ = Describe("CreateEnvCmd", func() { err := fs.WriteFileString(deploymentStatePath, "{}") Expect(err).ToNot(HaveOccurred()) - expectLegacyMigrate.Times(0) - err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) Expect(fakeInstallationParser.ParsePath).To(Equal(deploymentManifestPath)) + Expect(mockLegacyDeploymentStateMigrator.MigrateIfExistsCallCount()).To(Equal(0)) }) It("migrates the legacy bosh-deployments.yml if manifest-state.json does not exist", func() { err := fs.RemoveAll(deploymentStatePath) Expect(err).ToNot(HaveOccurred()) - expectLegacyMigrate.Return(true, nil).Times(1) + mockLegacyDeploymentStateMigrator.MigrateIfExistsReturns(true, nil) err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) Expect(fakeInstallationParser.ParsePath).To(Equal(deploymentManifestPath)) + Expect(mockLegacyDeploymentStateMigrator.MigrateIfExistsCallCount()).To(Equal(1)) Expect(stdOut).To(gbytes.Say("Deployment manifest: '" + regexp.QuoteMeta(filepath.Join("/", "path", "to", "manifest.yml")) + "'")) Expect(stdOut).To(gbytes.Say("Deployment state: '" + regexp.QuoteMeta(filepath.Join("/", "path", "to", "manifest-state.json")) + "'")) @@ -577,11 +550,10 @@ var _ = Describe("CreateEnvCmd", func() { }) It("installs the CPI locally", func() { - expectInstall.Times(1) - expectNewCloud.Times(1) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockInstaller.InstallCallCount()).To(Equal(1)) + Expect(mockCloudFactory.NewCloudCallCount()).To(Equal(1)) }) It("adds a new 'installing CPI' event logger stage", func() { @@ -609,10 +581,9 @@ var _ = Describe("CreateEnvCmd", func() { }) It("uploads the stemcell", func() { - expectStemcellUpload.Times(1) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).ToNot(HaveOccurred()) + Expect(mockStemcellManager.UploadCallCount()).To(Equal(1)) }) It("adds a new 'deploying' event logger stage", func() { @@ -626,10 +597,9 @@ var _ = Describe("CreateEnvCmd", func() { }) It("deploys", func() { - expectDeploy.Times(1) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockDeployer.DeployCallCount()).To(Equal(1)) }) It("updates the deployment record", func() { @@ -650,10 +620,9 @@ var _ = Describe("CreateEnvCmd", func() { }) It("deletes unused stemcells", func() { - expectStemcellDeleteUnused.Times(1) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockStemcellManager.DeleteUnusedCallCount()).To(Equal(1)) }) Context("when SkipDrain is specified", func() { @@ -662,12 +631,14 @@ var _ = Describe("CreateEnvCmd", func() { }) It("passes it through", func() { - expectDeploy.Times(1) - defaultCreateEnvOpts.SkipDrain = true err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + + Expect(mockDeployer.DeployCallCount()).To(Equal(1)) + _, _, _, _, _, gotSkipDrain, _, _ := mockDeployer.DeployArgsForCall(0) + Expect(gotSkipDrain).To(Equal(expectedSkipDrain)) }) }) @@ -695,29 +666,26 @@ var _ = Describe("CreateEnvCmd", func() { }) It("skips deploy", func() { - expectDeploy.Times(0) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) Expect(stdOut).To(gbytes.Say("No deployment, stemcell or release changes. Skipping deploy.")) + Expect(mockDeployer.DeployCallCount()).To(Equal(0)) }) It("deploys if `recreate` flag is specified", func() { - expectDeploy.Times(1) - defaultCreateEnvOpts.Recreate = true err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockDeployer.DeployCallCount()).To(Equal(1)) }) It("deploys if `recreate-persistent-disks` flag is specified", func() { - expectDeploy.Times(1) - defaultCreateEnvOpts.RecreatePersistentDisks = true err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockDeployer.DeployCallCount()).To(Equal(1)) }) }) @@ -796,11 +764,10 @@ var _ = Describe("CreateEnvCmd", func() { }) It("installs the CPI release locally", func() { - expectInstall.Times(1) - expectNewCloud.Times(1) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockInstaller.InstallCallCount()).To(Equal(1)) + Expect(mockCloudFactory.NewCloudCallCount()).To(Equal(1)) }) It("updates the deployment record", func() { @@ -910,20 +877,18 @@ var _ = Describe("CreateEnvCmd", func() { }) It("skips deploy", func() { - expectDeploy.Times(0) - err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) Expect(stdOut).To(gbytes.Say("No deployment, stemcell or release changes. Skipping deploy.")) + Expect(mockDeployer.DeployCallCount()).To(Equal(0)) }) It("deploys if recreate flag is specified", func() { - expectDeploy.Times(1) - defaultCreateEnvOpts.Recreate = true err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + Expect(mockDeployer.DeployCallCount()).To(Equal(1)) }) }) }) @@ -1045,7 +1010,7 @@ var _ = Describe("CreateEnvCmd", func() { Context("when uploading stemcell fails", func() { JustBeforeEach(func() { - expectStemcellUpload.Return(nil, bosherr.Error("fake-upload-error")) + mockStemcellManager.UploadReturns(nil, bosherr.Error("fake-upload-error")) }) It("returns an error", func() { @@ -1059,17 +1024,6 @@ var _ = Describe("CreateEnvCmd", func() { BeforeEach(func() { expectedDeployError = errors.New("fake-deploy-error") - mockDeployer.EXPECT().Deploy( - mockCloud, - boshDeploymentManifest, - cloudStemcell, - fakeVMManager, - mockBlobstore, - expectedSkipDrain, - gomock.Any(), - gomock.Any(), - ).Return(nil, expectedDeployError).AnyTimes() - previousDeploymentState := biconfig.DeploymentState{ CurrentReleaseIDs: []string{"my-release-id-1"}, Releases: []biconfig.ReleaseRecord{{ @@ -1139,11 +1093,11 @@ var _ = Describe("CreateEnvCmd", func() { }`) Expect(err).ToNot(HaveOccurred()) - expectDeploy.Do(func(_, _, _, _, _, _ interface{}, diskCIDs []string, _ interface{}) { - Expect(diskCIDs).To(ConsistOf("disk-cid-from-state")) - }) err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + + _, _, _, _, _, _, diskCIDs, _ := mockDeployer.DeployArgsForCall(0) + Expect(diskCIDs).To(ConsistOf("disk-cid-from-state")) }) It("constructs and empty array of disks using make, due to odd behavior in golang where empty var []string marshals as null", func() { @@ -1153,13 +1107,13 @@ var _ = Describe("CreateEnvCmd", func() { }`) Expect(err).ToNot(HaveOccurred()) - expectDeploy.Do(func(_, _, _, _, _, _ interface{}, diskCIDs []string, _ interface{}) { - jsonMarshalOfDisks, err := json.Marshal(diskCIDs) - Expect(err).ToNot(HaveOccurred()) - Expect(string(jsonMarshalOfDisks)).To(Equal("[]")) - }) err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) + + _, _, _, _, _, _, diskCIDs, _ := mockDeployer.DeployArgsForCall(0) + jsonMarshalOfDisks, err := json.Marshal(diskCIDs) + Expect(err).ToNot(HaveOccurred()) + Expect(string(jsonMarshalOfDisks)).To(Equal("[]")) }) }) }) diff --git a/cmd/delete_env_test.go b/cmd/delete_env_test.go index 391c4081ac..100d271aa4 100644 --- a/cmd/delete_env_test.go +++ b/cmd/delete_env_test.go @@ -4,31 +4,20 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/cloudfoundry/bosh-cli/v7/cmd" - mockcmd "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("DeleteEnvCmd", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( - mockDeploymentDeleter *mockcmd.MockDeploymentDeleter + mockDeploymentDeleter *cmdfakes.FakeDeploymentDeleter fs *fakesys.FakeFileSystem fakeUI *fakeui.FakeUI @@ -56,7 +45,7 @@ var _ = Describe("DeleteEnvCmd", func() { } BeforeEach(func() { - mockDeploymentDeleter = mockcmd.NewMockDeploymentDeleter(mockCtrl) + mockDeploymentDeleter = &cmdfakes.FakeDeploymentDeleter{} fs = fakesys.NewFakeFileSystem() fs.EnableStrictTempRootBehavior() fakeUI = &fakeui.FakeUI{} @@ -67,7 +56,7 @@ var _ = Describe("DeleteEnvCmd", func() { Context("when skip drain is specified", func() { It("gets passed to DeleteDeployment", func() { skipDrain = true - mockDeploymentDeleter.EXPECT().DeleteDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentDeleter.DeleteDeploymentReturns(nil) err := newDeleteEnvCmd().Run(fakeStage, opts.DeleteEnvOpts{ Args: opts.DeleteEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, @@ -83,12 +72,17 @@ var _ = Describe("DeleteEnvCmd", func() { }, }) Expect(err).ToNot(HaveOccurred()) + + Expect(mockDeploymentDeleter.DeleteDeploymentCallCount()).To(Equal(1)) + actualSkipDrain, actualStage := mockDeploymentDeleter.DeleteDeploymentArgsForCall(0) + Expect(actualSkipDrain).To(BeTrue()) + Expect(actualStage).To(Equal(fakeStage)) }) }) Context("state path is NOT specified", func() { It("sends the manifest on to the deleter", func() { - mockDeploymentDeleter.EXPECT().DeleteDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentDeleter.DeleteDeploymentReturns(nil) err := newDeleteEnvCmd().Run(fakeStage, opts.DeleteEnvOpts{ Args: opts.DeleteEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, @@ -111,7 +105,7 @@ var _ = Describe("DeleteEnvCmd", func() { Context("state path is specified", func() { It("sends the manifest on to the deleter", func() { - mockDeploymentDeleter.EXPECT().DeleteDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentDeleter.DeleteDeploymentReturns(nil) err := newDeleteEnvCmd().Run(fakeStage, opts.DeleteEnvOpts{ StatePath: "/new/state/file/path/state.json", SkipDrain: skipDrain, @@ -136,7 +130,7 @@ var _ = Describe("DeleteEnvCmd", func() { Context("when the deployment deleter returns an error", func() { It("sends the manifest on to the deleter", func() { err := bosherr.Error("boom") - mockDeploymentDeleter.EXPECT().DeleteDeployment(skipDrain, fakeStage).Return(err) + mockDeploymentDeleter.DeleteDeploymentReturns(err) returnedErr := newDeleteEnvCmd().Run(fakeStage, opts.DeleteEnvOpts{ Args: opts.DeleteEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, diff --git a/cmd/deployment_deleter.go b/cmd/deployment_deleter.go index d761c8feee..c6d1d4eb74 100644 --- a/cmd/deployment_deleter.go +++ b/cmd/deployment_deleter.go @@ -19,6 +19,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . DeploymentDeleter + type DeploymentDeleter interface { DeleteDeployment(skipDrain bool, stage biui.Stage) (err error) } diff --git a/cmd/deployment_deleter_test.go b/cmd/deployment_deleter_test.go index 5949745a2d..c1f3230fa3 100644 --- a/cmd/deployment_deleter_test.go +++ b/cmd/deployment_deleter_test.go @@ -5,29 +5,27 @@ import ( "os" "path/filepath" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" - biproperty "github.com/cloudfoundry/bosh-utils/property" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mockblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" - mockcloud "github.com/cloudfoundry/bosh-cli/v7/cloud/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" + bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" fakecmd "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" bicpirel "github.com/cloudfoundry/bosh-cli/v7/cpi/release" - mockdeployment "github.com/cloudfoundry/bosh-cli/v7/deployment/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/deploymentfakes" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - mockinstall "github.com/cloudfoundry/bosh-cli/v7/installation/mocks" bitarball "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" boshrel "github.com/cloudfoundry/bosh-cli/v7/release" boshjob "github.com/cloudfoundry/bosh-cli/v7/release/job" @@ -40,42 +38,32 @@ import ( ) var _ = Describe("DeploymentDeleter", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("DeleteDeployment", func() { var ( fs *fakesys.FakeFileSystem logger boshlog.Logger releaseReader *fakerel.FakeReader releaseManager boshrel.Manager - mockCpiInstaller *mockinstall.MockInstaller - mockCpiUninstaller *mockinstall.MockUninstaller - mockInstallerFactory *mockinstall.MockInstallerFactory - mockCloudFactory *mockcloud.MockFactory + mockCpiInstaller *installationfakes.FakeInstaller + mockCpiUninstaller *installationfakes.FakeUninstaller + mockInstallerFactory *installationfakes.FakeInstallerFactory + mockCloudFactory *cloudfakes.FakeFactory fakeUUIDGenerator *fakeuuid.FakeGenerator setupDeploymentStateService biconfig.DeploymentStateService fakeInstallation *fakecmd.FakeInstallation fakeUI *fakeui.FakeUI - mockBlobstoreFactory *mockblobstore.MockFactory - mockBlobstore *mockblobstore.MockBlobstore + mockBlobstoreFactory *blobstorefakes.FakeFactory + mockBlobstore *blobstorefakes.FakeBlobstore - mockDeploymentManagerFactory *mockdeployment.MockManagerFactory - mockDeploymentManager *mockdeployment.MockManager - mockDeployment *mockdeployment.MockDeployment + mockDeploymentManagerFactory *deploymentfakes.FakeManagerFactory + mockDeploymentManager *deploymentfakes.FakeManager + mockDeployment *deploymentfakes.FakeDeployment - mockAgentClient *mockagentclient.MockAgentClient - mockAgentClientFactory *mockhttpagent.MockAgentClientFactory - mockCloud *mockcloud.MockCloud + mockAgentClient *agentclientfakes.FakeAgentClient + mockAgentClientFactory *fakecmd.FakeAgentClientFactory + mockCloud *cloudfakes.FakeCloud fakeStage *fakeui.FakeStage @@ -84,8 +72,9 @@ var _ = Describe("DeploymentDeleter", func() { deploymentManifestPath = "/deployment-dir/fake-deployment-manifest.yml" deploymentStatePath string - expectCPIInstall *gomock.Call - expectNewCloud *gomock.Call + // callOrder records, in invocation order, calls to Install/NewCloud/Delete/Cleanup + // made during a test -- the counterfeiter equivalent of gomock.InOrder(). + callOrder []string mbusURL = "http://fake-mbus-user:fake-mbus-password@fake-mbus-endpoint" stemcellApiVersionForDelete = 1 @@ -181,27 +170,19 @@ cloud_provider: } var allowCPIToBeInstalled = func() { - installationManifest := biinstallmanifest.Manifest{ - Name: "test-release", - Templates: []biinstallmanifest.ReleaseJobRef{ - {Name: "fake-cpi-release-job-name", Release: "fake-cpi-release-name"}, - }, - Mbus: mbusURL, - Properties: biproperty.Map{}, - Cert: biinstallmanifest.Certificate{ - CA: certificate, - }, - } - - target := biinstall.NewTarget(filepath.Join("fake-install-dir", "fake-installation-id"), "") - mockInstallerFactory.EXPECT().NewInstaller(target).Return(mockCpiInstaller).AnyTimes() + mockInstallerFactory.NewInstallerReturns(mockCpiInstaller) - expectCPIInstall = mockCpiInstaller.EXPECT().Install(installationManifest, gomock.Any()).Do(func(_ biinstallmanifest.Manifest, stage boshui.Stage) { + mockCpiInstaller.InstallStub = func(manifest biinstallmanifest.Manifest, stage boshui.Stage) (biinstall.Installation, error) { + callOrder = append(callOrder, "Install") Expect(fakeStage.SubStages).To(ContainElement(stage)) - }).Return(fakeInstallation, nil).AnyTimes() - mockCpiInstaller.EXPECT().Cleanup(fakeInstallation).AnyTimes() + return fakeInstallation, nil + } + mockCpiInstaller.CleanupReturns(nil) - expectNewCloud = mockCloudFactory.EXPECT().NewCloud(fakeInstallation, directorID, stemcellApiVersionForDelete).Return(mockCloud, nil).AnyTimes() + mockCloudFactory.NewCloudStub = func(installation biinstall.Installation, directorID string, stemcellApiVersion int) (bicloud.Cloud, error) { + callOrder = append(callOrder, "NewCloud") + return mockCloud, nil + } } var newDeploymentDeleter = func() cmd.DeploymentDeleter { @@ -256,26 +237,29 @@ cloud_provider: } var expectDeleteAndCleanup = func(skipDrain, defaultUninstallerUsed bool) { - mockDeploymentManagerFactory.EXPECT().NewManager(mockCloud, mockAgentClient, mockBlobstore).Return(mockDeploymentManager) - mockDeploymentManager.EXPECT().FindCurrent().Return(mockDeployment, true, nil) + mockDeploymentManagerFactory.NewManagerReturns(mockDeploymentManager) + mockDeploymentManager.FindCurrentReturns(mockDeployment, true, nil) - gomock.InOrder( - mockDeployment.EXPECT().Delete(skipDrain, gomock.Any()).Do(func(_ bool, stage boshui.Stage) { - Expect(fakeStage.SubStages).To(ContainElement(stage)) - }), - mockDeploymentManager.EXPECT().Cleanup(fakeStage), - ) + mockDeployment.DeleteStub = func(_ bool, stage boshui.Stage) error { + callOrder = append(callOrder, "Delete") + Expect(fakeStage.SubStages).To(ContainElement(stage)) + return nil + } + mockDeploymentManager.CleanupStub = func(stage boshui.Stage) error { + callOrder = append(callOrder, "Cleanup") + return nil + } if defaultUninstallerUsed { - mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil) + mockCpiUninstaller.UninstallReturns(nil) } } var expectCleanup = func() { - mockDeploymentManagerFactory.EXPECT().NewManager(mockCloud, mockAgentClient, mockBlobstore).Return(mockDeploymentManager).AnyTimes() - mockDeploymentManager.EXPECT().FindCurrent().Return(nil, false, nil).AnyTimes() + mockDeploymentManagerFactory.NewManagerReturns(mockDeploymentManager) + mockDeploymentManager.FindCurrentReturns(nil, false, nil) - mockDeploymentManager.EXPECT().Cleanup(fakeStage) - mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil) + mockDeploymentManager.CleanupReturns(nil) + mockCpiUninstaller.UninstallReturns(nil) } var expectValidationInstallationDeletionEvents = func() { @@ -328,37 +312,35 @@ cloud_provider: fakeStage = fakeui.NewFakeStage() - mockCloud = mockcloud.NewMockCloud(mockCtrl) - mockCloudFactory = mockcloud.NewMockFactory(mockCtrl) + callOrder = nil - mockCpiInstaller = mockinstall.NewMockInstaller(mockCtrl) - mockCpiUninstaller = mockinstall.NewMockUninstaller(mockCtrl) - mockInstallerFactory = mockinstall.NewMockInstallerFactory(mockCtrl) + mockCloud = &cloudfakes.FakeCloud{} + mockCloudFactory = &cloudfakes.FakeFactory{} + + mockCpiInstaller = &installationfakes.FakeInstaller{} + mockCpiUninstaller = &installationfakes.FakeUninstaller{} + mockInstallerFactory = &installationfakes.FakeInstallerFactory{} fakeInstallation = &fakecmd.FakeInstallation{} - mockBlobstoreFactory = mockblobstore.NewMockFactory(mockCtrl) - mockBlobstore = mockblobstore.NewMockBlobstore(mockCtrl) - mockBlobstoreFactory.EXPECT().Create(mbusURL, SecureTLSClientMatcher()).Return(mockBlobstore, nil).AnyTimes() + mockBlobstoreFactory = &blobstorefakes.FakeFactory{} + mockBlobstore = &blobstorefakes.FakeBlobstore{} + mockBlobstoreFactory.CreateReturns(mockBlobstore, nil) - mockDeploymentManagerFactory = mockdeployment.NewMockManagerFactory(mockCtrl) - mockDeploymentManager = mockdeployment.NewMockManager(mockCtrl) - mockDeployment = mockdeployment.NewMockDeployment(mockCtrl) + mockDeploymentManagerFactory = &deploymentfakes.FakeManagerFactory{} + mockDeploymentManager = &deploymentfakes.FakeManager{} + mockDeployment = &deploymentfakes.FakeDeployment{} releaseReader = &fakerel.FakeReader{} releaseManager = biinstall.NewReleaseManager(logger) - mockAgentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) - mockAgentClient = mockagentclient.NewMockAgentClient(mockCtrl) + mockAgentClientFactory = &fakecmd.FakeAgentClientFactory{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} directorID = "fake-uuid-0" skipDrain = false - mockAgentClientFactory.EXPECT().NewAgentClient( - directorID, - "http://fake-mbus-user:fake-mbus-password@fake-mbus-endpoint", - certificate, - ).Return(mockAgentClient, nil).AnyTimes() + mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) writeDeploymentManifest() writeCPIReleaseTarball() @@ -423,6 +405,11 @@ cloud_provider: expectDeleteAndCleanup(true, true) err := newDeploymentDeleter().DeleteDeployment(true, fakeStage) Expect(err).ToNot(HaveOccurred()) + + Expect(mockCloudFactory.NewCloudCallCount()).To(Equal(1)) + _, gotDirectorID, gotStemcellApiVersion := mockCloudFactory.NewCloudArgsForCall(0) + Expect(gotDirectorID).To(Equal(directorID)) + Expect(gotStemcellApiVersion).To(Equal(stemcellApiVersionForDelete)) }) }) @@ -445,13 +432,21 @@ cloud_provider: It("extracts & install CPI release tarball", func() { expectDeleteAndCleanup(skipDrain, true) - gomock.InOrder( - expectCPIInstall.Times(1), - expectNewCloud.Times(1), - ) - err := newDeploymentDeleter().DeleteDeployment(skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) + + installIndex := -1 + newCloudIndex := -1 + for i, name := range callOrder { + switch name { + case "Install": + installIndex = i + case "NewCloud": + newCloudIndex = i + } + } + Expect(installIndex).To(BeNumerically(">=", 0), "Install should have been called") + Expect(newCloudIndex).To(BeNumerically(">", installIndex), "NewCloud should have been called after Install") }) It("deletes the extracted CPI release", func() { @@ -468,11 +463,22 @@ cloud_provider: err := newDeploymentDeleter().DeleteDeployment(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) Expect(fakeUI.Errors).To(BeEmpty()) + + Expect(mockBlobstoreFactory.CreateCallCount()).To(Equal(1)) + gotURL, gotClient := mockBlobstoreFactory.CreateArgsForCall(0) + Expect(gotURL).To(Equal(mbusURL)) + Expect(gotClient).To(SecureTLSClientMatcher()) + + Expect(mockAgentClientFactory.NewAgentClientCallCount()).To(Equal(1)) + gotDirectorID, gotMbusURL, gotCert := mockAgentClientFactory.NewAgentClientArgsForCall(0) + Expect(gotDirectorID).To(Equal(directorID)) + Expect(gotMbusURL).To(Equal(mbusURL)) + Expect(gotCert).To(Equal(certificate)) }) It("deletes the local CPI installation", func() { expectDeleteAndCleanup(skipDrain, false) - mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil) + mockCpiUninstaller.UninstallReturns(nil) err := newDeploymentDeleter().DeleteDeployment(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -523,39 +529,27 @@ cloud_provider: Context("when the CPI fails to Delete", func() { JustBeforeEach(func() { - installationManifest := biinstallmanifest.Manifest{ - Name: "test-release", - Templates: []biinstallmanifest.ReleaseJobRef{ - {Name: "fake-cpi-release-job-name", Release: "fake-cpi-release-name"}, - }, - Mbus: mbusURL, - Properties: biproperty.Map{}, - Cert: biinstallmanifest.Certificate{ - CA: certificate, - }, - } - - target := biinstall.NewTarget(filepath.Join("fake-install-dir", "fake-installation-id"), "") - mockInstallerFactory.EXPECT().NewInstaller(target).Return(mockCpiInstaller).AnyTimes() + mockInstallerFactory.NewInstallerReturns(mockCpiInstaller) fakeInstallation := &fakecmd.FakeInstallation{} - expectCPIInstall = mockCpiInstaller.EXPECT().Install(installationManifest, gomock.Any()).Do(func(_ biinstallmanifest.Manifest, stage boshui.Stage) { + mockCpiInstaller.InstallStub = func(manifest biinstallmanifest.Manifest, stage boshui.Stage) (biinstall.Installation, error) { Expect(fakeStage.SubStages).To(ContainElement(stage)) - }).Return(fakeInstallation, nil).AnyTimes() - mockCpiInstaller.EXPECT().Cleanup(fakeInstallation).AnyTimes() + return fakeInstallation, nil + } + mockCpiInstaller.CleanupReturns(nil) - expectNewCloud = mockCloudFactory.EXPECT().NewCloud(fakeInstallation, directorID, stemcellApiVersionForDelete).Return(mockCloud, nil).AnyTimes() + mockCloudFactory.NewCloudReturns(mockCloud, nil) }) Context("when the call to delete the deployment returns an error", func() { It("returns the error", func() { - mockDeploymentManagerFactory.EXPECT().NewManager(mockCloud, mockAgentClient, mockBlobstore).Return(mockDeploymentManager) - mockDeploymentManager.EXPECT().FindCurrent().Return(mockDeployment, true, nil) + mockDeploymentManagerFactory.NewManagerReturns(mockDeploymentManager) + mockDeploymentManager.FindCurrentReturns(mockDeployment, true, nil) deleteError := bosherr.Error("delete error") - mockDeployment.EXPECT().Delete(skipDrain, gomock.Any()).Return(deleteError) + mockDeployment.DeleteReturns(deleteError) err := newDeploymentDeleter().DeleteDeployment(skipDrain, fakeStage) diff --git a/cmd/deployment_state_manager.go b/cmd/deployment_state_manager.go index f37d8aa35f..e9206c27b7 100644 --- a/cmd/deployment_state_manager.go +++ b/cmd/deployment_state_manager.go @@ -15,6 +15,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . DeploymentStateManager + type DeploymentStateManager interface { StopDeployment(skipDrain bool, stage biui.Stage) (err error) StartDeployment(stage biui.Stage) (err error) diff --git a/cmd/deployment_state_manager_test.go b/cmd/deployment_state_manager_test.go index ce653ac6bc..744b7567a7 100644 --- a/cmd/deployment_state_manager_test.go +++ b/cmd/deployment_state_manager_test.go @@ -3,40 +3,28 @@ package cmd_test import ( "path/filepath" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" boshlog "github.com/cloudfoundry/bosh-utils/logger" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" + "github.com/cloudfoundry/bosh-cli/v7/deployment/deploymentfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - mockdeployment "github.com/cloudfoundry/bosh-cli/v7/deployment/mocks" bidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" - boshui "github.com/cloudfoundry/bosh-cli/v7/ui" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("DeploymentStateManager", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( fs *fakesys.FakeFileSystem logger boshlog.Logger @@ -45,12 +33,12 @@ var _ = Describe("DeploymentStateManager", func() { fakeUI *fakeui.FakeUI - mockDeploymentManagerFactory *mockdeployment.MockManagerFactory - mockDeploymentManager *mockdeployment.MockManager - mockDeployment *mockdeployment.MockDeployment + mockDeploymentManagerFactory *deploymentfakes.FakeManagerFactory + mockDeploymentManager *deploymentfakes.FakeManager + mockDeployment *deploymentfakes.FakeDeployment - mockAgentClient *mockagentclient.MockAgentClient - mockAgentClientFactory *mockhttpagent.MockAgentClientFactory + mockAgentClient *agentclientfakes.FakeAgentClient + mockAgentClientFactory *cmdfakes.FakeAgentClientFactory fakeStage *fakeui.FakeStage @@ -169,35 +157,39 @@ cloud_provider: fakeStage = fakeui.NewFakeStage() - mockDeploymentManagerFactory = mockdeployment.NewMockManagerFactory(mockCtrl) - mockDeploymentManager = mockdeployment.NewMockManager(mockCtrl) - mockDeployment = mockdeployment.NewMockDeployment(mockCtrl) + mockDeploymentManagerFactory = &deploymentfakes.FakeManagerFactory{} + mockDeploymentManager = &deploymentfakes.FakeManager{} + mockDeployment = &deploymentfakes.FakeDeployment{} - mockAgentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) - mockAgentClient = mockagentclient.NewMockAgentClient(mockCtrl) + mockAgentClientFactory = &cmdfakes.FakeAgentClientFactory{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} directorID = "fake-uuid-0" skipDrain = false - mockAgentClientFactory.EXPECT().NewAgentClient( - directorID, - "http://fake-mbus-user:fake-mbus-password@fake-mbus-endpoint", - certificate, - ).Return(mockAgentClient, nil).AnyTimes() + mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) writeDeploymentManifest() }) Describe("StopDeployment", func() { var expectStop = func(skipDrain bool) { - mockDeploymentManagerFactory.EXPECT().NewManager(gomock.Any(), mockAgentClient, gomock.Any()).AnyTimes().Return(mockDeploymentManager) - mockDeploymentManager.EXPECT().FindCurrent().Return(mockDeployment, true, nil) - - gomock.InOrder( - mockDeployment.EXPECT().Stop(skipDrain, gomock.Any()).Do(func(_ bool, stage boshui.Stage) { - Expect(fakeStage.SubStages).To(ContainElement(stage)) - }), - ) + mockDeploymentManagerFactory.NewManagerReturns(mockDeploymentManager) + mockDeploymentManager.FindCurrentReturns(mockDeployment, true, nil) + mockDeployment.StopReturns(nil) + } + + var assertStopArgs = func(skipDrain bool) { + Expect(mockDeployment.StopCallCount()).To(Equal(1)) + gotSkipDrain, stage := mockDeployment.StopArgsForCall(0) + Expect(gotSkipDrain).To(Equal(skipDrain)) + Expect(fakeStage.SubStages).To(ContainElement(stage)) + + Expect(mockAgentClientFactory.NewAgentClientCallCount()).To(Equal(1)) + gotDirectorID, gotMbusURL, gotCert := mockAgentClientFactory.NewAgentClientArgsForCall(0) + Expect(gotDirectorID).To(Equal(directorID)) + Expect(gotMbusURL).To(Equal("http://fake-mbus-user:fake-mbus-password@fake-mbus-endpoint")) + Expect(gotCert).To(Equal(certificate)) } var expectValidationStopEvents = func() { @@ -253,6 +245,7 @@ cloud_provider: err := newDeploymentStateManager().StopDeployment(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) Expect(fakeUI.Errors).To(BeEmpty()) + assertStopArgs(skipDrain) }) It("logs validating & stop stages", func() { @@ -270,6 +263,7 @@ cloud_provider: err := newDeploymentStateManager().StopDeployment(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + assertStopArgs(skipDrain) }) }) @@ -292,15 +286,16 @@ cloud_provider: Describe("StartDeployment", func() { var expectStart = func() { - mockDeploymentManagerFactory.EXPECT().NewManager(gomock.Any(), mockAgentClient, gomock.Any()).AnyTimes().Return(mockDeploymentManager) - mockDeploymentManager.EXPECT().FindCurrent().Return(mockDeployment, true, nil) - - gomock.InOrder( - mockDeployment.EXPECT().Start(gomock.Any(), gomock.Any()).Do(func(stage boshui.Stage, update bideplmanifest.Update) { - Expect(fakeStage.SubStages).To(ContainElement(stage)) - Expect(update).ToNot(BeNil()) - }), - ) + mockDeploymentManagerFactory.NewManagerReturns(mockDeploymentManager) + mockDeploymentManager.FindCurrentReturns(mockDeployment, true, nil) + mockDeployment.StartReturns(nil) + } + + var assertStartArgs = func() { + Expect(mockDeployment.StartCallCount()).To(Equal(1)) + stage, update := mockDeployment.StartArgsForCall(0) + Expect(fakeStage.SubStages).To(ContainElement(stage)) + Expect(update).ToNot(BeNil()) } var expectValidationStartEvents = func() { @@ -356,6 +351,7 @@ cloud_provider: err := newDeploymentStateManager().StartDeployment(fakeStage) Expect(err).ToNot(HaveOccurred()) Expect(fakeUI.Errors).To(BeEmpty()) + assertStartArgs() }) It("logs validating & starting stages", func() { diff --git a/cmd/log_in.go b/cmd/log_in.go index ddf0228bec..e1ed6d2766 100644 --- a/cmd/log_in.go +++ b/cmd/log_in.go @@ -10,6 +10,7 @@ import ( //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . LoginStrategy +//counterfeiter:generate github.com/cloudfoundry/bosh-agent/v2/agentclient/http.AgentClientFactory type LoginStrategy interface { Try() error diff --git a/cmd/logs_test.go b/cmd/logs_test.go index 4c59ec914c..41c862bdfe 100644 --- a/cmd/logs_test.go +++ b/cmd/logs_test.go @@ -10,18 +10,15 @@ import ( "code.cloudfoundry.org/clock" "code.cloudfoundry.org/clock/fakeclock" "github.com/cloudfoundry/bosh-agent/v2/agentclient" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" boshsys "github.com/cloudfoundry/bosh-utils/system" "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" fakecmd "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" - "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshdir "github.com/cloudfoundry/bosh-cli/v7/director" fakedir "github.com/cloudfoundry/bosh-cli/v7/director/directorfakes" @@ -358,10 +355,8 @@ var _ = Describe("Logs", func() { Describe("EnvLogsCmd", func() { var ( - mockCtrl *gomock.Controller - - agentClientFactory *mockhttpagent.MockAgentClientFactory - agentClient *mockagentclient.MockAgentClient + agentClientFactory *fakecmd.FakeAgentClientFactory + agentClient *agentclientfakes.FakeAgentClient nonIntSSHRunner *fakessh.FakeRunner scpRunner *fakessh.FakeSCPRunner fs *fakes.FakeFileSystem @@ -374,10 +369,8 @@ var _ = Describe("Logs", func() { ) BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - - agentClient = mockagentclient.NewMockAgentClient(mockCtrl) - agentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) + agentClient = &agentclientfakes.FakeAgentClient{} + agentClientFactory = &fakecmd.FakeAgentClientFactory{} nonIntSSHRunner = &fakessh.FakeRunner{} scpRunner = &fakessh.FakeSCPRunner{} fs = fakes.NewFakeFileSystem() @@ -389,10 +382,6 @@ var _ = Describe("Logs", func() { command = cmd.NewEnvLogsCmd(agentClientFactory, nonIntSSHRunner, scpRunner, fs, timeService, ui) }) - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( logsOpts opts.LogsOpts @@ -455,11 +444,7 @@ var _ = Describe("Logs", func() { uuidGen.GeneratedUUID = UUID - agentClientFactory.EXPECT().NewAgentClient( - gomock.Eq("bosh-cli"), - gomock.Eq("https:///foo:bar@10.0.0.5"), - gomock.Eq("some-cert"), - ).Return(agentClient, nil).Times(1) + agentClientFactory.NewAgentClientReturns(agentClient, nil) }) It("returns an error if generating SSH options fails", func() { @@ -471,7 +456,7 @@ var _ = Describe("Logs", func() { }) It("returns an error if setting up SSH access fails", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()).Return(agentclient.SSHResult{}, errors.New("fake-ssh-err")) + agentClient.SetUpSSHReturns(agentclient.SSHResult{}, errors.New("fake-ssh-err")) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -485,18 +470,22 @@ var _ = Describe("Logs", func() { It("sets up SSH access, runs SSH command and later cleans up SSH access", func() { nonIntSSHRunner.RunStub = func(boshssh.ConnectionOpts, boshdir.SSHResult, []string) error { - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(0) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(0)) return nil } - agentClient.EXPECT().SetUpSSH(gomock.Eq(ExpUsername), mocks.GomegaMock(ContainSubstring("ssh-rsa AAAA"))). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Eq(ExpUsername)). - Times(1) - Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) Expect(nonIntSSHRunner.RunCallCount()).To(Equal(1)) + + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + username, publicKey := agentClient.SetUpSSHArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(publicKey).To(ContainSubstring("ssh-rsa AAAA")) + + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + cleanUpUsername := agentClient.CleanUpSSHArgsForCall(0) + Expect(cleanUpUsername).To(Equal(ExpUsername)) }) It("runs non-interactive SSH session with flags, and basic tail -f command that tails all logs", func() { @@ -506,8 +495,7 @@ var _ = Describe("Logs", func() { Ip: "10.0.0.5", HostPublicKey: "some-public-key", } - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()).Return(result, nil) - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(1) + agentClient.SetUpSSHReturns(result, nil) logsOpts.GatewayFlags.Disable = true //nolint:staticcheck logsOpts.GatewayFlags.Username = "gw-username" //nolint:staticcheck @@ -532,8 +520,7 @@ var _ = Describe("Logs", func() { Context("tail options", func() { BeforeEach(func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()).Return(agentclient.SSHResult{}, nil).Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(1) + agentClient.SetUpSSHReturns(agentclient.SSHResult{}, nil) }) It("runs tail command with specified number of lines and quiet option", func() { @@ -608,9 +595,8 @@ var _ = Describe("Logs", func() { }) It("does not try to fetch logs", func() { - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()).Times(0) - Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) + Expect(agentClient.BundleLogsCallCount()).To(Equal(0)) }) }) }) @@ -622,8 +608,7 @@ var _ = Describe("Logs", func() { ) BeforeEach(func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()).Return(agentclient.SSHResult{}, nil).Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(1) + agentClient.SetUpSSHReturns(agentclient.SSHResult{}, nil) bundleResult = agentclient.BundleLogsResult{ LogsTarPath: "/foo/bar", @@ -632,72 +617,68 @@ var _ = Describe("Logs", func() { }) It("bundles logs for jobs by default", func() { - agentClient.EXPECT().BundleLogs( - gomock.Eq(ExpUsername), - gomock.Eq("job"), - mocks.GomegaMock(HaveLen(0)), - ). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) + + Expect(agentClient.BundleLogsCallCount()).To(Equal(1)) + username, logType, filters := agentClient.BundleLogsArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(logType).To(Equal("job")) + Expect(filters).To(HaveLen(0)) + Expect(agentClient.RemoveFileCallCount()).To(Equal(1)) }) It("bundles agent logs and allows custom filters", func() { logsOpts.Filters = []string{"filter1", "filter2"} logsOpts.Agent = true - agentClient.EXPECT().BundleLogs( - gomock.Eq(ExpUsername), - gomock.Eq("agent"), - gomock.Eq([]string{"filter1", "filter2"}), - ). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) + + Expect(agentClient.BundleLogsCallCount()).To(Equal(1)) + username, logType, filters := agentClient.BundleLogsArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(logType).To(Equal("agent")) + Expect(filters).To(Equal([]string{"filter1", "filter2"})) + Expect(agentClient.RemoveFileCallCount()).To(Equal(1)) }) It("bundles system logs", func() { logsOpts.Filters = []string{} logsOpts.System = true - agentClient.EXPECT().BundleLogs( - gomock.Eq(ExpUsername), - gomock.Eq("system"), - gomock.Eq([]string{}), - ). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) + + Expect(agentClient.BundleLogsCallCount()).To(Equal(1)) + username, logType, filters := agentClient.BundleLogsArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(logType).To(Equal("system")) + Expect(filters).To(Equal([]string{})) + Expect(agentClient.RemoveFileCallCount()).To(Equal(1)) }) It("bundles all logs", func() { logsOpts.Filters = []string{} logsOpts.All = true - agentClient.EXPECT().BundleLogs( - gomock.Eq(ExpUsername), - gomock.Eq("agent,job,system"), - gomock.Eq([]string{}), - ). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) + + Expect(agentClient.BundleLogsCallCount()).To(Equal(1)) + username, logType, filters := agentClient.BundleLogsArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(logType).To(Equal("agent,job,system")) + Expect(filters).To(Equal([]string{})) + Expect(agentClient.RemoveFileCallCount()).To(Equal(1)) }) It("returns error if bundling logs failed", func() { - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()).Return(agentclient.BundleLogsResult{}, errors.New("fake-logs-err")) + agentClient.BundleLogsReturns(agentclient.BundleLogsResult{}, errors.New("fake-logs-err")) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -707,11 +688,7 @@ var _ = Describe("Logs", func() { It("uses scp to download the log bundle", func() { fakeFile := fakes.NewFakeFile("/tmp/baz", fs) fs.ReturnTempFile = fakeFile - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) @@ -728,11 +705,7 @@ var _ = Describe("Logs", func() { It("returns error if scp fails", func() { scpRunner.RunReturns(errors.New("fake-scp-error")) - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -743,11 +716,7 @@ var _ = Describe("Logs", func() { It("returns error if parsing the sha fails", func() { bundleResult.SHA512Digest = "garbage can" - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -759,11 +728,7 @@ var _ = Describe("Logs", func() { fakeFile.Write([]byte("not empty anymore!")) //nolint:errcheck fs.ReturnTempFile = fakeFile - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -771,11 +736,7 @@ var _ = Describe("Logs", func() { }) It("Respects the path arg", func() { - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) logsOpts.Directory.Path = "/hey/hello" fs.MkdirAll("/hey/hello", os.FileMode(0777)) //nolint:errcheck fs.ReturnTempFilesByPrefix = map[string]boshsys.File{ @@ -796,11 +757,7 @@ var _ = Describe("Logs", func() { fakeFile := fakes.NewFakeFile("/tmp/baz", fs) fakeFile.CloseErr = errors.New("fake-close-error") fs.ReturnTempFile = fakeFile - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -809,11 +766,7 @@ var _ = Describe("Logs", func() { It("returns error if moving file fails", func() { fs.RenameError = errors.New("fake-rename-error") - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) err := command.Run(logsOpts) Expect(err).To(HaveOccurred()) @@ -822,11 +775,7 @@ var _ = Describe("Logs", func() { }) It("does not try to tail logs", func() { - agentClient.EXPECT().BundleLogs(gomock.Any(), gomock.Any(), gomock.Any()). - Return(bundleResult, nil). - Times(1) - agentClient.EXPECT().RemoveFile(gomock.Any()). - Times(1) + agentClient.BundleLogsReturns(bundleResult, nil) Expect(command.Run(logsOpts)).ToNot(HaveOccurred()) Expect(nonIntSSHRunner.RunCallCount()).To(Equal(0)) diff --git a/cmd/mocks/gomock_gomega_wrapper.go b/cmd/mocks/gomock_gomega_wrapper.go deleted file mode 100644 index a3db70fad1..0000000000 --- a/cmd/mocks/gomock_gomega_wrapper.go +++ /dev/null @@ -1,29 +0,0 @@ -package mocks - -import "github.com/golang/mock/gomock" - -// Shamelessly lifted from https://github.com/onsi/gomega/issues/451 - -type GomegaMatcher interface { - Match(actual interface{}) (success bool, err error) - FailureMessage(actual interface{}) (message string) -} - -type matcher struct { - GomegaMatcher - x interface{} -} - -func (m matcher) Matches(x interface{}) bool { - m.x = x - result, _ := m.Match(x) //nolint:errcheck - return result -} - -func (m matcher) String() string { - return m.FailureMessage(m.x) -} - -func GomegaMock(gmather GomegaMatcher) gomock.Matcher { - return matcher{gmather, nil} -} diff --git a/cmd/mocks/mocks.go b/cmd/mocks/mocks.go deleted file mode 100644 index 802c3d70b0..0000000000 --- a/cmd/mocks/mocks.go +++ /dev/null @@ -1,100 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/cmd (interfaces: DeploymentDeleter,DeploymentStateManager) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockDeploymentDeleter is a mock of DeploymentDeleter interface. -type MockDeploymentDeleter struct { - ctrl *gomock.Controller - recorder *MockDeploymentDeleterMockRecorder -} - -// MockDeploymentDeleterMockRecorder is the mock recorder for MockDeploymentDeleter. -type MockDeploymentDeleterMockRecorder struct { - mock *MockDeploymentDeleter -} - -// NewMockDeploymentDeleter creates a new mock instance. -func NewMockDeploymentDeleter(ctrl *gomock.Controller) *MockDeploymentDeleter { - mock := &MockDeploymentDeleter{ctrl: ctrl} - mock.recorder = &MockDeploymentDeleterMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDeploymentDeleter) EXPECT() *MockDeploymentDeleterMockRecorder { - return m.recorder -} - -// DeleteDeployment mocks base method. -func (m *MockDeploymentDeleter) DeleteDeployment(arg0 bool, arg1 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDeployment", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteDeployment indicates an expected call of DeleteDeployment. -func (mr *MockDeploymentDeleterMockRecorder) DeleteDeployment(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeployment", reflect.TypeOf((*MockDeploymentDeleter)(nil).DeleteDeployment), arg0, arg1) -} - -// MockDeploymentStateManager is a mock of DeploymentStateManager interface. -type MockDeploymentStateManager struct { - ctrl *gomock.Controller - recorder *MockDeploymentStateManagerMockRecorder -} - -// MockDeploymentStateManagerMockRecorder is the mock recorder for MockDeploymentStateManager. -type MockDeploymentStateManagerMockRecorder struct { - mock *MockDeploymentStateManager -} - -// NewMockDeploymentStateManager creates a new mock instance. -func NewMockDeploymentStateManager(ctrl *gomock.Controller) *MockDeploymentStateManager { - mock := &MockDeploymentStateManager{ctrl: ctrl} - mock.recorder = &MockDeploymentStateManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDeploymentStateManager) EXPECT() *MockDeploymentStateManagerMockRecorder { - return m.recorder -} - -// StartDeployment mocks base method. -func (m *MockDeploymentStateManager) StartDeployment(arg0 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartDeployment", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// StartDeployment indicates an expected call of StartDeployment. -func (mr *MockDeploymentStateManagerMockRecorder) StartDeployment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDeployment", reflect.TypeOf((*MockDeploymentStateManager)(nil).StartDeployment), arg0) -} - -// StopDeployment mocks base method. -func (m *MockDeploymentStateManager) StopDeployment(arg0 bool, arg1 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopDeployment", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// StopDeployment indicates an expected call of StopDeployment. -func (mr *MockDeploymentStateManagerMockRecorder) StopDeployment(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopDeployment", reflect.TypeOf((*MockDeploymentStateManager)(nil).StopDeployment), arg0, arg1) -} diff --git a/cmd/scp_test.go b/cmd/scp_test.go index ec9205ff74..9cae97e3bb 100644 --- a/cmd/scp_test.go +++ b/cmd/scp_test.go @@ -4,15 +4,13 @@ import ( "errors" "github.com/cloudfoundry/bosh-agent/v2/agentclient" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" - "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshdir "github.com/cloudfoundry/bosh-cli/v7/director" fakedir "github.com/cloudfoundry/bosh-cli/v7/director/directorfakes" @@ -221,30 +219,22 @@ var _ = Describe("SCP", func() { Describe("EnvSCPCmd", func() { var ( - mockCtrl *gomock.Controller - - agentClientFactory *mockhttpagent.MockAgentClientFactory - agentClient *mockagentclient.MockAgentClient + agentClientFactory *cmdfakes.FakeAgentClientFactory + agentClient *agentclientfakes.FakeAgentClient uuidGen *fakeuuid.FakeGenerator scpRunner *fakessh.FakeSCPRunner command cmd.EnvSCPCmd ) BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - - agentClient = mockagentclient.NewMockAgentClient(mockCtrl) - agentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) + agentClient = &agentclientfakes.FakeAgentClient{} + agentClientFactory = &cmdfakes.FakeAgentClientFactory{} uuidGen = &fakeuuid.FakeGenerator{} scpRunner = &fakessh.FakeSCPRunner{} command = cmd.NewEnvSCPCmd(agentClientFactory, scpRunner) }) - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( scpOpts opts.SCPOpts @@ -321,11 +311,7 @@ var _ = Describe("SCP", func() { } uuidGen.GeneratedUUID = UUID - agentClientFactory.EXPECT().NewAgentClient( - gomock.Eq("bosh-cli"), - gomock.Eq("https:///foo:bar@10.0.0.5"), - gomock.Eq("some-cert"), - ).Return(agentClient, nil).Times(1) + agentClientFactory.NewAgentClientReturns(agentClient, nil) }) Context("when valid SCP args are provided", func() { @@ -335,23 +321,26 @@ var _ = Describe("SCP", func() { It("sets up SSH access, runs SSH command and later cleans up SSH access", func() { scpRunner.RunStub = func(boshssh.ConnectionOpts, boshdir.SSHResult, boshssh.SCPArgs) error { - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(0) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(0)) return nil } - agentClient.EXPECT().SetUpSSH(gomock.Eq(ExpUsername), mocks.GomegaMock(ContainSubstring("ssh-rsa AAAA"))). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Eq(ExpUsername)). - Times(1) Expect(command.Run(scpOpts)).ToNot(HaveOccurred()) Expect(scpRunner.RunCallCount()).To(Equal(1)) + + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + username, publicKey := agentClient.SetUpSSHArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(publicKey).To(ContainSubstring("ssh-rsa AAAA")) + + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + cleanUpUsername := agentClient.CleanUpSSHArgsForCall(0) + Expect(cleanUpUsername).To(Equal(ExpUsername)) }) It("returns an error if setting up SSH access fails", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Return(agentclient.SSHResult{}, errors.New("fake-ssh-err")). - Times(1) + agentClient.SetUpSSHReturns(agentclient.SSHResult{}, errors.New("fake-ssh-err")) err := command.Run(scpOpts) @@ -375,11 +364,7 @@ var _ = Describe("SCP", func() { Ip: "10.0.0.5", HostPublicKey: "some-public-key", } - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Return(result, nil). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) + agentClient.SetUpSSHReturns(result, nil) scpOpts.GatewayFlags.Disable = true //nolint:staticcheck scpOpts.GatewayFlags.Username = "gw-username" //nolint:staticcheck @@ -404,23 +389,17 @@ var _ = Describe("SCP", func() { It("sets up SCP to be recursive if recursive flag is set", func() { scpOpts.Recursive = true - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) Expect(command.Run(scpOpts)).ToNot(HaveOccurred()) Expect(scpRunner.RunCallCount()).To(Equal(1)) + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) _, _, runCommand := scpRunner.RunArgsForCall(0) Expect(runCommand).To(Equal(boshssh.NewSCPArgs([]string{"from:file", "/something"}, true))) }) It("returns error if SCP errors", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) scpRunner.RunReturns(errors.New("fake-scp-err")) err := command.Run(scpOpts) diff --git a/cmd/ssh_test.go b/cmd/ssh_test.go index 493545bb9a..c33bfa4e66 100644 --- a/cmd/ssh_test.go +++ b/cmd/ssh_test.go @@ -4,16 +4,14 @@ import ( "errors" "github.com/cloudfoundry/bosh-agent/v2/agentclient" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" boshlog "github.com/cloudfoundry/bosh-utils/logger" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" - "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshdir "github.com/cloudfoundry/bosh-cli/v7/director" fakedir "github.com/cloudfoundry/bosh-cli/v7/director/directorfakes" @@ -345,10 +343,8 @@ var _ = Describe("SSH", func() { Describe("EnvSSHCmd", func() { var ( - mockCtrl *gomock.Controller - - agentClientFactory *mockhttpagent.MockAgentClientFactory - agentClient *mockagentclient.MockAgentClient + agentClientFactory *cmdfakes.FakeAgentClientFactory + agentClient *agentclientfakes.FakeAgentClient intSSHRunner *fakessh.FakeRunner nonIntSSHRunner *fakessh.FakeRunner resultsSSHRunner *fakessh.FakeRunner @@ -361,10 +357,8 @@ var _ = Describe("SSH", func() { ) BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - - agentClient = mockagentclient.NewMockAgentClient(mockCtrl) - agentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) + agentClient = &agentclientfakes.FakeAgentClient{} + agentClientFactory = &cmdfakes.FakeAgentClientFactory{} intSSHRunner = &fakessh.FakeRunner{} nonIntSSHRunner = &fakessh.FakeRunner{} resultsSSHRunner = &fakessh.FakeRunner{} @@ -376,10 +370,6 @@ var _ = Describe("SSH", func() { command = cmd.NewEnvSSHCmd(agentClientFactory, intSSHRunner, nonIntSSHRunner, resultsSSHRunner, ui, logger) }) - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( sshOpts opts.SSHOpts @@ -456,11 +446,7 @@ var _ = Describe("SSH", func() { uuidGen.GeneratedUUID = UUID - agentClientFactory.EXPECT().NewAgentClient( - gomock.Eq("bosh-cli"), - gomock.Eq("https:///foo:bar@10.0.0.5"), - gomock.Eq("some-cert"), - ).Return(agentClient, nil).Times(1) + agentClientFactory.NewAgentClientReturns(agentClient, nil) }) It("returns an error if generating SSH options fails", func() { @@ -479,35 +465,35 @@ var _ = Describe("SSH", func() { It("sets up SSH access, runs SSH command and later cleans up SSH access", func() { (*runner).RunStub = func(boshssh.ConnectionOpts, boshdir.SSHResult, []string) error { - agentClient.EXPECT().CleanUpSSH(gomock.Any()).Times(0) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(0)) return nil } - agentClient.EXPECT().SetUpSSH(gomock.Eq(ExpUsername), mocks.GomegaMock(ContainSubstring("ssh-rsa AAAA"))). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Eq(ExpUsername)). - Times(1) Expect(command.Run(sshOpts)).ToNot(HaveOccurred()) Expect((*runner).RunCallCount()).To(Equal(1)) + + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + username, publicKey := agentClient.SetUpSSHArgsForCall(0) + Expect(username).To(Equal(ExpUsername)) + Expect(publicKey).To(ContainSubstring("ssh-rsa AAAA")) + + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + cleanUpUsername := agentClient.CleanUpSSHArgsForCall(0) + Expect(cleanUpUsername).To(Equal(ExpUsername)) }) It("runs non-interactive SSH", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) - Expect(command.Run(sshOpts)).ToNot(HaveOccurred()) Expect((*runner).RunCallCount()).To(Equal(1)) Expect(intSSHRunner.RunCallCount()).To(Equal(0)) + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) }) It("returns an error if setting up SSH access fails", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Return(agentclient.SSHResult{}, errors.New("fake-ssh-err")). - Times(1) + agentClient.SetUpSSHReturns(agentclient.SSHResult{}, errors.New("fake-ssh-err")) err := command.Run(sshOpts) @@ -531,11 +517,7 @@ var _ = Describe("SSH", func() { Ip: "10.0.0.5", HostPublicKey: "some-public-key", } - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Return(result, nil). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) + agentClient.SetUpSSHReturns(result, nil) sshOpts.RawOpts = []string{"raw1", "raw2"} sshOpts.GatewayFlags.Disable = true //nolint:staticcheck @@ -562,10 +544,6 @@ var _ = Describe("SSH", func() { It("returns error if non-interactive SSH session errors", func() { (*runner).RunReturns(errors.New("fake-err")) - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) err := command.Run(sshOpts) @@ -583,13 +561,11 @@ var _ = Describe("SSH", func() { itRunsSpecifiedRunnerProperlyWhenCommandGiven(&nonIntSSHRunner) It("uses the interactive runner", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) - Expect(command.Run(sshOpts)).ToNot(HaveOccurred()) + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + Expect(intSSHRunner.RunCallCount()).To(Equal(1)) Expect(nonIntSSHRunner.RunCallCount()).To(Equal(0)) Expect(resultsSSHRunner.RunCallCount()).To(Equal(0)) @@ -604,13 +580,11 @@ var _ = Describe("SSH", func() { itRunsSpecifiedRunnerProperlyWhenCommandGiven(&nonIntSSHRunner) It("uses the noninteractive runner", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) - Expect(command.Run(sshOpts)).ToNot(HaveOccurred()) + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + Expect(intSSHRunner.RunCallCount()).To(Equal(0)) Expect(nonIntSSHRunner.RunCallCount()).To(Equal(1)) Expect(resultsSSHRunner.RunCallCount()).To(Equal(0)) @@ -625,13 +599,11 @@ var _ = Describe("SSH", func() { itRunsSpecifiedRunnerProperlyWhenCommandGiven(&resultsSSHRunner) It("uses the results runner", func() { - agentClient.EXPECT().SetUpSSH(gomock.Any(), gomock.Any()). - Times(1) - agentClient.EXPECT().CleanUpSSH(gomock.Any()). - Times(1) - Expect(command.Run(sshOpts)).ToNot(HaveOccurred()) + Expect(agentClient.SetUpSSHCallCount()).To(Equal(1)) + Expect(agentClient.CleanUpSSHCallCount()).To(Equal(1)) + Expect(intSSHRunner.RunCallCount()).To(Equal(0)) Expect(nonIntSSHRunner.RunCallCount()).To(Equal(0)) Expect(resultsSSHRunner.RunCallCount()).To(Equal(1)) diff --git a/cmd/start_env_test.go b/cmd/start_env_test.go index 157d556835..5e4abb5d51 100644 --- a/cmd/start_env_test.go +++ b/cmd/start_env_test.go @@ -4,31 +4,20 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/cloudfoundry/bosh-cli/v7/cmd" - mockcmd "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("StartEnvCmd", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( - mockDeploymentStateManager *mockcmd.MockDeploymentStateManager + mockDeploymentStateManager *cmdfakes.FakeDeploymentStateManager fs *fakesys.FakeFileSystem fakeUI *fakebiui.FakeUI @@ -55,7 +44,7 @@ var _ = Describe("StartEnvCmd", func() { } BeforeEach(func() { - mockDeploymentStateManager = mockcmd.NewMockDeploymentStateManager(mockCtrl) + mockDeploymentStateManager = &cmdfakes.FakeDeploymentStateManager{} fs = fakesys.NewFakeFileSystem() fs.EnableStrictTempRootBehavior() fakeUI = &fakebiui.FakeUI{} @@ -64,7 +53,7 @@ var _ = Describe("StartEnvCmd", func() { Context("state path is NOT specified", func() { It("sends the manifest on to the StartDeployment", func() { - mockDeploymentStateManager.EXPECT().StartDeployment(fakeStage).Return(nil) + mockDeploymentStateManager.StartDeploymentReturns(nil) err := newStartEnvCmd().Run(fakeStage, opts.StartEnvOpts{ Args: opts.StartStopEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, @@ -81,12 +70,15 @@ var _ = Describe("StartEnvCmd", func() { Expect(err).ToNot(HaveOccurred()) Expect(statePath).To(Equal("")) + + Expect(mockDeploymentStateManager.StartDeploymentCallCount()).To(Equal(1)) + Expect(mockDeploymentStateManager.StartDeploymentArgsForCall(0)).To(Equal(fakeStage)) }) }) Context("state path is specified", func() { It("sends the manifest on to the StartDeployment", func() { - mockDeploymentStateManager.EXPECT().StartDeployment(fakeStage).Return(nil) + mockDeploymentStateManager.StartDeploymentReturns(nil) err := newStartEnvCmd().Run(fakeStage, opts.StartEnvOpts{ StatePath: "/new/state/file/path/state.json", Args: opts.StartStopEnvArgs{ @@ -110,7 +102,7 @@ var _ = Describe("StartEnvCmd", func() { Context("when the deployment state changer returns an error", func() { It("sends the manifest on to the StartDeployment", func() { err := bosherr.Error("boom") - mockDeploymentStateManager.EXPECT().StartDeployment(fakeStage).Return(err) + mockDeploymentStateManager.StartDeploymentReturns(err) returnedErr := newStartEnvCmd().Run(fakeStage, opts.StartEnvOpts{ Args: opts.StartStopEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, diff --git a/cmd/stop_env_test.go b/cmd/stop_env_test.go index 95eca52597..58341c553a 100644 --- a/cmd/stop_env_test.go +++ b/cmd/stop_env_test.go @@ -4,31 +4,20 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/cloudfoundry/bosh-cli/v7/cmd" - mockcmd "github.com/cloudfoundry/bosh-cli/v7/cmd/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("StopEnvCmd", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Run", func() { var ( - mockDeploymentStateManager *mockcmd.MockDeploymentStateManager + mockDeploymentStateManager *cmdfakes.FakeDeploymentStateManager fs *fakesys.FakeFileSystem fakeUI *fakeui.FakeUI @@ -56,7 +45,7 @@ var _ = Describe("StopEnvCmd", func() { } BeforeEach(func() { - mockDeploymentStateManager = mockcmd.NewMockDeploymentStateManager(mockCtrl) + mockDeploymentStateManager = &cmdfakes.FakeDeploymentStateManager{} fs = fakesys.NewFakeFileSystem() fs.EnableStrictTempRootBehavior() fakeUI = &fakeui.FakeUI{} @@ -67,7 +56,7 @@ var _ = Describe("StopEnvCmd", func() { Context("when skip drain is specified", func() { It("gets passed to StopDeployment", func() { skipDrain = true - mockDeploymentStateManager.EXPECT().StopDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentStateManager.StopDeploymentReturns(nil) err := newStopEnvCmd().Run(fakeStage, opts.StopEnvOpts{ Args: opts.StartStopEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, @@ -83,12 +72,17 @@ var _ = Describe("StopEnvCmd", func() { }, }) Expect(err).ToNot(HaveOccurred()) + + Expect(mockDeploymentStateManager.StopDeploymentCallCount()).To(Equal(1)) + actualSkipDrain, actualStage := mockDeploymentStateManager.StopDeploymentArgsForCall(0) + Expect(actualSkipDrain).To(BeTrue()) + Expect(actualStage).To(Equal(fakeStage)) }) }) Context("state path is NOT specified", func() { It("sends the manifest on to the StopDeployment", func() { - mockDeploymentStateManager.EXPECT().StopDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentStateManager.StopDeploymentReturns(nil) err := newStopEnvCmd().Run(fakeStage, opts.StopEnvOpts{ Args: opts.StartStopEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, @@ -111,7 +105,7 @@ var _ = Describe("StopEnvCmd", func() { Context("state path is specified", func() { It("sends the manifest on to the StopDeployment", func() { - mockDeploymentStateManager.EXPECT().StopDeployment(skipDrain, fakeStage).Return(nil) + mockDeploymentStateManager.StopDeploymentReturns(nil) err := newStopEnvCmd().Run(fakeStage, opts.StopEnvOpts{ StatePath: "/new/state/file/path/state.json", SkipDrain: skipDrain, @@ -136,7 +130,7 @@ var _ = Describe("StopEnvCmd", func() { Context("when the deployment state changer returns an error", func() { It("sends the manifest on to the StopDeployment", func() { err := bosherr.Error("boom") - mockDeploymentStateManager.EXPECT().StopDeployment(skipDrain, fakeStage).Return(err) + mockDeploymentStateManager.StopDeploymentReturns(err) returnedErr := newStopEnvCmd().Run(fakeStage, opts.StopEnvOpts{ Args: opts.StartStopEnvArgs{ Manifest: opts.FileBytesWithPathArg{Path: deploymentManifestPath}, diff --git a/cmd/suite_test.go b/cmd/suite_test.go index 145e7f84aa..dd0626aba6 100644 --- a/cmd/suite_test.go +++ b/cmd/suite_test.go @@ -2,12 +2,13 @@ package cmd_test import ( "crypto/tls" + "fmt" "net/http" "testing" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" + "github.com/onsi/gomega/types" "github.com/cloudfoundry/bosh-cli/v7/testutils" ) @@ -30,27 +31,31 @@ func TestReg(t *testing.T) { RunSpecs(t, "cmd") } -// secureTLSClientMatcher is a gomock.Matcher that asserts an *http.Client +// secureTLSClientMatcher is a Gomega matcher that asserts an *http.Client // has TLS certificate verification enabled (InsecureSkipVerify == false). // Use SecureTLSClientMatcher() to obtain an instance. type secureTLSClientMatcher struct{} -func SecureTLSClientMatcher() gomock.Matcher { +func SecureTLSClientMatcher() types.GomegaMatcher { return secureTLSClientMatcher{} } -func (m secureTLSClientMatcher) Matches(x interface{}) bool { - client, ok := x.(*http.Client) +func (m secureTLSClientMatcher) Match(actual interface{}) (bool, error) { + client, ok := actual.(*http.Client) if !ok { - return false + return false, fmt.Errorf("SecureTLSClientMatcher expects a *http.Client, got %T", actual) } transport, ok := client.Transport.(*http.Transport) if !ok { - return false + return false, nil } - return transport.TLSClientConfig != nil && !transport.TLSClientConfig.InsecureSkipVerify + return transport.TLSClientConfig != nil && !transport.TLSClientConfig.InsecureSkipVerify, nil } -func (m secureTLSClientMatcher) String() string { - return "is a secure *http.Client with TLS certificate verification enabled (InsecureSkipVerify=false)" +func (m secureTLSClientMatcher) FailureMessage(actual interface{}) string { + return "Expected\n\t" + fmt.Sprintf("%#v", actual) + "\nto be a secure *http.Client with TLS certificate verification enabled (InsecureSkipVerify=false)" +} + +func (m secureTLSClientMatcher) NegatedFailureMessage(actual interface{}) string { + return "Expected\n\t" + fmt.Sprintf("%#v", actual) + "\nnot to be a secure *http.Client with TLS certificate verification enabled (InsecureSkipVerify=false)" } diff --git a/config/configfakes/fake_legacy_deployment_state_migrator.go b/config/configfakes/fake_legacy_deployment_state_migrator.go new file mode 100644 index 0000000000..12d23f7ef9 --- /dev/null +++ b/config/configfakes/fake_legacy_deployment_state_migrator.go @@ -0,0 +1,114 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" +) + +type FakeLegacyDeploymentStateMigrator struct { + MigrateIfExistsStub func(string) (bool, error) + migrateIfExistsMutex sync.RWMutex + migrateIfExistsArgsForCall []struct { + arg1 string + } + migrateIfExistsReturns struct { + result1 bool + result2 error + } + migrateIfExistsReturnsOnCall map[int]struct { + result1 bool + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExists(arg1 string) (bool, error) { + fake.migrateIfExistsMutex.Lock() + ret, specificReturn := fake.migrateIfExistsReturnsOnCall[len(fake.migrateIfExistsArgsForCall)] + fake.migrateIfExistsArgsForCall = append(fake.migrateIfExistsArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.MigrateIfExistsStub + fakeReturns := fake.migrateIfExistsReturns + fake.recordInvocation("MigrateIfExists", []interface{}{arg1}) + fake.migrateIfExistsMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExistsCallCount() int { + fake.migrateIfExistsMutex.RLock() + defer fake.migrateIfExistsMutex.RUnlock() + return len(fake.migrateIfExistsArgsForCall) +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExistsCalls(stub func(string) (bool, error)) { + fake.migrateIfExistsMutex.Lock() + defer fake.migrateIfExistsMutex.Unlock() + fake.MigrateIfExistsStub = stub +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExistsArgsForCall(i int) string { + fake.migrateIfExistsMutex.RLock() + defer fake.migrateIfExistsMutex.RUnlock() + argsForCall := fake.migrateIfExistsArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExistsReturns(result1 bool, result2 error) { + fake.migrateIfExistsMutex.Lock() + defer fake.migrateIfExistsMutex.Unlock() + fake.MigrateIfExistsStub = nil + fake.migrateIfExistsReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeLegacyDeploymentStateMigrator) MigrateIfExistsReturnsOnCall(i int, result1 bool, result2 error) { + fake.migrateIfExistsMutex.Lock() + defer fake.migrateIfExistsMutex.Unlock() + fake.MigrateIfExistsStub = nil + if fake.migrateIfExistsReturnsOnCall == nil { + fake.migrateIfExistsReturnsOnCall = make(map[int]struct { + result1 bool + result2 error + }) + } + fake.migrateIfExistsReturnsOnCall[i] = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeLegacyDeploymentStateMigrator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeLegacyDeploymentStateMigrator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.LegacyDeploymentStateMigrator = new(FakeLegacyDeploymentStateMigrator) diff --git a/config/legacy_deployment_state_migrator.go b/config/legacy_deployment_state_migrator.go index d1687413a4..26a4f5a972 100644 --- a/config/legacy_deployment_state_migrator.go +++ b/config/legacy_deployment_state_migrator.go @@ -13,6 +13,10 @@ import ( boshuuid "github.com/cloudfoundry/bosh-utils/uuid" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . LegacyDeploymentStateMigrator + type LegacyDeploymentStateMigrator interface { MigrateIfExists(configPath string) (migrated bool, err error) } diff --git a/config/mocks/mocks.go b/config/mocks/mocks.go deleted file mode 100644 index 945b7b70c4..0000000000 --- a/config/mocks/mocks.go +++ /dev/null @@ -1,49 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/config (interfaces: LegacyDeploymentStateMigrator) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - gomock "github.com/golang/mock/gomock" -) - -// MockLegacyDeploymentStateMigrator is a mock of LegacyDeploymentStateMigrator interface. -type MockLegacyDeploymentStateMigrator struct { - ctrl *gomock.Controller - recorder *MockLegacyDeploymentStateMigratorMockRecorder -} - -// MockLegacyDeploymentStateMigratorMockRecorder is the mock recorder for MockLegacyDeploymentStateMigrator. -type MockLegacyDeploymentStateMigratorMockRecorder struct { - mock *MockLegacyDeploymentStateMigrator -} - -// NewMockLegacyDeploymentStateMigrator creates a new mock instance. -func NewMockLegacyDeploymentStateMigrator(ctrl *gomock.Controller) *MockLegacyDeploymentStateMigrator { - mock := &MockLegacyDeploymentStateMigrator{ctrl: ctrl} - mock.recorder = &MockLegacyDeploymentStateMigratorMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockLegacyDeploymentStateMigrator) EXPECT() *MockLegacyDeploymentStateMigratorMockRecorder { - return m.recorder -} - -// MigrateIfExists mocks base method. -func (m *MockLegacyDeploymentStateMigrator) MigrateIfExists(arg0 string) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MigrateIfExists", arg0) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MigrateIfExists indicates an expected call of MigrateIfExists. -func (mr *MockLegacyDeploymentStateMigratorMockRecorder) MigrateIfExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MigrateIfExists", reflect.TypeOf((*MockLegacyDeploymentStateMigrator)(nil).MigrateIfExists), arg0) -} diff --git a/cpi/release/installer_test.go b/cpi/release/installer_test.go index 46dfd6ce0b..a745ce1d3b 100644 --- a/cpi/release/installer_test.go +++ b/cpi/release/installer_test.go @@ -3,52 +3,38 @@ package release_test import ( "errors" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/cloudfoundry/bosh-cli/v7/cpi/release" biinstallation "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallationmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - "github.com/cloudfoundry/bosh-cli/v7/installation/mocks" - "github.com/cloudfoundry/bosh-cli/v7/ui" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("Installer", func() { Describe("WithInstalledCpiRelease", func() { var ( - mockCtrl *gomock.Controller - mockInstaller *mocks.MockInstaller - mockInstallerFactory *mocks.MockInstallerFactory + mockInstaller *installationfakes.FakeInstaller + mockInstallerFactory *installationfakes.FakeInstallerFactory installationManifest biinstallationmanifest.Manifest installStage *fakeui.FakeStage - installation *mocks.MockInstallation - expectInstall *gomock.Call - expectCleanup *gomock.Call + installation *installationfakes.FakeInstallation target biinstallation.Target ) BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - - BeforeEach(func() { - mockInstaller = mocks.NewMockInstaller(mockCtrl) - mockInstallerFactory = mocks.NewMockInstallerFactory(mockCtrl) + mockInstaller = &installationfakes.FakeInstaller{} + mockInstallerFactory = &installationfakes.FakeInstallerFactory{} installationManifest = biinstallationmanifest.Manifest{} installStage = fakeui.NewFakeStage() - installation = mocks.NewMockInstallation(mockCtrl) + installation = &installationfakes.FakeInstallation{} target = biinstallation.NewTarget("fake-installation-path", "") - mockInstallerFactory.EXPECT().NewInstaller(target).Return(mockInstaller).AnyTimes() - expectInstall = mockInstaller.EXPECT().Install(installationManifest, gomock.Any()) - expectCleanup = mockInstaller.EXPECT().Cleanup(installation).Return(nil) + mockInstallerFactory.NewInstallerReturns(mockInstaller) + mockInstaller.CleanupReturns(nil) }) It("should validate CPI release that include CPI and plugin releases", Pending, func() {}) @@ -58,7 +44,7 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) + mockInstaller.InstallReturns(installation, nil) var installationArgumentToFunction biinstallation.Installation err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { @@ -77,15 +63,14 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - var stageForInstall ui.Stage - expectInstall.Do(func(manifest biinstallationmanifest.Manifest, stage ui.Stage) { - stageForInstall = stage - }).Return(installation, nil) + mockInstaller.InstallReturns(installation, nil) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return nil }) Expect(err).ToNot(HaveOccurred()) + + _, stageForInstall := mockInstaller.InstallArgsForCall(0) Expect(stageForInstall).To(fakeui.BeASubstageOf(installStage)) Expect(installStage.PerformCalls).To(ContainElement( @@ -101,23 +86,21 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - cleanupCalled := false - expectInstall.Return(installation, nil) - expectCleanup.Times(1).Do(func(_ biinstallation.Installation) { - cleanupCalled = true - }) + mockInstaller.InstallReturns(installation, nil) + err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { - Expect(cleanupCalled).To(BeFalse()) + Expect(mockInstaller.CleanupCallCount()).To(Equal(0)) return nil }) Expect(err).ToNot(HaveOccurred()) + Expect(mockInstaller.CleanupCallCount()).To(Equal(1)) }) It("creates a stage for the cleanup", func() { cpiInstaller := release.CpiInstaller{ InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) + mockInstaller.InstallReturns(installation, nil) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return nil @@ -138,8 +121,7 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(nil, errors.New("couldn't install that")) - expectCleanup.Times(0) + mockInstaller.InstallReturns(nil, errors.New("couldn't install that")) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return nil @@ -147,6 +129,7 @@ var _ = Describe("Installer", func() { Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("couldn't install that")) + Expect(mockInstaller.CleanupCallCount()).To(Equal(0)) }) }) @@ -156,7 +139,7 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) + mockInstaller.InstallReturns(installation, nil) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return errors.New("My passed in function failed") @@ -171,13 +154,13 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) - expectCleanup.Times(1) + mockInstaller.InstallReturns(installation, nil) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return errors.New("My passed in function failed") }) Expect(err).To(HaveOccurred()) + Expect(mockInstaller.CleanupCallCount()).To(Equal(1)) }) }) @@ -187,8 +170,8 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) - expectCleanup.Return(errors.New("cleanup failed")) + mockInstaller.InstallReturns(installation, nil) + mockInstaller.CleanupReturns(errors.New("cleanup failed")) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return nil @@ -203,8 +186,8 @@ var _ = Describe("Installer", func() { InstallerFactory: mockInstallerFactory, } - expectInstall.Return(installation, nil) - expectCleanup.Return(errors.New("cleanup failed")) + mockInstaller.InstallReturns(installation, nil) + mockInstaller.CleanupReturns(errors.New("cleanup failed")) err := cpiInstaller.WithInstalledCpiRelease(installationManifest, target, installStage, func(installation biinstallation.Installation) error { return errors.New("My passed in function failed") diff --git a/cpi/release/mocks/mocks.go b/cpi/release/mocks/mocks.go deleted file mode 100644 index 605240c4ca..0000000000 --- a/cpi/release/mocks/mocks.go +++ /dev/null @@ -1,41 +0,0 @@ -// Automatically generated by MockGen. DO NOT EDIT! -// Source: github.com/cloudfoundry/bosh-cli/v7/cpi/release (interfaces: CPIReleaseValidator) - -package mocks - -import ( - manifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// Mock of CPIReleaseValidator interface -type MockCPIReleaseValidator struct { - ctrl *gomock.Controller - recorder *_MockCPIReleaseValidatorRecorder -} - -// Recorder for MockCPIReleaseValidator (not exported) -type _MockCPIReleaseValidatorRecorder struct { - mock *MockCPIReleaseValidator -} - -func NewMockCPIReleaseValidator(ctrl *gomock.Controller) *MockCPIReleaseValidator { - mock := &MockCPIReleaseValidator{ctrl: ctrl} - mock.recorder = &_MockCPIReleaseValidatorRecorder{mock} - return mock -} - -func (_m *MockCPIReleaseValidator) EXPECT() *_MockCPIReleaseValidatorRecorder { - return _m.recorder -} - -func (_m *MockCPIReleaseValidator) RegisterValidCpiReleaseSpecifiedIn(_param0 string, _param1 manifest.Manifest, _param2 ui.Stage) error { - ret := _m.ctrl.Call(_m, "RegisterValidCpiReleaseSpecifiedIn", _param0, _param1, _param2) - ret0, _ := ret[0].(error) - return ret0 -} - -func (_mr *_MockCPIReleaseValidatorRecorder) RegisterValidCpiReleaseSpecifiedIn(arg0, arg1, arg2 interface{}) *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "RegisterValidCpiReleaseSpecifiedIn", arg0, arg1, arg2) -} diff --git a/deployment/deployer.go b/deployment/deployer.go index 25e1fb1d38..3c57417290 100644 --- a/deployment/deployer.go +++ b/deployment/deployer.go @@ -16,6 +16,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . Deployer + type Deployer interface { Deploy( cloud bicloud.Cloud, diff --git a/deployment/deployer_test.go b/deployment/deployer_test.go index 377cf99453..4391ca7ad7 100644 --- a/deployment/deployer_test.go +++ b/deployment/deployer_test.go @@ -5,47 +5,36 @@ import ( "github.com/cloudfoundry/bosh-agent/v2/agentclient" bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - mock_httpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mock_agentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mock_blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mock_instance_state "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" - mock_vm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("Deployer", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( deployer Deployer - mockVMManagerFactory *mock_vm.MockManagerFactory + mockVMManagerFactory *vmfakes.FakeManagerFactory fakeVMManager *fakebivm.FakeManager - mockAgentClient *mock_agentclient.MockAgentClient - mockAgentClientFactory *mock_httpagent.MockAgentClientFactory + mockAgentClient *agentclientfakes.FakeAgentClient + mockAgentClientFactory *cmdfakes.FakeAgentClientFactory fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory fakeSSHTunnel *fakebisshtunnel.FakeTunnel cloud *fakebicloud.FakeCloud @@ -60,11 +49,11 @@ var _ = Describe("Deployer", func() { applySpec bias.ApplySpec - mockStateBuilderFactory *mock_instance_state.MockBuilderFactory - mockStateBuilder *mock_instance_state.MockBuilder - mockState *mock_instance_state.MockState + mockStateBuilderFactory *statefakes.FakeBuilderFactory + mockStateBuilder *statefakes.FakeBuilder + mockState *statefakes.FakeState - mockBlobstore *mock_blobstore.MockBlobstore + mockBlobstore *blobstorefakes.FakeBlobstore ) BeforeEach(func() { @@ -98,13 +87,13 @@ var _ = Describe("Deployer", func() { diskCIDs = []string{"fake-disk-cid-1"} cloud = fakebicloud.NewFakeCloud() - mockAgentClientFactory = mock_httpagent.NewMockAgentClientFactory(mockCtrl) - mockAgentClient = mock_agentclient.NewMockAgentClient(mockCtrl) - mockAgentClientFactory.EXPECT().NewAgentClient(gomock.Any(), gomock.Any(), gomock.Any()).Return(mockAgentClient, nil).AnyTimes() + mockAgentClientFactory = &cmdfakes.FakeAgentClientFactory{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} + mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) - mockVMManagerFactory = mock_vm.NewMockManagerFactory(mockCtrl) + mockVMManagerFactory = &vmfakes.FakeManagerFactory{} fakeVMManager = fakebivm.NewFakeManager() - mockVMManagerFactory.EXPECT().NewManager(cloud, mockAgentClient).Return(fakeVMManager).AnyTimes() + mockVMManagerFactory.NewManagerReturns(fakeVMManager) fakeSSHTunnelFactory = fakebisshtunnel.NewFakeFactory() fakeSSHTunnel = fakebisshtunnel.NewFakeTunnel() @@ -131,14 +120,14 @@ var _ = Describe("Deployer", func() { cloudStemcell = bistemcell.NewCloudStemcell(stemcellRecord, fakeStemcellRepo, cloud) - mockStateBuilderFactory = mock_instance_state.NewMockBuilderFactory(mockCtrl) - mockStateBuilder = mock_instance_state.NewMockBuilder(mockCtrl) - mockState = mock_instance_state.NewMockState(mockCtrl) + mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} + mockStateBuilder = &statefakes.FakeBuilder{} + mockState = &statefakes.FakeState{} instanceFactory := biinstance.NewFactory(mockStateBuilderFactory) instanceManagerFactory := biinstance.NewManagerFactory(fakeSSHTunnelFactory, instanceFactory, logger) - mockBlobstore = mock_blobstore.NewMockBlobstore(mockCtrl) + mockBlobstore = &blobstorefakes.FakeBlobstore{} pingTimeout := 10 * time.Second pingDelay := 500 * time.Millisecond @@ -153,9 +142,6 @@ var _ = Describe("Deployer", func() { }) JustBeforeEach(func() { - jobName := "fake-job-name" - jobIndex := 0 - // since we're just passing this from State.ToApplySpec() to VM.Apply(), it doesn't need to be filled out applySpec = bias.ApplySpec{ Deployment: "fake-deployment-name", @@ -164,10 +150,10 @@ var _ = Describe("Deployer", func() { fakeAgentState := agentclient.AgentState{} fakeVM.GetStateResult = fakeAgentState - mockStateBuilderFactory.EXPECT().NewBuilder(mockBlobstore, mockAgentClient).Return(mockStateBuilder).AnyTimes() - mockStateBuilder.EXPECT().Build(jobName, jobIndex, deploymentManifest, fakeStage, fakeAgentState).Return(mockState, nil).AnyTimes() - mockStateBuilder.EXPECT().BuildInitialState(jobName, jobIndex, deploymentManifest).Return(mockState, nil).AnyTimes() - mockState.EXPECT().ToApplySpec().Return(applySpec).AnyTimes() + mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) + mockStateBuilder.BuildReturns(mockState, nil) + mockStateBuilder.BuildInitialStateReturns(mockState, nil) + mockState.ToApplySpecReturns(applySpec) }) Context("when a previous instance exists", func() { diff --git a/deployment/deployment.go b/deployment/deployment.go index d8b6fbed02..5aa2121c67 100644 --- a/deployment/deployment.go +++ b/deployment/deployment.go @@ -13,6 +13,10 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Deployment + type Deployment interface { Delete(bool, biui.Stage) error Stop(bool, biui.Stage) error diff --git a/deployment/deployment_test.go b/deployment/deployment_test.go index ba0a8e4631..2ee900eba2 100644 --- a/deployment/deployment_test.go +++ b/deployment/deployment_test.go @@ -10,19 +10,18 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mockblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - mockcloud "github.com/cloudfoundry/bosh-cli/v7/cloud/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" . "github.com/cloudfoundry/bosh-cli/v7/deployment" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mockinstancestate "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" @@ -33,9 +32,8 @@ import ( var _ = Describe("Deployment", func() { var ( - mockCtrl *gomock.Controller - logger boshlog.Logger - fs boshsys.FileSystem + logger boshlog.Logger + fs boshsys.FileSystem fakeUUIDGenerator *fakeuuid.FakeGenerator fakeRepoUUIDGenerator *fakeuuid.FakeGenerator @@ -44,14 +42,14 @@ var _ = Describe("Deployment", func() { diskRepo biconfig.DiskRepo stemcellRepo biconfig.StemcellRepo - mockCloud *mockcloud.MockCloud - mockAgentClient *mockagentclient.MockAgentClient + mockCloud *cloudfakes.FakeCloud + mockAgentClient *agentclientfakes.FakeAgentClient - mockStateBuilderFactory *mockinstancestate.MockBuilderFactory - mockStateBuilder *mockinstancestate.MockBuilder - mockState *mockinstancestate.MockState + mockStateBuilderFactory *statefakes.FakeBuilderFactory + mockStateBuilder *statefakes.FakeBuilder + mockState *statefakes.FakeState - mockBlobstore *mockblobstore.MockBlobstore + mockBlobstore *blobstorefakes.FakeBlobstore fakeStage *fakebiui.FakeStage @@ -60,10 +58,13 @@ var _ = Describe("Deployment", func() { stemcellApiVersion = 2 deployment Deployment skipDrain bool + + // callOrder records, in invocation order, every tracked mockCloud/mockAgentClient + // call made during a test -- the counterfeiter equivalent of gomock.InOrder(). + callOrder []string ) var allowApplySpecToBeCreated = func() { - jobName := "fake-job-name" jobIndex := 0 applySpec := bias.ApplySpec{ @@ -78,19 +79,18 @@ var _ = Describe("Deployment", func() { }, }, Job: bias.Job{ - Name: jobName, + Name: "fake-job-name", Templates: []bias.Blob{}, }, RenderedTemplatesArchive: bias.RenderedTemplatesArchiveSpec{}, ConfigurationHash: "", } - mockStateBuilderFactory.EXPECT().NewBuilder(mockBlobstore, mockAgentClient).Return(mockStateBuilder).AnyTimes() - mockState.EXPECT().ToApplySpec().Return(applySpec).AnyTimes() + mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) + mockState.ToApplySpecReturns(applySpec) } BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) logger = boshlog.NewLogger(boshlog.LevelNone) fs = fakesys.NewFakeFileSystem() @@ -102,8 +102,59 @@ var _ = Describe("Deployment", func() { diskRepo = biconfig.NewDiskRepo(deploymentStateService, fakeRepoUUIDGenerator) stemcellRepo = biconfig.NewStemcellRepo(deploymentStateService, fakeRepoUUIDGenerator) - mockCloud = mockcloud.NewMockCloud(mockCtrl) - mockAgentClient = mockagentclient.NewMockAgentClient(mockCtrl) + callOrder = nil + + mockCloud = &cloudfakes.FakeCloud{} + mockCloud.HasVMStub = func(cid string) (bool, error) { + callOrder = append(callOrder, "HasVM") + return true, nil + } + mockCloud.DeleteVMStub = func(cid string) error { + callOrder = append(callOrder, "DeleteVM") + return nil + } + mockCloud.DeleteDiskStub = func(cid string) error { + callOrder = append(callOrder, "DeleteDisk") + return nil + } + mockCloud.DeleteStemcellStub = func(cid string) error { + callOrder = append(callOrder, "DeleteStemcell") + return nil + } + + mockAgentClient = &agentclientfakes.FakeAgentClient{} + mockAgentClient.PingStub = func() (string, error) { + callOrder = append(callOrder, "Ping") + return "any-state", nil + } + mockAgentClient.RunScriptStub = func(name string, opts map[string]interface{}) error { + callOrder = append(callOrder, "RunScript:"+name) + return nil + } + mockAgentClient.DrainStub = func(state string) (int64, error) { + callOrder = append(callOrder, "Drain") + return 0, nil + } + mockAgentClient.StopStub = func() error { + callOrder = append(callOrder, "Stop") + return nil + } + mockAgentClient.ListDiskStub = func() ([]string, error) { + callOrder = append(callOrder, "ListDisk") + return []string{"fake-disk-cid"}, nil + } + mockAgentClient.UnmountDiskStub = func(cid string) error { + callOrder = append(callOrder, "UnmountDisk") + return nil + } + mockAgentClient.StartStub = func() error { + callOrder = append(callOrder, "Start") + return nil + } + mockAgentClient.GetStateStub = func() (biagentclient.AgentState, error) { + callOrder = append(callOrder, "GetState") + return biagentclient.AgentState{JobState: "running"}, nil + } fakeStage = fakebiui.NewFakeStage() @@ -122,15 +173,15 @@ var _ = Describe("Deployment", func() { vmManagerFactory := bivm.NewManagerFactory(vmRepo, stemcellRepo, diskDeployer, fakeUUIDGenerator, fs, logger) sshTunnelFactory := bisshtunnel.NewFactory(logger) - mockStateBuilderFactory = mockinstancestate.NewMockBuilderFactory(mockCtrl) - mockStateBuilder = mockinstancestate.NewMockBuilder(mockCtrl) - mockState = mockinstancestate.NewMockState(mockCtrl) + mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} + mockStateBuilder = &statefakes.FakeBuilder{} + mockState = &statefakes.FakeState{} instanceFactory := biinstance.NewFactory(mockStateBuilderFactory) instanceManagerFactory := biinstance.NewManagerFactory(sshTunnelFactory, instanceFactory, logger) stemcellManagerFactory := bistemcell.NewManagerFactory(stemcellRepo) - mockBlobstore = mockblobstore.NewMockBlobstore(mockCtrl) + mockBlobstore = &blobstorefakes.FakeBlobstore{} deploymentManagerFactory := NewManagerFactory(vmManagerFactory, instanceManagerFactory, diskManagerFactory, stemcellManagerFactory, deploymentFactory) deploymentManager := deploymentManagerFactory.NewManager(mockCloud, mockAgentClient, mockBlobstore) @@ -143,41 +194,15 @@ var _ = Describe("Deployment", func() { // Note: deployment will be nil if the config has no vms, disks, or stemcells }) - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Delete", func() { - var expectNormalFlow = func() { - gomock.InOrder( - mockCloud.EXPECT().HasVM("fake-vm-cid").Return(true, nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), // ping to make sure agent is responsive - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), // drain all jobs - mockAgentClient.EXPECT().Stop(), // stop all jobs - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{"fake-disk-cid"}, nil), // get mounted disks to be unmounted - mockAgentClient.EXPECT().UnmountDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteVM("fake-vm-cid"), - mockCloud.EXPECT().DeleteDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid"), - ) + normalFlowOrder := []string{ + "HasVM", "Ping", "RunScript:pre-stop", "Drain", "Stop", "RunScript:post-stop", + "ListDisk", "UnmountDisk", "DeleteVM", "DeleteDisk", "DeleteStemcell", } - - var expectDrainlessFlow = func() { - gomock.InOrder( - mockCloud.EXPECT().HasVM("fake-vm-cid").Return(true, nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), // ping to make sure agent is responsive - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Stop(), // stop all jobs - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{"fake-disk-cid"}, nil), // get mounted disks to be unmounted - mockAgentClient.EXPECT().UnmountDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteVM("fake-vm-cid"), - mockCloud.EXPECT().DeleteDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid"), - ) + drainlessFlowOrder := []string{ + "HasVM", "Ping", "RunScript:pre-stop", "Stop", "RunScript:post-stop", + "ListDisk", "UnmountDisk", "DeleteVM", "DeleteDisk", "DeleteStemcell", } Context("when the deployment has been deployed", func() { @@ -207,23 +232,20 @@ var _ = Describe("Deployment", func() { }) It("stops agent, unmounts disk, deletes vm, deletes disk, deletes stemcell", func() { - expectNormalFlow() - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal(normalFlowOrder)) }) It("skips draining if specified", func() { skipDrain = true - expectDrainlessFlow() err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal(drainlessFlowOrder)) }) It("logs validation stages", func() { - expectNormalFlow() - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -241,8 +263,6 @@ var _ = Describe("Deployment", func() { }) It("clears current vm, disk and stemcell", func() { - expectNormalFlow() - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -277,13 +297,10 @@ var _ = Describe("Deployment", func() { }) It("times out pinging agent, deletes vm, deletes disk, deletes stemcell", func() { - gomock.InOrder( - mockCloud.EXPECT().HasVM("fake-vm-cid").Return(true, nil), - mockAgentClient.EXPECT().Ping().Return("", bosherr.Error("unresponsive agent")).AnyTimes(), // ping to make sure agent is responsive - mockCloud.EXPECT().DeleteVM("fake-vm-cid"), - mockCloud.EXPECT().DeleteDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid"), - ) + mockAgentClient.PingStub = func() (string, error) { + callOrder = append(callOrder, "Ping") + return "", bosherr.Error("unresponsive agent") + } err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -292,8 +309,6 @@ var _ = Describe("Deployment", func() { Context("and delete previously suceeded", func() { JustBeforeEach(func() { - expectNormalFlow() - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -332,51 +347,44 @@ var _ = Describe("Deployment", func() { }) Context("when VM has been deployed", func() { - var ( - expectHasVM *gomock.Call - ) BeforeEach(func() { err := deploymentStateService.Save(biconfig.DeploymentState{}) Expect(err).ToNot(HaveOccurred()) err = vmRepo.UpdateCurrent("fake-vm-cid") Expect(err).ToNot(HaveOccurred()) - - expectHasVM = mockCloud.EXPECT().HasVM("fake-vm-cid").Return(true, nil) }) It("stops the agent and deletes the VM", func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("any-state", nil), // ping to make sure agent is responsive - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), // drain all jobs - mockAgentClient.EXPECT().Stop(), // stop all jobs - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{"fake-disk-cid"}, nil), // get mounted disks to be unmounted - mockAgentClient.EXPECT().UnmountDisk("fake-disk-cid"), - mockCloud.EXPECT().DeleteVM("fake-vm-cid"), - ) - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal([]string{ + "HasVM", "Ping", "RunScript:pre-stop", "Drain", "Stop", "RunScript:post-stop", + "ListDisk", "UnmountDisk", "DeleteVM", + })) }) Context("when VM has been deleted manually (outside of bosh)", func() { BeforeEach(func() { - expectHasVM.Return(false, nil) + mockCloud.HasVMStub = func(cid string) (bool, error) { + callOrder = append(callOrder, "HasVM") + return false, nil + } }) It("skips agent shutdown & deletes the VM (to ensure related resources are released by the CPI)", func() { - mockCloud.EXPECT().DeleteVM("fake-vm-cid") - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(mockCloud.DeleteVMCallCount()).To(Equal(1)) }) It("ignores VMNotFound errors", func() { - mockCloud.EXPECT().DeleteVM("fake-vm-cid").Return(bicloud.NewCPIError("delete_vm", bicloud.CmdError{ - Type: bicloud.VMNotFoundError, - Message: "fake-vm-not-found-message", - })) + mockCloud.DeleteVMStub = func(cid string) error { + callOrder = append(callOrder, "DeleteVM") + return bicloud.NewCPIError("delete_vm", bicloud.CmdError{ + Type: bicloud.VMNotFoundError, + Message: "fake-vm-not-found-message", + }) + } err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -395,25 +403,26 @@ var _ = Describe("Deployment", func() { }) It("deletes the disk", func() { - mockCloud.EXPECT().DeleteDisk("fake-disk-cid") - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(mockCloud.DeleteDiskCallCount()).To(Equal(1)) }) Context("when current disk has been deleted manually (outside of bosh)", func() { It("deletes the disk (to ensure related resources are released by the CPI)", func() { - mockCloud.EXPECT().DeleteDisk("fake-disk-cid") - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(mockCloud.DeleteDiskCallCount()).To(Equal(1)) }) It("ignores DiskNotFound errors", func() { - mockCloud.EXPECT().DeleteDisk("fake-disk-cid").Return(bicloud.NewCPIError("delete_disk", bicloud.CmdError{ - Type: bicloud.DiskNotFoundError, - Message: "fake-disk-not-found-message", - })) + mockCloud.DeleteDiskStub = func(cid string) error { + callOrder = append(callOrder, "DeleteDisk") + return bicloud.NewCPIError("delete_disk", bicloud.CmdError{ + Type: bicloud.DiskNotFoundError, + Message: "fake-disk-not-found-message", + }) + } err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -432,25 +441,26 @@ var _ = Describe("Deployment", func() { }) It("deletes the stemcell", func() { - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid") - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(mockCloud.DeleteStemcellCallCount()).To(Equal(1)) }) Context("when current stemcell has been deleted manually (outside of bosh)", func() { It("deletes the stemcell (to ensure related resources are released by the CPI)", func() { - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid") - err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(mockCloud.DeleteStemcellCallCount()).To(Equal(1)) }) It("ignores StemcellNotFound errors", func() { - mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid").Return(bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ - Type: bicloud.StemcellNotFoundError, - Message: "fake-stemcell-not-found-message", - })) + mockCloud.DeleteStemcellStub = func(cid string) error { + callOrder = append(callOrder, "DeleteStemcell") + return bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ + Type: bicloud.StemcellNotFoundError, + Message: "fake-stemcell-not-found-message", + }) + } err := deployment.Delete(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -461,24 +471,8 @@ var _ = Describe("Deployment", func() { Describe("Stop", func() { - var expectNormalFlow = func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - ) - } - - var expectDrainlessFlow = func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - ) - } + stopNormalFlowOrder := []string{"Ping", "RunScript:pre-stop", "Drain", "Stop", "RunScript:post-stop"} + stopDrainlessFlowOrder := []string{"Ping", "RunScript:pre-stop", "Stop", "RunScript:post-stop"} Context("when the deployment has been deployed", func() { BeforeEach(func() { @@ -507,23 +501,20 @@ var _ = Describe("Deployment", func() { }) It("stops agent and executes the pre-stop and post-stop scripts", func() { - expectNormalFlow() - err := deployment.Stop(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal(stopNormalFlowOrder)) }) It("skips draining if specified", func() { skipDrain = true - expectDrainlessFlow() err := deployment.Stop(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal(stopDrainlessFlowOrder)) }) It("logs validation stages", func() { - expectNormalFlow() - err := deployment.Stop(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -545,9 +536,10 @@ var _ = Describe("Deployment", func() { }) It("times out pinging agent and does nothing", func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("", bosherr.Error("unresponsive agent")).AnyTimes(), - ) + mockAgentClient.PingStub = func() (string, error) { + callOrder = append(callOrder, "Ping") + return "", bosherr.Error("unresponsive agent") + } err := deployment.Stop(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -556,8 +548,6 @@ var _ = Describe("Deployment", func() { Context("and delete previously suceeded", func() { JustBeforeEach(func() { - expectNormalFlow() - err := deployment.Stop(skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -597,16 +587,7 @@ var _ = Describe("Deployment", func() { }) Describe("Start", func() { - var agentRunningState = biagentclient.AgentState{JobState: "running"} - var expectNormalFlow = func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("any-state", nil), // ping to make sure agent is responsive - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}), - mockAgentClient.EXPECT().Start(), // stop all jobs - mockAgentClient.EXPECT().GetState().AnyTimes().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}), - ) - } + startNormalFlowOrder := []string{"Ping", "RunScript:pre-start", "Start", "GetState", "RunScript:post-start"} var update = bideplmanifest.Update{ UpdateWatchTime: bideplmanifest.WatchTime{ @@ -642,15 +623,12 @@ var _ = Describe("Deployment", func() { }) It("starts agent and executes the pre-start and post-start scripts", func() { - expectNormalFlow() - err := deployment.Start(fakeStage, update) Expect(err).ToNot(HaveOccurred()) + Expect(callOrder).To(Equal(startNormalFlowOrder)) }) It("logs validation stages", func() { - expectNormalFlow() - err := deployment.Start(fakeStage, update) Expect(err).ToNot(HaveOccurred()) @@ -672,9 +650,10 @@ var _ = Describe("Deployment", func() { }) It("times out pinging agent and does nothing", func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("", bosherr.Error("unresponsive agent")).AnyTimes(), // ping to make sure agent is responsive - ) + mockAgentClient.PingStub = func() (string, error) { + callOrder = append(callOrder, "Ping") + return "", bosherr.Error("unresponsive agent") + } err := deployment.Start(fakeStage, update) Expect(err).ToNot(HaveOccurred()) @@ -682,29 +661,16 @@ var _ = Describe("Deployment", func() { }) Context("and start previously suceeded", func() { - var expectNormalFlow = func() { - gomock.InOrder( - mockAgentClient.EXPECT().Ping().Return("any-state", nil).AnyTimes(), - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}).AnyTimes(), - mockAgentClient.EXPECT().Start().AnyTimes(), - mockAgentClient.EXPECT().GetState().AnyTimes().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}).AnyTimes(), - ) - } - JustBeforeEach(func() { - expectNormalFlow() - err := deployment.Start(fakeStage, update) Expect(err).ToNot(HaveOccurred()) // reset event log recording fakeStage = fakebiui.NewFakeStage() + callOrder = nil }) It("does execute the normal flow", func() { - expectNormalFlow() - err := deployment.Start(fakeStage, update) Expect(err).ToNot(HaveOccurred()) }) diff --git a/deployment/deploymentfakes/fake_deployer.go b/deployment/deploymentfakes/fake_deployer.go new file mode 100644 index 0000000000..c14cda4ae2 --- /dev/null +++ b/deployment/deploymentfakes/fake_deployer.go @@ -0,0 +1,139 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package deploymentfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/blobstore" + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" + "github.com/cloudfoundry/bosh-cli/v7/stemcell" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDeployer struct { + DeployStub func(cloud.Cloud, manifest.Manifest, stemcell.CloudStemcell, vm.Manager, blobstore.Blobstore, bool, []string, ui.Stage) (deployment.Deployment, error) + deployMutex sync.RWMutex + deployArgsForCall []struct { + arg1 cloud.Cloud + arg2 manifest.Manifest + arg3 stemcell.CloudStemcell + arg4 vm.Manager + arg5 blobstore.Blobstore + arg6 bool + arg7 []string + arg8 ui.Stage + } + deployReturns struct { + result1 deployment.Deployment + result2 error + } + deployReturnsOnCall map[int]struct { + result1 deployment.Deployment + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDeployer) Deploy(arg1 cloud.Cloud, arg2 manifest.Manifest, arg3 stemcell.CloudStemcell, arg4 vm.Manager, arg5 blobstore.Blobstore, arg6 bool, arg7 []string, arg8 ui.Stage) (deployment.Deployment, error) { + var arg7Copy []string + if arg7 != nil { + arg7Copy = make([]string, len(arg7)) + copy(arg7Copy, arg7) + } + fake.deployMutex.Lock() + ret, specificReturn := fake.deployReturnsOnCall[len(fake.deployArgsForCall)] + fake.deployArgsForCall = append(fake.deployArgsForCall, struct { + arg1 cloud.Cloud + arg2 manifest.Manifest + arg3 stemcell.CloudStemcell + arg4 vm.Manager + arg5 blobstore.Blobstore + arg6 bool + arg7 []string + arg8 ui.Stage + }{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8}) + stub := fake.DeployStub + fakeReturns := fake.deployReturns + fake.recordInvocation("Deploy", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6, arg7Copy, arg8}) + fake.deployMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDeployer) DeployCallCount() int { + fake.deployMutex.RLock() + defer fake.deployMutex.RUnlock() + return len(fake.deployArgsForCall) +} + +func (fake *FakeDeployer) DeployCalls(stub func(cloud.Cloud, manifest.Manifest, stemcell.CloudStemcell, vm.Manager, blobstore.Blobstore, bool, []string, ui.Stage) (deployment.Deployment, error)) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = stub +} + +func (fake *FakeDeployer) DeployArgsForCall(i int) (cloud.Cloud, manifest.Manifest, stemcell.CloudStemcell, vm.Manager, blobstore.Blobstore, bool, []string, ui.Stage) { + fake.deployMutex.RLock() + defer fake.deployMutex.RUnlock() + argsForCall := fake.deployArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6, argsForCall.arg7, argsForCall.arg8 +} + +func (fake *FakeDeployer) DeployReturns(result1 deployment.Deployment, result2 error) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = nil + fake.deployReturns = struct { + result1 deployment.Deployment + result2 error + }{result1, result2} +} + +func (fake *FakeDeployer) DeployReturnsOnCall(i int, result1 deployment.Deployment, result2 error) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = nil + if fake.deployReturnsOnCall == nil { + fake.deployReturnsOnCall = make(map[int]struct { + result1 deployment.Deployment + result2 error + }) + } + fake.deployReturnsOnCall[i] = struct { + result1 deployment.Deployment + result2 error + }{result1, result2} +} + +func (fake *FakeDeployer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDeployer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ deployment.Deployer = new(FakeDeployer) diff --git a/deployment/deploymentfakes/fake_deployment.go b/deployment/deploymentfakes/fake_deployment.go new file mode 100644 index 0000000000..21f76b331d --- /dev/null +++ b/deployment/deploymentfakes/fake_deployment.go @@ -0,0 +1,261 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package deploymentfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDeployment struct { + DeleteStub func(bool, ui.Stage) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + arg1 bool + arg2 ui.Stage + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + StartStub func(ui.Stage, manifest.Update) error + startMutex sync.RWMutex + startArgsForCall []struct { + arg1 ui.Stage + arg2 manifest.Update + } + startReturns struct { + result1 error + } + startReturnsOnCall map[int]struct { + result1 error + } + StopStub func(bool, ui.Stage) error + stopMutex sync.RWMutex + stopArgsForCall []struct { + arg1 bool + arg2 ui.Stage + } + stopReturns struct { + result1 error + } + stopReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDeployment) Delete(arg1 bool, arg2 ui.Stage) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + arg1 bool + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{arg1, arg2}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeployment) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeDeployment) DeleteCalls(stub func(bool, ui.Stage) error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeDeployment) DeleteArgsForCall(i int) (bool, ui.Stage) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + argsForCall := fake.deleteArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDeployment) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) Start(arg1 ui.Stage, arg2 manifest.Update) error { + fake.startMutex.Lock() + ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)] + fake.startArgsForCall = append(fake.startArgsForCall, struct { + arg1 ui.Stage + arg2 manifest.Update + }{arg1, arg2}) + stub := fake.StartStub + fakeReturns := fake.startReturns + fake.recordInvocation("Start", []interface{}{arg1, arg2}) + fake.startMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeployment) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeDeployment) StartCalls(stub func(ui.Stage, manifest.Update) error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + +func (fake *FakeDeployment) StartArgsForCall(i int) (ui.Stage, manifest.Update) { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + argsForCall := fake.startArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDeployment) StartReturns(result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + fake.startReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) StartReturnsOnCall(i int, result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + if fake.startReturnsOnCall == nil { + fake.startReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.startReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) Stop(arg1 bool, arg2 ui.Stage) error { + fake.stopMutex.Lock() + ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] + fake.stopArgsForCall = append(fake.stopArgsForCall, struct { + arg1 bool + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.StopStub + fakeReturns := fake.stopReturns + fake.recordInvocation("Stop", []interface{}{arg1, arg2}) + fake.stopMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeployment) StopCallCount() int { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + return len(fake.stopArgsForCall) +} + +func (fake *FakeDeployment) StopCalls(stub func(bool, ui.Stage) error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = stub +} + +func (fake *FakeDeployment) StopArgsForCall(i int) (bool, ui.Stage) { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + argsForCall := fake.stopArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDeployment) StopReturns(result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + fake.stopReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) StopReturnsOnCall(i int, result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + if fake.stopReturnsOnCall == nil { + fake.stopReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.stopReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeployment) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDeployment) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ deployment.Deployment = new(FakeDeployment) diff --git a/deployment/deploymentfakes/fake_factory.go b/deployment/deploymentfakes/fake_factory.go new file mode 100644 index 0000000000..4273898ae7 --- /dev/null +++ b/deployment/deploymentfakes/fake_factory.go @@ -0,0 +1,131 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package deploymentfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" + "github.com/cloudfoundry/bosh-cli/v7/stemcell" +) + +type FakeFactory struct { + NewDeploymentStub func([]instance.Instance, []disk.Disk, []stemcell.CloudStemcell) deployment.Deployment + newDeploymentMutex sync.RWMutex + newDeploymentArgsForCall []struct { + arg1 []instance.Instance + arg2 []disk.Disk + arg3 []stemcell.CloudStemcell + } + newDeploymentReturns struct { + result1 deployment.Deployment + } + newDeploymentReturnsOnCall map[int]struct { + result1 deployment.Deployment + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeFactory) NewDeployment(arg1 []instance.Instance, arg2 []disk.Disk, arg3 []stemcell.CloudStemcell) deployment.Deployment { + var arg1Copy []instance.Instance + if arg1 != nil { + arg1Copy = make([]instance.Instance, len(arg1)) + copy(arg1Copy, arg1) + } + var arg2Copy []disk.Disk + if arg2 != nil { + arg2Copy = make([]disk.Disk, len(arg2)) + copy(arg2Copy, arg2) + } + var arg3Copy []stemcell.CloudStemcell + if arg3 != nil { + arg3Copy = make([]stemcell.CloudStemcell, len(arg3)) + copy(arg3Copy, arg3) + } + fake.newDeploymentMutex.Lock() + ret, specificReturn := fake.newDeploymentReturnsOnCall[len(fake.newDeploymentArgsForCall)] + fake.newDeploymentArgsForCall = append(fake.newDeploymentArgsForCall, struct { + arg1 []instance.Instance + arg2 []disk.Disk + arg3 []stemcell.CloudStemcell + }{arg1Copy, arg2Copy, arg3Copy}) + stub := fake.NewDeploymentStub + fakeReturns := fake.newDeploymentReturns + fake.recordInvocation("NewDeployment", []interface{}{arg1Copy, arg2Copy, arg3Copy}) + fake.newDeploymentMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeFactory) NewDeploymentCallCount() int { + fake.newDeploymentMutex.RLock() + defer fake.newDeploymentMutex.RUnlock() + return len(fake.newDeploymentArgsForCall) +} + +func (fake *FakeFactory) NewDeploymentCalls(stub func([]instance.Instance, []disk.Disk, []stemcell.CloudStemcell) deployment.Deployment) { + fake.newDeploymentMutex.Lock() + defer fake.newDeploymentMutex.Unlock() + fake.NewDeploymentStub = stub +} + +func (fake *FakeFactory) NewDeploymentArgsForCall(i int) ([]instance.Instance, []disk.Disk, []stemcell.CloudStemcell) { + fake.newDeploymentMutex.RLock() + defer fake.newDeploymentMutex.RUnlock() + argsForCall := fake.newDeploymentArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeFactory) NewDeploymentReturns(result1 deployment.Deployment) { + fake.newDeploymentMutex.Lock() + defer fake.newDeploymentMutex.Unlock() + fake.NewDeploymentStub = nil + fake.newDeploymentReturns = struct { + result1 deployment.Deployment + }{result1} +} + +func (fake *FakeFactory) NewDeploymentReturnsOnCall(i int, result1 deployment.Deployment) { + fake.newDeploymentMutex.Lock() + defer fake.newDeploymentMutex.Unlock() + fake.NewDeploymentStub = nil + if fake.newDeploymentReturnsOnCall == nil { + fake.newDeploymentReturnsOnCall = make(map[int]struct { + result1 deployment.Deployment + }) + } + fake.newDeploymentReturnsOnCall[i] = struct { + result1 deployment.Deployment + }{result1} +} + +func (fake *FakeFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ deployment.Factory = new(FakeFactory) diff --git a/deployment/deploymentfakes/fake_manager.go b/deployment/deploymentfakes/fake_manager.go new file mode 100644 index 0000000000..525957a4c5 --- /dev/null +++ b/deployment/deploymentfakes/fake_manager.go @@ -0,0 +1,183 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package deploymentfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeManager struct { + CleanupStub func(ui.Stage) error + cleanupMutex sync.RWMutex + cleanupArgsForCall []struct { + arg1 ui.Stage + } + cleanupReturns struct { + result1 error + } + cleanupReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() (deployment.Deployment, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 deployment.Deployment + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 deployment.Deployment + result2 bool + result3 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) Cleanup(arg1 ui.Stage) error { + fake.cleanupMutex.Lock() + ret, specificReturn := fake.cleanupReturnsOnCall[len(fake.cleanupArgsForCall)] + fake.cleanupArgsForCall = append(fake.cleanupArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.CleanupStub + fakeReturns := fake.cleanupReturns + fake.recordInvocation("Cleanup", []interface{}{arg1}) + fake.cleanupMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) CleanupCallCount() int { + fake.cleanupMutex.RLock() + defer fake.cleanupMutex.RUnlock() + return len(fake.cleanupArgsForCall) +} + +func (fake *FakeManager) CleanupCalls(stub func(ui.Stage) error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = stub +} + +func (fake *FakeManager) CleanupArgsForCall(i int) ui.Stage { + fake.cleanupMutex.RLock() + defer fake.cleanupMutex.RUnlock() + argsForCall := fake.cleanupArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManager) CleanupReturns(result1 error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = nil + fake.cleanupReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) CleanupReturnsOnCall(i int, result1 error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = nil + if fake.cleanupReturnsOnCall == nil { + fake.cleanupReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.cleanupReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) FindCurrent() (deployment.Deployment, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() (deployment.Deployment, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeManager) FindCurrentReturns(result1 deployment.Deployment, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 deployment.Deployment + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 deployment.Deployment, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 deployment.Deployment + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 deployment.Deployment + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ deployment.Manager = new(FakeManager) diff --git a/deployment/deploymentfakes/fake_manager_factory.go b/deployment/deploymentfakes/fake_manager_factory.go new file mode 100644 index 0000000000..da9dd5cc90 --- /dev/null +++ b/deployment/deploymentfakes/fake_manager_factory.go @@ -0,0 +1,116 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package deploymentfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-cli/v7/blobstore" + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/deployment" +) + +type FakeManagerFactory struct { + NewManagerStub func(cloud.Cloud, agentclient.AgentClient, blobstore.Blobstore) deployment.Manager + newManagerMutex sync.RWMutex + newManagerArgsForCall []struct { + arg1 cloud.Cloud + arg2 agentclient.AgentClient + arg3 blobstore.Blobstore + } + newManagerReturns struct { + result1 deployment.Manager + } + newManagerReturnsOnCall map[int]struct { + result1 deployment.Manager + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManagerFactory) NewManager(arg1 cloud.Cloud, arg2 agentclient.AgentClient, arg3 blobstore.Blobstore) deployment.Manager { + fake.newManagerMutex.Lock() + ret, specificReturn := fake.newManagerReturnsOnCall[len(fake.newManagerArgsForCall)] + fake.newManagerArgsForCall = append(fake.newManagerArgsForCall, struct { + arg1 cloud.Cloud + arg2 agentclient.AgentClient + arg3 blobstore.Blobstore + }{arg1, arg2, arg3}) + stub := fake.NewManagerStub + fakeReturns := fake.newManagerReturns + fake.recordInvocation("NewManager", []interface{}{arg1, arg2, arg3}) + fake.newManagerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManagerFactory) NewManagerCallCount() int { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + return len(fake.newManagerArgsForCall) +} + +func (fake *FakeManagerFactory) NewManagerCalls(stub func(cloud.Cloud, agentclient.AgentClient, blobstore.Blobstore) deployment.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = stub +} + +func (fake *FakeManagerFactory) NewManagerArgsForCall(i int) (cloud.Cloud, agentclient.AgentClient, blobstore.Blobstore) { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + argsForCall := fake.newManagerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeManagerFactory) NewManagerReturns(result1 deployment.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + fake.newManagerReturns = struct { + result1 deployment.Manager + }{result1} +} + +func (fake *FakeManagerFactory) NewManagerReturnsOnCall(i int, result1 deployment.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + if fake.newManagerReturnsOnCall == nil { + fake.newManagerReturnsOnCall = make(map[int]struct { + result1 deployment.Manager + }) + } + fake.newManagerReturnsOnCall[i] = struct { + result1 deployment.Manager + }{result1} +} + +func (fake *FakeManagerFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManagerFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ deployment.ManagerFactory = new(FakeManagerFactory) diff --git a/deployment/disk/disk.go b/deployment/disk/disk.go index 8e55f0ae34..3ce1a5b39d 100644 --- a/deployment/disk/disk.go +++ b/deployment/disk/disk.go @@ -11,6 +11,10 @@ import ( biconfig "github.com/cloudfoundry/bosh-cli/v7/config" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Disk + type Disk interface { CID() string NeedsMigration(newSize int, newCloudProperties biproperty.Map) (bool, error) diff --git a/deployment/disk/diskfakes/fake_disk.go b/deployment/disk/diskfakes/fake_disk.go new file mode 100644 index 0000000000..468207a1d5 --- /dev/null +++ b/deployment/disk/diskfakes/fake_disk.go @@ -0,0 +1,243 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package diskfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-utils/property" +) + +type FakeDisk struct { + CIDStub func() string + cIDMutex sync.RWMutex + cIDArgsForCall []struct { + } + cIDReturns struct { + result1 string + } + cIDReturnsOnCall map[int]struct { + result1 string + } + DeleteStub func() error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + NeedsMigrationStub func(int, property.Map) (bool, error) + needsMigrationMutex sync.RWMutex + needsMigrationArgsForCall []struct { + arg1 int + arg2 property.Map + } + needsMigrationReturns struct { + result1 bool + result2 error + } + needsMigrationReturnsOnCall map[int]struct { + result1 bool + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDisk) CID() string { + fake.cIDMutex.Lock() + ret, specificReturn := fake.cIDReturnsOnCall[len(fake.cIDArgsForCall)] + fake.cIDArgsForCall = append(fake.cIDArgsForCall, struct { + }{}) + stub := fake.CIDStub + fakeReturns := fake.cIDReturns + fake.recordInvocation("CID", []interface{}{}) + fake.cIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDisk) CIDCallCount() int { + fake.cIDMutex.RLock() + defer fake.cIDMutex.RUnlock() + return len(fake.cIDArgsForCall) +} + +func (fake *FakeDisk) CIDCalls(stub func() string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = stub +} + +func (fake *FakeDisk) CIDReturns(result1 string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = nil + fake.cIDReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeDisk) CIDReturnsOnCall(i int, result1 string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = nil + if fake.cIDReturnsOnCall == nil { + fake.cIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.cIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeDisk) Delete() error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + }{}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDisk) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeDisk) DeleteCalls(stub func() error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeDisk) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDisk) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDisk) NeedsMigration(arg1 int, arg2 property.Map) (bool, error) { + fake.needsMigrationMutex.Lock() + ret, specificReturn := fake.needsMigrationReturnsOnCall[len(fake.needsMigrationArgsForCall)] + fake.needsMigrationArgsForCall = append(fake.needsMigrationArgsForCall, struct { + arg1 int + arg2 property.Map + }{arg1, arg2}) + stub := fake.NeedsMigrationStub + fakeReturns := fake.needsMigrationReturns + fake.recordInvocation("NeedsMigration", []interface{}{arg1, arg2}) + fake.needsMigrationMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDisk) NeedsMigrationCallCount() int { + fake.needsMigrationMutex.RLock() + defer fake.needsMigrationMutex.RUnlock() + return len(fake.needsMigrationArgsForCall) +} + +func (fake *FakeDisk) NeedsMigrationCalls(stub func(int, property.Map) (bool, error)) { + fake.needsMigrationMutex.Lock() + defer fake.needsMigrationMutex.Unlock() + fake.NeedsMigrationStub = stub +} + +func (fake *FakeDisk) NeedsMigrationArgsForCall(i int) (int, property.Map) { + fake.needsMigrationMutex.RLock() + defer fake.needsMigrationMutex.RUnlock() + argsForCall := fake.needsMigrationArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDisk) NeedsMigrationReturns(result1 bool, result2 error) { + fake.needsMigrationMutex.Lock() + defer fake.needsMigrationMutex.Unlock() + fake.NeedsMigrationStub = nil + fake.needsMigrationReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeDisk) NeedsMigrationReturnsOnCall(i int, result1 bool, result2 error) { + fake.needsMigrationMutex.Lock() + defer fake.needsMigrationMutex.Unlock() + fake.NeedsMigrationStub = nil + if fake.needsMigrationReturnsOnCall == nil { + fake.needsMigrationReturnsOnCall = make(map[int]struct { + result1 bool + result2 error + }) + } + fake.needsMigrationReturnsOnCall[i] = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeDisk) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDisk) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ disk.Disk = new(FakeDisk) diff --git a/deployment/disk/diskfakes/fake_manager.go b/deployment/disk/diskfakes/fake_manager.go new file mode 100644 index 0000000000..c8d70ecdf6 --- /dev/null +++ b/deployment/disk/diskfakes/fake_manager.go @@ -0,0 +1,326 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package diskfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeManager struct { + CreateStub func(manifest.DiskPool, string) (disk.Disk, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 manifest.DiskPool + arg2 string + } + createReturns struct { + result1 disk.Disk + result2 error + } + createReturnsOnCall map[int]struct { + result1 disk.Disk + result2 error + } + DeleteUnusedStub func(ui.Stage) error + deleteUnusedMutex sync.RWMutex + deleteUnusedArgsForCall []struct { + arg1 ui.Stage + } + deleteUnusedReturns struct { + result1 error + } + deleteUnusedReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() ([]disk.Disk, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 []disk.Disk + result2 error + } + findCurrentReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + FindUnusedStub func() ([]disk.Disk, error) + findUnusedMutex sync.RWMutex + findUnusedArgsForCall []struct { + } + findUnusedReturns struct { + result1 []disk.Disk + result2 error + } + findUnusedReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) Create(arg1 manifest.DiskPool, arg2 string) (disk.Disk, error) { + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 manifest.DiskPool + arg2 string + }{arg1, arg2}) + stub := fake.CreateStub + fakeReturns := fake.createReturns + fake.recordInvocation("Create", []interface{}{arg1, arg2}) + fake.createMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeManager) CreateCalls(stub func(manifest.DiskPool, string) (disk.Disk, error)) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = stub +} + +func (fake *FakeManager) CreateArgsForCall(i int) (manifest.DiskPool, string) { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + argsForCall := fake.createArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeManager) CreateReturns(result1 disk.Disk, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + fake.createReturns = struct { + result1 disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) CreateReturnsOnCall(i int, result1 disk.Disk, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 disk.Disk + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) DeleteUnused(arg1 ui.Stage) error { + fake.deleteUnusedMutex.Lock() + ret, specificReturn := fake.deleteUnusedReturnsOnCall[len(fake.deleteUnusedArgsForCall)] + fake.deleteUnusedArgsForCall = append(fake.deleteUnusedArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.DeleteUnusedStub + fakeReturns := fake.deleteUnusedReturns + fake.recordInvocation("DeleteUnused", []interface{}{arg1}) + fake.deleteUnusedMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) DeleteUnusedCallCount() int { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + return len(fake.deleteUnusedArgsForCall) +} + +func (fake *FakeManager) DeleteUnusedCalls(stub func(ui.Stage) error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = stub +} + +func (fake *FakeManager) DeleteUnusedArgsForCall(i int) ui.Stage { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + argsForCall := fake.deleteUnusedArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManager) DeleteUnusedReturns(result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + fake.deleteUnusedReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) DeleteUnusedReturnsOnCall(i int, result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + if fake.deleteUnusedReturnsOnCall == nil { + fake.deleteUnusedReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteUnusedReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) FindCurrent() ([]disk.Disk, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() ([]disk.Disk, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeManager) FindCurrentReturns(result1 []disk.Disk, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnused() ([]disk.Disk, error) { + fake.findUnusedMutex.Lock() + ret, specificReturn := fake.findUnusedReturnsOnCall[len(fake.findUnusedArgsForCall)] + fake.findUnusedArgsForCall = append(fake.findUnusedArgsForCall, struct { + }{}) + stub := fake.FindUnusedStub + fakeReturns := fake.findUnusedReturns + fake.recordInvocation("FindUnused", []interface{}{}) + fake.findUnusedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindUnusedCallCount() int { + fake.findUnusedMutex.RLock() + defer fake.findUnusedMutex.RUnlock() + return len(fake.findUnusedArgsForCall) +} + +func (fake *FakeManager) FindUnusedCalls(stub func() ([]disk.Disk, error)) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = stub +} + +func (fake *FakeManager) FindUnusedReturns(result1 []disk.Disk, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + fake.findUnusedReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnusedReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + if fake.findUnusedReturnsOnCall == nil { + fake.findUnusedReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.findUnusedReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ disk.Manager = new(FakeManager) diff --git a/deployment/disk/manager.go b/deployment/disk/manager.go index 211dc4186c..e2706f9c20 100644 --- a/deployment/disk/manager.go +++ b/deployment/disk/manager.go @@ -13,6 +13,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . Manager + type Manager interface { FindCurrent() ([]Disk, error) Create(bideplmanifest.DiskPool, string) (Disk, error) diff --git a/deployment/disk/mocks/mocks.go b/deployment/disk/mocks/mocks.go deleted file mode 100644 index c03462260c..0000000000 --- a/deployment/disk/mocks/mocks.go +++ /dev/null @@ -1,163 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment/disk (interfaces: Disk,Manager) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - disk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - manifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - property "github.com/cloudfoundry/bosh-utils/property" - gomock "github.com/golang/mock/gomock" -) - -// MockDisk is a mock of Disk interface. -type MockDisk struct { - ctrl *gomock.Controller - recorder *MockDiskMockRecorder -} - -// MockDiskMockRecorder is the mock recorder for MockDisk. -type MockDiskMockRecorder struct { - mock *MockDisk -} - -// NewMockDisk creates a new mock instance. -func NewMockDisk(ctrl *gomock.Controller) *MockDisk { - mock := &MockDisk{ctrl: ctrl} - mock.recorder = &MockDiskMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDisk) EXPECT() *MockDiskMockRecorder { - return m.recorder -} - -// CID mocks base method. -func (m *MockDisk) CID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CID") - ret0, _ := ret[0].(string) - return ret0 -} - -// CID indicates an expected call of CID. -func (mr *MockDiskMockRecorder) CID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CID", reflect.TypeOf((*MockDisk)(nil).CID)) -} - -// Delete mocks base method. -func (m *MockDisk) Delete() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete") - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockDiskMockRecorder) Delete() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDisk)(nil).Delete)) -} - -// NeedsMigration mocks base method. -func (m *MockDisk) NeedsMigration(arg0 int, arg1 property.Map) (bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NeedsMigration", arg0, arg1) - ret0, _ := ret[0].(bool) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// NeedsMigration indicates an expected call of NeedsMigration. -func (mr *MockDiskMockRecorder) NeedsMigration(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NeedsMigration", reflect.TypeOf((*MockDisk)(nil).NeedsMigration), arg0, arg1) -} - -// MockManager is a mock of Manager interface. -type MockManager struct { - ctrl *gomock.Controller - recorder *MockManagerMockRecorder -} - -// MockManagerMockRecorder is the mock recorder for MockManager. -type MockManagerMockRecorder struct { - mock *MockManager -} - -// NewMockManager creates a new mock instance. -func NewMockManager(ctrl *gomock.Controller) *MockManager { - mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder -} - -// Create mocks base method. -func (m *MockManager) Create(arg0 manifest.DiskPool, arg1 string) (disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1) - ret0, _ := ret[0].(disk.Disk) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Create indicates an expected call of Create. -func (mr *MockManagerMockRecorder) Create(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockManager)(nil).Create), arg0, arg1) -} - -// DeleteUnused mocks base method. -func (m *MockManager) DeleteUnused(arg0 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteUnused", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteUnused indicates an expected call of DeleteUnused. -func (mr *MockManagerMockRecorder) DeleteUnused(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUnused", reflect.TypeOf((*MockManager)(nil).DeleteUnused), arg0) -} - -// FindCurrent mocks base method. -func (m *MockManager) FindCurrent() ([]disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindCurrent") - ret0, _ := ret[0].([]disk.Disk) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindCurrent indicates an expected call of FindCurrent. -func (mr *MockManagerMockRecorder) FindCurrent() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCurrent", reflect.TypeOf((*MockManager)(nil).FindCurrent)) -} - -// FindUnused mocks base method. -func (m *MockManager) FindUnused() ([]disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindUnused") - ret0, _ := ret[0].([]disk.Disk) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindUnused indicates an expected call of FindUnused. -func (mr *MockManagerMockRecorder) FindUnused() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindUnused", reflect.TypeOf((*MockManager)(nil).FindUnused)) -} diff --git a/deployment/factory.go b/deployment/factory.go index a36b90bd2e..1389534732 100644 --- a/deployment/factory.go +++ b/deployment/factory.go @@ -8,6 +8,8 @@ import ( bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" ) +//counterfeiter:generate . Factory + type Factory interface { NewDeployment( []biinstance.Instance, diff --git a/deployment/instance/instance.go b/deployment/instance/instance.go index 6f92a2f5f6..4310b62be9 100644 --- a/deployment/instance/instance.go +++ b/deployment/instance/instance.go @@ -17,6 +17,10 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Instance + type Instance interface { JobName() string ID() int diff --git a/deployment/instance/instance_test.go b/deployment/instance/instance_test.go index 967c434e6a..80ebc9c4f9 100644 --- a/deployment/instance/instance_test.go +++ b/deployment/instance/instance_test.go @@ -7,7 +7,6 @@ import ( bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" bosherr "github.com/cloudfoundry/bosh-utils/errors" "github.com/cloudfoundry/bosh-utils/logger/loggerfakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -15,7 +14,7 @@ import ( bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mock_instance_state "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" @@ -24,19 +23,9 @@ import ( var _ = Describe("Instance", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockStateBuilder *mock_instance_state.MockBuilder - mockState *mock_instance_state.MockState + mockStateBuilder *statefakes.FakeBuilder + mockState *statefakes.FakeState fakeVMManager *fakebivm.FakeManager fakeVM *fakebivm.FakeVM @@ -65,8 +54,8 @@ var _ = Describe("Instance", func() { fakeSSHTunnel.SetStartBehavior(nil, nil) fakeSSHTunnelFactory.SSHTunnel = fakeSSHTunnel - mockStateBuilder = mock_instance_state.NewMockBuilder(mockCtrl) - mockState = mock_instance_state.NewMockState(mockCtrl) + mockStateBuilder = &statefakes.FakeBuilder{} + mockState = &statefakes.FakeState{} logger = &loggerfakes.FakeLogger{} @@ -294,10 +283,6 @@ var _ = Describe("Instance", func() { deploymentManifest bideplmanifest.Manifest applySpec bias.ApplySpec - - expectStateBuild *gomock.Call - - expectStateBuildInitialState *gomock.Call ) BeforeEach(func() { @@ -322,17 +307,28 @@ var _ = Describe("Instance", func() { fakeAgentState := agentclient.AgentState{JobState: "testing"} fakeVM.GetStateResult = fakeAgentState - expectStateBuild = mockStateBuilder.EXPECT().Build(jobName, jobIndex, deploymentManifest, fakeStage, fakeAgentState).Return(mockState, nil).AnyTimes() - expectStateBuildInitialState = mockStateBuilder.EXPECT().BuildInitialState(jobName, jobIndex, deploymentManifest).Return(mockState, nil).AnyTimes() - mockState.EXPECT().ToApplySpec().Return(applySpec).AnyTimes() + mockStateBuilder.BuildReturns(mockState, nil) + mockStateBuilder.BuildInitialStateReturns(mockState, nil) + mockState.ToApplySpecReturns(applySpec) }) It("builds a new instance state", func() { - expectStateBuild.Times(1) - expectStateBuildInitialState.Times(1) - err := instance.UpdateJobs(deploymentManifest, fakeStage) Expect(err).ToNot(HaveOccurred()) + + Expect(mockStateBuilder.BuildCallCount()).To(Equal(1)) + buildJobName, buildJobIndex, buildManifest, buildStage, buildAgentState := mockStateBuilder.BuildArgsForCall(0) + Expect(buildJobName).To(Equal(jobName)) + Expect(buildJobIndex).To(Equal(jobIndex)) + Expect(buildManifest).To(Equal(deploymentManifest)) + Expect(buildStage).To(Equal(fakeStage)) + Expect(buildAgentState).To(Equal(agentclient.AgentState{JobState: "testing"})) + + Expect(mockStateBuilder.BuildInitialStateCallCount()).To(Equal(1)) + initJobName, initJobIndex, initManifest := mockStateBuilder.BuildInitialStateArgsForCall(0) + Expect(initJobName).To(Equal(jobName)) + Expect(initJobIndex).To(Equal(jobIndex)) + Expect(initManifest).To(Equal(deploymentManifest)) }) It("tells agent to stop jobs, apply a new spec (with new rendered jobs templates), and start jobs", func() { @@ -371,7 +367,7 @@ var _ = Describe("Instance", func() { Context("when instance state building fails", func() { JustBeforeEach(func() { - expectStateBuild.Return(nil, bosherr.Error("fake-template-err")).Times(1) + mockStateBuilder.BuildReturns(nil, bosherr.Error("fake-template-err")) }) It("returns an error", func() { diff --git a/deployment/instance/instancefakes/fake_instance.go b/deployment/instance/instancefakes/fake_instance.go new file mode 100644 index 0000000000..7ad1be28c6 --- /dev/null +++ b/deployment/instance/instancefakes/fake_instance.go @@ -0,0 +1,694 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package instancefakes + +import ( + "sync" + "time" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeInstance struct { + DeleteStub func(time.Duration, time.Duration, bool, ui.Stage) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DisksStub func() ([]disk.Disk, error) + disksMutex sync.RWMutex + disksArgsForCall []struct { + } + disksReturns struct { + result1 []disk.Disk + result2 error + } + disksReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + IDStub func() int + iDMutex sync.RWMutex + iDArgsForCall []struct { + } + iDReturns struct { + result1 int + } + iDReturnsOnCall map[int]struct { + result1 int + } + JobNameStub func() string + jobNameMutex sync.RWMutex + jobNameArgsForCall []struct { + } + jobNameReturns struct { + result1 string + } + jobNameReturnsOnCall map[int]struct { + result1 string + } + StartStub func(manifest.Update, time.Duration, time.Duration, ui.Stage) error + startMutex sync.RWMutex + startArgsForCall []struct { + arg1 manifest.Update + arg2 time.Duration + arg3 time.Duration + arg4 ui.Stage + } + startReturns struct { + result1 error + } + startReturnsOnCall map[int]struct { + result1 error + } + StopStub func(time.Duration, time.Duration, bool, ui.Stage) error + stopMutex sync.RWMutex + stopArgsForCall []struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + } + stopReturns struct { + result1 error + } + stopReturnsOnCall map[int]struct { + result1 error + } + UpdateDisksStub func(manifest.Manifest, ui.Stage) ([]disk.Disk, error) + updateDisksMutex sync.RWMutex + updateDisksArgsForCall []struct { + arg1 manifest.Manifest + arg2 ui.Stage + } + updateDisksReturns struct { + result1 []disk.Disk + result2 error + } + updateDisksReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + UpdateJobsStub func(manifest.Manifest, ui.Stage) error + updateJobsMutex sync.RWMutex + updateJobsArgsForCall []struct { + arg1 manifest.Manifest + arg2 ui.Stage + } + updateJobsReturns struct { + result1 error + } + updateJobsReturnsOnCall map[int]struct { + result1 error + } + WaitUntilReadyStub func(ui.Stage) error + waitUntilReadyMutex sync.RWMutex + waitUntilReadyArgsForCall []struct { + arg1 ui.Stage + } + waitUntilReadyReturns struct { + result1 error + } + waitUntilReadyReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeInstance) Delete(arg1 time.Duration, arg2 time.Duration, arg3 bool, arg4 ui.Stage) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + }{arg1, arg2, arg3, arg4}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{arg1, arg2, arg3, arg4}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeInstance) DeleteCalls(stub func(time.Duration, time.Duration, bool, ui.Stage) error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeInstance) DeleteArgsForCall(i int) (time.Duration, time.Duration, bool, ui.Stage) { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + argsForCall := fake.deleteArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeInstance) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) Disks() ([]disk.Disk, error) { + fake.disksMutex.Lock() + ret, specificReturn := fake.disksReturnsOnCall[len(fake.disksArgsForCall)] + fake.disksArgsForCall = append(fake.disksArgsForCall, struct { + }{}) + stub := fake.DisksStub + fakeReturns := fake.disksReturns + fake.recordInvocation("Disks", []interface{}{}) + fake.disksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeInstance) DisksCallCount() int { + fake.disksMutex.RLock() + defer fake.disksMutex.RUnlock() + return len(fake.disksArgsForCall) +} + +func (fake *FakeInstance) DisksCalls(stub func() ([]disk.Disk, error)) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = stub +} + +func (fake *FakeInstance) DisksReturns(result1 []disk.Disk, result2 error) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = nil + fake.disksReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeInstance) DisksReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = nil + if fake.disksReturnsOnCall == nil { + fake.disksReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.disksReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeInstance) ID() int { + fake.iDMutex.Lock() + ret, specificReturn := fake.iDReturnsOnCall[len(fake.iDArgsForCall)] + fake.iDArgsForCall = append(fake.iDArgsForCall, struct { + }{}) + stub := fake.IDStub + fakeReturns := fake.iDReturns + fake.recordInvocation("ID", []interface{}{}) + fake.iDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) IDCallCount() int { + fake.iDMutex.RLock() + defer fake.iDMutex.RUnlock() + return len(fake.iDArgsForCall) +} + +func (fake *FakeInstance) IDCalls(stub func() int) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = stub +} + +func (fake *FakeInstance) IDReturns(result1 int) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + fake.iDReturns = struct { + result1 int + }{result1} +} + +func (fake *FakeInstance) IDReturnsOnCall(i int, result1 int) { + fake.iDMutex.Lock() + defer fake.iDMutex.Unlock() + fake.IDStub = nil + if fake.iDReturnsOnCall == nil { + fake.iDReturnsOnCall = make(map[int]struct { + result1 int + }) + } + fake.iDReturnsOnCall[i] = struct { + result1 int + }{result1} +} + +func (fake *FakeInstance) JobName() string { + fake.jobNameMutex.Lock() + ret, specificReturn := fake.jobNameReturnsOnCall[len(fake.jobNameArgsForCall)] + fake.jobNameArgsForCall = append(fake.jobNameArgsForCall, struct { + }{}) + stub := fake.JobNameStub + fakeReturns := fake.jobNameReturns + fake.recordInvocation("JobName", []interface{}{}) + fake.jobNameMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) JobNameCallCount() int { + fake.jobNameMutex.RLock() + defer fake.jobNameMutex.RUnlock() + return len(fake.jobNameArgsForCall) +} + +func (fake *FakeInstance) JobNameCalls(stub func() string) { + fake.jobNameMutex.Lock() + defer fake.jobNameMutex.Unlock() + fake.JobNameStub = stub +} + +func (fake *FakeInstance) JobNameReturns(result1 string) { + fake.jobNameMutex.Lock() + defer fake.jobNameMutex.Unlock() + fake.JobNameStub = nil + fake.jobNameReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeInstance) JobNameReturnsOnCall(i int, result1 string) { + fake.jobNameMutex.Lock() + defer fake.jobNameMutex.Unlock() + fake.JobNameStub = nil + if fake.jobNameReturnsOnCall == nil { + fake.jobNameReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.jobNameReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeInstance) Start(arg1 manifest.Update, arg2 time.Duration, arg3 time.Duration, arg4 ui.Stage) error { + fake.startMutex.Lock() + ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)] + fake.startArgsForCall = append(fake.startArgsForCall, struct { + arg1 manifest.Update + arg2 time.Duration + arg3 time.Duration + arg4 ui.Stage + }{arg1, arg2, arg3, arg4}) + stub := fake.StartStub + fakeReturns := fake.startReturns + fake.recordInvocation("Start", []interface{}{arg1, arg2, arg3, arg4}) + fake.startMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeInstance) StartCalls(stub func(manifest.Update, time.Duration, time.Duration, ui.Stage) error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + +func (fake *FakeInstance) StartArgsForCall(i int) (manifest.Update, time.Duration, time.Duration, ui.Stage) { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + argsForCall := fake.startArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeInstance) StartReturns(result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + fake.startReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) StartReturnsOnCall(i int, result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + if fake.startReturnsOnCall == nil { + fake.startReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.startReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) Stop(arg1 time.Duration, arg2 time.Duration, arg3 bool, arg4 ui.Stage) error { + fake.stopMutex.Lock() + ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] + fake.stopArgsForCall = append(fake.stopArgsForCall, struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + }{arg1, arg2, arg3, arg4}) + stub := fake.StopStub + fakeReturns := fake.stopReturns + fake.recordInvocation("Stop", []interface{}{arg1, arg2, arg3, arg4}) + fake.stopMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) StopCallCount() int { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + return len(fake.stopArgsForCall) +} + +func (fake *FakeInstance) StopCalls(stub func(time.Duration, time.Duration, bool, ui.Stage) error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = stub +} + +func (fake *FakeInstance) StopArgsForCall(i int) (time.Duration, time.Duration, bool, ui.Stage) { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + argsForCall := fake.stopArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeInstance) StopReturns(result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + fake.stopReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) StopReturnsOnCall(i int, result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + if fake.stopReturnsOnCall == nil { + fake.stopReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.stopReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) UpdateDisks(arg1 manifest.Manifest, arg2 ui.Stage) ([]disk.Disk, error) { + fake.updateDisksMutex.Lock() + ret, specificReturn := fake.updateDisksReturnsOnCall[len(fake.updateDisksArgsForCall)] + fake.updateDisksArgsForCall = append(fake.updateDisksArgsForCall, struct { + arg1 manifest.Manifest + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.UpdateDisksStub + fakeReturns := fake.updateDisksReturns + fake.recordInvocation("UpdateDisks", []interface{}{arg1, arg2}) + fake.updateDisksMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeInstance) UpdateDisksCallCount() int { + fake.updateDisksMutex.RLock() + defer fake.updateDisksMutex.RUnlock() + return len(fake.updateDisksArgsForCall) +} + +func (fake *FakeInstance) UpdateDisksCalls(stub func(manifest.Manifest, ui.Stage) ([]disk.Disk, error)) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = stub +} + +func (fake *FakeInstance) UpdateDisksArgsForCall(i int) (manifest.Manifest, ui.Stage) { + fake.updateDisksMutex.RLock() + defer fake.updateDisksMutex.RUnlock() + argsForCall := fake.updateDisksArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeInstance) UpdateDisksReturns(result1 []disk.Disk, result2 error) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = nil + fake.updateDisksReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeInstance) UpdateDisksReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = nil + if fake.updateDisksReturnsOnCall == nil { + fake.updateDisksReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.updateDisksReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeInstance) UpdateJobs(arg1 manifest.Manifest, arg2 ui.Stage) error { + fake.updateJobsMutex.Lock() + ret, specificReturn := fake.updateJobsReturnsOnCall[len(fake.updateJobsArgsForCall)] + fake.updateJobsArgsForCall = append(fake.updateJobsArgsForCall, struct { + arg1 manifest.Manifest + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.UpdateJobsStub + fakeReturns := fake.updateJobsReturns + fake.recordInvocation("UpdateJobs", []interface{}{arg1, arg2}) + fake.updateJobsMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) UpdateJobsCallCount() int { + fake.updateJobsMutex.RLock() + defer fake.updateJobsMutex.RUnlock() + return len(fake.updateJobsArgsForCall) +} + +func (fake *FakeInstance) UpdateJobsCalls(stub func(manifest.Manifest, ui.Stage) error) { + fake.updateJobsMutex.Lock() + defer fake.updateJobsMutex.Unlock() + fake.UpdateJobsStub = stub +} + +func (fake *FakeInstance) UpdateJobsArgsForCall(i int) (manifest.Manifest, ui.Stage) { + fake.updateJobsMutex.RLock() + defer fake.updateJobsMutex.RUnlock() + argsForCall := fake.updateJobsArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeInstance) UpdateJobsReturns(result1 error) { + fake.updateJobsMutex.Lock() + defer fake.updateJobsMutex.Unlock() + fake.UpdateJobsStub = nil + fake.updateJobsReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) UpdateJobsReturnsOnCall(i int, result1 error) { + fake.updateJobsMutex.Lock() + defer fake.updateJobsMutex.Unlock() + fake.UpdateJobsStub = nil + if fake.updateJobsReturnsOnCall == nil { + fake.updateJobsReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateJobsReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) WaitUntilReady(arg1 ui.Stage) error { + fake.waitUntilReadyMutex.Lock() + ret, specificReturn := fake.waitUntilReadyReturnsOnCall[len(fake.waitUntilReadyArgsForCall)] + fake.waitUntilReadyArgsForCall = append(fake.waitUntilReadyArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.WaitUntilReadyStub + fakeReturns := fake.waitUntilReadyReturns + fake.recordInvocation("WaitUntilReady", []interface{}{arg1}) + fake.waitUntilReadyMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstance) WaitUntilReadyCallCount() int { + fake.waitUntilReadyMutex.RLock() + defer fake.waitUntilReadyMutex.RUnlock() + return len(fake.waitUntilReadyArgsForCall) +} + +func (fake *FakeInstance) WaitUntilReadyCalls(stub func(ui.Stage) error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = stub +} + +func (fake *FakeInstance) WaitUntilReadyArgsForCall(i int) ui.Stage { + fake.waitUntilReadyMutex.RLock() + defer fake.waitUntilReadyMutex.RUnlock() + argsForCall := fake.waitUntilReadyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeInstance) WaitUntilReadyReturns(result1 error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = nil + fake.waitUntilReadyReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) WaitUntilReadyReturnsOnCall(i int, result1 error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = nil + if fake.waitUntilReadyReturnsOnCall == nil { + fake.waitUntilReadyReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilReadyReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstance) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeInstance) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ instance.Instance = new(FakeInstance) diff --git a/deployment/instance/instancefakes/fake_manager.go b/deployment/instance/instancefakes/fake_manager.go new file mode 100644 index 0000000000..fac7d25964 --- /dev/null +++ b/deployment/instance/instancefakes/fake_manager.go @@ -0,0 +1,285 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package instancefakes + +import ( + "sync" + "time" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/stemcell" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeManager struct { + CreateStub func(string, int, manifest.Manifest, stemcell.CloudStemcell, []string, ui.Stage) (instance.Instance, []disk.Disk, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 string + arg2 int + arg3 manifest.Manifest + arg4 stemcell.CloudStemcell + arg5 []string + arg6 ui.Stage + } + createReturns struct { + result1 instance.Instance + result2 []disk.Disk + result3 error + } + createReturnsOnCall map[int]struct { + result1 instance.Instance + result2 []disk.Disk + result3 error + } + DeleteAllStub func(time.Duration, time.Duration, bool, ui.Stage) error + deleteAllMutex sync.RWMutex + deleteAllArgsForCall []struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + } + deleteAllReturns struct { + result1 error + } + deleteAllReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() ([]instance.Instance, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 []instance.Instance + result2 error + } + findCurrentReturnsOnCall map[int]struct { + result1 []instance.Instance + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) Create(arg1 string, arg2 int, arg3 manifest.Manifest, arg4 stemcell.CloudStemcell, arg5 []string, arg6 ui.Stage) (instance.Instance, []disk.Disk, error) { + var arg5Copy []string + if arg5 != nil { + arg5Copy = make([]string, len(arg5)) + copy(arg5Copy, arg5) + } + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 string + arg2 int + arg3 manifest.Manifest + arg4 stemcell.CloudStemcell + arg5 []string + arg6 ui.Stage + }{arg1, arg2, arg3, arg4, arg5Copy, arg6}) + stub := fake.CreateStub + fakeReturns := fake.createReturns + fake.recordInvocation("Create", []interface{}{arg1, arg2, arg3, arg4, arg5Copy, arg6}) + fake.createMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeManager) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeManager) CreateCalls(stub func(string, int, manifest.Manifest, stemcell.CloudStemcell, []string, ui.Stage) (instance.Instance, []disk.Disk, error)) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = stub +} + +func (fake *FakeManager) CreateArgsForCall(i int) (string, int, manifest.Manifest, stemcell.CloudStemcell, []string, ui.Stage) { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + argsForCall := fake.createArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *FakeManager) CreateReturns(result1 instance.Instance, result2 []disk.Disk, result3 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + fake.createReturns = struct { + result1 instance.Instance + result2 []disk.Disk + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) CreateReturnsOnCall(i int, result1 instance.Instance, result2 []disk.Disk, result3 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 instance.Instance + result2 []disk.Disk + result3 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 instance.Instance + result2 []disk.Disk + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) DeleteAll(arg1 time.Duration, arg2 time.Duration, arg3 bool, arg4 ui.Stage) error { + fake.deleteAllMutex.Lock() + ret, specificReturn := fake.deleteAllReturnsOnCall[len(fake.deleteAllArgsForCall)] + fake.deleteAllArgsForCall = append(fake.deleteAllArgsForCall, struct { + arg1 time.Duration + arg2 time.Duration + arg3 bool + arg4 ui.Stage + }{arg1, arg2, arg3, arg4}) + stub := fake.DeleteAllStub + fakeReturns := fake.deleteAllReturns + fake.recordInvocation("DeleteAll", []interface{}{arg1, arg2, arg3, arg4}) + fake.deleteAllMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) DeleteAllCallCount() int { + fake.deleteAllMutex.RLock() + defer fake.deleteAllMutex.RUnlock() + return len(fake.deleteAllArgsForCall) +} + +func (fake *FakeManager) DeleteAllCalls(stub func(time.Duration, time.Duration, bool, ui.Stage) error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = stub +} + +func (fake *FakeManager) DeleteAllArgsForCall(i int) (time.Duration, time.Duration, bool, ui.Stage) { + fake.deleteAllMutex.RLock() + defer fake.deleteAllMutex.RUnlock() + argsForCall := fake.deleteAllArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeManager) DeleteAllReturns(result1 error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = nil + fake.deleteAllReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) DeleteAllReturnsOnCall(i int, result1 error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = nil + if fake.deleteAllReturnsOnCall == nil { + fake.deleteAllReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteAllReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) FindCurrent() ([]instance.Instance, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() ([]instance.Instance, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeManager) FindCurrentReturns(result1 []instance.Instance, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 []instance.Instance + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 []instance.Instance, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 []instance.Instance + result2 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 []instance.Instance + result2 error + }{result1, result2} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ instance.Manager = new(FakeManager) diff --git a/deployment/instance/manager.go b/deployment/instance/manager.go index e85eb754c3..1eb2ee8ba6 100644 --- a/deployment/instance/manager.go +++ b/deployment/instance/manager.go @@ -17,6 +17,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . Manager + type Manager interface { FindCurrent() ([]Instance, error) Create( diff --git a/deployment/instance/manager_test.go b/deployment/instance/manager_test.go index fbf93be070..d37f792f90 100644 --- a/deployment/instance/manager_test.go +++ b/deployment/instance/manager_test.go @@ -8,17 +8,16 @@ import ( bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mock_agentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mock_blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mock_instance_state "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" @@ -28,26 +27,17 @@ import ( var _ = Describe("Manager", func() { var ( - mockCtrl *gomock.Controller apiVersion = 2 ) - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( fakeCloud *fakebicloud.FakeCloud - mockStateBuilderFactory *mock_instance_state.MockBuilderFactory - mockStateBuilder *mock_instance_state.MockBuilder - mockState *mock_instance_state.MockState + mockStateBuilderFactory *statefakes.FakeBuilderFactory + mockStateBuilder *statefakes.FakeBuilder + mockState *statefakes.FakeState - mockBlobstore *mock_blobstore.MockBlobstore + mockBlobstore *blobstorefakes.FakeBlobstore fakeVMManager *fakebivm.FakeManager fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory @@ -69,13 +59,13 @@ var _ = Describe("Manager", func() { fakeSSHTunnel.SetStartBehavior(nil, nil) fakeSSHTunnelFactory.SSHTunnel = fakeSSHTunnel - mockStateBuilderFactory = mock_instance_state.NewMockBuilderFactory(mockCtrl) - mockStateBuilder = mock_instance_state.NewMockBuilder(mockCtrl) - mockState = mock_instance_state.NewMockState(mockCtrl) + mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} + mockStateBuilder = &statefakes.FakeBuilder{} + mockState = &statefakes.FakeState{} instanceFactory = NewFactory(mockStateBuilderFactory) - mockBlobstore = mock_blobstore.NewMockBlobstore(mockCtrl) + mockBlobstore = &blobstorefakes.FakeBlobstore{} logger = boshlog.NewLogger(boshlog.LevelNone) @@ -93,7 +83,7 @@ var _ = Describe("Manager", func() { Describe("Create", func() { var ( - mockAgentClient *mock_agentclient.MockAgentClient + mockAgentClient *agentclientfakes.FakeAgentClient fakeVM *fakebivm.FakeVM diskPool bideplmanifest.DiskPool deploymentManifest bideplmanifest.Manifest @@ -130,9 +120,9 @@ var _ = Describe("Manager", func() { fakeAgentState := agentclient.AgentState{} fakeVM.GetStateResult = fakeAgentState - mockStateBuilderFactory.EXPECT().NewBuilder(mockBlobstore, mockAgentClient).Return(mockStateBuilder).AnyTimes() - mockStateBuilder.EXPECT().Build(jobName, jobIndex, deploymentManifest, fakeStage, fakeAgentState).Return(mockState, nil).AnyTimes() - mockState.EXPECT().ToApplySpec().Return(applySpec).AnyTimes() + mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) + mockStateBuilder.BuildReturns(mockState, nil) + mockState.ToApplySpecReturns(applySpec) } BeforeEach(func() { @@ -170,7 +160,7 @@ var _ = Describe("Manager", func() { fakeVM = fakebivm.NewFakeVM("fake-vm-cid") fakeVMManager.CreateVM = fakeVM - mockAgentClient = mock_agentclient.NewMockAgentClient(mockCtrl) + mockAgentClient = &agentclientfakes.FakeAgentClient{} fakeVM.AgentClientReturn = mockAgentClient expectedInstance = NewInstance( diff --git a/deployment/instance/mocks/mocks.go b/deployment/instance/mocks/mocks.go deleted file mode 100644 index d99f1a0ffc..0000000000 --- a/deployment/instance/mocks/mocks.go +++ /dev/null @@ -1,236 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment/instance (interfaces: Instance,Manager) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - time "time" - - disk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - instance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - manifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - stemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockInstance is a mock of Instance interface. -type MockInstance struct { - ctrl *gomock.Controller - recorder *MockInstanceMockRecorder -} - -// MockInstanceMockRecorder is the mock recorder for MockInstance. -type MockInstanceMockRecorder struct { - mock *MockInstance -} - -// NewMockInstance creates a new mock instance. -func NewMockInstance(ctrl *gomock.Controller) *MockInstance { - mock := &MockInstance{ctrl: ctrl} - mock.recorder = &MockInstanceMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockInstance) EXPECT() *MockInstanceMockRecorder { - return m.recorder -} - -// Delete mocks base method. -func (m *MockInstance) Delete(arg0, arg1 time.Duration, arg2 bool, arg3 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0, arg1, arg2, arg3) - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockInstanceMockRecorder) Delete(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockInstance)(nil).Delete), arg0, arg1, arg2, arg3) -} - -// Disks mocks base method. -func (m *MockInstance) Disks() ([]disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Disks") - ret0, _ := ret[0].([]disk.Disk) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Disks indicates an expected call of Disks. -func (mr *MockInstanceMockRecorder) Disks() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disks", reflect.TypeOf((*MockInstance)(nil).Disks)) -} - -// ID mocks base method. -func (m *MockInstance) ID() int { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ID") - ret0, _ := ret[0].(int) - return ret0 -} - -// ID indicates an expected call of ID. -func (mr *MockInstanceMockRecorder) ID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockInstance)(nil).ID)) -} - -// JobName mocks base method. -func (m *MockInstance) JobName() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "JobName") - ret0, _ := ret[0].(string) - return ret0 -} - -// JobName indicates an expected call of JobName. -func (mr *MockInstanceMockRecorder) JobName() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JobName", reflect.TypeOf((*MockInstance)(nil).JobName)) -} - -// Start mocks base method. -func (m *MockInstance) Start(arg0 manifest.Update, arg1, arg2 time.Duration, arg3 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Start", arg0, arg1, arg2, arg3) - ret0, _ := ret[0].(error) - return ret0 -} - -// Start indicates an expected call of Start. -func (mr *MockInstanceMockRecorder) Start(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockInstance)(nil).Start), arg0, arg1, arg2, arg3) -} - -// Stop mocks base method. -func (m *MockInstance) Stop(arg0, arg1 time.Duration, arg2 bool, arg3 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stop", arg0, arg1, arg2, arg3) - ret0, _ := ret[0].(error) - return ret0 -} - -// Stop indicates an expected call of Stop. -func (mr *MockInstanceMockRecorder) Stop(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockInstance)(nil).Stop), arg0, arg1, arg2, arg3) -} - -// UpdateDisks mocks base method. -func (m *MockInstance) UpdateDisks(arg0 manifest.Manifest, arg1 ui.Stage) ([]disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateDisks", arg0, arg1) - ret0, _ := ret[0].([]disk.Disk) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateDisks indicates an expected call of UpdateDisks. -func (mr *MockInstanceMockRecorder) UpdateDisks(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDisks", reflect.TypeOf((*MockInstance)(nil).UpdateDisks), arg0, arg1) -} - -// UpdateJobs mocks base method. -func (m *MockInstance) UpdateJobs(arg0 manifest.Manifest, arg1 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateJobs", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// UpdateJobs indicates an expected call of UpdateJobs. -func (mr *MockInstanceMockRecorder) UpdateJobs(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateJobs", reflect.TypeOf((*MockInstance)(nil).UpdateJobs), arg0, arg1) -} - -// WaitUntilReady mocks base method. -func (m *MockInstance) WaitUntilReady(arg0 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilReady", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilReady indicates an expected call of WaitUntilReady. -func (mr *MockInstanceMockRecorder) WaitUntilReady(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilReady", reflect.TypeOf((*MockInstance)(nil).WaitUntilReady), arg0) -} - -// MockManager is a mock of Manager interface. -type MockManager struct { - ctrl *gomock.Controller - recorder *MockManagerMockRecorder -} - -// MockManagerMockRecorder is the mock recorder for MockManager. -type MockManagerMockRecorder struct { - mock *MockManager -} - -// NewMockManager creates a new mock instance. -func NewMockManager(ctrl *gomock.Controller) *MockManager { - mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder -} - -// Create mocks base method. -func (m *MockManager) Create(arg0 string, arg1 int, arg2 manifest.Manifest, arg3 stemcell.CloudStemcell, arg4 []string, arg5 ui.Stage) (instance.Instance, []disk.Disk, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Create", arg0, arg1, arg2, arg3, arg4, arg5) - ret0, _ := ret[0].(instance.Instance) - ret1, _ := ret[1].([]disk.Disk) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// Create indicates an expected call of Create. -func (mr *MockManagerMockRecorder) Create(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockManager)(nil).Create), arg0, arg1, arg2, arg3, arg4, arg5) -} - -// DeleteAll mocks base method. -func (m *MockManager) DeleteAll(arg0, arg1 time.Duration, arg2 bool, arg3 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteAll", arg0, arg1, arg2, arg3) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteAll indicates an expected call of DeleteAll. -func (mr *MockManagerMockRecorder) DeleteAll(arg0, arg1, arg2, arg3 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAll", reflect.TypeOf((*MockManager)(nil).DeleteAll), arg0, arg1, arg2, arg3) -} - -// FindCurrent mocks base method. -func (m *MockManager) FindCurrent() ([]instance.Instance, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindCurrent") - ret0, _ := ret[0].([]instance.Instance) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindCurrent indicates an expected call of FindCurrent. -func (mr *MockManagerMockRecorder) FindCurrent() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCurrent", reflect.TypeOf((*MockManager)(nil).FindCurrent)) -} diff --git a/deployment/instance/state/builder.go b/deployment/instance/state/builder.go index 26e7b12f75..a7bdff7a6f 100644 --- a/deployment/instance/state/builder.go +++ b/deployment/instance/state/builder.go @@ -17,6 +17,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . Builder + type Builder interface { Build(jobName string, instanceID int, deploymentManifest bideplmanifest.Manifest, stage biui.Stage, agentState agentclient.AgentState) (State, error) BuildInitialState(jobName string, instanceID int, deploymentManifest bideplmanifest.Manifest) (State, error) diff --git a/deployment/instance/state/builder_factory.go b/deployment/instance/state/builder_factory.go index d139acddde..563ae1c27d 100644 --- a/deployment/instance/state/builder_factory.go +++ b/deployment/instance/state/builder_factory.go @@ -11,6 +11,10 @@ import ( bitemplate "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . BuilderFactory + type BuilderFactory interface { NewBuilder(biblobstore.Blobstore, biagentclient.AgentClient) Builder } diff --git a/deployment/instance/state/builder_test.go b/deployment/instance/state/builder_test.go index 6d4a18f44c..107b29ffb7 100644 --- a/deployment/instance/state/builder_test.go +++ b/deployment/instance/state/builder_test.go @@ -5,42 +5,31 @@ import ( bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mockblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - mockdeploymentrelease "github.com/cloudfoundry/bosh-cli/v7/deployment/release/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/release/releasefakes" boshjob "github.com/cloudfoundry/bosh-cli/v7/release/job" boshpkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" bistatejob "github.com/cloudfoundry/bosh-cli/v7/state/job" - mockstatejob "github.com/cloudfoundry/bosh-cli/v7/state/job/mocks" - mocktemplate "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/mocks" + "github.com/cloudfoundry/bosh-cli/v7/state/job/jobfakes" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/templatescompilerfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("Builder", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( logger boshlog.Logger - mockReleaseJobResolver *mockdeploymentrelease.MockJobResolver - mockDependencyCompiler *mockstatejob.MockDependencyCompiler - mockJobListRenderer *mocktemplate.MockJobListRenderer - mockCompressor *mocktemplate.MockRenderedJobListCompressor - mockBlobstore *mockblobstore.MockBlobstore + mockReleaseJobResolver *releasefakes.FakeJobResolver + mockDependencyCompiler *jobfakes.FakeDependencyCompiler + mockJobListRenderer *templatescompilerfakes.FakeJobListRenderer + mockCompressor *templatescompilerfakes.FakeRenderedJobListCompressor + mockBlobstore *blobstorefakes.FakeBlobstore stateBuilder Builder ) @@ -48,11 +37,11 @@ var _ = Describe("Builder", func() { BeforeEach(func() { logger = boshlog.NewLogger(boshlog.LevelNone) - mockReleaseJobResolver = mockdeploymentrelease.NewMockJobResolver(mockCtrl) - mockDependencyCompiler = mockstatejob.NewMockDependencyCompiler(mockCtrl) - mockJobListRenderer = mocktemplate.NewMockJobListRenderer(mockCtrl) - mockCompressor = mocktemplate.NewMockRenderedJobListCompressor(mockCtrl) - mockBlobstore = mockblobstore.NewMockBlobstore(mockCtrl) + mockReleaseJobResolver = &releasefakes.FakeJobResolver{} + mockDependencyCompiler = &jobfakes.FakeDependencyCompiler{} + mockJobListRenderer = &templatescompilerfakes.FakeJobListRenderer{} + mockCompressor = &templatescompilerfakes.FakeRenderedJobListCompressor{} + mockBlobstore = &blobstorefakes.FakeBlobstore{} }) Describe("BuildInitialState", func() { @@ -147,8 +136,8 @@ var _ = Describe("Builder", func() { Describe("Build", func() { var ( - mockRenderedJobList *mocktemplate.MockRenderedJobList - mockRenderedJobListArchive *mocktemplate.MockRenderedJobListArchive + mockRenderedJobList *templatescompilerfakes.FakeRenderedJobList + mockRenderedJobListArchive *templatescompilerfakes.FakeRenderedJobListArchive jobName string instanceID int @@ -160,13 +149,11 @@ var _ = Describe("Builder", func() { releasePackageLibyaml *boshpkg.Package releasePackageRuby *boshpkg.Package releasePackageCPI *boshpkg.Package - - expectCompile *gomock.Call ) BeforeEach(func() { - mockRenderedJobList = mocktemplate.NewMockRenderedJobList(mockCtrl) - mockRenderedJobListArchive = mocktemplate.NewMockRenderedJobListArchive(mockCtrl) + mockRenderedJobList = &templatescompilerfakes.FakeRenderedJobList{} + mockRenderedJobListArchive = &templatescompilerfakes.FakeRenderedJobListArchive{} jobName = "fake-deployment-job-name" instanceID = 0 @@ -244,14 +231,20 @@ var _ = Describe("Builder", func() { Expect(err).ToNot(HaveOccurred()) }) + AfterEach(func() { + if mockJobListRenderer.RenderCallCount() > 0 { + _, _, _, _, _, address := mockJobListRenderer.RenderArgsForCall(0) + Expect(address).To(Equal(expectedIP)) + } + }) + JustBeforeEach(func() { releaseJob := *boshjob.NewJob(NewResource("job-name", "job-fp", nil)) err := releaseJob.AttachPackages([]*boshpkg.Package{releasePackageCPI, releasePackageRuby}) Expect(err).ToNot(HaveOccurred()) - mockReleaseJobResolver.EXPECT().Resolve("job-name", "fake-release-name").Return(releaseJob, nil) + mockReleaseJobResolver.ResolveReturns(releaseJob, nil) - releaseJobs := []boshjob.Job{releaseJob} compiledPackageRefs := []bistatejob.CompiledPackageRef{ { Name: "libyaml", @@ -272,40 +265,25 @@ var _ = Describe("Builder", func() { SHA1: "cpi-sha1", }, } - expectCompile = mockDependencyCompiler.EXPECT().Compile(releaseJobs, fakeStage).Return(compiledPackageRefs, nil).AnyTimes() + mockDependencyCompiler.CompileReturns(compiledPackageRefs, nil) - releaseJobProperties := map[string]*biproperty.Map{ - "job-name": { - "fake-template-property": "fake-template-property-value", - }, - } - - jobProperties := biproperty.Map{ - "fake-job-property": "fake-job-property-value", - } - globalProperties := biproperty.Map{ - "fake-job-property": "fake-global-property-value", - } + mockJobListRenderer.RenderReturns(mockRenderedJobList, nil) - mockJobListRenderer.EXPECT().Render(releaseJobs, releaseJobProperties, jobProperties, globalProperties, "fake-deployment-name", expectedIP).Return(mockRenderedJobList, nil) + mockCompressor.CompressReturns(mockRenderedJobListArchive, nil) - mockRenderedJobList.EXPECT().DeleteSilently() + mockRenderedJobListArchive.PathReturns("fake-rendered-job-list-archive-path") + mockRenderedJobListArchive.SHA1Returns("fake-rendered-job-list-archive-sha1") - mockCompressor.EXPECT().Compress(mockRenderedJobList).Return(mockRenderedJobListArchive, nil) - - mockRenderedJobListArchive.EXPECT().DeleteSilently() - - mockRenderedJobListArchive.EXPECT().Path().Return("fake-rendered-job-list-archive-path") - mockRenderedJobListArchive.EXPECT().SHA1().Return("fake-rendered-job-list-archive-sha1") - - mockBlobstore.EXPECT().Add("fake-rendered-job-list-archive-path").Return("fake-rendered-job-list-archive-blob-id", nil) + mockBlobstore.AddReturns("fake-rendered-job-list-archive-blob-id", nil) }) It("compiles the dependencies of the jobs", func() { - expectCompile.Times(1) - _, err := stateBuilder.Build(jobName, instanceID, deploymentManifest, fakeStage, agentState) Expect(err).ToNot(HaveOccurred()) + + Expect(mockDependencyCompiler.CompileCallCount()).To(Equal(1)) + Expect(mockRenderedJobList.DeleteSilentlyCallCount()).To(Equal(1)) + Expect(mockRenderedJobListArchive.DeleteSilentlyCallCount()).To(Equal(1)) }) It("builds a new instance state with zero-to-many networks", func() { diff --git a/deployment/instance/state/mocks/mocks.go b/deployment/instance/state/mocks/mocks.go deleted file mode 100644 index 9dddf40f88..0000000000 --- a/deployment/instance/state/mocks/mocks.go +++ /dev/null @@ -1,200 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state (interfaces: BuilderFactory,Builder,State) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - agentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - applyspec "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore" - state "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" - manifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockBuilderFactory is a mock of BuilderFactory interface. -type MockBuilderFactory struct { - ctrl *gomock.Controller - recorder *MockBuilderFactoryMockRecorder -} - -// MockBuilderFactoryMockRecorder is the mock recorder for MockBuilderFactory. -type MockBuilderFactoryMockRecorder struct { - mock *MockBuilderFactory -} - -// NewMockBuilderFactory creates a new mock instance. -func NewMockBuilderFactory(ctrl *gomock.Controller) *MockBuilderFactory { - mock := &MockBuilderFactory{ctrl: ctrl} - mock.recorder = &MockBuilderFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockBuilderFactory) EXPECT() *MockBuilderFactoryMockRecorder { - return m.recorder -} - -// NewBuilder mocks base method. -func (m *MockBuilderFactory) NewBuilder(arg0 blobstore.Blobstore, arg1 agentclient.AgentClient) state.Builder { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewBuilder", arg0, arg1) - ret0, _ := ret[0].(state.Builder) - return ret0 -} - -// NewBuilder indicates an expected call of NewBuilder. -func (mr *MockBuilderFactoryMockRecorder) NewBuilder(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewBuilder", reflect.TypeOf((*MockBuilderFactory)(nil).NewBuilder), arg0, arg1) -} - -// MockBuilder is a mock of Builder interface. -type MockBuilder struct { - ctrl *gomock.Controller - recorder *MockBuilderMockRecorder -} - -// MockBuilderMockRecorder is the mock recorder for MockBuilder. -type MockBuilderMockRecorder struct { - mock *MockBuilder -} - -// NewMockBuilder creates a new mock instance. -func NewMockBuilder(ctrl *gomock.Controller) *MockBuilder { - mock := &MockBuilder{ctrl: ctrl} - mock.recorder = &MockBuilderMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockBuilder) EXPECT() *MockBuilderMockRecorder { - return m.recorder -} - -// Build mocks base method. -func (m *MockBuilder) Build(arg0 string, arg1 int, arg2 manifest.Manifest, arg3 ui.Stage, arg4 agentclient.AgentState) (state.State, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Build", arg0, arg1, arg2, arg3, arg4) - ret0, _ := ret[0].(state.State) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Build indicates an expected call of Build. -func (mr *MockBuilderMockRecorder) Build(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Build", reflect.TypeOf((*MockBuilder)(nil).Build), arg0, arg1, arg2, arg3, arg4) -} - -// BuildInitialState mocks base method. -func (m *MockBuilder) BuildInitialState(arg0 string, arg1 int, arg2 manifest.Manifest) (state.State, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BuildInitialState", arg0, arg1, arg2) - ret0, _ := ret[0].(state.State) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BuildInitialState indicates an expected call of BuildInitialState. -func (mr *MockBuilderMockRecorder) BuildInitialState(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildInitialState", reflect.TypeOf((*MockBuilder)(nil).BuildInitialState), arg0, arg1, arg2) -} - -// MockState is a mock of State interface. -type MockState struct { - ctrl *gomock.Controller - recorder *MockStateMockRecorder -} - -// MockStateMockRecorder is the mock recorder for MockState. -type MockStateMockRecorder struct { - mock *MockState -} - -// NewMockState creates a new mock instance. -func NewMockState(ctrl *gomock.Controller) *MockState { - mock := &MockState{ctrl: ctrl} - mock.recorder = &MockStateMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockState) EXPECT() *MockStateMockRecorder { - return m.recorder -} - -// CompiledPackages mocks base method. -func (m *MockState) CompiledPackages() []state.PackageRef { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CompiledPackages") - ret0, _ := ret[0].([]state.PackageRef) - return ret0 -} - -// CompiledPackages indicates an expected call of CompiledPackages. -func (mr *MockStateMockRecorder) CompiledPackages() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompiledPackages", reflect.TypeOf((*MockState)(nil).CompiledPackages)) -} - -// NetworkInterfaces mocks base method. -func (m *MockState) NetworkInterfaces() []state.NetworkRef { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NetworkInterfaces") - ret0, _ := ret[0].([]state.NetworkRef) - return ret0 -} - -// NetworkInterfaces indicates an expected call of NetworkInterfaces. -func (mr *MockStateMockRecorder) NetworkInterfaces() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkInterfaces", reflect.TypeOf((*MockState)(nil).NetworkInterfaces)) -} - -// RenderedJobListArchive mocks base method. -func (m *MockState) RenderedJobListArchive() state.BlobRef { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RenderedJobListArchive") - ret0, _ := ret[0].(state.BlobRef) - return ret0 -} - -// RenderedJobListArchive indicates an expected call of RenderedJobListArchive. -func (mr *MockStateMockRecorder) RenderedJobListArchive() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenderedJobListArchive", reflect.TypeOf((*MockState)(nil).RenderedJobListArchive)) -} - -// RenderedJobs mocks base method. -func (m *MockState) RenderedJobs() []state.JobRef { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RenderedJobs") - ret0, _ := ret[0].([]state.JobRef) - return ret0 -} - -// RenderedJobs indicates an expected call of RenderedJobs. -func (mr *MockStateMockRecorder) RenderedJobs() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenderedJobs", reflect.TypeOf((*MockState)(nil).RenderedJobs)) -} - -// ToApplySpec mocks base method. -func (m *MockState) ToApplySpec() applyspec.ApplySpec { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ToApplySpec") - ret0, _ := ret[0].(applyspec.ApplySpec) - return ret0 -} - -// ToApplySpec indicates an expected call of ToApplySpec. -func (mr *MockStateMockRecorder) ToApplySpec() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ToApplySpec", reflect.TypeOf((*MockState)(nil).ToApplySpec)) -} diff --git a/deployment/instance/state/remote_package_compiler_test.go b/deployment/instance/state/remote_package_compiler_test.go index 2d3e1e3852..dfc188b680 100644 --- a/deployment/instance/state/remote_package_compiler_test.go +++ b/deployment/instance/state/remote_package_compiler_test.go @@ -1,13 +1,12 @@ package state_test import ( - biagentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mock_agentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mock_blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + biagentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" biindex "github.com/cloudfoundry/bosh-cli/v7/index" boshpkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" @@ -16,33 +15,20 @@ import ( ) var _ = Describe("RemotePackageCompiler", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( packageRepo bistatepkg.CompiledPackageRepo - mockBlobstore *mock_blobstore.MockBlobstore - mockAgentClient *mock_agentclient.MockAgentClient + mockBlobstore *blobstorefakes.FakeBlobstore + mockAgentClient *agentclientfakes.FakeAgentClient archivePath = "fake-archive-path" remotePackageCompiler bistatepkg.Compiler - - expectBlobstoreAdd *gomock.Call - expectAgentCompile *gomock.Call ) BeforeEach(func() { - mockBlobstore = mock_blobstore.NewMockBlobstore(mockCtrl) - mockAgentClient = mock_agentclient.NewMockAgentClient(mockCtrl) + mockBlobstore = &blobstorefakes.FakeBlobstore{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} index := biindex.NewInMemoryIndex() packageRepo = bistatepkg.NewCompiledPackageRepo(index) @@ -84,20 +70,6 @@ var _ = Describe("RemotePackageCompiler", func() { Expect(err).ToNot(HaveOccurred()) } - packageSource := biagentclient.BlobRef{ - Name: "fake-package-name", - Version: "fake-package-fingerprint", - BlobstoreID: "fake-source-package-blob-id", - SHA1: "fake-source-package-sha1", - } - packageDependencies := []biagentclient.BlobRef{ - { - Name: "fake-package-name-dep", - Version: "fake-package-fingerprint-dep", - BlobstoreID: "fake-compiled-package-blob-id-dep", - SHA1: "fake-compiled-package-sha1-dep", - }, - } compiledPackageRef := biagentclient.BlobRef{ Name: "fake-package-name", Version: "fake-package-version", @@ -105,17 +77,28 @@ var _ = Describe("RemotePackageCompiler", func() { SHA1: "fake-compiled-package-sha1", } - expectBlobstoreAdd = mockBlobstore.EXPECT().Add(archivePath).Return("fake-source-package-blob-id", nil).AnyTimes() - expectAgentCompile = mockAgentClient.EXPECT().CompilePackage(packageSource, packageDependencies).Return(compiledPackageRef, nil).AnyTimes() + mockBlobstore.AddReturns("fake-source-package-blob-id", nil) + mockAgentClient.CompilePackageReturns(compiledPackageRef, nil) }) It("uploads the package archive to the blobstore and then compiles the package with the agent", func() { - gomock.InOrder( - expectBlobstoreAdd.Times(1), - expectAgentCompile.Times(1), - ) + var order []string + mockBlobstore.AddStub = func(path string) (string, error) { + order = append(order, "Add") + return "fake-source-package-blob-id", nil + } + mockAgentClient.CompilePackageStub = func(source biagentclient.BlobRef, deps []biagentclient.BlobRef) (biagentclient.BlobRef, error) { + order = append(order, "CompilePackage") + return biagentclient.BlobRef{ + Name: "fake-package-name", + Version: "fake-package-version", + BlobstoreID: "fake-compiled-package-blob-id", + SHA1: "fake-compiled-package-sha1", + }, nil + } compiledPackageRecord, _, err := remotePackageCompiler.Compile(pkg) + Expect(order).To(Equal([]string{"Add", "CompilePackage"})) Expect(err).ToNot(HaveOccurred()) Expect(compiledPackageRecord).To(Equal(bistatepkg.CompiledPackageRecord{ BlobID: "fake-compiled-package-blob-id", @@ -169,8 +152,7 @@ var _ = Describe("RemotePackageCompiler", func() { }) Expect(err).ToNot(HaveOccurred()) - expectBlobstoreAdd = mockBlobstore.EXPECT().Add(archivePath).Return("fake-source-package-blob-id", nil).AnyTimes() - expectAgentCompile = mockAgentClient.EXPECT().CompilePackage(gomock.Any(), gomock.Any()).AnyTimes() + mockBlobstore.AddReturns("fake-source-package-blob-id", nil) compiledPackageRecord, isAlreadyCompiled, err := remotePackageCompiler.Compile(pkg) Expect(err).ToNot(HaveOccurred()) @@ -180,7 +162,7 @@ var _ = Describe("RemotePackageCompiler", func() { BlobSHA1: "fake-source-package-sha1", })) - expectAgentCompile.Times(0) + Expect(mockAgentClient.CompilePackageCallCount()).To(Equal(0)) }) }) }) diff --git a/deployment/instance/state/state.go b/deployment/instance/state/state.go index 720eb7038e..03ace86d17 100644 --- a/deployment/instance/state/state.go +++ b/deployment/instance/state/state.go @@ -6,6 +6,8 @@ import ( bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" ) +//counterfeiter:generate . State + type State interface { NetworkInterfaces() []NetworkRef RenderedJobs() []JobRef diff --git a/deployment/instance/state/statefakes/fake_builder.go b/deployment/instance/state/statefakes/fake_builder.go new file mode 100644 index 0000000000..3658326937 --- /dev/null +++ b/deployment/instance/state/statefakes/fake_builder.go @@ -0,0 +1,206 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package statefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeBuilder struct { + BuildStub func(string, int, manifest.Manifest, ui.Stage, agentclient.AgentState) (state.State, error) + buildMutex sync.RWMutex + buildArgsForCall []struct { + arg1 string + arg2 int + arg3 manifest.Manifest + arg4 ui.Stage + arg5 agentclient.AgentState + } + buildReturns struct { + result1 state.State + result2 error + } + buildReturnsOnCall map[int]struct { + result1 state.State + result2 error + } + BuildInitialStateStub func(string, int, manifest.Manifest) (state.State, error) + buildInitialStateMutex sync.RWMutex + buildInitialStateArgsForCall []struct { + arg1 string + arg2 int + arg3 manifest.Manifest + } + buildInitialStateReturns struct { + result1 state.State + result2 error + } + buildInitialStateReturnsOnCall map[int]struct { + result1 state.State + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeBuilder) Build(arg1 string, arg2 int, arg3 manifest.Manifest, arg4 ui.Stage, arg5 agentclient.AgentState) (state.State, error) { + fake.buildMutex.Lock() + ret, specificReturn := fake.buildReturnsOnCall[len(fake.buildArgsForCall)] + fake.buildArgsForCall = append(fake.buildArgsForCall, struct { + arg1 string + arg2 int + arg3 manifest.Manifest + arg4 ui.Stage + arg5 agentclient.AgentState + }{arg1, arg2, arg3, arg4, arg5}) + stub := fake.BuildStub + fakeReturns := fake.buildReturns + fake.recordInvocation("Build", []interface{}{arg1, arg2, arg3, arg4, arg5}) + fake.buildMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeBuilder) BuildCallCount() int { + fake.buildMutex.RLock() + defer fake.buildMutex.RUnlock() + return len(fake.buildArgsForCall) +} + +func (fake *FakeBuilder) BuildCalls(stub func(string, int, manifest.Manifest, ui.Stage, agentclient.AgentState) (state.State, error)) { + fake.buildMutex.Lock() + defer fake.buildMutex.Unlock() + fake.BuildStub = stub +} + +func (fake *FakeBuilder) BuildArgsForCall(i int) (string, int, manifest.Manifest, ui.Stage, agentclient.AgentState) { + fake.buildMutex.RLock() + defer fake.buildMutex.RUnlock() + argsForCall := fake.buildArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5 +} + +func (fake *FakeBuilder) BuildReturns(result1 state.State, result2 error) { + fake.buildMutex.Lock() + defer fake.buildMutex.Unlock() + fake.BuildStub = nil + fake.buildReturns = struct { + result1 state.State + result2 error + }{result1, result2} +} + +func (fake *FakeBuilder) BuildReturnsOnCall(i int, result1 state.State, result2 error) { + fake.buildMutex.Lock() + defer fake.buildMutex.Unlock() + fake.BuildStub = nil + if fake.buildReturnsOnCall == nil { + fake.buildReturnsOnCall = make(map[int]struct { + result1 state.State + result2 error + }) + } + fake.buildReturnsOnCall[i] = struct { + result1 state.State + result2 error + }{result1, result2} +} + +func (fake *FakeBuilder) BuildInitialState(arg1 string, arg2 int, arg3 manifest.Manifest) (state.State, error) { + fake.buildInitialStateMutex.Lock() + ret, specificReturn := fake.buildInitialStateReturnsOnCall[len(fake.buildInitialStateArgsForCall)] + fake.buildInitialStateArgsForCall = append(fake.buildInitialStateArgsForCall, struct { + arg1 string + arg2 int + arg3 manifest.Manifest + }{arg1, arg2, arg3}) + stub := fake.BuildInitialStateStub + fakeReturns := fake.buildInitialStateReturns + fake.recordInvocation("BuildInitialState", []interface{}{arg1, arg2, arg3}) + fake.buildInitialStateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeBuilder) BuildInitialStateCallCount() int { + fake.buildInitialStateMutex.RLock() + defer fake.buildInitialStateMutex.RUnlock() + return len(fake.buildInitialStateArgsForCall) +} + +func (fake *FakeBuilder) BuildInitialStateCalls(stub func(string, int, manifest.Manifest) (state.State, error)) { + fake.buildInitialStateMutex.Lock() + defer fake.buildInitialStateMutex.Unlock() + fake.BuildInitialStateStub = stub +} + +func (fake *FakeBuilder) BuildInitialStateArgsForCall(i int) (string, int, manifest.Manifest) { + fake.buildInitialStateMutex.RLock() + defer fake.buildInitialStateMutex.RUnlock() + argsForCall := fake.buildInitialStateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeBuilder) BuildInitialStateReturns(result1 state.State, result2 error) { + fake.buildInitialStateMutex.Lock() + defer fake.buildInitialStateMutex.Unlock() + fake.BuildInitialStateStub = nil + fake.buildInitialStateReturns = struct { + result1 state.State + result2 error + }{result1, result2} +} + +func (fake *FakeBuilder) BuildInitialStateReturnsOnCall(i int, result1 state.State, result2 error) { + fake.buildInitialStateMutex.Lock() + defer fake.buildInitialStateMutex.Unlock() + fake.BuildInitialStateStub = nil + if fake.buildInitialStateReturnsOnCall == nil { + fake.buildInitialStateReturnsOnCall = make(map[int]struct { + result1 state.State + result2 error + }) + } + fake.buildInitialStateReturnsOnCall[i] = struct { + result1 state.State + result2 error + }{result1, result2} +} + +func (fake *FakeBuilder) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeBuilder) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ state.Builder = new(FakeBuilder) diff --git a/deployment/instance/state/statefakes/fake_builder_factory.go b/deployment/instance/state/statefakes/fake_builder_factory.go new file mode 100644 index 0000000000..35f616582a --- /dev/null +++ b/deployment/instance/state/statefakes/fake_builder_factory.go @@ -0,0 +1,113 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package statefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-cli/v7/blobstore" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" +) + +type FakeBuilderFactory struct { + NewBuilderStub func(blobstore.Blobstore, agentclient.AgentClient) state.Builder + newBuilderMutex sync.RWMutex + newBuilderArgsForCall []struct { + arg1 blobstore.Blobstore + arg2 agentclient.AgentClient + } + newBuilderReturns struct { + result1 state.Builder + } + newBuilderReturnsOnCall map[int]struct { + result1 state.Builder + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeBuilderFactory) NewBuilder(arg1 blobstore.Blobstore, arg2 agentclient.AgentClient) state.Builder { + fake.newBuilderMutex.Lock() + ret, specificReturn := fake.newBuilderReturnsOnCall[len(fake.newBuilderArgsForCall)] + fake.newBuilderArgsForCall = append(fake.newBuilderArgsForCall, struct { + arg1 blobstore.Blobstore + arg2 agentclient.AgentClient + }{arg1, arg2}) + stub := fake.NewBuilderStub + fakeReturns := fake.newBuilderReturns + fake.recordInvocation("NewBuilder", []interface{}{arg1, arg2}) + fake.newBuilderMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeBuilderFactory) NewBuilderCallCount() int { + fake.newBuilderMutex.RLock() + defer fake.newBuilderMutex.RUnlock() + return len(fake.newBuilderArgsForCall) +} + +func (fake *FakeBuilderFactory) NewBuilderCalls(stub func(blobstore.Blobstore, agentclient.AgentClient) state.Builder) { + fake.newBuilderMutex.Lock() + defer fake.newBuilderMutex.Unlock() + fake.NewBuilderStub = stub +} + +func (fake *FakeBuilderFactory) NewBuilderArgsForCall(i int) (blobstore.Blobstore, agentclient.AgentClient) { + fake.newBuilderMutex.RLock() + defer fake.newBuilderMutex.RUnlock() + argsForCall := fake.newBuilderArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeBuilderFactory) NewBuilderReturns(result1 state.Builder) { + fake.newBuilderMutex.Lock() + defer fake.newBuilderMutex.Unlock() + fake.NewBuilderStub = nil + fake.newBuilderReturns = struct { + result1 state.Builder + }{result1} +} + +func (fake *FakeBuilderFactory) NewBuilderReturnsOnCall(i int, result1 state.Builder) { + fake.newBuilderMutex.Lock() + defer fake.newBuilderMutex.Unlock() + fake.NewBuilderStub = nil + if fake.newBuilderReturnsOnCall == nil { + fake.newBuilderReturnsOnCall = make(map[int]struct { + result1 state.Builder + }) + } + fake.newBuilderReturnsOnCall[i] = struct { + result1 state.Builder + }{result1} +} + +func (fake *FakeBuilderFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeBuilderFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ state.BuilderFactory = new(FakeBuilderFactory) diff --git a/deployment/instance/state/statefakes/fake_state.go b/deployment/instance/state/statefakes/fake_state.go new file mode 100644 index 0000000000..92986df745 --- /dev/null +++ b/deployment/instance/state/statefakes/fake_state.go @@ -0,0 +1,353 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package statefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state" +) + +type FakeState struct { + CompiledPackagesStub func() []state.PackageRef + compiledPackagesMutex sync.RWMutex + compiledPackagesArgsForCall []struct { + } + compiledPackagesReturns struct { + result1 []state.PackageRef + } + compiledPackagesReturnsOnCall map[int]struct { + result1 []state.PackageRef + } + NetworkInterfacesStub func() []state.NetworkRef + networkInterfacesMutex sync.RWMutex + networkInterfacesArgsForCall []struct { + } + networkInterfacesReturns struct { + result1 []state.NetworkRef + } + networkInterfacesReturnsOnCall map[int]struct { + result1 []state.NetworkRef + } + RenderedJobListArchiveStub func() state.BlobRef + renderedJobListArchiveMutex sync.RWMutex + renderedJobListArchiveArgsForCall []struct { + } + renderedJobListArchiveReturns struct { + result1 state.BlobRef + } + renderedJobListArchiveReturnsOnCall map[int]struct { + result1 state.BlobRef + } + RenderedJobsStub func() []state.JobRef + renderedJobsMutex sync.RWMutex + renderedJobsArgsForCall []struct { + } + renderedJobsReturns struct { + result1 []state.JobRef + } + renderedJobsReturnsOnCall map[int]struct { + result1 []state.JobRef + } + ToApplySpecStub func() applyspec.ApplySpec + toApplySpecMutex sync.RWMutex + toApplySpecArgsForCall []struct { + } + toApplySpecReturns struct { + result1 applyspec.ApplySpec + } + toApplySpecReturnsOnCall map[int]struct { + result1 applyspec.ApplySpec + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeState) CompiledPackages() []state.PackageRef { + fake.compiledPackagesMutex.Lock() + ret, specificReturn := fake.compiledPackagesReturnsOnCall[len(fake.compiledPackagesArgsForCall)] + fake.compiledPackagesArgsForCall = append(fake.compiledPackagesArgsForCall, struct { + }{}) + stub := fake.CompiledPackagesStub + fakeReturns := fake.compiledPackagesReturns + fake.recordInvocation("CompiledPackages", []interface{}{}) + fake.compiledPackagesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeState) CompiledPackagesCallCount() int { + fake.compiledPackagesMutex.RLock() + defer fake.compiledPackagesMutex.RUnlock() + return len(fake.compiledPackagesArgsForCall) +} + +func (fake *FakeState) CompiledPackagesCalls(stub func() []state.PackageRef) { + fake.compiledPackagesMutex.Lock() + defer fake.compiledPackagesMutex.Unlock() + fake.CompiledPackagesStub = stub +} + +func (fake *FakeState) CompiledPackagesReturns(result1 []state.PackageRef) { + fake.compiledPackagesMutex.Lock() + defer fake.compiledPackagesMutex.Unlock() + fake.CompiledPackagesStub = nil + fake.compiledPackagesReturns = struct { + result1 []state.PackageRef + }{result1} +} + +func (fake *FakeState) CompiledPackagesReturnsOnCall(i int, result1 []state.PackageRef) { + fake.compiledPackagesMutex.Lock() + defer fake.compiledPackagesMutex.Unlock() + fake.CompiledPackagesStub = nil + if fake.compiledPackagesReturnsOnCall == nil { + fake.compiledPackagesReturnsOnCall = make(map[int]struct { + result1 []state.PackageRef + }) + } + fake.compiledPackagesReturnsOnCall[i] = struct { + result1 []state.PackageRef + }{result1} +} + +func (fake *FakeState) NetworkInterfaces() []state.NetworkRef { + fake.networkInterfacesMutex.Lock() + ret, specificReturn := fake.networkInterfacesReturnsOnCall[len(fake.networkInterfacesArgsForCall)] + fake.networkInterfacesArgsForCall = append(fake.networkInterfacesArgsForCall, struct { + }{}) + stub := fake.NetworkInterfacesStub + fakeReturns := fake.networkInterfacesReturns + fake.recordInvocation("NetworkInterfaces", []interface{}{}) + fake.networkInterfacesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeState) NetworkInterfacesCallCount() int { + fake.networkInterfacesMutex.RLock() + defer fake.networkInterfacesMutex.RUnlock() + return len(fake.networkInterfacesArgsForCall) +} + +func (fake *FakeState) NetworkInterfacesCalls(stub func() []state.NetworkRef) { + fake.networkInterfacesMutex.Lock() + defer fake.networkInterfacesMutex.Unlock() + fake.NetworkInterfacesStub = stub +} + +func (fake *FakeState) NetworkInterfacesReturns(result1 []state.NetworkRef) { + fake.networkInterfacesMutex.Lock() + defer fake.networkInterfacesMutex.Unlock() + fake.NetworkInterfacesStub = nil + fake.networkInterfacesReturns = struct { + result1 []state.NetworkRef + }{result1} +} + +func (fake *FakeState) NetworkInterfacesReturnsOnCall(i int, result1 []state.NetworkRef) { + fake.networkInterfacesMutex.Lock() + defer fake.networkInterfacesMutex.Unlock() + fake.NetworkInterfacesStub = nil + if fake.networkInterfacesReturnsOnCall == nil { + fake.networkInterfacesReturnsOnCall = make(map[int]struct { + result1 []state.NetworkRef + }) + } + fake.networkInterfacesReturnsOnCall[i] = struct { + result1 []state.NetworkRef + }{result1} +} + +func (fake *FakeState) RenderedJobListArchive() state.BlobRef { + fake.renderedJobListArchiveMutex.Lock() + ret, specificReturn := fake.renderedJobListArchiveReturnsOnCall[len(fake.renderedJobListArchiveArgsForCall)] + fake.renderedJobListArchiveArgsForCall = append(fake.renderedJobListArchiveArgsForCall, struct { + }{}) + stub := fake.RenderedJobListArchiveStub + fakeReturns := fake.renderedJobListArchiveReturns + fake.recordInvocation("RenderedJobListArchive", []interface{}{}) + fake.renderedJobListArchiveMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeState) RenderedJobListArchiveCallCount() int { + fake.renderedJobListArchiveMutex.RLock() + defer fake.renderedJobListArchiveMutex.RUnlock() + return len(fake.renderedJobListArchiveArgsForCall) +} + +func (fake *FakeState) RenderedJobListArchiveCalls(stub func() state.BlobRef) { + fake.renderedJobListArchiveMutex.Lock() + defer fake.renderedJobListArchiveMutex.Unlock() + fake.RenderedJobListArchiveStub = stub +} + +func (fake *FakeState) RenderedJobListArchiveReturns(result1 state.BlobRef) { + fake.renderedJobListArchiveMutex.Lock() + defer fake.renderedJobListArchiveMutex.Unlock() + fake.RenderedJobListArchiveStub = nil + fake.renderedJobListArchiveReturns = struct { + result1 state.BlobRef + }{result1} +} + +func (fake *FakeState) RenderedJobListArchiveReturnsOnCall(i int, result1 state.BlobRef) { + fake.renderedJobListArchiveMutex.Lock() + defer fake.renderedJobListArchiveMutex.Unlock() + fake.RenderedJobListArchiveStub = nil + if fake.renderedJobListArchiveReturnsOnCall == nil { + fake.renderedJobListArchiveReturnsOnCall = make(map[int]struct { + result1 state.BlobRef + }) + } + fake.renderedJobListArchiveReturnsOnCall[i] = struct { + result1 state.BlobRef + }{result1} +} + +func (fake *FakeState) RenderedJobs() []state.JobRef { + fake.renderedJobsMutex.Lock() + ret, specificReturn := fake.renderedJobsReturnsOnCall[len(fake.renderedJobsArgsForCall)] + fake.renderedJobsArgsForCall = append(fake.renderedJobsArgsForCall, struct { + }{}) + stub := fake.RenderedJobsStub + fakeReturns := fake.renderedJobsReturns + fake.recordInvocation("RenderedJobs", []interface{}{}) + fake.renderedJobsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeState) RenderedJobsCallCount() int { + fake.renderedJobsMutex.RLock() + defer fake.renderedJobsMutex.RUnlock() + return len(fake.renderedJobsArgsForCall) +} + +func (fake *FakeState) RenderedJobsCalls(stub func() []state.JobRef) { + fake.renderedJobsMutex.Lock() + defer fake.renderedJobsMutex.Unlock() + fake.RenderedJobsStub = stub +} + +func (fake *FakeState) RenderedJobsReturns(result1 []state.JobRef) { + fake.renderedJobsMutex.Lock() + defer fake.renderedJobsMutex.Unlock() + fake.RenderedJobsStub = nil + fake.renderedJobsReturns = struct { + result1 []state.JobRef + }{result1} +} + +func (fake *FakeState) RenderedJobsReturnsOnCall(i int, result1 []state.JobRef) { + fake.renderedJobsMutex.Lock() + defer fake.renderedJobsMutex.Unlock() + fake.RenderedJobsStub = nil + if fake.renderedJobsReturnsOnCall == nil { + fake.renderedJobsReturnsOnCall = make(map[int]struct { + result1 []state.JobRef + }) + } + fake.renderedJobsReturnsOnCall[i] = struct { + result1 []state.JobRef + }{result1} +} + +func (fake *FakeState) ToApplySpec() applyspec.ApplySpec { + fake.toApplySpecMutex.Lock() + ret, specificReturn := fake.toApplySpecReturnsOnCall[len(fake.toApplySpecArgsForCall)] + fake.toApplySpecArgsForCall = append(fake.toApplySpecArgsForCall, struct { + }{}) + stub := fake.ToApplySpecStub + fakeReturns := fake.toApplySpecReturns + fake.recordInvocation("ToApplySpec", []interface{}{}) + fake.toApplySpecMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeState) ToApplySpecCallCount() int { + fake.toApplySpecMutex.RLock() + defer fake.toApplySpecMutex.RUnlock() + return len(fake.toApplySpecArgsForCall) +} + +func (fake *FakeState) ToApplySpecCalls(stub func() applyspec.ApplySpec) { + fake.toApplySpecMutex.Lock() + defer fake.toApplySpecMutex.Unlock() + fake.ToApplySpecStub = stub +} + +func (fake *FakeState) ToApplySpecReturns(result1 applyspec.ApplySpec) { + fake.toApplySpecMutex.Lock() + defer fake.toApplySpecMutex.Unlock() + fake.ToApplySpecStub = nil + fake.toApplySpecReturns = struct { + result1 applyspec.ApplySpec + }{result1} +} + +func (fake *FakeState) ToApplySpecReturnsOnCall(i int, result1 applyspec.ApplySpec) { + fake.toApplySpecMutex.Lock() + defer fake.toApplySpecMutex.Unlock() + fake.ToApplySpecStub = nil + if fake.toApplySpecReturnsOnCall == nil { + fake.toApplySpecReturnsOnCall = make(map[int]struct { + result1 applyspec.ApplySpec + }) + } + fake.toApplySpecReturnsOnCall[i] = struct { + result1 applyspec.ApplySpec + }{result1} +} + +func (fake *FakeState) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeState) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ state.State = new(FakeState) diff --git a/deployment/manager.go b/deployment/manager.go index 4498fa4024..691a82130b 100644 --- a/deployment/manager.go +++ b/deployment/manager.go @@ -9,6 +9,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . Manager + type Manager interface { FindCurrent() (deployment Deployment, found bool, err error) Cleanup(biui.Stage) error diff --git a/deployment/manager_factory.go b/deployment/manager_factory.go index 49acd086b1..10a341de3f 100644 --- a/deployment/manager_factory.go +++ b/deployment/manager_factory.go @@ -11,6 +11,8 @@ import ( bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" ) +//counterfeiter:generate . ManagerFactory + type ManagerFactory interface { NewManager(bicloud.Cloud, biagentclient.AgentClient, biblobstore.Blobstore) Manager } diff --git a/deployment/manager_test.go b/deployment/manager_test.go index a45f3dc705..55ed658644 100644 --- a/deployment/manager_test.go +++ b/deployment/manager_test.go @@ -5,63 +5,51 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mock_agentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mock_blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - mock_cloud "github.com/cloudfoundry/bosh-cli/v7/cloud/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" . "github.com/cloudfoundry/bosh-cli/v7/deployment" + "github.com/cloudfoundry/bosh-cli/v7/deployment/deploymentfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - mock_disk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mock_instance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/mocks" - mock_instance_state "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" - mock_deployment "github.com/cloudfoundry/bosh-cli/v7/deployment/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/instancefakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - mock_stemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/mocks" + "github.com/cloudfoundry/bosh-cli/v7/stemcell/mockfakes" + "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("Manager", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("FindCurrent", func() { var ( - mockInstanceManager *mock_instance.MockManager - mockDiskManager *mock_disk.MockManager - mockStemcellManager *mock_stemcell.MockManager - mockDeploymentFactory *mock_deployment.MockFactory - mockDeployment *mock_deployment.MockDeployment + mockInstanceManager *instancefakes.FakeManager + mockDiskManager *diskfakes.FakeManager + mockStemcellManager *mockfakes.FakeManager + mockDeploymentFactory *deploymentfakes.FakeFactory + mockDeployment *deploymentfakes.FakeDeployment deploymentManager Manager expectedInstances []biinstance.Instance expectedDisks []bidisk.Disk expectedStemcells []bistemcell.CloudStemcell - - expectNewDeployment *gomock.Call ) BeforeEach(func() { - mockInstanceManager = mock_instance.NewMockManager(mockCtrl) - mockDiskManager = mock_disk.NewMockManager(mockCtrl) - mockStemcellManager = mock_stemcell.NewMockManager(mockCtrl) - mockDeploymentFactory = mock_deployment.NewMockFactory(mockCtrl) - mockDeployment = mock_deployment.NewMockDeployment(mockCtrl) + mockInstanceManager = &instancefakes.FakeManager{} + mockDiskManager = &diskfakes.FakeManager{} + mockStemcellManager = &mockfakes.FakeManager{} + mockDeploymentFactory = &deploymentfakes.FakeFactory{} + mockDeployment = &deploymentfakes.FakeDeployment{} expectedInstances = []biinstance.Instance{} expectedDisks = []bidisk.Disk{} @@ -69,11 +57,11 @@ var _ = Describe("Manager", func() { }) JustBeforeEach(func() { - mockInstanceManager.EXPECT().FindCurrent().Return(expectedInstances, nil) - mockDiskManager.EXPECT().FindCurrent().Return(expectedDisks, nil) - mockStemcellManager.EXPECT().FindCurrent().Return(expectedStemcells, nil) + mockInstanceManager.FindCurrentReturns(expectedInstances, nil) + mockDiskManager.FindCurrentReturns(expectedDisks, nil) + mockStemcellManager.FindCurrentReturns(expectedStemcells, nil) - expectNewDeployment = mockDeploymentFactory.EXPECT().NewDeployment(expectedInstances, expectedDisks, expectedStemcells).Return(mockDeployment).AnyTimes() + mockDeploymentFactory.NewDeploymentReturns(mockDeployment) deploymentManager = NewManager(mockInstanceManager, mockDiskManager, mockStemcellManager, mockDeploymentFactory) }) @@ -88,49 +76,53 @@ var _ = Describe("Manager", func() { Context("when current instances exist", func() { BeforeEach(func() { - instance := mock_instance.NewMockInstance(mockCtrl) + instance := &instancefakes.FakeInstance{} expectedInstances = append(expectedInstances, instance) }) It("returns a deployment that wraps the current instances, disks, & stemcells", func() { - expectNewDeployment.Times(1) - deployment, found, err := deploymentManager.FindCurrent() Expect(err).ToNot(HaveOccurred()) Expect(found).To(BeTrue()) Expect(deployment).To(Equal(mockDeployment)) + + Expect(mockDeploymentFactory.NewDeploymentCallCount()).To(Equal(1)) + instances, disks, stemcells := mockDeploymentFactory.NewDeploymentArgsForCall(0) + Expect(instances).To(Equal(expectedInstances)) + Expect(disks).To(Equal(expectedDisks)) + Expect(stemcells).To(Equal(expectedStemcells)) }) }) Context("when current disk exist", func() { BeforeEach(func() { - disk := mock_disk.NewMockDisk(mockCtrl) + disk := &diskfakes.FakeDisk{} expectedDisks = append(expectedDisks, disk) }) It("returns a deployment that wraps the current instances, disks, & stemcells", func() { - expectNewDeployment.Times(1) - deployment, found, err := deploymentManager.FindCurrent() Expect(err).ToNot(HaveOccurred()) Expect(found).To(BeTrue()) Expect(deployment).To(Equal(mockDeployment)) + + Expect(mockDeploymentFactory.NewDeploymentCallCount()).To(Equal(1)) }) }) Context("when current stemcell exist", func() { BeforeEach(func() { - stemcell := mock_stemcell.NewMockCloudStemcell(mockCtrl) + stemcell := stemcellfakes.NewFakeCloudStemcell("fake-stemcell-cid", "fake-stemcell-name", "fake-stemcell-version", 1) expectedStemcells = append(expectedStemcells, stemcell) }) It("returns a deployment that wraps the current instances, disks, & stemcells", func() { - expectNewDeployment.Times(1) - deployment, found, err := deploymentManager.FindCurrent() Expect(err).ToNot(HaveOccurred()) Expect(found).To(BeTrue()) Expect(deployment).To(Equal(mockDeployment)) + + Expect(mockDeploymentFactory.NewDeploymentCallCount()).To(Equal(1)) }) }) }) @@ -140,11 +132,11 @@ var _ = Describe("Manager", func() { logger boshlog.Logger fs boshsys.FileSystem - mockDeploymentFactory *mock_deployment.MockFactory + mockDeploymentFactory *deploymentfakes.FakeFactory - mockStateBuilderFactory *mock_instance_state.MockBuilderFactory + mockStateBuilderFactory *statefakes.FakeBuilderFactory - mockBlobstore *mock_blobstore.MockBlobstore + mockBlobstore *blobstorefakes.FakeBlobstore fakeUUIDGenerator *fakeuuid.FakeGenerator fakeRepoUUIDGenerator *fakeuuid.FakeGenerator @@ -153,8 +145,8 @@ var _ = Describe("Manager", func() { diskRepo biconfig.DiskRepo stemcellRepo biconfig.StemcellRepo - mockCloud *mock_cloud.MockCloud - mockAgentClient *mock_agentclient.MockAgentClient + mockCloud *cloudfakes.FakeCloud + mockAgentClient *agentclientfakes.FakeAgentClient fakeStage *fakebiui.FakeStage @@ -166,7 +158,7 @@ var _ = Describe("Manager", func() { logger = boshlog.NewLogger(boshlog.LevelNone) fs = fakesys.NewFakeFileSystem() - mockDeploymentFactory = mock_deployment.NewMockFactory(mockCtrl) + mockDeploymentFactory = &deploymentfakes.FakeFactory{} fakeUUIDGenerator = fakeuuid.NewFakeGenerator() deploymentStateService = biconfig.NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, "/deployment.json") @@ -176,8 +168,8 @@ var _ = Describe("Manager", func() { diskRepo = biconfig.NewDiskRepo(deploymentStateService, fakeRepoUUIDGenerator) stemcellRepo = biconfig.NewStemcellRepo(deploymentStateService, fakeRepoUUIDGenerator) - mockCloud = mock_cloud.NewMockCloud(mockCtrl) - mockAgentClient = mock_agentclient.NewMockAgentClient(mockCtrl) + mockCloud = &cloudfakes.FakeCloud{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} fakeStage = fakebiui.NewFakeStage() }) @@ -189,13 +181,13 @@ var _ = Describe("Manager", func() { vmManagerFactory := bivm.NewManagerFactory(vmRepo, stemcellRepo, diskDeployer, fakeUUIDGenerator, fs, logger) sshTunnelFactory := bisshtunnel.NewFactory(logger) - mockStateBuilderFactory = mock_instance_state.NewMockBuilderFactory(mockCtrl) + mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} instanceFactory := biinstance.NewFactory(mockStateBuilderFactory) instanceManagerFactory := biinstance.NewManagerFactory(sshTunnelFactory, instanceFactory, logger) stemcellManagerFactory := bistemcell.NewManagerFactory(stemcellRepo) - mockBlobstore = mock_blobstore.NewMockBlobstore(mockCtrl) + mockBlobstore = &blobstorefakes.FakeBlobstore{} deploymentManagerFactory := NewManagerFactory(vmManagerFactory, instanceManagerFactory, diskManagerFactory, stemcellManagerFactory, mockDeploymentFactory) deploymentManager = deploymentManagerFactory.NewManager(mockCloud, mockAgentClient, mockBlobstore) @@ -250,7 +242,7 @@ var _ = Describe("Manager", func() { }) It("deletes the unused disks", func() { - mockCloud.EXPECT().DeleteDisk("orphan-disk-cid") + mockCloud.DeleteDiskReturns(nil) err := deploymentManager.Cleanup(fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -261,7 +253,7 @@ var _ = Describe("Manager", func() { }) It("logs delete stage", func() { - mockCloud.EXPECT().DeleteDisk("orphan-disk-cid") + mockCloud.DeleteDiskReturns(nil) err := deploymentManager.Cleanup(fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -273,7 +265,7 @@ var _ = Describe("Manager", func() { Context("when disks have been deleted manually (in the infrastructure)", func() { It("deletes the unused disks, ignoring DiskNotFoundError", func() { - mockCloud.EXPECT().DeleteDisk("orphan-disk-cid").Return(bicloud.NewCPIError("delete_disk", bicloud.CmdError{ + mockCloud.DeleteDiskReturns(bicloud.NewCPIError("delete_disk", bicloud.CmdError{ Type: bicloud.DiskNotFoundError, Message: "fake-disk-not-found-message", })) @@ -287,7 +279,7 @@ var _ = Describe("Manager", func() { }) It("logs disk deletion as skipped", func() { - mockCloud.EXPECT().DeleteDisk("orphan-disk-cid").Return(bicloud.NewCPIError("delete_disk", bicloud.CmdError{ + mockCloud.DeleteDiskReturns(bicloud.NewCPIError("delete_disk", bicloud.CmdError{ Type: bicloud.DiskNotFoundError, Message: "fake-disk-not-found-message", })) @@ -308,7 +300,7 @@ var _ = Describe("Manager", func() { }) It("deletes the unused stemcells", func() { - mockCloud.EXPECT().DeleteStemcell("orphan-stemcell-cid") + mockCloud.DeleteStemcellReturns(nil) err := deploymentManager.Cleanup(fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -319,7 +311,7 @@ var _ = Describe("Manager", func() { }) It("logs delete stage", func() { - mockCloud.EXPECT().DeleteStemcell("orphan-stemcell-cid") + mockCloud.DeleteStemcellReturns(nil) err := deploymentManager.Cleanup(fakeStage) Expect(err).ToNot(HaveOccurred()) @@ -331,7 +323,7 @@ var _ = Describe("Manager", func() { Context("when stemcells have been deleted manually (in the infrastructure)", func() { It("deletes the unused stemcells, ignoring StemcellNotFoundError", func() { - mockCloud.EXPECT().DeleteStemcell("orphan-stemcell-cid").Return(bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ + mockCloud.DeleteStemcellReturns(bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ Type: bicloud.StemcellNotFoundError, Message: "fake-stemcell-not-found-message", })) @@ -345,7 +337,7 @@ var _ = Describe("Manager", func() { }) It("logs stemcell deletion as skipped", func() { - mockCloud.EXPECT().DeleteStemcell("orphan-stemcell-cid").Return(bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ + mockCloud.DeleteStemcellReturns(bicloud.NewCPIError("delete_stemcell", bicloud.CmdError{ Type: bicloud.StemcellNotFoundError, Message: "fake-stemcell-not-found-message", })) diff --git a/deployment/mocks/mocks.go b/deployment/mocks/mocks.go deleted file mode 100644 index 13770854b5..0000000000 --- a/deployment/mocks/mocks.go +++ /dev/null @@ -1,251 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment (interfaces: Deployment,Factory,Deployer,Manager,ManagerFactory) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - agentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - blobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore" - cloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - deployment "github.com/cloudfoundry/bosh-cli/v7/deployment" - disk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - instance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - manifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - vm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - stemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockDeployment is a mock of Deployment interface. -type MockDeployment struct { - ctrl *gomock.Controller - recorder *MockDeploymentMockRecorder -} - -// MockDeploymentMockRecorder is the mock recorder for MockDeployment. -type MockDeploymentMockRecorder struct { - mock *MockDeployment -} - -// NewMockDeployment creates a new mock instance. -func NewMockDeployment(ctrl *gomock.Controller) *MockDeployment { - mock := &MockDeployment{ctrl: ctrl} - mock.recorder = &MockDeploymentMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDeployment) EXPECT() *MockDeploymentMockRecorder { - return m.recorder -} - -// Delete mocks base method. -func (m *MockDeployment) Delete(arg0 bool, arg1 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockDeploymentMockRecorder) Delete(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDeployment)(nil).Delete), arg0, arg1) -} - -// Start mocks base method. -func (m *MockDeployment) Start(arg0 ui.Stage, arg1 manifest.Update) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Start", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// Start indicates an expected call of Start. -func (mr *MockDeploymentMockRecorder) Start(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockDeployment)(nil).Start), arg0, arg1) -} - -// Stop mocks base method. -func (m *MockDeployment) Stop(arg0 bool, arg1 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Stop", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// Stop indicates an expected call of Stop. -func (mr *MockDeploymentMockRecorder) Stop(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stop", reflect.TypeOf((*MockDeployment)(nil).Stop), arg0, arg1) -} - -// MockFactory is a mock of Factory interface. -type MockFactory struct { - ctrl *gomock.Controller - recorder *MockFactoryMockRecorder -} - -// MockFactoryMockRecorder is the mock recorder for MockFactory. -type MockFactoryMockRecorder struct { - mock *MockFactory -} - -// NewMockFactory creates a new mock instance. -func NewMockFactory(ctrl *gomock.Controller) *MockFactory { - mock := &MockFactory{ctrl: ctrl} - mock.recorder = &MockFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockFactory) EXPECT() *MockFactoryMockRecorder { - return m.recorder -} - -// NewDeployment mocks base method. -func (m *MockFactory) NewDeployment(arg0 []instance.Instance, arg1 []disk.Disk, arg2 []stemcell.CloudStemcell) deployment.Deployment { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewDeployment", arg0, arg1, arg2) - ret0, _ := ret[0].(deployment.Deployment) - return ret0 -} - -// NewDeployment indicates an expected call of NewDeployment. -func (mr *MockFactoryMockRecorder) NewDeployment(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeployment", reflect.TypeOf((*MockFactory)(nil).NewDeployment), arg0, arg1, arg2) -} - -// MockDeployer is a mock of Deployer interface. -type MockDeployer struct { - ctrl *gomock.Controller - recorder *MockDeployerMockRecorder -} - -// MockDeployerMockRecorder is the mock recorder for MockDeployer. -type MockDeployerMockRecorder struct { - mock *MockDeployer -} - -// NewMockDeployer creates a new mock instance. -func NewMockDeployer(ctrl *gomock.Controller) *MockDeployer { - mock := &MockDeployer{ctrl: ctrl} - mock.recorder = &MockDeployerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDeployer) EXPECT() *MockDeployerMockRecorder { - return m.recorder -} - -// Deploy mocks base method. -func (m *MockDeployer) Deploy(arg0 cloud.Cloud, arg1 manifest.Manifest, arg2 stemcell.CloudStemcell, arg3 vm.Manager, arg4 blobstore.Blobstore, arg5 bool, arg6 []string, arg7 ui.Stage) (deployment.Deployment, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Deploy", arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) - ret0, _ := ret[0].(deployment.Deployment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Deploy indicates an expected call of Deploy. -func (mr *MockDeployerMockRecorder) Deploy(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Deploy", reflect.TypeOf((*MockDeployer)(nil).Deploy), arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) -} - -// MockManager is a mock of Manager interface. -type MockManager struct { - ctrl *gomock.Controller - recorder *MockManagerMockRecorder -} - -// MockManagerMockRecorder is the mock recorder for MockManager. -type MockManagerMockRecorder struct { - mock *MockManager -} - -// NewMockManager creates a new mock instance. -func NewMockManager(ctrl *gomock.Controller) *MockManager { - mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder -} - -// Cleanup mocks base method. -func (m *MockManager) Cleanup(arg0 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Cleanup", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// Cleanup indicates an expected call of Cleanup. -func (mr *MockManagerMockRecorder) Cleanup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockManager)(nil).Cleanup), arg0) -} - -// FindCurrent mocks base method. -func (m *MockManager) FindCurrent() (deployment.Deployment, bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindCurrent") - ret0, _ := ret[0].(deployment.Deployment) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// FindCurrent indicates an expected call of FindCurrent. -func (mr *MockManagerMockRecorder) FindCurrent() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCurrent", reflect.TypeOf((*MockManager)(nil).FindCurrent)) -} - -// MockManagerFactory is a mock of ManagerFactory interface. -type MockManagerFactory struct { - ctrl *gomock.Controller - recorder *MockManagerFactoryMockRecorder -} - -// MockManagerFactoryMockRecorder is the mock recorder for MockManagerFactory. -type MockManagerFactoryMockRecorder struct { - mock *MockManagerFactory -} - -// NewMockManagerFactory creates a new mock instance. -func NewMockManagerFactory(ctrl *gomock.Controller) *MockManagerFactory { - mock := &MockManagerFactory{ctrl: ctrl} - mock.recorder = &MockManagerFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManagerFactory) EXPECT() *MockManagerFactoryMockRecorder { - return m.recorder -} - -// NewManager mocks base method. -func (m *MockManagerFactory) NewManager(arg0 cloud.Cloud, arg1 agentclient.AgentClient, arg2 blobstore.Blobstore) deployment.Manager { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewManager", arg0, arg1, arg2) - ret0, _ := ret[0].(deployment.Manager) - return ret0 -} - -// NewManager indicates an expected call of NewManager. -func (mr *MockManagerFactoryMockRecorder) NewManager(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewManager", reflect.TypeOf((*MockManagerFactory)(nil).NewManager), arg0, arg1, arg2) -} diff --git a/deployment/release/job_resolver.go b/deployment/release/job_resolver.go index 14fde1d711..02d1b8dff4 100644 --- a/deployment/release/job_resolver.go +++ b/deployment/release/job_resolver.go @@ -7,6 +7,10 @@ import ( bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . JobResolver + type JobResolver interface { Resolve(jobName, releaseName string) (bireljob.Job, error) } diff --git a/deployment/release/job_resolver_test.go b/deployment/release/job_resolver_test.go index 03cc828148..5da835d0ce 100644 --- a/deployment/release/job_resolver_test.go +++ b/deployment/release/job_resolver_test.go @@ -1,36 +1,24 @@ package release_test import ( - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-cli/v7/deployment/release" bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" - mock_release "github.com/cloudfoundry/bosh-cli/v7/release/mocks" fakerel "github.com/cloudfoundry/bosh-cli/v7/release/releasefakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" ) var _ = Describe("JobResolver", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockReleaseManager *mock_release.MockManager + mockReleaseManager *fakerel.FakeManager release *fakerel.FakeRelease jobResolver JobResolver ) BeforeEach(func() { - mockReleaseManager = mock_release.NewMockManager(mockCtrl) + mockReleaseManager = &fakerel.FakeManager{} release = &fakerel.FakeRelease{ NameStub: func() string { return "rel-name" }, @@ -43,7 +31,7 @@ var _ = Describe("JobResolver", func() { Describe("Resolve", func() { It("Returns the matching release job", func() { job0 := bireljob.NewJob(NewResource("job0", "job0-fp", nil)) - mockReleaseManager.EXPECT().Find("rel-name").Return(release, true) + mockReleaseManager.FindReturns(release, true) release.FindJobByNameStub = func(name string) (bireljob.Job, bool) { Expect(name).To(Equal("job0")) return *job0, true @@ -52,10 +40,13 @@ var _ = Describe("JobResolver", func() { releaseJob, err := jobResolver.Resolve("job0", "rel-name") Expect(err).ToNot(HaveOccurred()) Expect(releaseJob).To(Equal(*job0)) + + Expect(mockReleaseManager.FindCallCount()).To(Equal(1)) + Expect(mockReleaseManager.FindArgsForCall(0)).To(Equal("rel-name")) }) It("Returns an error, when the job is not in the release", func() { - mockReleaseManager.EXPECT().Find("rel-name").Return(release, true) + mockReleaseManager.FindReturns(release, true) release.FindJobByNameReturns(bireljob.Job{}, false) _, err := jobResolver.Resolve("fake-missing-release-job-name", "rel-name") @@ -64,7 +55,7 @@ var _ = Describe("JobResolver", func() { }) It("Returns an error, when the release is not in resolvable", func() { - mockReleaseManager.EXPECT().Find("fake-missing-release-name").Return(nil, false) + mockReleaseManager.FindReturns(nil, false) _, err := jobResolver.Resolve("job0", "fake-missing-release-name") Expect(err).To(HaveOccurred()) diff --git a/deployment/release/mocks/mocks.go b/deployment/release/mocks/mocks.go deleted file mode 100644 index c51f638a90..0000000000 --- a/deployment/release/mocks/mocks.go +++ /dev/null @@ -1,50 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment/release (interfaces: JobResolver) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - job "github.com/cloudfoundry/bosh-cli/v7/release/job" - gomock "github.com/golang/mock/gomock" -) - -// MockJobResolver is a mock of JobResolver interface. -type MockJobResolver struct { - ctrl *gomock.Controller - recorder *MockJobResolverMockRecorder -} - -// MockJobResolverMockRecorder is the mock recorder for MockJobResolver. -type MockJobResolverMockRecorder struct { - mock *MockJobResolver -} - -// NewMockJobResolver creates a new mock instance. -func NewMockJobResolver(ctrl *gomock.Controller) *MockJobResolver { - mock := &MockJobResolver{ctrl: ctrl} - mock.recorder = &MockJobResolverMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockJobResolver) EXPECT() *MockJobResolverMockRecorder { - return m.recorder -} - -// Resolve mocks base method. -func (m *MockJobResolver) Resolve(arg0, arg1 string) (job.Job, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Resolve", arg0, arg1) - ret0, _ := ret[0].(job.Job) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Resolve indicates an expected call of Resolve. -func (mr *MockJobResolverMockRecorder) Resolve(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockJobResolver)(nil).Resolve), arg0, arg1) -} diff --git a/deployment/release/releasefakes/fake_job_resolver.go b/deployment/release/releasefakes/fake_job_resolver.go new file mode 100644 index 0000000000..f5c875cb2f --- /dev/null +++ b/deployment/release/releasefakes/fake_job_resolver.go @@ -0,0 +1,117 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package releasefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/release" + "github.com/cloudfoundry/bosh-cli/v7/release/job" +) + +type FakeJobResolver struct { + ResolveStub func(string, string) (job.Job, error) + resolveMutex sync.RWMutex + resolveArgsForCall []struct { + arg1 string + arg2 string + } + resolveReturns struct { + result1 job.Job + result2 error + } + resolveReturnsOnCall map[int]struct { + result1 job.Job + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeJobResolver) Resolve(arg1 string, arg2 string) (job.Job, error) { + fake.resolveMutex.Lock() + ret, specificReturn := fake.resolveReturnsOnCall[len(fake.resolveArgsForCall)] + fake.resolveArgsForCall = append(fake.resolveArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.ResolveStub + fakeReturns := fake.resolveReturns + fake.recordInvocation("Resolve", []interface{}{arg1, arg2}) + fake.resolveMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeJobResolver) ResolveCallCount() int { + fake.resolveMutex.RLock() + defer fake.resolveMutex.RUnlock() + return len(fake.resolveArgsForCall) +} + +func (fake *FakeJobResolver) ResolveCalls(stub func(string, string) (job.Job, error)) { + fake.resolveMutex.Lock() + defer fake.resolveMutex.Unlock() + fake.ResolveStub = stub +} + +func (fake *FakeJobResolver) ResolveArgsForCall(i int) (string, string) { + fake.resolveMutex.RLock() + defer fake.resolveMutex.RUnlock() + argsForCall := fake.resolveArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeJobResolver) ResolveReturns(result1 job.Job, result2 error) { + fake.resolveMutex.Lock() + defer fake.resolveMutex.Unlock() + fake.ResolveStub = nil + fake.resolveReturns = struct { + result1 job.Job + result2 error + }{result1, result2} +} + +func (fake *FakeJobResolver) ResolveReturnsOnCall(i int, result1 job.Job, result2 error) { + fake.resolveMutex.Lock() + defer fake.resolveMutex.Unlock() + fake.ResolveStub = nil + if fake.resolveReturnsOnCall == nil { + fake.resolveReturnsOnCall = make(map[int]struct { + result1 job.Job + result2 error + }) + } + fake.resolveReturnsOnCall[i] = struct { + result1 job.Job + result2 error + }{result1, result2} +} + +func (fake *FakeJobResolver) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeJobResolver) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ release.JobResolver = new(FakeJobResolver) diff --git a/deployment/vm/manager_factory.go b/deployment/vm/manager_factory.go index c374fe77fd..432a23ba3d 100644 --- a/deployment/vm/manager_factory.go +++ b/deployment/vm/manager_factory.go @@ -11,6 +11,8 @@ import ( biconfig "github.com/cloudfoundry/bosh-cli/v7/config" ) +//counterfeiter:generate . ManagerFactory + type ManagerFactory interface { NewManager(cloud bicloud.Cloud, agentClient biagentclient.AgentClient) Manager } diff --git a/deployment/vm/mocks/mocks.go b/deployment/vm/mocks/mocks.go deleted file mode 100644 index 2fe675de45..0000000000 --- a/deployment/vm/mocks/mocks.go +++ /dev/null @@ -1,51 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/deployment/vm (interfaces: ManagerFactory) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - agentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - cloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - vm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - gomock "github.com/golang/mock/gomock" -) - -// MockManagerFactory is a mock of ManagerFactory interface. -type MockManagerFactory struct { - ctrl *gomock.Controller - recorder *MockManagerFactoryMockRecorder -} - -// MockManagerFactoryMockRecorder is the mock recorder for MockManagerFactory. -type MockManagerFactoryMockRecorder struct { - mock *MockManagerFactory -} - -// NewMockManagerFactory creates a new mock instance. -func NewMockManagerFactory(ctrl *gomock.Controller) *MockManagerFactory { - mock := &MockManagerFactory{ctrl: ctrl} - mock.recorder = &MockManagerFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManagerFactory) EXPECT() *MockManagerFactoryMockRecorder { - return m.recorder -} - -// NewManager mocks base method. -func (m *MockManagerFactory) NewManager(arg0 cloud.Cloud, arg1 agentclient.AgentClient) vm.Manager { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewManager", arg0, arg1) - ret0, _ := ret[0].(vm.Manager) - return ret0 -} - -// NewManager indicates an expected call of NewManager. -func (mr *MockManagerFactoryMockRecorder) NewManager(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewManager", reflect.TypeOf((*MockManagerFactory)(nil).NewManager), arg0, arg1) -} diff --git a/deployment/vm/vmfakes/fake_manager_factory.go b/deployment/vm/vmfakes/fake_manager_factory.go new file mode 100644 index 0000000000..c2bcfa2441 --- /dev/null +++ b/deployment/vm/vmfakes/fake_manager_factory.go @@ -0,0 +1,113 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package vmfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" +) + +type FakeManagerFactory struct { + NewManagerStub func(cloud.Cloud, agentclient.AgentClient) vm.Manager + newManagerMutex sync.RWMutex + newManagerArgsForCall []struct { + arg1 cloud.Cloud + arg2 agentclient.AgentClient + } + newManagerReturns struct { + result1 vm.Manager + } + newManagerReturnsOnCall map[int]struct { + result1 vm.Manager + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManagerFactory) NewManager(arg1 cloud.Cloud, arg2 agentclient.AgentClient) vm.Manager { + fake.newManagerMutex.Lock() + ret, specificReturn := fake.newManagerReturnsOnCall[len(fake.newManagerArgsForCall)] + fake.newManagerArgsForCall = append(fake.newManagerArgsForCall, struct { + arg1 cloud.Cloud + arg2 agentclient.AgentClient + }{arg1, arg2}) + stub := fake.NewManagerStub + fakeReturns := fake.newManagerReturns + fake.recordInvocation("NewManager", []interface{}{arg1, arg2}) + fake.newManagerMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManagerFactory) NewManagerCallCount() int { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + return len(fake.newManagerArgsForCall) +} + +func (fake *FakeManagerFactory) NewManagerCalls(stub func(cloud.Cloud, agentclient.AgentClient) vm.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = stub +} + +func (fake *FakeManagerFactory) NewManagerArgsForCall(i int) (cloud.Cloud, agentclient.AgentClient) { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + argsForCall := fake.newManagerArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeManagerFactory) NewManagerReturns(result1 vm.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + fake.newManagerReturns = struct { + result1 vm.Manager + }{result1} +} + +func (fake *FakeManagerFactory) NewManagerReturnsOnCall(i int, result1 vm.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + if fake.newManagerReturnsOnCall == nil { + fake.newManagerReturnsOnCall = make(map[int]struct { + result1 vm.Manager + }) + } + fake.newManagerReturnsOnCall[i] = struct { + result1 vm.Manager + }{result1} +} + +func (fake *FakeManagerFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManagerFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ vm.ManagerFactory = new(FakeManagerFactory) diff --git a/go.mod b/go.mod index 0874a227c3..56e3ae3252 100644 --- a/go.mod +++ b/go.mod @@ -17,7 +17,6 @@ require ( github.com/cppforlife/go-semi-semantic v0.0.0-20160921010311-576b6af77ae4 github.com/dustin/go-humanize v1.0.1 github.com/fatih/color v1.19.0 - github.com/golang/mock v1.6.0 github.com/gopacket/gopacket v1.7.1 github.com/hashicorp/go-multierror v1.1.1 github.com/jessevdk/go-flags v1.6.1 diff --git a/go.sum b/go.sum index 8bcc4a2465..06d9c06197 100644 --- a/go.sum +++ b/go.sum @@ -144,8 +144,6 @@ github.com/go-task/slim-sprig/v3 v3.0.0 h1:sUs3vkvUymDpBKi3qH1YSqBQk9+9D/8M2mN1v github.com/go-task/slim-sprig/v3 v3.0.0/go.mod h1:W848ghGpv3Qj3dhTPRyJypKRiqCdHZiAzKg9hl15HA8= github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw= github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA= -github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek= github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps= github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg= @@ -245,7 +243,6 @@ github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74 h1:gga7acRE695AP github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0= github.com/vito/go-interact v1.0.2 h1:viJuANio3WH9utUG4rKbJC9V3JR5JgYNS+i0efeA+GU= github.com/vito/go-interact v1.0.2/go.mod h1:s+y0jK9Z2etBYt5ZM6+DhpOsE5C7NNGC3jrJvW0BBpc= -github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/detectors/gcp v1.45.0 h1:9jR0ZPRok9ryaOQ2Wx8rg5F7Aon59mxrqbVI60/vlBk= @@ -273,50 +270,28 @@ go.step.sm/crypto v0.77.9/go.mod h1:/5BzDlwYA7C1q6h9OIv0+oR8lbQvK+rTGeBmLLl7hIo= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= go.yaml.in/yaml/v3 v3.0.5 h1:N6y/pJk8buWs9NY5ERU2HSMfm+IuD/OtfdAnq6kESPw= go.yaml.in/yaml/v3 v3.0.5/go.mod h1:HVTZu1O7/Vkt2N+BFy8Zza+lnLsABggaTM2ZpNIGuKg= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.55.0 h1:+KWHjbgOaAQ66dh/YlkZKHlz9ZUlq61AFirAR9ntP8M= golang.org/x/crypto v0.55.0/go.mod h1:uq0V9dE/fzQuJtbnL+2EhWOE63vo164FY8xqEnV9xis= -golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.40.0 h1:hUv+3cXcdRHz08UmSiOob7sadHig73uo5bkXxQ/tvUs= golang.org/x/mod v0.40.0/go.mod h1:0/weTWkPWGBikyTWAX3dkjVztMmBA5hM0DH6BElSupE= -golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/telemetry v0.0.0-20260814151720-d8c169486af1 h1:tw/dhR3C+0y5Y8sTyXtV5GzjFE9hWblSlUUjF6Xs+Ko= golang.org/x/telemetry v0.0.0-20260814151720-d8c169486af1/go.mod h1:LVehoXe41cL5SCVQilsV7Gg6BNG+Js6P9PhSbYTIUkQ= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.49.0 h1:3NI7VXzL9+1WZD52Dx2ttoPwD5DWrFGpl9mFZDlmisI= golang.org/x/tools v0.49.0/go.mod h1:SJNXV9DBKT0UbdttsQjbfJlAE/q+y36++zo3uL3N0Oo= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/api v0.293.0 h1:p9XIWOf63U4OgYx120ZwVU8+vl4XTPmWfgVPnmOAS9w= diff --git a/installation/installation.go b/installation/installation.go index b2a34113a3..dd0cb47598 100644 --- a/installation/installation.go +++ b/installation/installation.go @@ -4,6 +4,10 @@ import ( biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Installation + type Installation interface { Target() Target Jobs() []InstalledJob diff --git a/installation/installationfakes/fake_installation.go b/installation/installationfakes/fake_installation.go new file mode 100644 index 0000000000..7319f6c960 --- /dev/null +++ b/installation/installationfakes/fake_installation.go @@ -0,0 +1,163 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" +) + +type FakeInstallation struct { + JobsStub func() []installation.InstalledJob + jobsMutex sync.RWMutex + jobsArgsForCall []struct { + } + jobsReturns struct { + result1 []installation.InstalledJob + } + jobsReturnsOnCall map[int]struct { + result1 []installation.InstalledJob + } + TargetStub func() installation.Target + targetMutex sync.RWMutex + targetArgsForCall []struct { + } + targetReturns struct { + result1 installation.Target + } + targetReturnsOnCall map[int]struct { + result1 installation.Target + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeInstallation) Jobs() []installation.InstalledJob { + fake.jobsMutex.Lock() + ret, specificReturn := fake.jobsReturnsOnCall[len(fake.jobsArgsForCall)] + fake.jobsArgsForCall = append(fake.jobsArgsForCall, struct { + }{}) + stub := fake.JobsStub + fakeReturns := fake.jobsReturns + fake.recordInvocation("Jobs", []interface{}{}) + fake.jobsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstallation) JobsCallCount() int { + fake.jobsMutex.RLock() + defer fake.jobsMutex.RUnlock() + return len(fake.jobsArgsForCall) +} + +func (fake *FakeInstallation) JobsCalls(stub func() []installation.InstalledJob) { + fake.jobsMutex.Lock() + defer fake.jobsMutex.Unlock() + fake.JobsStub = stub +} + +func (fake *FakeInstallation) JobsReturns(result1 []installation.InstalledJob) { + fake.jobsMutex.Lock() + defer fake.jobsMutex.Unlock() + fake.JobsStub = nil + fake.jobsReturns = struct { + result1 []installation.InstalledJob + }{result1} +} + +func (fake *FakeInstallation) JobsReturnsOnCall(i int, result1 []installation.InstalledJob) { + fake.jobsMutex.Lock() + defer fake.jobsMutex.Unlock() + fake.JobsStub = nil + if fake.jobsReturnsOnCall == nil { + fake.jobsReturnsOnCall = make(map[int]struct { + result1 []installation.InstalledJob + }) + } + fake.jobsReturnsOnCall[i] = struct { + result1 []installation.InstalledJob + }{result1} +} + +func (fake *FakeInstallation) Target() installation.Target { + fake.targetMutex.Lock() + ret, specificReturn := fake.targetReturnsOnCall[len(fake.targetArgsForCall)] + fake.targetArgsForCall = append(fake.targetArgsForCall, struct { + }{}) + stub := fake.TargetStub + fakeReturns := fake.targetReturns + fake.recordInvocation("Target", []interface{}{}) + fake.targetMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstallation) TargetCallCount() int { + fake.targetMutex.RLock() + defer fake.targetMutex.RUnlock() + return len(fake.targetArgsForCall) +} + +func (fake *FakeInstallation) TargetCalls(stub func() installation.Target) { + fake.targetMutex.Lock() + defer fake.targetMutex.Unlock() + fake.TargetStub = stub +} + +func (fake *FakeInstallation) TargetReturns(result1 installation.Target) { + fake.targetMutex.Lock() + defer fake.targetMutex.Unlock() + fake.TargetStub = nil + fake.targetReturns = struct { + result1 installation.Target + }{result1} +} + +func (fake *FakeInstallation) TargetReturnsOnCall(i int, result1 installation.Target) { + fake.targetMutex.Lock() + defer fake.targetMutex.Unlock() + fake.TargetStub = nil + if fake.targetReturnsOnCall == nil { + fake.targetReturnsOnCall = make(map[int]struct { + result1 installation.Target + }) + } + fake.targetReturnsOnCall[i] = struct { + result1 installation.Target + }{result1} +} + +func (fake *FakeInstallation) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeInstallation) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.Installation = new(FakeInstallation) diff --git a/installation/installationfakes/fake_installer.go b/installation/installationfakes/fake_installer.go new file mode 100644 index 0000000000..69c2c66530 --- /dev/null +++ b/installation/installationfakes/fake_installer.go @@ -0,0 +1,190 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeInstaller struct { + CleanupStub func(installation.Installation) error + cleanupMutex sync.RWMutex + cleanupArgsForCall []struct { + arg1 installation.Installation + } + cleanupReturns struct { + result1 error + } + cleanupReturnsOnCall map[int]struct { + result1 error + } + InstallStub func(manifest.Manifest, ui.Stage) (installation.Installation, error) + installMutex sync.RWMutex + installArgsForCall []struct { + arg1 manifest.Manifest + arg2 ui.Stage + } + installReturns struct { + result1 installation.Installation + result2 error + } + installReturnsOnCall map[int]struct { + result1 installation.Installation + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeInstaller) Cleanup(arg1 installation.Installation) error { + fake.cleanupMutex.Lock() + ret, specificReturn := fake.cleanupReturnsOnCall[len(fake.cleanupArgsForCall)] + fake.cleanupArgsForCall = append(fake.cleanupArgsForCall, struct { + arg1 installation.Installation + }{arg1}) + stub := fake.CleanupStub + fakeReturns := fake.cleanupReturns + fake.recordInvocation("Cleanup", []interface{}{arg1}) + fake.cleanupMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstaller) CleanupCallCount() int { + fake.cleanupMutex.RLock() + defer fake.cleanupMutex.RUnlock() + return len(fake.cleanupArgsForCall) +} + +func (fake *FakeInstaller) CleanupCalls(stub func(installation.Installation) error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = stub +} + +func (fake *FakeInstaller) CleanupArgsForCall(i int) installation.Installation { + fake.cleanupMutex.RLock() + defer fake.cleanupMutex.RUnlock() + argsForCall := fake.cleanupArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeInstaller) CleanupReturns(result1 error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = nil + fake.cleanupReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeInstaller) CleanupReturnsOnCall(i int, result1 error) { + fake.cleanupMutex.Lock() + defer fake.cleanupMutex.Unlock() + fake.CleanupStub = nil + if fake.cleanupReturnsOnCall == nil { + fake.cleanupReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.cleanupReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeInstaller) Install(arg1 manifest.Manifest, arg2 ui.Stage) (installation.Installation, error) { + fake.installMutex.Lock() + ret, specificReturn := fake.installReturnsOnCall[len(fake.installArgsForCall)] + fake.installArgsForCall = append(fake.installArgsForCall, struct { + arg1 manifest.Manifest + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.InstallStub + fakeReturns := fake.installReturns + fake.recordInvocation("Install", []interface{}{arg1, arg2}) + fake.installMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeInstaller) InstallCallCount() int { + fake.installMutex.RLock() + defer fake.installMutex.RUnlock() + return len(fake.installArgsForCall) +} + +func (fake *FakeInstaller) InstallCalls(stub func(manifest.Manifest, ui.Stage) (installation.Installation, error)) { + fake.installMutex.Lock() + defer fake.installMutex.Unlock() + fake.InstallStub = stub +} + +func (fake *FakeInstaller) InstallArgsForCall(i int) (manifest.Manifest, ui.Stage) { + fake.installMutex.RLock() + defer fake.installMutex.RUnlock() + argsForCall := fake.installArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeInstaller) InstallReturns(result1 installation.Installation, result2 error) { + fake.installMutex.Lock() + defer fake.installMutex.Unlock() + fake.InstallStub = nil + fake.installReturns = struct { + result1 installation.Installation + result2 error + }{result1, result2} +} + +func (fake *FakeInstaller) InstallReturnsOnCall(i int, result1 installation.Installation, result2 error) { + fake.installMutex.Lock() + defer fake.installMutex.Unlock() + fake.InstallStub = nil + if fake.installReturnsOnCall == nil { + fake.installReturnsOnCall = make(map[int]struct { + result1 installation.Installation + result2 error + }) + } + fake.installReturnsOnCall[i] = struct { + result1 installation.Installation + result2 error + }{result1, result2} +} + +func (fake *FakeInstaller) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeInstaller) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.Installer = new(FakeInstaller) diff --git a/installation/installationfakes/fake_installer_factory.go b/installation/installationfakes/fake_installer_factory.go new file mode 100644 index 0000000000..96b9deb8aa --- /dev/null +++ b/installation/installationfakes/fake_installer_factory.go @@ -0,0 +1,109 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" +) + +type FakeInstallerFactory struct { + NewInstallerStub func(installation.Target) installation.Installer + newInstallerMutex sync.RWMutex + newInstallerArgsForCall []struct { + arg1 installation.Target + } + newInstallerReturns struct { + result1 installation.Installer + } + newInstallerReturnsOnCall map[int]struct { + result1 installation.Installer + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeInstallerFactory) NewInstaller(arg1 installation.Target) installation.Installer { + fake.newInstallerMutex.Lock() + ret, specificReturn := fake.newInstallerReturnsOnCall[len(fake.newInstallerArgsForCall)] + fake.newInstallerArgsForCall = append(fake.newInstallerArgsForCall, struct { + arg1 installation.Target + }{arg1}) + stub := fake.NewInstallerStub + fakeReturns := fake.newInstallerReturns + fake.recordInvocation("NewInstaller", []interface{}{arg1}) + fake.newInstallerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeInstallerFactory) NewInstallerCallCount() int { + fake.newInstallerMutex.RLock() + defer fake.newInstallerMutex.RUnlock() + return len(fake.newInstallerArgsForCall) +} + +func (fake *FakeInstallerFactory) NewInstallerCalls(stub func(installation.Target) installation.Installer) { + fake.newInstallerMutex.Lock() + defer fake.newInstallerMutex.Unlock() + fake.NewInstallerStub = stub +} + +func (fake *FakeInstallerFactory) NewInstallerArgsForCall(i int) installation.Target { + fake.newInstallerMutex.RLock() + defer fake.newInstallerMutex.RUnlock() + argsForCall := fake.newInstallerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeInstallerFactory) NewInstallerReturns(result1 installation.Installer) { + fake.newInstallerMutex.Lock() + defer fake.newInstallerMutex.Unlock() + fake.NewInstallerStub = nil + fake.newInstallerReturns = struct { + result1 installation.Installer + }{result1} +} + +func (fake *FakeInstallerFactory) NewInstallerReturnsOnCall(i int, result1 installation.Installer) { + fake.newInstallerMutex.Lock() + defer fake.newInstallerMutex.Unlock() + fake.NewInstallerStub = nil + if fake.newInstallerReturnsOnCall == nil { + fake.newInstallerReturnsOnCall = make(map[int]struct { + result1 installation.Installer + }) + } + fake.newInstallerReturnsOnCall[i] = struct { + result1 installation.Installer + }{result1} +} + +func (fake *FakeInstallerFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeInstallerFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.InstallerFactory = new(FakeInstallerFactory) diff --git a/installation/installationfakes/fake_job_renderer.go b/installation/installationfakes/fake_job_renderer.go new file mode 100644 index 0000000000..af4647700e --- /dev/null +++ b/installation/installationfakes/fake_job_renderer.go @@ -0,0 +1,126 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" + "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeJobRenderer struct { + RenderAndUploadFromStub func(manifest.Manifest, []job.Job, ui.Stage) ([]installation.RenderedJobRef, error) + renderAndUploadFromMutex sync.RWMutex + renderAndUploadFromArgsForCall []struct { + arg1 manifest.Manifest + arg2 []job.Job + arg3 ui.Stage + } + renderAndUploadFromReturns struct { + result1 []installation.RenderedJobRef + result2 error + } + renderAndUploadFromReturnsOnCall map[int]struct { + result1 []installation.RenderedJobRef + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeJobRenderer) RenderAndUploadFrom(arg1 manifest.Manifest, arg2 []job.Job, arg3 ui.Stage) ([]installation.RenderedJobRef, error) { + var arg2Copy []job.Job + if arg2 != nil { + arg2Copy = make([]job.Job, len(arg2)) + copy(arg2Copy, arg2) + } + fake.renderAndUploadFromMutex.Lock() + ret, specificReturn := fake.renderAndUploadFromReturnsOnCall[len(fake.renderAndUploadFromArgsForCall)] + fake.renderAndUploadFromArgsForCall = append(fake.renderAndUploadFromArgsForCall, struct { + arg1 manifest.Manifest + arg2 []job.Job + arg3 ui.Stage + }{arg1, arg2Copy, arg3}) + stub := fake.RenderAndUploadFromStub + fakeReturns := fake.renderAndUploadFromReturns + fake.recordInvocation("RenderAndUploadFrom", []interface{}{arg1, arg2Copy, arg3}) + fake.renderAndUploadFromMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeJobRenderer) RenderAndUploadFromCallCount() int { + fake.renderAndUploadFromMutex.RLock() + defer fake.renderAndUploadFromMutex.RUnlock() + return len(fake.renderAndUploadFromArgsForCall) +} + +func (fake *FakeJobRenderer) RenderAndUploadFromCalls(stub func(manifest.Manifest, []job.Job, ui.Stage) ([]installation.RenderedJobRef, error)) { + fake.renderAndUploadFromMutex.Lock() + defer fake.renderAndUploadFromMutex.Unlock() + fake.RenderAndUploadFromStub = stub +} + +func (fake *FakeJobRenderer) RenderAndUploadFromArgsForCall(i int) (manifest.Manifest, []job.Job, ui.Stage) { + fake.renderAndUploadFromMutex.RLock() + defer fake.renderAndUploadFromMutex.RUnlock() + argsForCall := fake.renderAndUploadFromArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeJobRenderer) RenderAndUploadFromReturns(result1 []installation.RenderedJobRef, result2 error) { + fake.renderAndUploadFromMutex.Lock() + defer fake.renderAndUploadFromMutex.Unlock() + fake.RenderAndUploadFromStub = nil + fake.renderAndUploadFromReturns = struct { + result1 []installation.RenderedJobRef + result2 error + }{result1, result2} +} + +func (fake *FakeJobRenderer) RenderAndUploadFromReturnsOnCall(i int, result1 []installation.RenderedJobRef, result2 error) { + fake.renderAndUploadFromMutex.Lock() + defer fake.renderAndUploadFromMutex.Unlock() + fake.RenderAndUploadFromStub = nil + if fake.renderAndUploadFromReturnsOnCall == nil { + fake.renderAndUploadFromReturnsOnCall = make(map[int]struct { + result1 []installation.RenderedJobRef + result2 error + }) + } + fake.renderAndUploadFromReturnsOnCall[i] = struct { + result1 []installation.RenderedJobRef + result2 error + }{result1, result2} +} + +func (fake *FakeJobRenderer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeJobRenderer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.JobRenderer = new(FakeJobRenderer) diff --git a/installation/installationfakes/fake_job_resolver.go b/installation/installationfakes/fake_job_resolver.go new file mode 100644 index 0000000000..cbe84e7fd6 --- /dev/null +++ b/installation/installationfakes/fake_job_resolver.go @@ -0,0 +1,116 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" + "github.com/cloudfoundry/bosh-cli/v7/release/job" +) + +type FakeJobResolver struct { + FromStub func(manifest.Manifest) ([]job.Job, error) + fromMutex sync.RWMutex + fromArgsForCall []struct { + arg1 manifest.Manifest + } + fromReturns struct { + result1 []job.Job + result2 error + } + fromReturnsOnCall map[int]struct { + result1 []job.Job + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeJobResolver) From(arg1 manifest.Manifest) ([]job.Job, error) { + fake.fromMutex.Lock() + ret, specificReturn := fake.fromReturnsOnCall[len(fake.fromArgsForCall)] + fake.fromArgsForCall = append(fake.fromArgsForCall, struct { + arg1 manifest.Manifest + }{arg1}) + stub := fake.FromStub + fakeReturns := fake.fromReturns + fake.recordInvocation("From", []interface{}{arg1}) + fake.fromMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeJobResolver) FromCallCount() int { + fake.fromMutex.RLock() + defer fake.fromMutex.RUnlock() + return len(fake.fromArgsForCall) +} + +func (fake *FakeJobResolver) FromCalls(stub func(manifest.Manifest) ([]job.Job, error)) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = stub +} + +func (fake *FakeJobResolver) FromArgsForCall(i int) manifest.Manifest { + fake.fromMutex.RLock() + defer fake.fromMutex.RUnlock() + argsForCall := fake.fromArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeJobResolver) FromReturns(result1 []job.Job, result2 error) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = nil + fake.fromReturns = struct { + result1 []job.Job + result2 error + }{result1, result2} +} + +func (fake *FakeJobResolver) FromReturnsOnCall(i int, result1 []job.Job, result2 error) { + fake.fromMutex.Lock() + defer fake.fromMutex.Unlock() + fake.FromStub = nil + if fake.fromReturnsOnCall == nil { + fake.fromReturnsOnCall = make(map[int]struct { + result1 []job.Job + result2 error + }) + } + fake.fromReturnsOnCall[i] = struct { + result1 []job.Job + result2 error + }{result1, result2} +} + +func (fake *FakeJobResolver) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeJobResolver) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.JobResolver = new(FakeJobResolver) diff --git a/installation/installationfakes/fake_package_compiler.go b/installation/installationfakes/fake_package_compiler.go new file mode 100644 index 0000000000..7fc7959af2 --- /dev/null +++ b/installation/installationfakes/fake_package_compiler.go @@ -0,0 +1,123 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakePackageCompiler struct { + ForStub func([]job.Job, ui.Stage) ([]installation.CompiledPackageRef, error) + forMutex sync.RWMutex + forArgsForCall []struct { + arg1 []job.Job + arg2 ui.Stage + } + forReturns struct { + result1 []installation.CompiledPackageRef + result2 error + } + forReturnsOnCall map[int]struct { + result1 []installation.CompiledPackageRef + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakePackageCompiler) For(arg1 []job.Job, arg2 ui.Stage) ([]installation.CompiledPackageRef, error) { + var arg1Copy []job.Job + if arg1 != nil { + arg1Copy = make([]job.Job, len(arg1)) + copy(arg1Copy, arg1) + } + fake.forMutex.Lock() + ret, specificReturn := fake.forReturnsOnCall[len(fake.forArgsForCall)] + fake.forArgsForCall = append(fake.forArgsForCall, struct { + arg1 []job.Job + arg2 ui.Stage + }{arg1Copy, arg2}) + stub := fake.ForStub + fakeReturns := fake.forReturns + fake.recordInvocation("For", []interface{}{arg1Copy, arg2}) + fake.forMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakePackageCompiler) ForCallCount() int { + fake.forMutex.RLock() + defer fake.forMutex.RUnlock() + return len(fake.forArgsForCall) +} + +func (fake *FakePackageCompiler) ForCalls(stub func([]job.Job, ui.Stage) ([]installation.CompiledPackageRef, error)) { + fake.forMutex.Lock() + defer fake.forMutex.Unlock() + fake.ForStub = stub +} + +func (fake *FakePackageCompiler) ForArgsForCall(i int) ([]job.Job, ui.Stage) { + fake.forMutex.RLock() + defer fake.forMutex.RUnlock() + argsForCall := fake.forArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakePackageCompiler) ForReturns(result1 []installation.CompiledPackageRef, result2 error) { + fake.forMutex.Lock() + defer fake.forMutex.Unlock() + fake.ForStub = nil + fake.forReturns = struct { + result1 []installation.CompiledPackageRef + result2 error + }{result1, result2} +} + +func (fake *FakePackageCompiler) ForReturnsOnCall(i int, result1 []installation.CompiledPackageRef, result2 error) { + fake.forMutex.Lock() + defer fake.forMutex.Unlock() + fake.ForStub = nil + if fake.forReturnsOnCall == nil { + fake.forReturnsOnCall = make(map[int]struct { + result1 []installation.CompiledPackageRef + result2 error + }) + } + fake.forReturnsOnCall[i] = struct { + result1 []installation.CompiledPackageRef + result2 error + }{result1, result2} +} + +func (fake *FakePackageCompiler) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakePackageCompiler) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.PackageCompiler = new(FakePackageCompiler) diff --git a/installation/installationfakes/fake_uninstaller.go b/installation/installationfakes/fake_uninstaller.go new file mode 100644 index 0000000000..01b62a1271 --- /dev/null +++ b/installation/installationfakes/fake_uninstaller.go @@ -0,0 +1,109 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package installationfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation" +) + +type FakeUninstaller struct { + UninstallStub func(installation.Target) error + uninstallMutex sync.RWMutex + uninstallArgsForCall []struct { + arg1 installation.Target + } + uninstallReturns struct { + result1 error + } + uninstallReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeUninstaller) Uninstall(arg1 installation.Target) error { + fake.uninstallMutex.Lock() + ret, specificReturn := fake.uninstallReturnsOnCall[len(fake.uninstallArgsForCall)] + fake.uninstallArgsForCall = append(fake.uninstallArgsForCall, struct { + arg1 installation.Target + }{arg1}) + stub := fake.UninstallStub + fakeReturns := fake.uninstallReturns + fake.recordInvocation("Uninstall", []interface{}{arg1}) + fake.uninstallMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeUninstaller) UninstallCallCount() int { + fake.uninstallMutex.RLock() + defer fake.uninstallMutex.RUnlock() + return len(fake.uninstallArgsForCall) +} + +func (fake *FakeUninstaller) UninstallCalls(stub func(installation.Target) error) { + fake.uninstallMutex.Lock() + defer fake.uninstallMutex.Unlock() + fake.UninstallStub = stub +} + +func (fake *FakeUninstaller) UninstallArgsForCall(i int) installation.Target { + fake.uninstallMutex.RLock() + defer fake.uninstallMutex.RUnlock() + argsForCall := fake.uninstallArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeUninstaller) UninstallReturns(result1 error) { + fake.uninstallMutex.Lock() + defer fake.uninstallMutex.Unlock() + fake.UninstallStub = nil + fake.uninstallReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeUninstaller) UninstallReturnsOnCall(i int, result1 error) { + fake.uninstallMutex.Lock() + defer fake.uninstallMutex.Unlock() + fake.UninstallStub = nil + if fake.uninstallReturnsOnCall == nil { + fake.uninstallReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.uninstallReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeUninstaller) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeUninstaller) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ installation.Uninstaller = new(FakeUninstaller) diff --git a/installation/installer.go b/installation/installer.go index d054ab7cc2..84d06d209c 100644 --- a/installation/installer.go +++ b/installation/installer.go @@ -22,6 +22,8 @@ func NewInstalledJob(ref RenderedJobRef, path string) InstalledJob { return InstalledJob{RenderedJobRef: ref, Path: path} } +//counterfeiter:generate . Installer + type Installer interface { Install(biinstallmanifest.Manifest, biui.Stage) (Installation, error) Cleanup(Installation) error diff --git a/installation/installer_factory.go b/installation/installer_factory.go index 79e1525373..b2b797e83d 100644 --- a/installation/installer_factory.go +++ b/installation/installer_factory.go @@ -19,6 +19,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . InstallerFactory + type InstallerFactory interface { NewInstaller(Target) Installer } diff --git a/installation/installer_test.go b/installation/installer_test.go index 9df024b7e6..fe3477a4a1 100644 --- a/installation/installer_test.go +++ b/installation/installer_test.go @@ -5,34 +5,23 @@ import ( boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-cli/v7/installation" "github.com/cloudfoundry/bosh-cli/v7/installation/blobextract/blobextractfakes" + "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - mock_install "github.com/cloudfoundry/bosh-cli/v7/installation/mocks" bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("Installer", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( installationManifest biinstallmanifest.Manifest - mockJobRenderer *mock_install.MockJobRenderer - mockJobResolver *mock_install.MockJobResolver - mockPackageCompiler *mock_install.MockPackageCompiler + mockJobRenderer *installationfakes.FakeJobRenderer + mockJobResolver *installationfakes.FakeJobResolver + mockPackageCompiler *installationfakes.FakePackageCompiler fakeExtractor *blobextractfakes.FakeExtractor logger boshlog.Logger @@ -45,9 +34,9 @@ var _ = Describe("Installer", func() { BeforeEach(func() { logger = boshlog.NewWriterLogger(boshlog.LevelDebug, GinkgoWriter) - mockJobRenderer = mock_install.NewMockJobRenderer(mockCtrl) - mockJobResolver = mock_install.NewMockJobResolver(mockCtrl) - mockPackageCompiler = mock_install.NewMockPackageCompiler(mockCtrl) + mockJobRenderer = &installationfakes.FakeJobRenderer{} + mockJobResolver = &installationfakes.FakeJobResolver{} + mockPackageCompiler = &installationfakes.FakePackageCompiler{} fakeExtractor = &blobextractfakes.FakeExtractor{} target = NewTarget("fake-installation-path", "") @@ -102,18 +91,32 @@ var _ = Describe("Installer", func() { for _, installedJob := range installedJobs { renderedJobRefs = append(renderedJobRefs, installedJob.RenderedJobRef) } - mockJobResolver.EXPECT().From(installationManifest).Return(releaseJobs, nil).AnyTimes() - mockPackageCompiler.EXPECT().For(releaseJobs, fakeStage).Return(compiledPackages, nil).AnyTimes() + mockJobResolver.FromReturns(releaseJobs, nil) + mockPackageCompiler.ForReturns(compiledPackages, nil) }) Context("success", func() { JustBeforeEach(func() { - mockJobRenderer.EXPECT().RenderAndUploadFrom(installationManifest, releaseJobs, fakeStage).Return(renderedJobRefs, nil).AnyTimes() + mockJobRenderer.RenderAndUploadFromReturns(renderedJobRefs, nil) }) It("compiles and installs the jobs' packages", func() { _, err := installer.Install(installationManifest, fakeStage) Expect(err).NotTo(HaveOccurred()) + + Expect(mockJobResolver.FromCallCount()).To(Equal(1)) + Expect(mockJobResolver.FromArgsForCall(0)).To(Equal(installationManifest)) + + Expect(mockPackageCompiler.ForCallCount()).To(Equal(1)) + actualJobs, actualStage := mockPackageCompiler.ForArgsForCall(0) + Expect(actualJobs).To(Equal(releaseJobs)) + Expect(actualStage).To(Equal(fakeStage)) + + Expect(mockJobRenderer.RenderAndUploadFromCallCount()).To(Equal(1)) + actualManifest, actualRenderJobs, actualRenderStage := mockJobRenderer.RenderAndUploadFromArgsForCall(0) + Expect(actualManifest).To(Equal(installationManifest)) + Expect(actualRenderJobs).To(Equal(releaseJobs)) + Expect(actualRenderStage).To(Equal(fakeStage)) }) It("installs the rendered jobs", func() { @@ -131,7 +134,7 @@ var _ = Describe("Installer", func() { Context("when rendering jobs errors", func() { JustBeforeEach(func() { err := errors.New("OMG - no ruby found!!") - mockJobRenderer.EXPECT().RenderAndUploadFrom(installationManifest, releaseJobs, fakeStage).Return([]RenderedJobRef{}, err).AnyTimes() + mockJobRenderer.RenderAndUploadFromReturns([]RenderedJobRef{}, err) }) It("should return an error", func() { _, err := installer.Install(installationManifest, fakeStage) @@ -155,8 +158,8 @@ var _ = Describe("Installer", func() { SHA1: "sha", } releaseJobs := []bireljob.Job{} - mockJobResolver.EXPECT().From(installationManifest).Return(releaseJobs, nil) - mockPackageCompiler.EXPECT().For(releaseJobs, fakeStage).Return([]CompiledPackageRef{maliciousRef}, nil) + mockJobResolver.FromReturns(releaseJobs, nil) + mockPackageCompiler.ForReturns([]CompiledPackageRef{maliciousRef}, nil) _, err := installer.Install(installationManifest, fakeStage) Expect(err).To(HaveOccurred()) @@ -167,9 +170,9 @@ var _ = Describe("Installer", func() { releaseJobs := []bireljob.Job{} compiledPackages := []CompiledPackageRef{} jobRef := NewRenderedJobRef("../../path", "fp", "blob-id", "sha") - mockJobResolver.EXPECT().From(installationManifest).Return(releaseJobs, nil) - mockPackageCompiler.EXPECT().For(releaseJobs, fakeStage).Return(compiledPackages, nil) - mockJobRenderer.EXPECT().RenderAndUploadFrom(installationManifest, releaseJobs, fakeStage).Return([]RenderedJobRef{jobRef}, nil) + mockJobResolver.FromReturns(releaseJobs, nil) + mockPackageCompiler.ForReturns(compiledPackages, nil) + mockJobRenderer.RenderAndUploadFromReturns([]RenderedJobRef{jobRef}, nil) _, err := installer.Install(installationManifest, fakeStage) Expect(err).To(HaveOccurred()) diff --git a/installation/job_renderer.go b/installation/job_renderer.go index 659db26418..0ad42b1642 100644 --- a/installation/job_renderer.go +++ b/installation/job_renderer.go @@ -12,6 +12,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . JobRenderer + type JobRenderer interface { RenderAndUploadFrom(biinstallmanifest.Manifest, []bireljob.Job, biui.Stage) ([]RenderedJobRef, error) } diff --git a/installation/job_renderer_test.go b/installation/job_renderer_test.go index ba169226e1..fdb4790823 100644 --- a/installation/job_renderer_test.go +++ b/installation/job_renderer_test.go @@ -7,7 +7,6 @@ import ( boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" fakeboshsys "github.com/cloudfoundry/bosh-utils/system/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -17,23 +16,13 @@ import ( birelpkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" bitemplate "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" - mocktemplate "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/mocks" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/templatescompilerfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("JobRenderer", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockJobListRenderer *mocktemplate.MockJobListRenderer + mockJobListRenderer *templatescompilerfakes.FakeJobListRenderer fakeCompressor *fakeboshcmd.FakeCompressor fakeBlobstore *fakeboshblob.FakeDigestBlobstore @@ -53,7 +42,7 @@ var _ = Describe("JobRenderer", func() { ) BeforeEach(func() { - mockJobListRenderer = mocktemplate.NewMockJobListRenderer(mockCtrl) + mockJobListRenderer = &templatescompilerfakes.FakeJobListRenderer{} fakeCompressor = fakeboshcmd.NewFakeCompressor() fakeBlobstore = &fakeboshblob.FakeDigestBlobstore{} @@ -94,20 +83,10 @@ var _ = Describe("JobRenderer", func() { fakeBlobstore, ) - releaseJobs := []bireljob.Job{releaseJob} - - releaseJobProperties := map[string]*biproperty.Map{} - jobProperties := biproperty.Map{ - "fake-installation-property": "fake-installation-property-value", - } - globalProperties := biproperty.Map{} - deploymentName := "fake-installation-name" - address := "" - renderedJobList = bitemplate.NewRenderedJobList() renderedJobList.Add(bitemplate.NewRenderedJob(releaseJob, "/fake-rendered-job-cpi", fs, logger)) - mockJobListRenderer.EXPECT().Render(releaseJobs, releaseJobProperties, jobProperties, globalProperties, deploymentName, address).Return(renderedJobList, nil).AnyTimes() + mockJobListRenderer.RenderReturns(renderedJobList, nil) fakeCompressor.CompressFilesInDirTarballPath = "/fake-rendered-job-tarball-cpi.tgz" multiDigest := boshcrypto.MustParseMultipleDigest("fakerenderedjobtarballsha1cpi") @@ -123,6 +102,15 @@ var _ = Describe("JobRenderer", func() { // compile stages not produced by mockDependencyCompiler {Name: "Rendering job templates"}, })) + + Expect(mockJobListRenderer.RenderCallCount()).To(Equal(1)) + actualReleaseJobs, actualReleaseJobProperties, actualJobProperties, actualGlobalProperties, actualDeploymentName, actualAddress := mockJobListRenderer.RenderArgsForCall(0) + Expect(actualReleaseJobs).To(Equal(releaseJobs)) + Expect(actualReleaseJobProperties).To(Equal(map[string]*biproperty.Map{})) + Expect(actualJobProperties).To(Equal(manifest.Properties)) + Expect(actualGlobalProperties).To(Equal(biproperty.Map{})) + Expect(actualDeploymentName).To(Equal(manifest.Name)) + Expect(actualAddress).To(Equal("")) }) It("compresses and uploads the rendered cpi job, deleting the local tarball afterward", func() { diff --git a/installation/job_resolver.go b/installation/job_resolver.go index ee08f539ff..dbd89273da 100644 --- a/installation/job_resolver.go +++ b/installation/job_resolver.go @@ -8,6 +8,8 @@ import ( bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" ) +//counterfeiter:generate . JobResolver + type JobResolver interface { From(biinstallmanifest.Manifest) ([]bireljob.Job, error) } diff --git a/installation/job_resolver_test.go b/installation/job_resolver_test.go index afd8612b32..eba43cb443 100644 --- a/installation/job_resolver_test.go +++ b/installation/job_resolver_test.go @@ -3,11 +3,10 @@ package installation_test import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - mock_deployment_release "github.com/cloudfoundry/bosh-cli/v7/deployment/release/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/release/releasefakes" "github.com/cloudfoundry/bosh-cli/v7/installation" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" @@ -15,26 +14,15 @@ import ( ) var _ = Describe("JobResolver", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockReleaseJobResolver *mock_deployment_release.MockJobResolver + mockReleaseJobResolver *releasefakes.FakeJobResolver resolver installation.JobResolver releaseJob bireljob.Job manifest biinstallmanifest.Manifest - expectJobResolve *gomock.Call ) BeforeEach(func() { - mockReleaseJobResolver = mock_deployment_release.NewMockJobResolver(mockCtrl) + mockReleaseJobResolver = &releasefakes.FakeJobResolver{} manifest = biinstallmanifest.Manifest{ Name: "fake-installation-name", @@ -52,7 +40,7 @@ var _ = Describe("JobResolver", func() { JustBeforeEach(func() { resolver = installation.NewJobResolver(mockReleaseJobResolver) - expectJobResolve = mockReleaseJobResolver.EXPECT().Resolve("fake-cpi-job-name", "fake-cpi-release-name").Return(releaseJob, nil).AnyTimes() + mockReleaseJobResolver.ResolveReturns(releaseJob, nil) }) Describe("From", func() { @@ -60,10 +48,14 @@ var _ = Describe("JobResolver", func() { jobs, err := resolver.From(manifest) Expect(err).ToNot(HaveOccurred()) Expect(jobs).To(Equal([]bireljob.Job{releaseJob})) + + jobName, releaseName := mockReleaseJobResolver.ResolveArgsForCall(0) + Expect(jobName).To(Equal("fake-cpi-job-name")) + Expect(releaseName).To(Equal("fake-cpi-release-name")) }) It("when the release does not contain a 'cpi' job returns an error", func() { - expectJobResolve.Return(bireljob.Job{}, bosherr.Error("fake-job-resolve-error")).Times(1) + mockReleaseJobResolver.ResolveReturns(bireljob.Job{}, bosherr.Error("fake-job-resolve-error")) _, err := resolver.From(manifest) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-job-resolve-error")) diff --git a/installation/mocks/mocks.go b/installation/mocks/mocks.go deleted file mode 100644 index 35c73bd2d3..0000000000 --- a/installation/mocks/mocks.go +++ /dev/null @@ -1,306 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/installation (interfaces: Installation,Installer,InstallerFactory,Uninstaller,JobResolver,PackageCompiler,JobRenderer) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - installation "github.com/cloudfoundry/bosh-cli/v7/installation" - manifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - job "github.com/cloudfoundry/bosh-cli/v7/release/job" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockInstallation is a mock of Installation interface. -type MockInstallation struct { - ctrl *gomock.Controller - recorder *MockInstallationMockRecorder -} - -// MockInstallationMockRecorder is the mock recorder for MockInstallation. -type MockInstallationMockRecorder struct { - mock *MockInstallation -} - -// NewMockInstallation creates a new mock instance. -func NewMockInstallation(ctrl *gomock.Controller) *MockInstallation { - mock := &MockInstallation{ctrl: ctrl} - mock.recorder = &MockInstallationMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockInstallation) EXPECT() *MockInstallationMockRecorder { - return m.recorder -} - -// Jobs mocks base method. -func (m *MockInstallation) Jobs() []installation.InstalledJob { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Jobs") - ret0, _ := ret[0].([]installation.InstalledJob) - return ret0 -} - -// Jobs indicates an expected call of Jobs. -func (mr *MockInstallationMockRecorder) Jobs() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Jobs", reflect.TypeOf((*MockInstallation)(nil).Jobs)) -} - -// Target mocks base method. -func (m *MockInstallation) Target() installation.Target { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Target") - ret0, _ := ret[0].(installation.Target) - return ret0 -} - -// Target indicates an expected call of Target. -func (mr *MockInstallationMockRecorder) Target() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Target", reflect.TypeOf((*MockInstallation)(nil).Target)) -} - -// MockInstaller is a mock of Installer interface. -type MockInstaller struct { - ctrl *gomock.Controller - recorder *MockInstallerMockRecorder -} - -// MockInstallerMockRecorder is the mock recorder for MockInstaller. -type MockInstallerMockRecorder struct { - mock *MockInstaller -} - -// NewMockInstaller creates a new mock instance. -func NewMockInstaller(ctrl *gomock.Controller) *MockInstaller { - mock := &MockInstaller{ctrl: ctrl} - mock.recorder = &MockInstallerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockInstaller) EXPECT() *MockInstallerMockRecorder { - return m.recorder -} - -// Cleanup mocks base method. -func (m *MockInstaller) Cleanup(arg0 installation.Installation) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Cleanup", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// Cleanup indicates an expected call of Cleanup. -func (mr *MockInstallerMockRecorder) Cleanup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cleanup", reflect.TypeOf((*MockInstaller)(nil).Cleanup), arg0) -} - -// Install mocks base method. -func (m *MockInstaller) Install(arg0 manifest.Manifest, arg1 ui.Stage) (installation.Installation, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Install", arg0, arg1) - ret0, _ := ret[0].(installation.Installation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Install indicates an expected call of Install. -func (mr *MockInstallerMockRecorder) Install(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Install", reflect.TypeOf((*MockInstaller)(nil).Install), arg0, arg1) -} - -// MockInstallerFactory is a mock of InstallerFactory interface. -type MockInstallerFactory struct { - ctrl *gomock.Controller - recorder *MockInstallerFactoryMockRecorder -} - -// MockInstallerFactoryMockRecorder is the mock recorder for MockInstallerFactory. -type MockInstallerFactoryMockRecorder struct { - mock *MockInstallerFactory -} - -// NewMockInstallerFactory creates a new mock instance. -func NewMockInstallerFactory(ctrl *gomock.Controller) *MockInstallerFactory { - mock := &MockInstallerFactory{ctrl: ctrl} - mock.recorder = &MockInstallerFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockInstallerFactory) EXPECT() *MockInstallerFactoryMockRecorder { - return m.recorder -} - -// NewInstaller mocks base method. -func (m *MockInstallerFactory) NewInstaller(arg0 installation.Target) installation.Installer { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewInstaller", arg0) - ret0, _ := ret[0].(installation.Installer) - return ret0 -} - -// NewInstaller indicates an expected call of NewInstaller. -func (mr *MockInstallerFactoryMockRecorder) NewInstaller(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewInstaller", reflect.TypeOf((*MockInstallerFactory)(nil).NewInstaller), arg0) -} - -// MockUninstaller is a mock of Uninstaller interface. -type MockUninstaller struct { - ctrl *gomock.Controller - recorder *MockUninstallerMockRecorder -} - -// MockUninstallerMockRecorder is the mock recorder for MockUninstaller. -type MockUninstallerMockRecorder struct { - mock *MockUninstaller -} - -// NewMockUninstaller creates a new mock instance. -func NewMockUninstaller(ctrl *gomock.Controller) *MockUninstaller { - mock := &MockUninstaller{ctrl: ctrl} - mock.recorder = &MockUninstallerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockUninstaller) EXPECT() *MockUninstallerMockRecorder { - return m.recorder -} - -// Uninstall mocks base method. -func (m *MockUninstaller) Uninstall(arg0 installation.Target) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Uninstall", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// Uninstall indicates an expected call of Uninstall. -func (mr *MockUninstallerMockRecorder) Uninstall(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Uninstall", reflect.TypeOf((*MockUninstaller)(nil).Uninstall), arg0) -} - -// MockJobResolver is a mock of JobResolver interface. -type MockJobResolver struct { - ctrl *gomock.Controller - recorder *MockJobResolverMockRecorder -} - -// MockJobResolverMockRecorder is the mock recorder for MockJobResolver. -type MockJobResolverMockRecorder struct { - mock *MockJobResolver -} - -// NewMockJobResolver creates a new mock instance. -func NewMockJobResolver(ctrl *gomock.Controller) *MockJobResolver { - mock := &MockJobResolver{ctrl: ctrl} - mock.recorder = &MockJobResolverMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockJobResolver) EXPECT() *MockJobResolverMockRecorder { - return m.recorder -} - -// From mocks base method. -func (m *MockJobResolver) From(arg0 manifest.Manifest) ([]job.Job, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "From", arg0) - ret0, _ := ret[0].([]job.Job) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// From indicates an expected call of From. -func (mr *MockJobResolverMockRecorder) From(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "From", reflect.TypeOf((*MockJobResolver)(nil).From), arg0) -} - -// MockPackageCompiler is a mock of PackageCompiler interface. -type MockPackageCompiler struct { - ctrl *gomock.Controller - recorder *MockPackageCompilerMockRecorder -} - -// MockPackageCompilerMockRecorder is the mock recorder for MockPackageCompiler. -type MockPackageCompilerMockRecorder struct { - mock *MockPackageCompiler -} - -// NewMockPackageCompiler creates a new mock instance. -func NewMockPackageCompiler(ctrl *gomock.Controller) *MockPackageCompiler { - mock := &MockPackageCompiler{ctrl: ctrl} - mock.recorder = &MockPackageCompilerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockPackageCompiler) EXPECT() *MockPackageCompilerMockRecorder { - return m.recorder -} - -// For mocks base method. -func (m *MockPackageCompiler) For(arg0 []job.Job, arg1 ui.Stage) ([]installation.CompiledPackageRef, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "For", arg0, arg1) - ret0, _ := ret[0].([]installation.CompiledPackageRef) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// For indicates an expected call of For. -func (mr *MockPackageCompilerMockRecorder) For(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "For", reflect.TypeOf((*MockPackageCompiler)(nil).For), arg0, arg1) -} - -// MockJobRenderer is a mock of JobRenderer interface. -type MockJobRenderer struct { - ctrl *gomock.Controller - recorder *MockJobRendererMockRecorder -} - -// MockJobRendererMockRecorder is the mock recorder for MockJobRenderer. -type MockJobRendererMockRecorder struct { - mock *MockJobRenderer -} - -// NewMockJobRenderer creates a new mock instance. -func NewMockJobRenderer(ctrl *gomock.Controller) *MockJobRenderer { - mock := &MockJobRenderer{ctrl: ctrl} - mock.recorder = &MockJobRendererMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockJobRenderer) EXPECT() *MockJobRendererMockRecorder { - return m.recorder -} - -// RenderAndUploadFrom mocks base method. -func (m *MockJobRenderer) RenderAndUploadFrom(arg0 manifest.Manifest, arg1 []job.Job, arg2 ui.Stage) ([]installation.RenderedJobRef, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RenderAndUploadFrom", arg0, arg1, arg2) - ret0, _ := ret[0].([]installation.RenderedJobRef) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RenderAndUploadFrom indicates an expected call of RenderAndUploadFrom. -func (mr *MockJobRendererMockRecorder) RenderAndUploadFrom(arg0, arg1, arg2 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenderAndUploadFrom", reflect.TypeOf((*MockJobRenderer)(nil).RenderAndUploadFrom), arg0, arg1, arg2) -} diff --git a/installation/package_compiler.go b/installation/package_compiler.go index 35df3b6a35..f16ded7878 100644 --- a/installation/package_compiler.go +++ b/installation/package_compiler.go @@ -16,6 +16,8 @@ type CompiledPackageRef struct { SHA1 string } +//counterfeiter:generate . PackageCompiler + type PackageCompiler interface { For([]bireljob.Job, biui.Stage) ([]CompiledPackageRef, error) } diff --git a/installation/package_compiler_test.go b/installation/package_compiler_test.go index 8796a4766b..f12946b0d4 100644 --- a/installation/package_compiler_test.go +++ b/installation/package_compiler_test.go @@ -3,7 +3,6 @@ package installation_test import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" fakeboshsys "github.com/cloudfoundry/bosh-utils/system/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -11,35 +10,24 @@ import ( bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" bistatejob "github.com/cloudfoundry/bosh-cli/v7/state/job" - mock_state_job "github.com/cloudfoundry/bosh-cli/v7/state/job/mocks" + "github.com/cloudfoundry/bosh-cli/v7/state/job/jobfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("PackageCompiler", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockDependencyCompiler *mock_state_job.MockDependencyCompiler + mockDependencyCompiler *jobfakes.FakeDependencyCompiler fs *fakeboshsys.FakeFileSystem compiler installation.PackageCompiler - releaseJob bireljob.Job - releaseJobs []bireljob.Job - stage *fakebiui.FakeStage - expectCompile *gomock.Call + releaseJob bireljob.Job + releaseJobs []bireljob.Job + stage *fakebiui.FakeStage ) BeforeEach(func() { - mockDependencyCompiler = mock_state_job.NewMockDependencyCompiler(mockCtrl) + mockDependencyCompiler = &jobfakes.FakeDependencyCompiler{} fs = fakeboshsys.NewFakeFileSystem() stage = fakebiui.NewFakeStage() @@ -65,7 +53,7 @@ var _ = Describe("PackageCompiler", func() { SHA1: "fake-compiled-package-sha1-2", }, } - expectCompile = mockDependencyCompiler.EXPECT().Compile(releaseJobs, stage).Return(compiledPackageRefs, nil).AnyTimes() + mockDependencyCompiler.CompileReturns(compiledPackageRefs, nil) }) Describe("From", func() { @@ -87,11 +75,15 @@ var _ = Describe("PackageCompiler", func() { SHA1: "fake-compiled-package-sha1-2", }, })) + + jobs, gotStage := mockDependencyCompiler.CompileArgsForCall(0) + Expect(jobs).To(Equal(releaseJobs)) + Expect(gotStage).To(Equal(stage)) }) Context("when package compilation fails", func() { JustBeforeEach(func() { - expectCompile.Return([]bistatejob.CompiledPackageRef{}, bosherr.Error("fake-compile-package-2-error")).Times(1) + mockDependencyCompiler.CompileReturns([]bistatejob.CompiledPackageRef{}, bosherr.Error("fake-compile-package-2-error")) }) It("returns an error", func() { diff --git a/installation/pkg/compiler_test.go b/installation/pkg/compiler_test.go index 00c064e7b5..d6fb6103b2 100644 --- a/installation/pkg/compiler_test.go +++ b/installation/pkg/compiler_test.go @@ -2,6 +2,7 @@ package pkg_test import ( "errors" + "fmt" "path/filepath" fakeblobstore "github.com/cloudfoundry/bosh-utils/blobstore/fakes" @@ -10,7 +11,6 @@ import ( boshlog "github.com/cloudfoundry/bosh-utils/logger" boshsys "github.com/cloudfoundry/bosh-utils/system" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -20,20 +20,10 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/release/pkg/pkgfakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" bistatepkg "github.com/cloudfoundry/bosh-cli/v7/state/pkg" - mockstatepackage "github.com/cloudfoundry/bosh-cli/v7/state/pkg/mocks" + statepkgfakes "github.com/cloudfoundry/bosh-cli/v7/state/pkg/pkgfakes" ) var _ = Describe("PackageCompiler", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( logger boshlog.Logger compiler bistatepkg.Compiler @@ -43,7 +33,7 @@ var _ = Describe("PackageCompiler", func() { compressor *fakecmd.FakeCompressor packagesDir string blobstore *fakeblobstore.FakeDigestBlobstore - mockCompiledPackageRepo *mockstatepackage.MockCompiledPackageRepo + mockCompiledPackageRepo *statepkgfakes.FakeCompiledPackageRepo fakeExtractor *blobextractfakes.FakeExtractor @@ -65,7 +55,7 @@ var _ = Describe("PackageCompiler", func() { blobstore.CreateReturns("fake-blob-id", digest, nil) - mockCompiledPackageRepo = mockstatepackage.NewMockCompiledPackageRepo(mockCtrl) + mockCompiledPackageRepo = &statepkgfakes.FakeCompiledPackageRepo{} dependency1 = birelpkg.NewPackage(NewResource("pkg-dep1-name", "", nil), nil) dependency2 = birelpkg.NewPackage(NewResource("pkg-dep2-name", "", nil), nil) @@ -93,8 +83,10 @@ var _ = Describe("PackageCompiler", func() { dep1 bistatepkg.CompiledPackageRecord dep2 bistatepkg.CompiledPackageRecord - expectFind *gomock.Call - expectSave *gomock.Call + findPkgRecord bistatepkg.CompiledPackageRecord + findPkgFound bool + findPkgErr error + saveErr error ) BeforeEach(func() { @@ -104,19 +96,32 @@ var _ = Describe("PackageCompiler", func() { Context("when the package is NOT pre-compiled", func() { JustBeforeEach(func() { - expectFind = mockCompiledPackageRepo.EXPECT().Find(pkg).Return(bistatepkg.CompiledPackageRecord{}, false, nil).AnyTimes() + findPkgRecord = bistatepkg.CompiledPackageRecord{} + findPkgFound = false + findPkgErr = nil + saveErr = nil dep1 = bistatepkg.CompiledPackageRecord{ BlobID: "fake-dependency-blobstore-id-1", BlobSHA1: "fake-dependency-sha1-1", } - mockCompiledPackageRepo.EXPECT().Find(dependency1).Return(dep1, true, nil).AnyTimes() dep2 = bistatepkg.CompiledPackageRecord{ BlobID: "fake-dependency-blobstore-id-2", BlobSHA1: "fake-dependency-sha1-2", } - mockCompiledPackageRepo.EXPECT().Find(dependency2).Return(dep2, true, nil).AnyTimes() + + mockCompiledPackageRepo.FindStub = func(p birelpkg.Compilable) (bistatepkg.CompiledPackageRecord, bool, error) { + switch p { + case pkg: + return findPkgRecord, findPkgFound, findPkgErr + case dependency1: + return dep1, true, nil + case dependency2: + return dep2, true, nil + } + return bistatepkg.CompiledPackageRecord{}, false, fmt.Errorf("unexpected package passed to Find: %#v", p) + } // packaging file created when source is extracted err := fs.WriteFileString("/pkg-dir/packaging", "") @@ -124,19 +129,17 @@ var _ = Describe("PackageCompiler", func() { compressor.CompressFilesInDirTarballPath = compiledPackageTarballPath - record := bistatepkg.CompiledPackageRecord{ - BlobID: "fake-blob-id", - BlobSHA1: "fakefingerprint", + mockCompiledPackageRepo.SaveStub = func(p birelpkg.Compilable, r bistatepkg.CompiledPackageRecord) error { + return saveErr } - expectSave = mockCompiledPackageRepo.EXPECT().Save(pkg, record).AnyTimes() }) Context("when the compiled package repo already has the package", func() { JustBeforeEach(func() { - compiledPkgRecord := bistatepkg.CompiledPackageRecord{ + findPkgRecord = bistatepkg.CompiledPackageRecord{ BlobSHA1: "fakefingerprint", } - expectFind.Return(compiledPkgRecord, true, nil).Times(1) + findPkgFound = true }) It("skips the compilation", func() { @@ -198,10 +201,16 @@ var _ = Describe("PackageCompiler", func() { }) It("stores the compiled package blobID and fingerprint into the compile package repo", func() { - expectSave.Times(1) - _, _, err := compiler.Compile(pkg) Expect(err).ToNot(HaveOccurred()) + + Expect(mockCompiledPackageRepo.SaveCallCount()).To(Equal(1)) + savedPkg, savedRecord := mockCompiledPackageRepo.SaveArgsForCall(0) + Expect(savedPkg).To(Equal(pkg)) + Expect(savedRecord).To(Equal(bistatepkg.CompiledPackageRecord{ + BlobID: "fake-blob-id", + BlobSHA1: "fakefingerprint", + })) }) It("returns the repo record", func() { @@ -296,7 +305,7 @@ var _ = Describe("PackageCompiler", func() { Context("when saving to the compiled package repo fails", func() { JustBeforeEach(func() { - expectSave.Return(errors.New("fake-error")).Times(1) + saveErr = errors.New("fake-error") }) It("returns error", func() { @@ -322,7 +331,7 @@ var _ = Describe("PackageCompiler", func() { Context("when finding compiled package in the repo fails", func() { JustBeforeEach(func() { - expectFind.Return(bistatepkg.CompiledPackageRecord{}, false, errors.New("fake-error")).Times(1) + findPkgErr = errors.New("fake-error") }) It("returns an error", func() { @@ -344,8 +353,10 @@ var _ = Describe("PackageCompiler", func() { dependency1 *birelpkg.CompiledPackage dependency2 *birelpkg.CompiledPackage - expectFind *gomock.Call - expectSave *gomock.Call + findPkgRecord bistatepkg.CompiledPackageRecord + findPkgFound bool + findPkgErr error + saveErr error ) BeforeEach(func() { @@ -379,25 +390,35 @@ var _ = Describe("PackageCompiler", func() { }) JustBeforeEach(func() { - expectFind = mockCompiledPackageRepo.EXPECT().Find(compiledPkg).Return(bistatepkg.CompiledPackageRecord{}, false, nil).AnyTimes() + findPkgRecord = bistatepkg.CompiledPackageRecord{} + findPkgFound = false + findPkgErr = nil + saveErr = nil dep1 = bistatepkg.CompiledPackageRecord{ BlobID: "fake-dependency-blobstore-id-1", BlobSHA1: "fake-dependency-sha1-1", } - mockCompiledPackageRepo.EXPECT().Find(dependency1).Return(dep1, true, nil).AnyTimes() - dep2 = bistatepkg.CompiledPackageRecord{ BlobID: "fake-dependency-blobstore-id-2", BlobSHA1: "fake-dependency-sha1-2", } - mockCompiledPackageRepo.EXPECT().Find(dependency2).Return(dep2, true, nil).AnyTimes() - record := bistatepkg.CompiledPackageRecord{ - BlobID: "fake-blob-id", - BlobSHA1: "fakefingerprint", + mockCompiledPackageRepo.FindStub = func(p birelpkg.Compilable) (bistatepkg.CompiledPackageRecord, bool, error) { + switch p { + case compiledPkg: + return findPkgRecord, findPkgFound, findPkgErr + case dependency1: + return dep1, true, nil + case dependency2: + return dep2, true, nil + } + return bistatepkg.CompiledPackageRecord{}, false, fmt.Errorf("unexpected package passed to Find: %#v", p) + } + + mockCompiledPackageRepo.SaveStub = func(p birelpkg.Compilable, r bistatepkg.CompiledPackageRecord) error { + return saveErr } - expectSave = mockCompiledPackageRepo.EXPECT().Save(compiledPkg, record).AnyTimes() }) It("installs all the dependencies for the package", func() { @@ -429,10 +450,10 @@ var _ = Describe("PackageCompiler", func() { }) It("stores the compiled package blobID and fingerprint into the compile package repo", func() { - expectSave.Times(1) - _, _, err := compiler.Compile(compiledPkg) Expect(err).ToNot(HaveOccurred()) + + Expect(mockCompiledPackageRepo.SaveCallCount()).To(Equal(1)) }) It("returns the repo record", func() { @@ -454,10 +475,10 @@ var _ = Describe("PackageCompiler", func() { Context("when the compiled package repo already has the package", func() { JustBeforeEach(func() { - compiledPkgRecord := bistatepkg.CompiledPackageRecord{ + findPkgRecord = bistatepkg.CompiledPackageRecord{ BlobSHA1: "fakefingerprint", } - expectFind.Return(compiledPkgRecord, true, nil).Times(1) + findPkgFound = true }) It("skips the compilation", func() { @@ -483,7 +504,7 @@ var _ = Describe("PackageCompiler", func() { Context("when finding compiled package in the repo fails", func() { JustBeforeEach(func() { - expectFind.Return(bistatepkg.CompiledPackageRecord{}, false, errors.New("fake-error")).Times(1) + findPkgErr = errors.New("fake-error") }) It("returns an error", func() { @@ -496,7 +517,7 @@ var _ = Describe("PackageCompiler", func() { Context("when saving to the compiled package repo fails", func() { JustBeforeEach(func() { - expectSave.Return(errors.New("fake-error")).Times(1) + saveErr = errors.New("fake-error") }) It("returns error", func() { @@ -523,7 +544,7 @@ var _ = Describe("PackageCompiler", func() { Context("when the package is of an unknown type", func() { It("panics", func() { fakePkg := &pkgfakes.FakeCompilable{} - mockCompiledPackageRepo.EXPECT().Find(fakePkg).Return(bistatepkg.CompiledPackageRecord{}, false, nil).AnyTimes() + mockCompiledPackageRepo.FindReturns(bistatepkg.CompiledPackageRecord{}, false, nil) Expect(func() { compiler.Compile(fakePkg) }).To(Panic()) //nolint:errcheck }) diff --git a/installation/tarball/mocks/mocks.go b/installation/tarball/mocks/mocks.go deleted file mode 100644 index 40e1cecefd..0000000000 --- a/installation/tarball/mocks/mocks.go +++ /dev/null @@ -1,51 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/installation/tarball (interfaces: Provider) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - tarball "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockProvider is a mock of Provider interface. -type MockProvider struct { - ctrl *gomock.Controller - recorder *MockProviderMockRecorder -} - -// MockProviderMockRecorder is the mock recorder for MockProvider. -type MockProviderMockRecorder struct { - mock *MockProvider -} - -// NewMockProvider creates a new mock instance. -func NewMockProvider(ctrl *gomock.Controller) *MockProvider { - mock := &MockProvider{ctrl: ctrl} - mock.recorder = &MockProviderMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockProvider) EXPECT() *MockProviderMockRecorder { - return m.recorder -} - -// Get mocks base method. -func (m *MockProvider) Get(arg0 tarball.Source, arg1 ui.Stage) (string, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", arg0, arg1) - ret0, _ := ret[0].(string) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Get indicates an expected call of Get. -func (mr *MockProviderMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockProvider)(nil).Get), arg0, arg1) -} diff --git a/installation/tarball/provider.go b/installation/tarball/provider.go index 68eb5a3fab..6c4afdd634 100644 --- a/installation/tarball/provider.go +++ b/installation/tarball/provider.go @@ -24,6 +24,10 @@ type Source interface { Description() string } +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Provider + type Provider interface { Get(Source, biui.Stage) (path string, err error) } diff --git a/installation/tarball/tarballfakes/fake_provider.go b/installation/tarball/tarballfakes/fake_provider.go new file mode 100644 index 0000000000..d5ac0c6edf --- /dev/null +++ b/installation/tarball/tarballfakes/fake_provider.go @@ -0,0 +1,117 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package tarballfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeProvider struct { + GetStub func(tarball.Source, ui.Stage) (string, error) + getMutex sync.RWMutex + getArgsForCall []struct { + arg1 tarball.Source + arg2 ui.Stage + } + getReturns struct { + result1 string + result2 error + } + getReturnsOnCall map[int]struct { + result1 string + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeProvider) Get(arg1 tarball.Source, arg2 ui.Stage) (string, error) { + fake.getMutex.Lock() + ret, specificReturn := fake.getReturnsOnCall[len(fake.getArgsForCall)] + fake.getArgsForCall = append(fake.getArgsForCall, struct { + arg1 tarball.Source + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.GetStub + fakeReturns := fake.getReturns + fake.recordInvocation("Get", []interface{}{arg1, arg2}) + fake.getMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeProvider) GetCallCount() int { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + return len(fake.getArgsForCall) +} + +func (fake *FakeProvider) GetCalls(stub func(tarball.Source, ui.Stage) (string, error)) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = stub +} + +func (fake *FakeProvider) GetArgsForCall(i int) (tarball.Source, ui.Stage) { + fake.getMutex.RLock() + defer fake.getMutex.RUnlock() + argsForCall := fake.getArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeProvider) GetReturns(result1 string, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + fake.getReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeProvider) GetReturnsOnCall(i int, result1 string, result2 error) { + fake.getMutex.Lock() + defer fake.getMutex.Unlock() + fake.GetStub = nil + if fake.getReturnsOnCall == nil { + fake.getReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.getReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeProvider) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeProvider) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ tarball.Provider = new(FakeProvider) diff --git a/installation/uninstaller.go b/installation/uninstaller.go index 8a02b30d37..b51cb536d5 100644 --- a/installation/uninstaller.go +++ b/installation/uninstaller.go @@ -5,6 +5,8 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" ) +//counterfeiter:generate . Uninstaller + type Uninstaller interface { Uninstall(Target) error } diff --git a/integration/create_env_test.go b/integration/create_env_test.go index 88498e5dee..a888d02870 100644 --- a/integration/create_env_test.go +++ b/integration/create_env_test.go @@ -9,7 +9,6 @@ import ( biagentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - mockhttpagent "github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks" bosherr "github.com/cloudfoundry/bosh-utils/errors" "github.com/cloudfoundry/bosh-utils/fileutil/fakes" boshlog "github.com/cloudfoundry/bosh-utils/logger" @@ -17,16 +16,16 @@ import ( fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" fakeuuid "github.com/cloudfoundry/bosh-utils/uuid/fakes" "github.com/cppforlife/go-patch/patch" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" "github.com/onsi/gomega/gbytes" - mockagentclient "github.com/cloudfoundry/bosh-cli/v7/agentclient/mocks" - mockblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore/mocks" + "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" + "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - mockcloud "github.com/cloudfoundry/bosh-cli/v7/cloud/mocks" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd" + fakecmd "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" bicpirel "github.com/cloudfoundry/bosh-cli/v7/cpi/release" @@ -34,15 +33,15 @@ import ( bidepl "github.com/cloudfoundry/bosh-cli/v7/deployment" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" - mockinstancestate "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/mocks" + "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" bidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template" bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" + "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - mockinstall "github.com/cloudfoundry/bosh-cli/v7/installation/mocks" bitarball "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" birel "github.com/cloudfoundry/bosh-cli/v7/release" bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" @@ -57,16 +56,6 @@ import ( ) var _ = Describe("bosh", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - Describe("Deploy", func() { var ( fs *fakesys.FakeFileSystem @@ -74,20 +63,24 @@ var _ = Describe("bosh", func() { releaseManager birel.Manager - mockInstaller *mockinstall.MockInstaller - mockInstallerFactory *mockinstall.MockInstallerFactory - mockCloudFactory *mockcloud.MockFactory - mockCloud *mockcloud.MockCloud - mockAgentClient *mockagentclient.MockAgentClient - mockAgentClientFactory *mockhttpagent.MockAgentClientFactory + mockInstaller *installationfakes.FakeInstaller + mockInstallerFactory *installationfakes.FakeInstallerFactory + mockCloudFactory *cloudfakes.FakeFactory + mockCloud *cloudfakes.FakeCloud + mockAgentClient *agentclientfakes.FakeAgentClient + mockAgentClientFactory *fakecmd.FakeAgentClientFactory releaseReader *fakerel.FakeReader - mockStateBuilderFactory *mockinstancestate.MockBuilderFactory - mockStateBuilder *mockinstancestate.MockBuilder - mockState *mockinstancestate.MockState + mockStateBuilderFactory *statefakes.FakeBuilderFactory + mockStateBuilder *statefakes.FakeBuilder + mockState *statefakes.FakeState + + mockBlobstoreFactory *blobstorefakes.FakeFactory + mockBlobstore *blobstorefakes.FakeBlobstore - mockBlobstoreFactory *mockblobstore.MockFactory - mockBlobstore *mockblobstore.MockBlobstore + // callOrder records, in invocation order, calls to mockCloud/mockAgentClient + // methods made during a deploy run -- the counterfeiter equivalent of gomock.InOrder(). + callOrder []string fakeStemcellExtractor *fakebistemcell.FakeExtractor fakeUUIDGenerator *fakeuuid.FakeGenerator @@ -162,8 +155,7 @@ nH9ttalAwSLBsobVaK8mmiAdtAdx+CmHWrB4UNxCPYasrt5A6a9A9SiQ2dLd -----END CERTIFICATE----- ` - expectHasVM1 *gomock.Call - expectDeleteVM1 *gomock.Call + deleteOldVM1Err error ) var manifestTemplate = `--- @@ -308,13 +300,14 @@ cloud_provider: installation := biinstall.NewInstallation(target, []biinstall.InstalledJob{installedJob}, installationManifest) - mockInstallerFactory.EXPECT().NewInstaller(target).Return(mockInstaller).AnyTimes() + mockInstallerFactory.NewInstallerReturns(mockInstaller) - mockInstaller.EXPECT().Install(installationManifest, gomock.Any()).Do(func(_ interface{}, stage biui.Stage) { + mockInstaller.InstallStub = func(_ biinstallmanifest.Manifest, stage biui.Stage) (biinstall.Installation, error) { Expect(fakeStage.SubStages).To(ContainElement(stage)) - }).Return(installation, nil).AnyTimes() - mockInstaller.EXPECT().Cleanup(installation).AnyTimes() - mockCloudFactory.EXPECT().NewCloud(installation, directorID, stemcellApiVersion).Return(mockCloud, nil).AnyTimes() + return installation, nil + } + mockInstaller.CleanupReturns(nil) + mockCloudFactory.NewCloudReturns(mockCloud, nil) } var writeStemcellReleaseTarball = func() { @@ -371,10 +364,10 @@ cloud_provider: // TODO: use a real state builder - mockStateBuilderFactory.EXPECT().NewBuilder(mockBlobstore, mockAgentClient).Return(mockStateBuilder).AnyTimes() - mockStateBuilder.EXPECT().Build(jobName, jobIndex, gomock.Any(), gomock.Any(), gomock.Any()).Return(mockState, nil).AnyTimes() - mockStateBuilder.EXPECT().BuildInitialState(jobName, jobIndex, gomock.Any()).Return(mockState, nil).AnyTimes() - mockState.EXPECT().ToApplySpec().Return(applySpec).AnyTimes() + mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) + mockStateBuilder.BuildReturns(mockState, nil) + mockStateBuilder.BuildInitialStateReturns(mockState, nil) + mockState.ToApplySpecReturns(applySpec) } var newCreateEnvCmd = func() *cmd.CreateEnvCmd { @@ -482,6 +475,82 @@ cloud_provider: return cmd.NewCreateEnvCmd(ui, doGet) } + var wireCommonStubs = func() { + mockCloud.InfoReturns(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil) + + mockCloud.SetVMMetadataStub = func(string, bicloud.VMMetadata) error { + callOrder = append(callOrder, "SetVMMetadata") + return nil + } + mockCloud.SetDiskMetadataStub = func(string, bicloud.DiskMetadata) error { + callOrder = append(callOrder, "SetDiskMetadata") + return nil + } + mockCloud.DeleteDiskStub = func(string) error { + callOrder = append(callOrder, "DeleteDisk") + return nil + } + mockCloud.DetachDiskStub = func(string, string) error { + callOrder = append(callOrder, "DetachDisk") + return nil + } + + mockAgentClient.PingStub = func() (string, error) { + callOrder = append(callOrder, "Ping") + return "any-state", nil + } + mockAgentClient.RunScriptStub = func(name string, _ map[string]interface{}) error { + callOrder = append(callOrder, "RunScript:"+name) + return nil + } + mockAgentClient.DrainStub = func(string) (int64, error) { + callOrder = append(callOrder, "Drain") + return 0, nil + } + mockAgentClient.StopStub = func() error { + callOrder = append(callOrder, "Stop") + return nil + } + mockAgentClient.StartStub = func() error { + callOrder = append(callOrder, "Start") + return nil + } + mockAgentClient.ApplyStub = func(bias.ApplySpec) error { + callOrder = append(callOrder, "Apply") + return nil + } + mockAgentClient.UnmountDiskStub = func(string) error { + callOrder = append(callOrder, "UnmountDisk") + return nil + } + mockAgentClient.AddPersistentDiskStub = func(string, interface{}) error { + callOrder = append(callOrder, "AddPersistentDisk") + return nil + } + mockAgentClient.MountDiskStub = func(string) error { + callOrder = append(callOrder, "MountDisk") + return nil + } + mockAgentClient.RemovePersistentDiskStub = func(string) error { + callOrder = append(callOrder, "RemovePersistentDisk") + return nil + } + mockAgentClient.MigrateDiskStub = func() error { + callOrder = append(callOrder, "MigrateDisk") + return nil + } + + getStateCallCount := 0 + mockAgentClient.GetStateStub = func() (biagentclient.AgentState, error) { + callOrder = append(callOrder, "GetState") + getStateCallCount++ + if getStateCallCount >= 2 { + return agentRunningState, nil + } + return biagentclient.AgentState{}, nil + } + } + var expectDeployFlow = func() { agentID := "fake-uuid-0" vmCID := "fake-vm-cid-1" @@ -490,29 +559,37 @@ cloud_provider: // TODO: use a real StateBuilder and test mockBlobstore.Add & mockAgentClient.CompilePackage - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil).AnyTimes(), - mockCloud.EXPECT().CreateStemcell(filepath.Join("fake-stemcell-extracted-dir", "image"), stemcellCloudProperties).Return(stemcellCID, nil), - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, gomock.Any(), networkInterfaces, vmEnv).Return(vmCID, nil), - mockCloud.EXPECT().SetVMMetadata(vmCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - mockCloud.EXPECT().CreateDisk(diskSize, diskCloudProperties, vmCID).Return(diskCID, nil), - mockCloud.EXPECT().AttachDisk(vmCID, diskCID).Return("/dev/xyz", nil), - mockCloud.EXPECT().SetDiskMetadata(diskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(diskCID, "/dev/xyz"), - mockAgentClient.EXPECT().MountDisk(diskCID), - - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().GetState(), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}), - mockAgentClient.EXPECT().Start(), - mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}), - ) + callOrder = nil + wireCommonStubs() + + mockCloud.CreateStemcellStub = func(imagePath string, cloudProperties biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateStemcell") + Expect(imagePath).To(Equal(filepath.Join("fake-stemcell-extracted-dir", "image"))) + Expect(cloudProperties).To(Equal(stemcellCloudProperties)) + return stemcellCID, nil + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(cloudProperties).To(Equal(vmCloudProperties)) + Expect(networks).To(Equal(networkInterfaces)) + Expect(env).To(Equal(vmEnv)) + return vmCID, nil + } + mockCloud.CreateDiskStub = func(size int, cloudProperties biproperty.Map, gotVMCID string) (string, error) { + callOrder = append(callOrder, "CreateDisk") + Expect(size).To(Equal(diskSize)) + Expect(cloudProperties).To(Equal(diskCloudProperties)) + Expect(gotVMCID).To(Equal(vmCID)) + return diskCID, nil + } + mockCloud.AttachDiskStub = func(gotVMCID, gotDiskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + Expect(gotVMCID).To(Equal(vmCID)) + Expect(gotDiskCID).To(Equal(diskCID)) + return "/dev/xyz", nil + } } var expectDeployWithDiskMigration = func() { @@ -523,55 +600,48 @@ cloud_provider: newDiskCID := "fake-disk-cid-2" newDiskSize := 2048 - expectHasVM1 = mockCloud.EXPECT().HasVM(oldVMCID).Return(true, nil) - - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil), - expectHasVM1, - - // shutdown old vm - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{oldDiskCID}, nil), - mockAgentClient.EXPECT().UnmountDisk(oldDiskCID), - mockCloud.EXPECT().DeleteVM(oldVMCID), - - // create new vm - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, []string{oldDiskCID}, networkInterfaces, vmEnv).Return(newVMCID, nil), - mockCloud.EXPECT().SetVMMetadata(newVMCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - // attach both disks and migrate - mockCloud.EXPECT().AttachDisk(newVMCID, oldDiskCID).Return("/dev/xyz", nil), - mockCloud.EXPECT().SetDiskMetadata(oldDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(oldDiskCID, "/dev/xyz"), - mockAgentClient.EXPECT().MountDisk(oldDiskCID), - mockCloud.EXPECT().CreateDisk(newDiskSize, diskCloudProperties, newVMCID).Return(newDiskCID, nil), - mockCloud.EXPECT().AttachDisk(newVMCID, newDiskCID).Return("/dev/abc", nil), - mockCloud.EXPECT().SetDiskMetadata(newDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(newDiskCID, "/dev/abc"), - mockAgentClient.EXPECT().MountDisk(newDiskCID), - mockAgentClient.EXPECT().MigrateDisk(), - mockAgentClient.EXPECT().RemovePersistentDisk(oldDiskCID), - mockCloud.EXPECT().DetachDisk(newVMCID, oldDiskCID), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockCloud.EXPECT().DeleteDisk(oldDiskCID), - - // start jobs & wait for running - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().GetState(), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}), - mockAgentClient.EXPECT().Start(), - mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}), - ) + callOrder = nil + wireCommonStubs() + + mockCloud.HasVMStub = func(vmCID string) (bool, error) { + callOrder = append(callOrder, "HasVM") + Expect(vmCID).To(Equal(oldVMCID)) + return true, nil + } + mockCloud.DeleteVMStub = func(vmCID string) error { + callOrder = append(callOrder, "DeleteVM") + Expect(vmCID).To(Equal(oldVMCID)) + return nil + } + mockAgentClient.ListDiskStub = func() ([]string, error) { + callOrder = append(callOrder, "ListDisk") + return []string{oldDiskCID}, nil + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(diskCIDs).To(Equal([]string{oldDiskCID})) + return newVMCID, nil + } + mockCloud.CreateDiskStub = func(size int, cloudProperties biproperty.Map, vmCID string) (string, error) { + callOrder = append(callOrder, "CreateDisk") + Expect(size).To(Equal(newDiskSize)) + Expect(vmCID).To(Equal(newVMCID)) + return newDiskCID, nil + } + attachDiskCallCount := 0 + mockCloud.AttachDiskStub = func(vmCID, diskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + attachDiskCallCount++ + Expect(vmCID).To(Equal(newVMCID)) + if attachDiskCallCount == 1 { + Expect(diskCID).To(Equal(oldDiskCID)) + return "/dev/xyz", nil + } + Expect(diskCID).To(Equal(newDiskCID)) + return "/dev/abc", nil + } } var expectDeployWithDiskMigrationMissingVM = func() { @@ -582,48 +652,46 @@ cloud_provider: newDiskCID := "fake-disk-cid-2" newDiskSize := 2048 - expectDeleteVM1 = mockCloud.EXPECT().DeleteVM(oldVMCID) - - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil), - mockCloud.EXPECT().HasVM(oldVMCID).Return(false, nil), - - // delete old vm (without talking to agent) so that the cpi can clean up related resources - expectDeleteVM1, - - // create new vm - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, []string{oldDiskCID}, networkInterfaces, vmEnv).Return(newVMCID, nil), - mockCloud.EXPECT().SetVMMetadata(newVMCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - // attach both disks and migrate - mockCloud.EXPECT().AttachDisk(newVMCID, oldDiskCID).Return("/dev/xyz", nil), - mockCloud.EXPECT().SetDiskMetadata(oldDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(oldDiskCID, "/dev/xyz"), - mockAgentClient.EXPECT().MountDisk(oldDiskCID), - mockCloud.EXPECT().CreateDisk(newDiskSize, diskCloudProperties, newVMCID).Return(newDiskCID, nil), - mockCloud.EXPECT().AttachDisk(newVMCID, newDiskCID).Return("/dev/abc", nil), - mockCloud.EXPECT().SetDiskMetadata(newDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(newDiskCID, "/dev/abc"), - mockAgentClient.EXPECT().MountDisk(newDiskCID), - mockAgentClient.EXPECT().MigrateDisk(), - mockAgentClient.EXPECT().RemovePersistentDisk(oldDiskCID), - mockCloud.EXPECT().DetachDisk(newVMCID, oldDiskCID), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockCloud.EXPECT().DeleteDisk(oldDiskCID), - - // start jobs & wait for running - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().GetState(), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}), - mockAgentClient.EXPECT().Start(), - mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}), - ) + callOrder = nil + wireCommonStubs() + deleteOldVM1Err = nil + + mockCloud.HasVMStub = func(vmCID string) (bool, error) { + callOrder = append(callOrder, "HasVM") + Expect(vmCID).To(Equal(oldVMCID)) + return false, nil + } + // delete old vm (without talking to agent) so that the cpi can clean up related resources + mockCloud.DeleteVMStub = func(vmCID string) error { + callOrder = append(callOrder, "DeleteVM") + Expect(vmCID).To(Equal(oldVMCID)) + return deleteOldVM1Err + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(diskCIDs).To(Equal([]string{oldDiskCID})) + return newVMCID, nil + } + mockCloud.CreateDiskStub = func(size int, cloudProperties biproperty.Map, vmCID string) (string, error) { + callOrder = append(callOrder, "CreateDisk") + Expect(size).To(Equal(newDiskSize)) + Expect(vmCID).To(Equal(newVMCID)) + return newDiskCID, nil + } + attachDiskCallCount := 0 + mockCloud.AttachDiskStub = func(vmCID, diskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + attachDiskCallCount++ + Expect(vmCID).To(Equal(newVMCID)) + if attachDiskCallCount == 1 { + Expect(diskCID).To(Equal(oldDiskCID)) + return "/dev/xyz", nil + } + Expect(diskCID).To(Equal(newDiskCID)) + return "/dev/abc", nil + } } var expectDeployWithNoDiskToMigrate = func() { @@ -632,34 +700,40 @@ cloud_provider: newVMCID := "fake-vm-cid-2" oldDiskCID := "fake-disk-cid-1" - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil), - mockCloud.EXPECT().HasVM(oldVMCID).Return(true, nil), - - // shutdown old vm - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{oldDiskCID}, nil), - mockAgentClient.EXPECT().UnmountDisk(oldDiskCID), - mockCloud.EXPECT().DeleteVM(oldVMCID), - - // create new vm - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, []string{oldDiskCID}, networkInterfaces, vmEnv).Return(newVMCID, nil), - mockCloud.EXPECT().SetVMMetadata(newVMCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - // attaching a missing disk will fail - mockCloud.EXPECT().AttachDisk(newVMCID, oldDiskCID).Return( - "", - bicloud.NewCPIError("attach_disk", bicloud.CmdError{ - Type: bicloud.DiskNotFoundError, - Message: "fake-disk-not-found-message", - }), - ), - ) + callOrder = nil + wireCommonStubs() + + mockCloud.HasVMStub = func(vmCID string) (bool, error) { + callOrder = append(callOrder, "HasVM") + Expect(vmCID).To(Equal(oldVMCID)) + return true, nil + } + mockCloud.DeleteVMStub = func(vmCID string) error { + callOrder = append(callOrder, "DeleteVM") + Expect(vmCID).To(Equal(oldVMCID)) + return nil + } + mockAgentClient.ListDiskStub = func() ([]string, error) { + callOrder = append(callOrder, "ListDisk") + return []string{oldDiskCID}, nil + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(diskCIDs).To(Equal([]string{oldDiskCID})) + return newVMCID, nil + } + // attaching a missing disk will fail + mockCloud.AttachDiskStub = func(vmCID, diskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + Expect(vmCID).To(Equal(newVMCID)) + Expect(diskCID).To(Equal(oldDiskCID)) + return "", bicloud.NewCPIError("attach_disk", bicloud.CmdError{ + Type: bicloud.DiskNotFoundError, + Message: "fake-disk-not-found-message", + }) + } } var expectDeployWithDiskMigrationFailure = func() { @@ -670,41 +744,53 @@ cloud_provider: newDiskCID := "fake-disk-cid-2" newDiskSize := 2048 - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil), - mockCloud.EXPECT().HasVM(oldVMCID).Return(true, nil), - - // shutdown old vm - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{oldDiskCID}, nil), - mockAgentClient.EXPECT().UnmountDisk(oldDiskCID), - mockCloud.EXPECT().DeleteVM(oldVMCID), - - // create new vm - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, []string{oldDiskCID}, networkInterfaces, vmEnv).Return(newVMCID, nil), - mockCloud.EXPECT().SetVMMetadata(newVMCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - // attach both disks and migrate (with error) - mockCloud.EXPECT().AttachDisk(newVMCID, oldDiskCID).Return("/dev/xyz", nil), - mockCloud.EXPECT().SetDiskMetadata(oldDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(oldDiskCID, "/dev/xyz"), - mockAgentClient.EXPECT().MountDisk(oldDiskCID), - mockCloud.EXPECT().CreateDisk(newDiskSize, diskCloudProperties, newVMCID).Return(newDiskCID, nil), - mockCloud.EXPECT().AttachDisk(newVMCID, newDiskCID).Return("/dev/abc", nil), - mockCloud.EXPECT().SetDiskMetadata(newDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(newDiskCID, "/dev/abc"), - mockAgentClient.EXPECT().MountDisk(newDiskCID), - mockAgentClient.EXPECT().MigrateDisk().Return( - bosherr.Error("fake-migration-error"), - ), - ) + callOrder = nil + wireCommonStubs() + + mockCloud.HasVMStub = func(vmCID string) (bool, error) { + callOrder = append(callOrder, "HasVM") + Expect(vmCID).To(Equal(oldVMCID)) + return true, nil + } + mockCloud.DeleteVMStub = func(vmCID string) error { + callOrder = append(callOrder, "DeleteVM") + Expect(vmCID).To(Equal(oldVMCID)) + return nil + } + mockAgentClient.ListDiskStub = func() ([]string, error) { + callOrder = append(callOrder, "ListDisk") + return []string{oldDiskCID}, nil + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(diskCIDs).To(Equal([]string{oldDiskCID})) + return newVMCID, nil + } + mockCloud.CreateDiskStub = func(size int, cloudProperties biproperty.Map, vmCID string) (string, error) { + callOrder = append(callOrder, "CreateDisk") + Expect(size).To(Equal(newDiskSize)) + Expect(vmCID).To(Equal(newVMCID)) + return newDiskCID, nil + } + attachDiskCallCount := 0 + mockCloud.AttachDiskStub = func(vmCID, diskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + attachDiskCallCount++ + Expect(vmCID).To(Equal(newVMCID)) + if attachDiskCallCount == 1 { + Expect(diskCID).To(Equal(oldDiskCID)) + return "/dev/xyz", nil + } + Expect(diskCID).To(Equal(newDiskCID)) + return "/dev/abc", nil + } + // migrate fails + mockAgentClient.MigrateDiskStub = func() error { + callOrder = append(callOrder, "MigrateDisk") + return bosherr.Error("fake-migration-error") + } } var expectDeployWithDiskMigrationRepair = func(failedMigrationDiskCID string) { @@ -715,52 +801,48 @@ cloud_provider: newDiskCID := "fake-disk-cid-3" newDiskSize := 2048 - gomock.InOrder( - mockCloud.EXPECT().Info().Return(bicloud.CpiInfo{ApiVersion: cpiApiVersion}, nil), - mockCloud.EXPECT().HasVM(oldVMCID).Return(true, nil), - - // shutdown old vm - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().RunScript("pre-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().Drain("shutdown"), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().RunScript("post-stop", map[string]interface{}{}), - mockAgentClient.EXPECT().ListDisk().Return([]string{oldDiskCID}, nil), - mockAgentClient.EXPECT().UnmountDisk(oldDiskCID), - mockCloud.EXPECT().DeleteVM(oldVMCID), - - mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, []string{oldDiskCID, failedMigrationDiskCID}, networkInterfaces, vmEnv).Return(newVMCID, nil), - mockCloud.EXPECT().SetVMMetadata(newVMCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - - // attach both disks and migrate - mockCloud.EXPECT().AttachDisk(newVMCID, oldDiskCID).Return("/dev/xyz", nil), - mockCloud.EXPECT().SetDiskMetadata(oldDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(oldDiskCID, "/dev/xyz"), - mockAgentClient.EXPECT().MountDisk(oldDiskCID), - mockCloud.EXPECT().CreateDisk(newDiskSize, diskCloudProperties, newVMCID).Return(newDiskCID, nil), - mockCloud.EXPECT().AttachDisk(newVMCID, newDiskCID).Return("/dev/abc", nil), - mockCloud.EXPECT().SetDiskMetadata(newDiskCID, gomock.Any()).Return(nil), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockAgentClient.EXPECT().AddPersistentDisk(newDiskCID, "/dev/abc"), - mockAgentClient.EXPECT().MountDisk(newDiskCID), - mockAgentClient.EXPECT().MigrateDisk(), - mockAgentClient.EXPECT().RemovePersistentDisk(oldDiskCID), - mockCloud.EXPECT().DetachDisk(newVMCID, oldDiskCID), - mockAgentClient.EXPECT().Ping().Return("any-state", nil), - mockCloud.EXPECT().DeleteDisk(oldDiskCID), - - // start jobs & wait for running - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().GetState(), - mockAgentClient.EXPECT().Stop(), - mockAgentClient.EXPECT().Apply(applySpec), - mockAgentClient.EXPECT().RunScript("pre-start", map[string]interface{}{}), - mockAgentClient.EXPECT().Start(), - mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil), - mockAgentClient.EXPECT().RunScript("post-start", map[string]interface{}{}), - ) + callOrder = nil + wireCommonStubs() + + mockCloud.HasVMStub = func(vmCID string) (bool, error) { + callOrder = append(callOrder, "HasVM") + Expect(vmCID).To(Equal(oldVMCID)) + return true, nil + } + mockCloud.DeleteVMStub = func(vmCID string) error { + callOrder = append(callOrder, "DeleteVM") + Expect(vmCID).To(Equal(oldVMCID)) + return nil + } + mockAgentClient.ListDiskStub = func() ([]string, error) { + callOrder = append(callOrder, "ListDisk") + return []string{oldDiskCID}, nil + } + mockCloud.CreateVMStub = func(gotAgentID, gotStemcellCID string, cloudProperties biproperty.Map, diskCIDs []string, networks map[string]biproperty.Map, env biproperty.Map) (string, error) { + callOrder = append(callOrder, "CreateVM") + Expect(gotAgentID).To(Equal(agentID)) + Expect(gotStemcellCID).To(Equal(stemcellCID)) + Expect(diskCIDs).To(Equal([]string{oldDiskCID, failedMigrationDiskCID})) + return newVMCID, nil + } + mockCloud.CreateDiskStub = func(size int, cloudProperties biproperty.Map, vmCID string) (string, error) { + callOrder = append(callOrder, "CreateDisk") + Expect(size).To(Equal(newDiskSize)) + Expect(vmCID).To(Equal(newVMCID)) + return newDiskCID, nil + } + attachDiskCallCount := 0 + mockCloud.AttachDiskStub = func(vmCID, diskCID string) (interface{}, error) { + callOrder = append(callOrder, "AttachDisk") + attachDiskCallCount++ + Expect(vmCID).To(Equal(newVMCID)) + if attachDiskCallCount == 1 { + Expect(diskCID).To(Equal(oldDiskCID)) + return "/dev/xyz", nil + } + Expect(diskCID).To(Equal(newDiskCID)) + return "/dev/abc", nil + } } BeforeEach(func() { @@ -778,26 +860,26 @@ cloud_provider: fakeDigestCalculator = fakebicrypto.NewFakeDigestCalculator() - mockInstaller = mockinstall.NewMockInstaller(mockCtrl) - mockInstallerFactory = mockinstall.NewMockInstallerFactory(mockCtrl) - mockCloudFactory = mockcloud.NewMockFactory(mockCtrl) + mockInstaller = &installationfakes.FakeInstaller{} + mockInstallerFactory = &installationfakes.FakeInstallerFactory{} + mockCloudFactory = &cloudfakes.FakeFactory{} sshTunnelFactory = bisshtunnel.NewFactory(logger) fakeRepoUUIDGenerator = fakeuuid.NewFakeGenerator() - mockCloud = mockcloud.NewMockCloud(mockCtrl) + mockCloud = &cloudfakes.FakeCloud{} releaseReader = &fakerel.FakeReader{} releaseManager = biinstall.NewReleaseManager(logger) - mockStateBuilderFactory = mockinstancestate.NewMockBuilderFactory(mockCtrl) - mockStateBuilder = mockinstancestate.NewMockBuilder(mockCtrl) - mockState = mockinstancestate.NewMockState(mockCtrl) + mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} + mockStateBuilder = &statefakes.FakeBuilder{} + mockState = &statefakes.FakeState{} - mockBlobstoreFactory = mockblobstore.NewMockFactory(mockCtrl) - mockBlobstore = mockblobstore.NewMockBlobstore(mockCtrl) - mockBlobstoreFactory.EXPECT().Create(mbusURL, gomock.Any()).Return(mockBlobstore, nil).AnyTimes() + mockBlobstoreFactory = &blobstorefakes.FakeFactory{} + mockBlobstore = &blobstorefakes.FakeBlobstore{} + mockBlobstoreFactory.CreateReturns(mockBlobstore, nil) fakeStemcellExtractor = fakebistemcell.NewFakeExtractor() @@ -805,10 +887,10 @@ cloud_provider: stdErr = gbytes.NewBuffer() fakeStage = fakebiui.NewFakeStage() - mockAgentClientFactory = mockhttpagent.NewMockAgentClientFactory(mockCtrl) - mockAgentClient = mockagentclient.NewMockAgentClient(mockCtrl) + mockAgentClientFactory = &fakecmd.FakeAgentClientFactory{} + mockAgentClient = &agentclientfakes.FakeAgentClient{} - mockAgentClientFactory.EXPECT().NewAgentClient(directorID, mbusURL, caCert).Return(mockAgentClient, nil).AnyTimes() + mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) writeDeploymentManifest() writeCPIReleaseTarball() @@ -826,6 +908,12 @@ cloud_provider: err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) + + Expect(callOrder).To(Equal([]string{ + "CreateStemcell", "CreateVM", "SetVMMetadata", "Ping", + "CreateDisk", "AttachDisk", "SetDiskMetadata", "Ping", "AddPersistentDisk", "MountDisk", + "Apply", "GetState", "Stop", "Apply", "RunScript:pre-start", "Start", "GetState", "RunScript:post-start", + })) }) Context("when multiple releases are provided", func() { @@ -872,8 +960,8 @@ cloud_provider: createsStatePath := func(statePath string, createdStatePath string) { expectDeployFlow() - // new directorID will be generated - mockAgentClientFactory.EXPECT().NewAgentClient(gomock.Any(), mbusURL, caCert).Return(mockAgentClient, nil) + // a new directorID will be generated; mockAgentClientFactory.NewAgentClientReturns + // (set in the outer BeforeEach) already covers whatever directorID is passed in. err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, statePath)) Expect(err).ToNot(HaveOccurred()) @@ -930,6 +1018,15 @@ cloud_provider: err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) + + Expect(callOrder).To(Equal([]string{ + "HasVM", "Ping", "RunScript:pre-stop", "Drain", "Stop", "RunScript:post-stop", "ListDisk", "UnmountDisk", "DeleteVM", + "CreateVM", "SetVMMetadata", "Ping", + "AttachDisk", "SetDiskMetadata", "Ping", "AddPersistentDisk", "MountDisk", + "CreateDisk", "AttachDisk", "SetDiskMetadata", "Ping", "AddPersistentDisk", "MountDisk", + "MigrateDisk", "RemovePersistentDisk", "DetachDisk", "Ping", "DeleteDisk", + "Apply", "GetState", "Stop", "Apply", "RunScript:pre-start", "Start", "GetState", "RunScript:post-start", + })) }) Context("when current VM has been deleted manually (outside of bosh)", func() { @@ -938,15 +1035,24 @@ cloud_provider: err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) + + Expect(callOrder).To(Equal([]string{ + "HasVM", "DeleteVM", + "CreateVM", "SetVMMetadata", "Ping", + "AttachDisk", "SetDiskMetadata", "Ping", "AddPersistentDisk", "MountDisk", + "CreateDisk", "AttachDisk", "SetDiskMetadata", "Ping", "AddPersistentDisk", "MountDisk", + "MigrateDisk", "RemovePersistentDisk", "DetachDisk", "Ping", "DeleteDisk", + "Apply", "GetState", "Stop", "Apply", "RunScript:pre-start", "Start", "GetState", "RunScript:post-start", + })) }) It("ignores DiskNotFound errors", func() { expectDeployWithDiskMigrationMissingVM() - expectDeleteVM1.Return(bicloud.NewCPIError("delete_vm", bicloud.CmdError{ + deleteOldVM1Err = bicloud.NewCPIError("delete_vm", bicloud.CmdError{ Type: bicloud.VMNotFoundError, Message: "fake-vm-not-found-message", - })) + }) err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) @@ -982,11 +1088,15 @@ cloud_provider: failedMigrationDiskCID := "fake-disk-cid-2" expectDeployWithDiskMigrationRepair(failedMigrationDiskCID) - mockCloud.EXPECT().DeleteDisk(failedMigrationDiskCID) - err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) + deletedDiskCIDs := []string{} + for i := 0; i < mockCloud.DeleteDiskCallCount(); i++ { + deletedDiskCIDs = append(deletedDiskCIDs, mockCloud.DeleteDiskArgsForCall(i)) + } + Expect(deletedDiskCIDs).To(ContainElement(failedMigrationDiskCID)) + diskRecord, found, err := diskRepo.FindCurrent() Expect(err).ToNot(HaveOccurred()) Expect(found).To(BeTrue()) @@ -1000,24 +1110,22 @@ cloud_provider: }) var expectNoDeployHappened = func() { - expectDeleteVM := mockCloud.EXPECT().DeleteVM(gomock.Any()) - expectDeleteVM.Times(0) - expectCreateVM := mockCloud.EXPECT().CreateVM(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) - expectCreateVM.Times(0) - - mockCloud.EXPECT().HasVM(gomock.Any()).Return(true, nil).AnyTimes() - mockAgentClient.EXPECT().Ping().AnyTimes() - mockAgentClient.EXPECT().Stop().AnyTimes() - mockAgentClient.EXPECT().ListDisk().AnyTimes() + mockCloud.HasVMReturns(true, nil) } Context("and the same deployment is attempted again", func() { It("skips the deploy", func() { + deleteVMCountBefore := mockCloud.DeleteVMCallCount() + createVMCountBefore := mockCloud.CreateVMCallCount() + expectNoDeployHappened() err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, "")) Expect(err).ToNot(HaveOccurred()) Expect(stdOut).To(gbytes.Say("No deployment, stemcell or release changes. Skipping deploy.")) + + Expect(mockCloud.DeleteVMCallCount()).To(Equal(deleteVMCountBefore)) + Expect(mockCloud.CreateVMCallCount()).To(Equal(createVMCountBefore)) }) }) }) @@ -1053,9 +1161,8 @@ cloud_provider: It("uses the version with the cpi api calls", func() { expectDeployFlow() - // new directorID will be generated - mockCloudFactory.EXPECT().NewCloud(gomock.Any(), directorID, stemcellApiVersion).Return(mockCloud, nil).AnyTimes() - mockAgentClientFactory.EXPECT().NewAgentClient(gomock.Any(), mbusURL, caCert).Return(mockAgentClient, nil) + // a new directorID will be generated; mockCloudFactory.NewCloudReturns and + // mockAgentClientFactory.NewAgentClientReturns already cover any directorID passed in. err := newCreateEnvCmd().Run(fakeStage, newDeployOpts(deploymentManifestPath, stateFilePath)) Expect(err).ToNot(HaveOccurred()) diff --git a/release/interfaces.go b/release/interfaces.go index e1f3aa0519..a1d131a5b3 100644 --- a/release/interfaces.go +++ b/release/interfaces.go @@ -11,6 +11,8 @@ import ( // You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate +//counterfeiter:generate . Extractor + type Extractor interface { Extract(string) (Release, error) } @@ -73,6 +75,8 @@ type ArchiveIndicies struct { Licenses boshres.ArchiveIndex } +//counterfeiter:generate . Manager + type Manager interface { Add(Release) List() []Release diff --git a/release/mocks/mocks.go b/release/mocks/mocks.go deleted file mode 100644 index 659a26ddfc..0000000000 --- a/release/mocks/mocks.go +++ /dev/null @@ -1,128 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/release (interfaces: Manager,Extractor) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - release "github.com/cloudfoundry/bosh-cli/v7/release" - gomock "github.com/golang/mock/gomock" -) - -// MockManager is a mock of Manager interface. -type MockManager struct { - ctrl *gomock.Controller - recorder *MockManagerMockRecorder -} - -// MockManagerMockRecorder is the mock recorder for MockManager. -type MockManagerMockRecorder struct { - mock *MockManager -} - -// NewMockManager creates a new mock instance. -func NewMockManager(ctrl *gomock.Controller) *MockManager { - mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder -} - -// Add mocks base method. -func (m *MockManager) Add(arg0 release.Release) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Add", arg0) -} - -// Add indicates an expected call of Add. -func (mr *MockManagerMockRecorder) Add(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockManager)(nil).Add), arg0) -} - -// DeleteAll mocks base method. -func (m *MockManager) DeleteAll() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteAll") - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteAll indicates an expected call of DeleteAll. -func (mr *MockManagerMockRecorder) DeleteAll() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAll", reflect.TypeOf((*MockManager)(nil).DeleteAll)) -} - -// Find mocks base method. -func (m *MockManager) Find(arg0 string) (release.Release, bool) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Find", arg0) - ret0, _ := ret[0].(release.Release) - ret1, _ := ret[1].(bool) - return ret0, ret1 -} - -// Find indicates an expected call of Find. -func (mr *MockManagerMockRecorder) Find(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockManager)(nil).Find), arg0) -} - -// List mocks base method. -func (m *MockManager) List() []release.Release { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List") - ret0, _ := ret[0].([]release.Release) - return ret0 -} - -// List indicates an expected call of List. -func (mr *MockManagerMockRecorder) List() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockManager)(nil).List)) -} - -// MockExtractor is a mock of Extractor interface. -type MockExtractor struct { - ctrl *gomock.Controller - recorder *MockExtractorMockRecorder -} - -// MockExtractorMockRecorder is the mock recorder for MockExtractor. -type MockExtractorMockRecorder struct { - mock *MockExtractor -} - -// NewMockExtractor creates a new mock instance. -func NewMockExtractor(ctrl *gomock.Controller) *MockExtractor { - mock := &MockExtractor{ctrl: ctrl} - mock.recorder = &MockExtractorMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockExtractor) EXPECT() *MockExtractorMockRecorder { - return m.recorder -} - -// Extract mocks base method. -func (m *MockExtractor) Extract(arg0 string) (release.Release, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Extract", arg0) - ret0, _ := ret[0].(release.Release) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Extract indicates an expected call of Extract. -func (mr *MockExtractorMockRecorder) Extract(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Extract", reflect.TypeOf((*MockExtractor)(nil).Extract), arg0) -} diff --git a/release/releasefakes/fake_extractor.go b/release/releasefakes/fake_extractor.go new file mode 100644 index 0000000000..5c5e9db19b --- /dev/null +++ b/release/releasefakes/fake_extractor.go @@ -0,0 +1,114 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package releasefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release" +) + +type FakeExtractor struct { + ExtractStub func(string) (release.Release, error) + extractMutex sync.RWMutex + extractArgsForCall []struct { + arg1 string + } + extractReturns struct { + result1 release.Release + result2 error + } + extractReturnsOnCall map[int]struct { + result1 release.Release + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeExtractor) Extract(arg1 string) (release.Release, error) { + fake.extractMutex.Lock() + ret, specificReturn := fake.extractReturnsOnCall[len(fake.extractArgsForCall)] + fake.extractArgsForCall = append(fake.extractArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.ExtractStub + fakeReturns := fake.extractReturns + fake.recordInvocation("Extract", []interface{}{arg1}) + fake.extractMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeExtractor) ExtractCallCount() int { + fake.extractMutex.RLock() + defer fake.extractMutex.RUnlock() + return len(fake.extractArgsForCall) +} + +func (fake *FakeExtractor) ExtractCalls(stub func(string) (release.Release, error)) { + fake.extractMutex.Lock() + defer fake.extractMutex.Unlock() + fake.ExtractStub = stub +} + +func (fake *FakeExtractor) ExtractArgsForCall(i int) string { + fake.extractMutex.RLock() + defer fake.extractMutex.RUnlock() + argsForCall := fake.extractArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeExtractor) ExtractReturns(result1 release.Release, result2 error) { + fake.extractMutex.Lock() + defer fake.extractMutex.Unlock() + fake.ExtractStub = nil + fake.extractReturns = struct { + result1 release.Release + result2 error + }{result1, result2} +} + +func (fake *FakeExtractor) ExtractReturnsOnCall(i int, result1 release.Release, result2 error) { + fake.extractMutex.Lock() + defer fake.extractMutex.Unlock() + fake.ExtractStub = nil + if fake.extractReturnsOnCall == nil { + fake.extractReturnsOnCall = make(map[int]struct { + result1 release.Release + result2 error + }) + } + fake.extractReturnsOnCall[i] = struct { + result1 release.Release + result2 error + }{result1, result2} +} + +func (fake *FakeExtractor) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeExtractor) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ release.Extractor = new(FakeExtractor) diff --git a/release/releasefakes/fake_manager.go b/release/releasefakes/fake_manager.go new file mode 100644 index 0000000000..555922c2af --- /dev/null +++ b/release/releasefakes/fake_manager.go @@ -0,0 +1,277 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package releasefakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release" +) + +type FakeManager struct { + AddStub func(release.Release) + addMutex sync.RWMutex + addArgsForCall []struct { + arg1 release.Release + } + DeleteAllStub func() error + deleteAllMutex sync.RWMutex + deleteAllArgsForCall []struct { + } + deleteAllReturns struct { + result1 error + } + deleteAllReturnsOnCall map[int]struct { + result1 error + } + FindStub func(string) (release.Release, bool) + findMutex sync.RWMutex + findArgsForCall []struct { + arg1 string + } + findReturns struct { + result1 release.Release + result2 bool + } + findReturnsOnCall map[int]struct { + result1 release.Release + result2 bool + } + ListStub func() []release.Release + listMutex sync.RWMutex + listArgsForCall []struct { + } + listReturns struct { + result1 []release.Release + } + listReturnsOnCall map[int]struct { + result1 []release.Release + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) Add(arg1 release.Release) { + fake.addMutex.Lock() + fake.addArgsForCall = append(fake.addArgsForCall, struct { + arg1 release.Release + }{arg1}) + stub := fake.AddStub + fake.recordInvocation("Add", []interface{}{arg1}) + fake.addMutex.Unlock() + if stub != nil { + fake.AddStub(arg1) + } +} + +func (fake *FakeManager) AddCallCount() int { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + return len(fake.addArgsForCall) +} + +func (fake *FakeManager) AddCalls(stub func(release.Release)) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = stub +} + +func (fake *FakeManager) AddArgsForCall(i int) release.Release { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + argsForCall := fake.addArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManager) DeleteAll() error { + fake.deleteAllMutex.Lock() + ret, specificReturn := fake.deleteAllReturnsOnCall[len(fake.deleteAllArgsForCall)] + fake.deleteAllArgsForCall = append(fake.deleteAllArgsForCall, struct { + }{}) + stub := fake.DeleteAllStub + fakeReturns := fake.deleteAllReturns + fake.recordInvocation("DeleteAll", []interface{}{}) + fake.deleteAllMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) DeleteAllCallCount() int { + fake.deleteAllMutex.RLock() + defer fake.deleteAllMutex.RUnlock() + return len(fake.deleteAllArgsForCall) +} + +func (fake *FakeManager) DeleteAllCalls(stub func() error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = stub +} + +func (fake *FakeManager) DeleteAllReturns(result1 error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = nil + fake.deleteAllReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) DeleteAllReturnsOnCall(i int, result1 error) { + fake.deleteAllMutex.Lock() + defer fake.deleteAllMutex.Unlock() + fake.DeleteAllStub = nil + if fake.deleteAllReturnsOnCall == nil { + fake.deleteAllReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteAllReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) Find(arg1 string) (release.Release, bool) { + fake.findMutex.Lock() + ret, specificReturn := fake.findReturnsOnCall[len(fake.findArgsForCall)] + fake.findArgsForCall = append(fake.findArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.FindStub + fakeReturns := fake.findReturns + fake.recordInvocation("Find", []interface{}{arg1}) + fake.findMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindCallCount() int { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + return len(fake.findArgsForCall) +} + +func (fake *FakeManager) FindCalls(stub func(string) (release.Release, bool)) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = stub +} + +func (fake *FakeManager) FindArgsForCall(i int) string { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + argsForCall := fake.findArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManager) FindReturns(result1 release.Release, result2 bool) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + fake.findReturns = struct { + result1 release.Release + result2 bool + }{result1, result2} +} + +func (fake *FakeManager) FindReturnsOnCall(i int, result1 release.Release, result2 bool) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + if fake.findReturnsOnCall == nil { + fake.findReturnsOnCall = make(map[int]struct { + result1 release.Release + result2 bool + }) + } + fake.findReturnsOnCall[i] = struct { + result1 release.Release + result2 bool + }{result1, result2} +} + +func (fake *FakeManager) List() []release.Release { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + }{}) + stub := fake.ListStub + fakeReturns := fake.listReturns + fake.recordInvocation("List", []interface{}{}) + fake.listMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeManager) ListCalls(stub func() []release.Release) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeManager) ListReturns(result1 []release.Release) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 []release.Release + }{result1} +} + +func (fake *FakeManager) ListReturnsOnCall(i int, result1 []release.Release) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 []release.Release + }) + } + fake.listReturnsOnCall[i] = struct { + result1 []release.Release + }{result1} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ release.Manager = new(FakeManager) diff --git a/state/job/dependency_compiler.go b/state/job/dependency_compiler.go index dc14f5aca0..0d5b282076 100644 --- a/state/job/dependency_compiler.go +++ b/state/job/dependency_compiler.go @@ -20,6 +20,10 @@ type CompiledPackageRef struct { SHA1 string } +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . DependencyCompiler + type DependencyCompiler interface { Compile([]bireljob.Job, biui.Stage) ([]CompiledPackageRef, error) } diff --git a/state/job/dependency_compiler_test.go b/state/job/dependency_compiler_test.go index 25f100536a..bcd7c062e1 100644 --- a/state/job/dependency_compiler_test.go +++ b/state/job/dependency_compiler_test.go @@ -1,8 +1,9 @@ package job_test import ( + "fmt" + boshlog "github.com/cloudfoundry/bosh-utils/logger" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -11,23 +12,13 @@ import ( . "github.com/cloudfoundry/bosh-cli/v7/release/resource" . "github.com/cloudfoundry/bosh-cli/v7/state/job" bistatepkg "github.com/cloudfoundry/bosh-cli/v7/state/pkg" - mockstatepackage "github.com/cloudfoundry/bosh-cli/v7/state/pkg/mocks" + "github.com/cloudfoundry/bosh-cli/v7/state/pkg/pkgfakes" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) var _ = Describe("DependencyCompiler", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( - mockPackageCompiler *mockstatepackage.MockCompiler + mockPackageCompiler *pkgfakes.FakeCompiler logger boshlog.Logger dependencyCompiler DependencyCompiler @@ -39,12 +30,15 @@ var _ = Describe("DependencyCompiler", func() { job *boshreljob.Job jobs []boshreljob.Job - expectCompilePkg1 *gomock.Call - expectCompilePkg2 *gomock.Call + order []string + + pkg1AlreadyCompiled bool + pkg2AlreadyCompiled bool ) BeforeEach(func() { - mockPackageCompiler = mockstatepackage.NewMockCompiler(mockCtrl) + mockPackageCompiler = &pkgfakes.FakeCompiler{} + order = nil logger = boshlog.NewLogger(boshlog.LevelNone) dependencyCompiler = NewDependencyCompiler(mockPackageCompiler, logger) @@ -60,6 +54,9 @@ var _ = Describe("DependencyCompiler", func() { err = job.AttachPackages([]*boshrelpkg.Package{pkg2}) Expect(err).ToNot(HaveOccurred()) jobs = []boshreljob.Job{*job} + + pkg1AlreadyCompiled = false + pkg2AlreadyCompiled = false }) JustBeforeEach(func() { @@ -67,23 +64,28 @@ var _ = Describe("DependencyCompiler", func() { BlobID: "fake-compiled-package-blobstore-id-1", BlobSHA1: "fake-compiled-package-sha1-1", } - expectCompilePkg1 = mockPackageCompiler.EXPECT().Compile(pkg1).Return(compiledPackageRecord1, false, nil).AnyTimes() - compiledPackageRecord2 := bistatepkg.CompiledPackageRecord{ BlobID: "fake-compiled-package-blobstore-id-2", BlobSHA1: "fake-compiled-package-sha1-2", } - expectCompilePkg2 = mockPackageCompiler.EXPECT().Compile(pkg2).Return(compiledPackageRecord2, false, nil).AnyTimes() + + mockPackageCompiler.CompileStub = func(pkg boshrelpkg.Compilable) (bistatepkg.CompiledPackageRecord, bool, error) { + switch pkg { + case pkg1: + order = append(order, "pkg1-name") + return compiledPackageRecord1, pkg1AlreadyCompiled, nil + case pkg2: + order = append(order, "pkg2-name") + return compiledPackageRecord2, pkg2AlreadyCompiled, nil + } + return bistatepkg.CompiledPackageRecord{}, false, fmt.Errorf("unexpected package passed to Compile: %#v", pkg) + } }) It("compiles all the job dependencies (packages) such that no package is compiled before its dependencies", func() { - gomock.InOrder( - expectCompilePkg1.Times(1), - expectCompilePkg2.Times(1), - ) - _, err := dependencyCompiler.Compile(jobs, stage) Expect(err).ToNot(HaveOccurred()) + Expect(order).To(Equal([]string{"pkg1-name", "pkg2-name"})) }) It("returns references to the compiled packages", func() { @@ -147,17 +149,8 @@ var _ = Describe("DependencyCompiler", func() { Context("when a compiled releases is provided", func() { BeforeEach(func() { - compiledPackageRecord1 := bistatepkg.CompiledPackageRecord{ - BlobID: "fake-compiled-package-blobstore-id-1", - BlobSHA1: "fake-compiled-package-sha1-1", - } - expectCompilePkg1 = mockPackageCompiler.EXPECT().Compile(pkg1).Return(compiledPackageRecord1, true, nil).AnyTimes() - - compiledPackageRecord2 := bistatepkg.CompiledPackageRecord{ - BlobID: "fake-compiled-package-blobstore-id-2", - BlobSHA1: "fake-compiled-package-sha1-2", - } - expectCompilePkg2 = mockPackageCompiler.EXPECT().Compile(pkg2).Return(compiledPackageRecord2, true, nil).AnyTimes() + pkg1AlreadyCompiled = true + pkg2AlreadyCompiled = true }) It("skips compiling the packages in the release", func() { @@ -181,20 +174,15 @@ var _ = Describe("DependencyCompiler", func() { }) It("only compiles each package once", func() { - gomock.InOrder( - expectCompilePkg1.Times(1), - expectCompilePkg2.Times(1), - ) - _, err := dependencyCompiler.Compile(jobs, stage) Expect(err).ToNot(HaveOccurred()) + Expect(order).To(Equal([]string{"pkg1-name", "pkg2-name"})) }) }) Context("when multiple packages depend on the same package", func() { var ( - pkg3 *boshrelpkg.Package - expectCompilePkg3 *gomock.Call + pkg3 *boshrelpkg.Package ) BeforeEach(func() { @@ -212,16 +200,43 @@ var _ = Describe("DependencyCompiler", func() { BlobID: "fake-compiled-package-blobstore-id-3", BlobSHA1: "fake-compiled-package-sha1-3", } - expectCompilePkg3 = mockPackageCompiler.EXPECT().Compile(pkg3).Return(compiledPackageRecord3, false, nil).AnyTimes() + + mockPackageCompiler.CompileStub = func(pkg boshrelpkg.Compilable) (bistatepkg.CompiledPackageRecord, bool, error) { + switch pkg { + case pkg1: + order = append(order, "pkg1-name") + return bistatepkg.CompiledPackageRecord{ + BlobID: "fake-compiled-package-blobstore-id-1", + BlobSHA1: "fake-compiled-package-sha1-1", + }, false, nil + case pkg2: + order = append(order, "pkg2-name") + return bistatepkg.CompiledPackageRecord{ + BlobID: "fake-compiled-package-blobstore-id-2", + BlobSHA1: "fake-compiled-package-sha1-2", + }, false, nil + case pkg3: + order = append(order, "pkg3-name") + return compiledPackageRecord3, false, nil + } + return bistatepkg.CompiledPackageRecord{}, false, fmt.Errorf("unexpected package passed to Compile: %#v", pkg) + } }) It("only compiles each package once", func() { - expectCompilePkg1.Times(1) - expectCompilePkg2.After(expectCompilePkg1) - expectCompilePkg3.After(expectCompilePkg1) - _, err := dependencyCompiler.Compile(jobs, stage) Expect(err).ToNot(HaveOccurred()) + + // pkg1 must be compiled exactly once, and before anything else (pkg2/pkg3 depend on it) + Expect(order).ToNot(BeEmpty()) + Expect(order[0]).To(Equal("pkg1-name")) + pkg1Count := 0 + for _, name := range order { + if name == "pkg1-name" { + pkg1Count++ + } + } + Expect(pkg1Count).To(Equal(1)) }) }) }) diff --git a/state/job/jobfakes/fake_dependency_compiler.go b/state/job/jobfakes/fake_dependency_compiler.go new file mode 100644 index 0000000000..bc8192065c --- /dev/null +++ b/state/job/jobfakes/fake_dependency_compiler.go @@ -0,0 +1,123 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package jobfakes + +import ( + "sync" + + joba "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/state/job" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDependencyCompiler struct { + CompileStub func([]joba.Job, ui.Stage) ([]job.CompiledPackageRef, error) + compileMutex sync.RWMutex + compileArgsForCall []struct { + arg1 []joba.Job + arg2 ui.Stage + } + compileReturns struct { + result1 []job.CompiledPackageRef + result2 error + } + compileReturnsOnCall map[int]struct { + result1 []job.CompiledPackageRef + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDependencyCompiler) Compile(arg1 []joba.Job, arg2 ui.Stage) ([]job.CompiledPackageRef, error) { + var arg1Copy []joba.Job + if arg1 != nil { + arg1Copy = make([]joba.Job, len(arg1)) + copy(arg1Copy, arg1) + } + fake.compileMutex.Lock() + ret, specificReturn := fake.compileReturnsOnCall[len(fake.compileArgsForCall)] + fake.compileArgsForCall = append(fake.compileArgsForCall, struct { + arg1 []joba.Job + arg2 ui.Stage + }{arg1Copy, arg2}) + stub := fake.CompileStub + fakeReturns := fake.compileReturns + fake.recordInvocation("Compile", []interface{}{arg1Copy, arg2}) + fake.compileMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDependencyCompiler) CompileCallCount() int { + fake.compileMutex.RLock() + defer fake.compileMutex.RUnlock() + return len(fake.compileArgsForCall) +} + +func (fake *FakeDependencyCompiler) CompileCalls(stub func([]joba.Job, ui.Stage) ([]job.CompiledPackageRef, error)) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = stub +} + +func (fake *FakeDependencyCompiler) CompileArgsForCall(i int) ([]joba.Job, ui.Stage) { + fake.compileMutex.RLock() + defer fake.compileMutex.RUnlock() + argsForCall := fake.compileArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeDependencyCompiler) CompileReturns(result1 []job.CompiledPackageRef, result2 error) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = nil + fake.compileReturns = struct { + result1 []job.CompiledPackageRef + result2 error + }{result1, result2} +} + +func (fake *FakeDependencyCompiler) CompileReturnsOnCall(i int, result1 []job.CompiledPackageRef, result2 error) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = nil + if fake.compileReturnsOnCall == nil { + fake.compileReturnsOnCall = make(map[int]struct { + result1 []job.CompiledPackageRef + result2 error + }) + } + fake.compileReturnsOnCall[i] = struct { + result1 []job.CompiledPackageRef + result2 error + }{result1, result2} +} + +func (fake *FakeDependencyCompiler) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDependencyCompiler) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ job.DependencyCompiler = new(FakeDependencyCompiler) diff --git a/state/job/mocks/mocks.go b/state/job/mocks/mocks.go deleted file mode 100644 index ffdb2e0b81..0000000000 --- a/state/job/mocks/mocks.go +++ /dev/null @@ -1,52 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/state/job (interfaces: DependencyCompiler) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - job "github.com/cloudfoundry/bosh-cli/v7/release/job" - job0 "github.com/cloudfoundry/bosh-cli/v7/state/job" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockDependencyCompiler is a mock of DependencyCompiler interface. -type MockDependencyCompiler struct { - ctrl *gomock.Controller - recorder *MockDependencyCompilerMockRecorder -} - -// MockDependencyCompilerMockRecorder is the mock recorder for MockDependencyCompiler. -type MockDependencyCompilerMockRecorder struct { - mock *MockDependencyCompiler -} - -// NewMockDependencyCompiler creates a new mock instance. -func NewMockDependencyCompiler(ctrl *gomock.Controller) *MockDependencyCompiler { - mock := &MockDependencyCompiler{ctrl: ctrl} - mock.recorder = &MockDependencyCompilerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockDependencyCompiler) EXPECT() *MockDependencyCompilerMockRecorder { - return m.recorder -} - -// Compile mocks base method. -func (m *MockDependencyCompiler) Compile(arg0 []job.Job, arg1 ui.Stage) ([]job0.CompiledPackageRef, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Compile", arg0, arg1) - ret0, _ := ret[0].([]job0.CompiledPackageRef) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Compile indicates an expected call of Compile. -func (mr *MockDependencyCompilerMockRecorder) Compile(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compile", reflect.TypeOf((*MockDependencyCompiler)(nil).Compile), arg0, arg1) -} diff --git a/state/pkg/compiled_package_repo.go b/state/pkg/compiled_package_repo.go index fcb5556507..061de46f24 100644 --- a/state/pkg/compiled_package_repo.go +++ b/state/pkg/compiled_package_repo.go @@ -17,6 +17,8 @@ type CompiledPackageRecord struct { BlobSHA1 string } +//counterfeiter:generate . CompiledPackageRepo + type CompiledPackageRepo interface { Save(birelpkg.Compilable, CompiledPackageRecord) error Find(birelpkg.Compilable) (CompiledPackageRecord, bool, error) diff --git a/state/pkg/compiler_interface.go b/state/pkg/compiler_interface.go index 55166f1980..b38cc86a48 100644 --- a/state/pkg/compiler_interface.go +++ b/state/pkg/compiler_interface.go @@ -4,6 +4,10 @@ import ( birelpkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Compiler + type Compiler interface { Compile(birelpkg.Compilable) (CompiledPackageRecord, bool, error) } diff --git a/state/pkg/mocks/mocks.go b/state/pkg/mocks/mocks.go deleted file mode 100644 index bdecc98d47..0000000000 --- a/state/pkg/mocks/mocks.go +++ /dev/null @@ -1,105 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/state/pkg (interfaces: Compiler,CompiledPackageRepo) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - pkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" - pkg0 "github.com/cloudfoundry/bosh-cli/v7/state/pkg" - gomock "github.com/golang/mock/gomock" -) - -// MockCompiler is a mock of Compiler interface. -type MockCompiler struct { - ctrl *gomock.Controller - recorder *MockCompilerMockRecorder -} - -// MockCompilerMockRecorder is the mock recorder for MockCompiler. -type MockCompilerMockRecorder struct { - mock *MockCompiler -} - -// NewMockCompiler creates a new mock instance. -func NewMockCompiler(ctrl *gomock.Controller) *MockCompiler { - mock := &MockCompiler{ctrl: ctrl} - mock.recorder = &MockCompilerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCompiler) EXPECT() *MockCompilerMockRecorder { - return m.recorder -} - -// Compile mocks base method. -func (m *MockCompiler) Compile(arg0 pkg.Compilable) (pkg0.CompiledPackageRecord, bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Compile", arg0) - ret0, _ := ret[0].(pkg0.CompiledPackageRecord) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// Compile indicates an expected call of Compile. -func (mr *MockCompilerMockRecorder) Compile(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compile", reflect.TypeOf((*MockCompiler)(nil).Compile), arg0) -} - -// MockCompiledPackageRepo is a mock of CompiledPackageRepo interface. -type MockCompiledPackageRepo struct { - ctrl *gomock.Controller - recorder *MockCompiledPackageRepoMockRecorder -} - -// MockCompiledPackageRepoMockRecorder is the mock recorder for MockCompiledPackageRepo. -type MockCompiledPackageRepoMockRecorder struct { - mock *MockCompiledPackageRepo -} - -// NewMockCompiledPackageRepo creates a new mock instance. -func NewMockCompiledPackageRepo(ctrl *gomock.Controller) *MockCompiledPackageRepo { - mock := &MockCompiledPackageRepo{ctrl: ctrl} - mock.recorder = &MockCompiledPackageRepoMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCompiledPackageRepo) EXPECT() *MockCompiledPackageRepoMockRecorder { - return m.recorder -} - -// Find mocks base method. -func (m *MockCompiledPackageRepo) Find(arg0 pkg.Compilable) (pkg0.CompiledPackageRecord, bool, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Find", arg0) - ret0, _ := ret[0].(pkg0.CompiledPackageRecord) - ret1, _ := ret[1].(bool) - ret2, _ := ret[2].(error) - return ret0, ret1, ret2 -} - -// Find indicates an expected call of Find. -func (mr *MockCompiledPackageRepoMockRecorder) Find(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCompiledPackageRepo)(nil).Find), arg0) -} - -// Save mocks base method. -func (m *MockCompiledPackageRepo) Save(arg0 pkg.Compilable, arg1 pkg0.CompiledPackageRecord) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Save", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// Save indicates an expected call of Save. -func (mr *MockCompiledPackageRepoMockRecorder) Save(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCompiledPackageRepo)(nil).Save), arg0, arg1) -} diff --git a/state/pkg/pkgfakes/fake_compiled_package_repo.go b/state/pkg/pkgfakes/fake_compiled_package_repo.go new file mode 100644 index 0000000000..276d55f530 --- /dev/null +++ b/state/pkg/pkgfakes/fake_compiled_package_repo.go @@ -0,0 +1,194 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package pkgfakes + +import ( + "sync" + + pkga "github.com/cloudfoundry/bosh-cli/v7/release/pkg" + "github.com/cloudfoundry/bosh-cli/v7/state/pkg" +) + +type FakeCompiledPackageRepo struct { + FindStub func(pkga.Compilable) (pkg.CompiledPackageRecord, bool, error) + findMutex sync.RWMutex + findArgsForCall []struct { + arg1 pkga.Compilable + } + findReturns struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + } + findReturnsOnCall map[int]struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + } + SaveStub func(pkga.Compilable, pkg.CompiledPackageRecord) error + saveMutex sync.RWMutex + saveArgsForCall []struct { + arg1 pkga.Compilable + arg2 pkg.CompiledPackageRecord + } + saveReturns struct { + result1 error + } + saveReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeCompiledPackageRepo) Find(arg1 pkga.Compilable) (pkg.CompiledPackageRecord, bool, error) { + fake.findMutex.Lock() + ret, specificReturn := fake.findReturnsOnCall[len(fake.findArgsForCall)] + fake.findArgsForCall = append(fake.findArgsForCall, struct { + arg1 pkga.Compilable + }{arg1}) + stub := fake.FindStub + fakeReturns := fake.findReturns + fake.recordInvocation("Find", []interface{}{arg1}) + fake.findMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCompiledPackageRepo) FindCallCount() int { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + return len(fake.findArgsForCall) +} + +func (fake *FakeCompiledPackageRepo) FindCalls(stub func(pkga.Compilable) (pkg.CompiledPackageRecord, bool, error)) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = stub +} + +func (fake *FakeCompiledPackageRepo) FindArgsForCall(i int) pkga.Compilable { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + argsForCall := fake.findArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCompiledPackageRepo) FindReturns(result1 pkg.CompiledPackageRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + fake.findReturns = struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCompiledPackageRepo) FindReturnsOnCall(i int, result1 pkg.CompiledPackageRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + if fake.findReturnsOnCall == nil { + fake.findReturnsOnCall = make(map[int]struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }) + } + fake.findReturnsOnCall[i] = struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCompiledPackageRepo) Save(arg1 pkga.Compilable, arg2 pkg.CompiledPackageRecord) error { + fake.saveMutex.Lock() + ret, specificReturn := fake.saveReturnsOnCall[len(fake.saveArgsForCall)] + fake.saveArgsForCall = append(fake.saveArgsForCall, struct { + arg1 pkga.Compilable + arg2 pkg.CompiledPackageRecord + }{arg1, arg2}) + stub := fake.SaveStub + fakeReturns := fake.saveReturns + fake.recordInvocation("Save", []interface{}{arg1, arg2}) + fake.saveMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeCompiledPackageRepo) SaveCallCount() int { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + return len(fake.saveArgsForCall) +} + +func (fake *FakeCompiledPackageRepo) SaveCalls(stub func(pkga.Compilable, pkg.CompiledPackageRecord) error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = stub +} + +func (fake *FakeCompiledPackageRepo) SaveArgsForCall(i int) (pkga.Compilable, pkg.CompiledPackageRecord) { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + argsForCall := fake.saveArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeCompiledPackageRepo) SaveReturns(result1 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + fake.saveReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeCompiledPackageRepo) SaveReturnsOnCall(i int, result1 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + if fake.saveReturnsOnCall == nil { + fake.saveReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.saveReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeCompiledPackageRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeCompiledPackageRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ pkg.CompiledPackageRepo = new(FakeCompiledPackageRepo) diff --git a/state/pkg/pkgfakes/fake_compiler.go b/state/pkg/pkgfakes/fake_compiler.go new file mode 100644 index 0000000000..ad27639886 --- /dev/null +++ b/state/pkg/pkgfakes/fake_compiler.go @@ -0,0 +1,120 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package pkgfakes + +import ( + "sync" + + pkga "github.com/cloudfoundry/bosh-cli/v7/release/pkg" + "github.com/cloudfoundry/bosh-cli/v7/state/pkg" +) + +type FakeCompiler struct { + CompileStub func(pkga.Compilable) (pkg.CompiledPackageRecord, bool, error) + compileMutex sync.RWMutex + compileArgsForCall []struct { + arg1 pkga.Compilable + } + compileReturns struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + } + compileReturnsOnCall map[int]struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeCompiler) Compile(arg1 pkga.Compilable) (pkg.CompiledPackageRecord, bool, error) { + fake.compileMutex.Lock() + ret, specificReturn := fake.compileReturnsOnCall[len(fake.compileArgsForCall)] + fake.compileArgsForCall = append(fake.compileArgsForCall, struct { + arg1 pkga.Compilable + }{arg1}) + stub := fake.CompileStub + fakeReturns := fake.compileReturns + fake.recordInvocation("Compile", []interface{}{arg1}) + fake.compileMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeCompiler) CompileCallCount() int { + fake.compileMutex.RLock() + defer fake.compileMutex.RUnlock() + return len(fake.compileArgsForCall) +} + +func (fake *FakeCompiler) CompileCalls(stub func(pkga.Compilable) (pkg.CompiledPackageRecord, bool, error)) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = stub +} + +func (fake *FakeCompiler) CompileArgsForCall(i int) pkga.Compilable { + fake.compileMutex.RLock() + defer fake.compileMutex.RUnlock() + argsForCall := fake.compileArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeCompiler) CompileReturns(result1 pkg.CompiledPackageRecord, result2 bool, result3 error) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = nil + fake.compileReturns = struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCompiler) CompileReturnsOnCall(i int, result1 pkg.CompiledPackageRecord, result2 bool, result3 error) { + fake.compileMutex.Lock() + defer fake.compileMutex.Unlock() + fake.CompileStub = nil + if fake.compileReturnsOnCall == nil { + fake.compileReturnsOnCall = make(map[int]struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }) + } + fake.compileReturnsOnCall[i] = struct { + result1 pkg.CompiledPackageRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeCompiler) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeCompiler) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ pkg.Compiler = new(FakeCompiler) diff --git a/stemcell/manager.go b/stemcell/manager.go index 5a3e6d22ab..2b55e9c503 100644 --- a/stemcell/manager.go +++ b/stemcell/manager.go @@ -12,6 +12,12 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +// stemcellfakes already contains a hand-written FakeManager used elsewhere, so this +// counterfeiter-generated one for full mock coverage lives in a separate package. +//counterfeiter:generate -o mockfakes/fake_manager.go . Manager + type Manager interface { FindCurrent() ([]CloudStemcell, error) Upload(ExtractedStemcell, biui.Stage) (CloudStemcell, error) diff --git a/stemcell/mockfakes/fake_manager.go b/stemcell/mockfakes/fake_manager.go new file mode 100644 index 0000000000..6b6a602005 --- /dev/null +++ b/stemcell/mockfakes/fake_manager.go @@ -0,0 +1,325 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mockfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/stemcell" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeManager struct { + DeleteUnusedStub func(ui.Stage) error + deleteUnusedMutex sync.RWMutex + deleteUnusedArgsForCall []struct { + arg1 ui.Stage + } + deleteUnusedReturns struct { + result1 error + } + deleteUnusedReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() ([]stemcell.CloudStemcell, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 []stemcell.CloudStemcell + result2 error + } + findCurrentReturnsOnCall map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + } + FindUnusedStub func() ([]stemcell.CloudStemcell, error) + findUnusedMutex sync.RWMutex + findUnusedArgsForCall []struct { + } + findUnusedReturns struct { + result1 []stemcell.CloudStemcell + result2 error + } + findUnusedReturnsOnCall map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + } + UploadStub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error) + uploadMutex sync.RWMutex + uploadArgsForCall []struct { + arg1 stemcell.ExtractedStemcell + arg2 ui.Stage + } + uploadReturns struct { + result1 stemcell.CloudStemcell + result2 error + } + uploadReturnsOnCall map[int]struct { + result1 stemcell.CloudStemcell + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) DeleteUnused(arg1 ui.Stage) error { + fake.deleteUnusedMutex.Lock() + ret, specificReturn := fake.deleteUnusedReturnsOnCall[len(fake.deleteUnusedArgsForCall)] + fake.deleteUnusedArgsForCall = append(fake.deleteUnusedArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.DeleteUnusedStub + fakeReturns := fake.deleteUnusedReturns + fake.recordInvocation("DeleteUnused", []interface{}{arg1}) + fake.deleteUnusedMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManager) DeleteUnusedCallCount() int { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + return len(fake.deleteUnusedArgsForCall) +} + +func (fake *FakeManager) DeleteUnusedCalls(stub func(ui.Stage) error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = stub +} + +func (fake *FakeManager) DeleteUnusedArgsForCall(i int) ui.Stage { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + argsForCall := fake.deleteUnusedArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManager) DeleteUnusedReturns(result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + fake.deleteUnusedReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) DeleteUnusedReturnsOnCall(i int, result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + if fake.deleteUnusedReturnsOnCall == nil { + fake.deleteUnusedReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteUnusedReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeManager) FindCurrent() ([]stemcell.CloudStemcell, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() ([]stemcell.CloudStemcell, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeManager) FindCurrentReturns(result1 []stemcell.CloudStemcell, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnused() ([]stemcell.CloudStemcell, error) { + fake.findUnusedMutex.Lock() + ret, specificReturn := fake.findUnusedReturnsOnCall[len(fake.findUnusedArgsForCall)] + fake.findUnusedArgsForCall = append(fake.findUnusedArgsForCall, struct { + }{}) + stub := fake.FindUnusedStub + fakeReturns := fake.findUnusedReturns + fake.recordInvocation("FindUnused", []interface{}{}) + fake.findUnusedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindUnusedCallCount() int { + fake.findUnusedMutex.RLock() + defer fake.findUnusedMutex.RUnlock() + return len(fake.findUnusedArgsForCall) +} + +func (fake *FakeManager) FindUnusedCalls(stub func() ([]stemcell.CloudStemcell, error)) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = stub +} + +func (fake *FakeManager) FindUnusedReturns(result1 []stemcell.CloudStemcell, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + fake.findUnusedReturns = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnusedReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + if fake.findUnusedReturnsOnCall == nil { + fake.findUnusedReturnsOnCall = make(map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + }) + } + fake.findUnusedReturnsOnCall[i] = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) Upload(arg1 stemcell.ExtractedStemcell, arg2 ui.Stage) (stemcell.CloudStemcell, error) { + fake.uploadMutex.Lock() + ret, specificReturn := fake.uploadReturnsOnCall[len(fake.uploadArgsForCall)] + fake.uploadArgsForCall = append(fake.uploadArgsForCall, struct { + arg1 stemcell.ExtractedStemcell + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.UploadStub + fakeReturns := fake.uploadReturns + fake.recordInvocation("Upload", []interface{}{arg1, arg2}) + fake.uploadMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) UploadCallCount() int { + fake.uploadMutex.RLock() + defer fake.uploadMutex.RUnlock() + return len(fake.uploadArgsForCall) +} + +func (fake *FakeManager) UploadCalls(stub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error)) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = stub +} + +func (fake *FakeManager) UploadArgsForCall(i int) (stemcell.ExtractedStemcell, ui.Stage) { + fake.uploadMutex.RLock() + defer fake.uploadMutex.RUnlock() + argsForCall := fake.uploadArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeManager) UploadReturns(result1 stemcell.CloudStemcell, result2 error) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = nil + fake.uploadReturns = struct { + result1 stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) UploadReturnsOnCall(i int, result1 stemcell.CloudStemcell, result2 error) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = nil + if fake.uploadReturnsOnCall == nil { + fake.uploadReturnsOnCall = make(map[int]struct { + result1 stemcell.CloudStemcell + result2 error + }) + } + fake.uploadReturnsOnCall[i] = struct { + result1 stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ stemcell.Manager = new(FakeManager) diff --git a/stemcell/mocks/mocks.go b/stemcell/mocks/mocks.go deleted file mode 100644 index ff2e7c34e7..0000000000 --- a/stemcell/mocks/mocks.go +++ /dev/null @@ -1,188 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/stemcell (interfaces: CloudStemcell,Manager) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - stemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - ui "github.com/cloudfoundry/bosh-cli/v7/ui" - gomock "github.com/golang/mock/gomock" -) - -// MockCloudStemcell is a mock of CloudStemcell interface. -type MockCloudStemcell struct { - ctrl *gomock.Controller - recorder *MockCloudStemcellMockRecorder -} - -// MockCloudStemcellMockRecorder is the mock recorder for MockCloudStemcell. -type MockCloudStemcellMockRecorder struct { - mock *MockCloudStemcell -} - -// NewMockCloudStemcell creates a new mock instance. -func NewMockCloudStemcell(ctrl *gomock.Controller) *MockCloudStemcell { - mock := &MockCloudStemcell{ctrl: ctrl} - mock.recorder = &MockCloudStemcellMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockCloudStemcell) EXPECT() *MockCloudStemcellMockRecorder { - return m.recorder -} - -// CID mocks base method. -func (m *MockCloudStemcell) CID() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CID") - ret0, _ := ret[0].(string) - return ret0 -} - -// CID indicates an expected call of CID. -func (mr *MockCloudStemcellMockRecorder) CID() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CID", reflect.TypeOf((*MockCloudStemcell)(nil).CID)) -} - -// Delete mocks base method. -func (m *MockCloudStemcell) Delete() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete") - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockCloudStemcellMockRecorder) Delete() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockCloudStemcell)(nil).Delete)) -} - -// Name mocks base method. -func (m *MockCloudStemcell) Name() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Name") - ret0, _ := ret[0].(string) - return ret0 -} - -// Name indicates an expected call of Name. -func (mr *MockCloudStemcellMockRecorder) Name() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockCloudStemcell)(nil).Name)) -} - -// PromoteAsCurrent mocks base method. -func (m *MockCloudStemcell) PromoteAsCurrent() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PromoteAsCurrent") - ret0, _ := ret[0].(error) - return ret0 -} - -// PromoteAsCurrent indicates an expected call of PromoteAsCurrent. -func (mr *MockCloudStemcellMockRecorder) PromoteAsCurrent() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PromoteAsCurrent", reflect.TypeOf((*MockCloudStemcell)(nil).PromoteAsCurrent)) -} - -// Version mocks base method. -func (m *MockCloudStemcell) Version() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Version") - ret0, _ := ret[0].(string) - return ret0 -} - -// Version indicates an expected call of Version. -func (mr *MockCloudStemcellMockRecorder) Version() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockCloudStemcell)(nil).Version)) -} - -// MockManager is a mock of Manager interface. -type MockManager struct { - ctrl *gomock.Controller - recorder *MockManagerMockRecorder -} - -// MockManagerMockRecorder is the mock recorder for MockManager. -type MockManagerMockRecorder struct { - mock *MockManager -} - -// NewMockManager creates a new mock instance. -func NewMockManager(ctrl *gomock.Controller) *MockManager { - mock := &MockManager{ctrl: ctrl} - mock.recorder = &MockManagerMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockManager) EXPECT() *MockManagerMockRecorder { - return m.recorder -} - -// DeleteUnused mocks base method. -func (m *MockManager) DeleteUnused(arg0 ui.Stage) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteUnused", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// DeleteUnused indicates an expected call of DeleteUnused. -func (mr *MockManagerMockRecorder) DeleteUnused(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUnused", reflect.TypeOf((*MockManager)(nil).DeleteUnused), arg0) -} - -// FindCurrent mocks base method. -func (m *MockManager) FindCurrent() ([]stemcell.CloudStemcell, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindCurrent") - ret0, _ := ret[0].([]stemcell.CloudStemcell) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindCurrent indicates an expected call of FindCurrent. -func (mr *MockManagerMockRecorder) FindCurrent() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindCurrent", reflect.TypeOf((*MockManager)(nil).FindCurrent)) -} - -// FindUnused mocks base method. -func (m *MockManager) FindUnused() ([]stemcell.CloudStemcell, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "FindUnused") - ret0, _ := ret[0].([]stemcell.CloudStemcell) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// FindUnused indicates an expected call of FindUnused. -func (mr *MockManagerMockRecorder) FindUnused() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindUnused", reflect.TypeOf((*MockManager)(nil).FindUnused)) -} - -// Upload mocks base method. -func (m *MockManager) Upload(arg0 stemcell.ExtractedStemcell, arg1 ui.Stage) (stemcell.CloudStemcell, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Upload", arg0, arg1) - ret0, _ := ret[0].(stemcell.CloudStemcell) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Upload indicates an expected call of Upload. -func (mr *MockManagerMockRecorder) Upload(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockManager)(nil).Upload), arg0, arg1) -} diff --git a/stemcell/stemcellfakes/fake_manager_factory.go b/stemcell/stemcellfakes/fake_manager_factory.go index 669a45e0e0..5b408f8205 100644 --- a/stemcell/stemcellfakes/fake_manager_factory.go +++ b/stemcell/stemcellfakes/fake_manager_factory.go @@ -3,11 +3,8 @@ package stemcellfakes import ( "fmt" - bosherr "github.com/cloudfoundry/bosh-utils/errors" - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - bitestutils "github.com/cloudfoundry/bosh-cli/v7/testutils" ) type NewManagerInput struct { @@ -20,13 +17,13 @@ type newManagerOutput struct { type FakeManagerFactory struct { NewManagerInputs []NewManagerInput - newManagerBehavior map[string]newManagerOutput + newManagerBehavior map[bicloud.Cloud]newManagerOutput } func NewFakeManagerFactory() *FakeManagerFactory { return &FakeManagerFactory{ NewManagerInputs: []NewManagerInput{}, - newManagerBehavior: map[string]newManagerOutput{}, + newManagerBehavior: map[bicloud.Cloud]newManagerOutput{}, } } @@ -36,12 +33,7 @@ func (f *FakeManagerFactory) NewManager(cloud bicloud.Cloud) bistemcell.Manager } f.NewManagerInputs = append(f.NewManagerInputs, input) - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - panic(bosherr.WrapError(marshalErr, "Marshaling NewManager input")) - } - - output, found := f.newManagerBehavior[inputString] + output, found := f.newManagerBehavior[cloud] if !found { panic(fmt.Errorf("Unsupported NewManager Input: %#v\nExpected Behavior: %#v", input, f.newManagerBehavior)) //nolint:staticcheck } @@ -50,14 +42,5 @@ func (f *FakeManagerFactory) NewManager(cloud bicloud.Cloud) bistemcell.Manager } func (f *FakeManagerFactory) SetNewManagerBehavior(cloud bicloud.Cloud, manager bistemcell.Manager) { - input := NewManagerInput{ - Cloud: cloud, - } - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - panic(bosherr.WrapError(marshalErr, "Marshaling NewManager input")) - } - - f.newManagerBehavior[inputString] = newManagerOutput{manager: manager} + f.newManagerBehavior[cloud] = newManagerOutput{manager: manager} } diff --git a/templatescompiler/job_list_renderer.go b/templatescompiler/job_list_renderer.go index 5f9e4d13aa..f7cb763ea7 100644 --- a/templatescompiler/job_list_renderer.go +++ b/templatescompiler/job_list_renderer.go @@ -8,6 +8,8 @@ import ( bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" ) +//counterfeiter:generate . JobListRenderer + type JobListRenderer interface { Render( releaseJobs []bireljob.Job, diff --git a/templatescompiler/job_list_renderer_test.go b/templatescompiler/job_list_renderer_test.go index f997d4aa90..94d460219d 100644 --- a/templatescompiler/job_list_renderer_test.go +++ b/templatescompiler/job_list_renderer_test.go @@ -4,31 +4,20 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" boshreljob "github.com/cloudfoundry/bosh-cli/v7/release/job" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" . "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" - mock_template "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/mocks" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/templatescompilerfakes" ) var _ = Describe("JobListRenderer", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( logger boshlog.Logger - mockJobRenderer *mock_template.MockJobRenderer + mockJobRenderer *templatescompilerfakes.FakeJobRenderer releaseJobs []boshreljob.Job releaseJobProperties map[string]*biproperty.Map @@ -37,16 +26,14 @@ var _ = Describe("JobListRenderer", func() { deploymentName string address string - renderedJobs []*mock_template.MockRenderedJob + renderedJobs []*templatescompilerfakes.FakeRenderedJob jobListRenderer JobListRenderer - - expectRender1 *gomock.Call ) BeforeEach(func() { logger = boshlog.NewLogger(boshlog.LevelNone) - mockJobRenderer = mock_template.NewMockJobRenderer(mockCtrl) + mockJobRenderer = &templatescompilerfakes.FakeJobRenderer{} // release jobs are just passed through to JobRenderer.Render, so they do not need real contents releaseJobs = []boshreljob.Job{ @@ -72,17 +59,17 @@ var _ = Describe("JobListRenderer", func() { deploymentName = "fake-deployment-name" address = "1.2.3.4" - renderedJobs = []*mock_template.MockRenderedJob{ - mock_template.NewMockRenderedJob(mockCtrl), - mock_template.NewMockRenderedJob(mockCtrl), + renderedJobs = []*templatescompilerfakes.FakeRenderedJob{ + {}, + {}, } jobListRenderer = NewJobListRenderer(mockJobRenderer, logger) }) JustBeforeEach(func() { - mockJobRenderer.EXPECT().Render(releaseJobs[0], releaseJobProperties[releaseJobs[0].Name()], jobProperties, globalProperties, deploymentName, address).Return(renderedJobs[0], nil) - expectRender1 = mockJobRenderer.EXPECT().Render(releaseJobs[1], releaseJobProperties[releaseJobs[1].Name()], jobProperties, globalProperties, deploymentName, address).Return(renderedJobs[1], nil) + mockJobRenderer.RenderReturnsOnCall(0, renderedJobs[0], nil) + mockJobRenderer.RenderReturnsOnCall(1, renderedJobs[1], nil) }) Describe("Render", func() { @@ -93,19 +80,36 @@ var _ = Describe("JobListRenderer", func() { renderedJobs[0], renderedJobs[1], })) + + Expect(mockJobRenderer.RenderCallCount()).To(Equal(2)) + + actualJob0, actualProps0, actualJobProperties0, actualGlobalProperties0, actualDeploymentName0, actualAddress0 := mockJobRenderer.RenderArgsForCall(0) + Expect(actualJob0).To(Equal(releaseJobs[0])) + Expect(actualProps0).To(Equal(releaseJobProperties[releaseJobs[0].Name()])) + Expect(actualJobProperties0).To(Equal(jobProperties)) + Expect(actualGlobalProperties0).To(Equal(globalProperties)) + Expect(actualDeploymentName0).To(Equal(deploymentName)) + Expect(actualAddress0).To(Equal(address)) + + actualJob1, actualProps1, actualJobProperties1, actualGlobalProperties1, actualDeploymentName1, actualAddress1 := mockJobRenderer.RenderArgsForCall(1) + Expect(actualJob1).To(Equal(releaseJobs[1])) + Expect(actualProps1).To(Equal(releaseJobProperties[releaseJobs[1].Name()])) + Expect(actualJobProperties1).To(Equal(jobProperties)) + Expect(actualGlobalProperties1).To(Equal(globalProperties)) + Expect(actualDeploymentName1).To(Equal(deploymentName)) + Expect(actualAddress1).To(Equal(address)) }) Context("when rendering a job fails", func() { JustBeforeEach(func() { - expectRender1.Return(nil, bosherr.Error("fake-render-error")) + mockJobRenderer.RenderReturnsOnCall(1, nil, bosherr.Error("fake-render-error")) }) It("returns an error and cleans up any sucessfully rendered jobs", func() { - renderedJobs[0].EXPECT().DeleteSilently() - _, err := jobListRenderer.Render(releaseJobs, releaseJobProperties, jobProperties, globalProperties, deploymentName, address) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-render-error")) + Expect(renderedJobs[0].DeleteSilentlyCallCount()).To(Equal(1)) }) }) }) diff --git a/templatescompiler/job_renderer.go b/templatescompiler/job_renderer.go index 6aebe85df7..389434df43 100644 --- a/templatescompiler/job_renderer.go +++ b/templatescompiler/job_renderer.go @@ -15,6 +15,10 @@ import ( bierbrenderer "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/erbrenderer" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . JobRenderer + type JobRenderer interface { Render(releaseJob bireljob.Job, releaseJobProperties *biproperty.Map, jobProperties biproperty.Map, globalProperties biproperty.Map, deploymentName string, address string) (RenderedJob, error) } diff --git a/templatescompiler/mocks/mocks.go b/templatescompiler/mocks/mocks.go deleted file mode 100644 index 9a38d6bd86..0000000000 --- a/templatescompiler/mocks/mocks.go +++ /dev/null @@ -1,371 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/templatescompiler (interfaces: JobRenderer,JobListRenderer,RenderedJob,RenderedJobList,RenderedJobListArchive,RenderedJobListCompressor) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - job "github.com/cloudfoundry/bosh-cli/v7/release/job" - templatescompiler "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" - property "github.com/cloudfoundry/bosh-utils/property" - gomock "github.com/golang/mock/gomock" -) - -// MockJobRenderer is a mock of JobRenderer interface. -type MockJobRenderer struct { - ctrl *gomock.Controller - recorder *MockJobRendererMockRecorder -} - -// MockJobRendererMockRecorder is the mock recorder for MockJobRenderer. -type MockJobRendererMockRecorder struct { - mock *MockJobRenderer -} - -// NewMockJobRenderer creates a new mock instance. -func NewMockJobRenderer(ctrl *gomock.Controller) *MockJobRenderer { - mock := &MockJobRenderer{ctrl: ctrl} - mock.recorder = &MockJobRendererMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockJobRenderer) EXPECT() *MockJobRendererMockRecorder { - return m.recorder -} - -// Render mocks base method. -func (m *MockJobRenderer) Render(arg0 job.Job, arg1 *property.Map, arg2, arg3 property.Map, arg4, arg5 string) (templatescompiler.RenderedJob, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Render", arg0, arg1, arg2, arg3, arg4, arg5) - ret0, _ := ret[0].(templatescompiler.RenderedJob) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Render indicates an expected call of Render. -func (mr *MockJobRendererMockRecorder) Render(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Render", reflect.TypeOf((*MockJobRenderer)(nil).Render), arg0, arg1, arg2, arg3, arg4, arg5) -} - -// MockJobListRenderer is a mock of JobListRenderer interface. -type MockJobListRenderer struct { - ctrl *gomock.Controller - recorder *MockJobListRendererMockRecorder -} - -// MockJobListRendererMockRecorder is the mock recorder for MockJobListRenderer. -type MockJobListRendererMockRecorder struct { - mock *MockJobListRenderer -} - -// NewMockJobListRenderer creates a new mock instance. -func NewMockJobListRenderer(ctrl *gomock.Controller) *MockJobListRenderer { - mock := &MockJobListRenderer{ctrl: ctrl} - mock.recorder = &MockJobListRendererMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockJobListRenderer) EXPECT() *MockJobListRendererMockRecorder { - return m.recorder -} - -// Render mocks base method. -func (m *MockJobListRenderer) Render(arg0 []job.Job, arg1 map[string]*property.Map, arg2, arg3 property.Map, arg4, arg5 string) (templatescompiler.RenderedJobList, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Render", arg0, arg1, arg2, arg3, arg4, arg5) - ret0, _ := ret[0].(templatescompiler.RenderedJobList) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Render indicates an expected call of Render. -func (mr *MockJobListRendererMockRecorder) Render(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Render", reflect.TypeOf((*MockJobListRenderer)(nil).Render), arg0, arg1, arg2, arg3, arg4, arg5) -} - -// MockRenderedJob is a mock of RenderedJob interface. -type MockRenderedJob struct { - ctrl *gomock.Controller - recorder *MockRenderedJobMockRecorder -} - -// MockRenderedJobMockRecorder is the mock recorder for MockRenderedJob. -type MockRenderedJobMockRecorder struct { - mock *MockRenderedJob -} - -// NewMockRenderedJob creates a new mock instance. -func NewMockRenderedJob(ctrl *gomock.Controller) *MockRenderedJob { - mock := &MockRenderedJob{ctrl: ctrl} - mock.recorder = &MockRenderedJobMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockRenderedJob) EXPECT() *MockRenderedJobMockRecorder { - return m.recorder -} - -// Delete mocks base method. -func (m *MockRenderedJob) Delete() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete") - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockRenderedJobMockRecorder) Delete() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRenderedJob)(nil).Delete)) -} - -// DeleteSilently mocks base method. -func (m *MockRenderedJob) DeleteSilently() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "DeleteSilently") -} - -// DeleteSilently indicates an expected call of DeleteSilently. -func (mr *MockRenderedJobMockRecorder) DeleteSilently() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSilently", reflect.TypeOf((*MockRenderedJob)(nil).DeleteSilently)) -} - -// Job mocks base method. -func (m *MockRenderedJob) Job() job.Job { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Job") - ret0, _ := ret[0].(job.Job) - return ret0 -} - -// Job indicates an expected call of Job. -func (mr *MockRenderedJobMockRecorder) Job() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Job", reflect.TypeOf((*MockRenderedJob)(nil).Job)) -} - -// Path mocks base method. -func (m *MockRenderedJob) Path() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Path") - ret0, _ := ret[0].(string) - return ret0 -} - -// Path indicates an expected call of Path. -func (mr *MockRenderedJobMockRecorder) Path() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockRenderedJob)(nil).Path)) -} - -// MockRenderedJobList is a mock of RenderedJobList interface. -type MockRenderedJobList struct { - ctrl *gomock.Controller - recorder *MockRenderedJobListMockRecorder -} - -// MockRenderedJobListMockRecorder is the mock recorder for MockRenderedJobList. -type MockRenderedJobListMockRecorder struct { - mock *MockRenderedJobList -} - -// NewMockRenderedJobList creates a new mock instance. -func NewMockRenderedJobList(ctrl *gomock.Controller) *MockRenderedJobList { - mock := &MockRenderedJobList{ctrl: ctrl} - mock.recorder = &MockRenderedJobListMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockRenderedJobList) EXPECT() *MockRenderedJobListMockRecorder { - return m.recorder -} - -// Add mocks base method. -func (m *MockRenderedJobList) Add(arg0 templatescompiler.RenderedJob) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Add", arg0) -} - -// Add indicates an expected call of Add. -func (mr *MockRenderedJobListMockRecorder) Add(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockRenderedJobList)(nil).Add), arg0) -} - -// All mocks base method. -func (m *MockRenderedJobList) All() []templatescompiler.RenderedJob { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "All") - ret0, _ := ret[0].([]templatescompiler.RenderedJob) - return ret0 -} - -// All indicates an expected call of All. -func (mr *MockRenderedJobListMockRecorder) All() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "All", reflect.TypeOf((*MockRenderedJobList)(nil).All)) -} - -// Delete mocks base method. -func (m *MockRenderedJobList) Delete() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete") - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockRenderedJobListMockRecorder) Delete() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRenderedJobList)(nil).Delete)) -} - -// DeleteSilently mocks base method. -func (m *MockRenderedJobList) DeleteSilently() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "DeleteSilently") -} - -// DeleteSilently indicates an expected call of DeleteSilently. -func (mr *MockRenderedJobListMockRecorder) DeleteSilently() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSilently", reflect.TypeOf((*MockRenderedJobList)(nil).DeleteSilently)) -} - -// MockRenderedJobListArchive is a mock of RenderedJobListArchive interface. -type MockRenderedJobListArchive struct { - ctrl *gomock.Controller - recorder *MockRenderedJobListArchiveMockRecorder -} - -// MockRenderedJobListArchiveMockRecorder is the mock recorder for MockRenderedJobListArchive. -type MockRenderedJobListArchiveMockRecorder struct { - mock *MockRenderedJobListArchive -} - -// NewMockRenderedJobListArchive creates a new mock instance. -func NewMockRenderedJobListArchive(ctrl *gomock.Controller) *MockRenderedJobListArchive { - mock := &MockRenderedJobListArchive{ctrl: ctrl} - mock.recorder = &MockRenderedJobListArchiveMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockRenderedJobListArchive) EXPECT() *MockRenderedJobListArchiveMockRecorder { - return m.recorder -} - -// Delete mocks base method. -func (m *MockRenderedJobListArchive) Delete() error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete") - ret0, _ := ret[0].(error) - return ret0 -} - -// Delete indicates an expected call of Delete. -func (mr *MockRenderedJobListArchiveMockRecorder) Delete() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRenderedJobListArchive)(nil).Delete)) -} - -// DeleteSilently mocks base method. -func (m *MockRenderedJobListArchive) DeleteSilently() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "DeleteSilently") -} - -// DeleteSilently indicates an expected call of DeleteSilently. -func (mr *MockRenderedJobListArchiveMockRecorder) DeleteSilently() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSilently", reflect.TypeOf((*MockRenderedJobListArchive)(nil).DeleteSilently)) -} - -// List mocks base method. -func (m *MockRenderedJobListArchive) List() templatescompiler.RenderedJobList { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "List") - ret0, _ := ret[0].(templatescompiler.RenderedJobList) - return ret0 -} - -// List indicates an expected call of List. -func (mr *MockRenderedJobListArchiveMockRecorder) List() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRenderedJobListArchive)(nil).List)) -} - -// Path mocks base method. -func (m *MockRenderedJobListArchive) Path() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Path") - ret0, _ := ret[0].(string) - return ret0 -} - -// Path indicates an expected call of Path. -func (mr *MockRenderedJobListArchiveMockRecorder) Path() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockRenderedJobListArchive)(nil).Path)) -} - -// SHA1 mocks base method. -func (m *MockRenderedJobListArchive) SHA1() string { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SHA1") - ret0, _ := ret[0].(string) - return ret0 -} - -// SHA1 indicates an expected call of SHA1. -func (mr *MockRenderedJobListArchiveMockRecorder) SHA1() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SHA1", reflect.TypeOf((*MockRenderedJobListArchive)(nil).SHA1)) -} - -// MockRenderedJobListCompressor is a mock of RenderedJobListCompressor interface. -type MockRenderedJobListCompressor struct { - ctrl *gomock.Controller - recorder *MockRenderedJobListCompressorMockRecorder -} - -// MockRenderedJobListCompressorMockRecorder is the mock recorder for MockRenderedJobListCompressor. -type MockRenderedJobListCompressorMockRecorder struct { - mock *MockRenderedJobListCompressor -} - -// NewMockRenderedJobListCompressor creates a new mock instance. -func NewMockRenderedJobListCompressor(ctrl *gomock.Controller) *MockRenderedJobListCompressor { - mock := &MockRenderedJobListCompressor{ctrl: ctrl} - mock.recorder = &MockRenderedJobListCompressorMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockRenderedJobListCompressor) EXPECT() *MockRenderedJobListCompressorMockRecorder { - return m.recorder -} - -// Compress mocks base method. -func (m *MockRenderedJobListCompressor) Compress(arg0 templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Compress", arg0) - ret0, _ := ret[0].(templatescompiler.RenderedJobListArchive) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// Compress indicates an expected call of Compress. -func (mr *MockRenderedJobListCompressorMockRecorder) Compress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compress", reflect.TypeOf((*MockRenderedJobListCompressor)(nil).Compress), arg0) -} diff --git a/templatescompiler/rendered_job.go b/templatescompiler/rendered_job.go index 4e3ecffc7d..bce967a303 100644 --- a/templatescompiler/rendered_job.go +++ b/templatescompiler/rendered_job.go @@ -10,6 +10,8 @@ import ( bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" ) +//counterfeiter:generate . RenderedJob + type RenderedJob interface { Job() bireljob.Job Path() string // dir of multiple rendered files diff --git a/templatescompiler/rendered_job_list.go b/templatescompiler/rendered_job_list.go index 782af93024..48cb973b7e 100644 --- a/templatescompiler/rendered_job_list.go +++ b/templatescompiler/rendered_job_list.go @@ -6,6 +6,8 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" ) +//counterfeiter:generate . RenderedJobList + type RenderedJobList interface { Add(RenderedJob) All() []RenderedJob diff --git a/templatescompiler/rendered_job_list_archive.go b/templatescompiler/rendered_job_list_archive.go index a8e5d2a18f..556f6c1ea0 100644 --- a/templatescompiler/rendered_job_list_archive.go +++ b/templatescompiler/rendered_job_list_archive.go @@ -8,6 +8,8 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" ) +//counterfeiter:generate . RenderedJobListArchive + type RenderedJobListArchive interface { List() RenderedJobList Path() string diff --git a/templatescompiler/rendered_job_list_archive_test.go b/templatescompiler/rendered_job_list_archive_test.go index 96a3366812..357ff613f7 100644 --- a/templatescompiler/rendered_job_list_archive_test.go +++ b/templatescompiler/rendered_job_list_archive_test.go @@ -7,31 +7,20 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" fakeboshsys "github.com/cloudfoundry/bosh-utils/system/fakes" - "github.com/golang/mock/gomock" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" . "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" - mock_template "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/mocks" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler/templatescompilerfakes" ) var _ = Describe("RenderedJobListArchive", func() { - var mockCtrl *gomock.Controller - - BeforeEach(func() { - mockCtrl = gomock.NewController(GinkgoT()) - }) - - AfterEach(func() { - mockCtrl.Finish() - }) - var ( outBuffer *bytes.Buffer logger boshlog.Logger fs *fakeboshsys.FakeFileSystem - mockRenderedJobList *mock_template.MockRenderedJobList + mockRenderedJobList *templatescompilerfakes.FakeRenderedJobList renderedJobListArchivePath string renderedJobListArchiveDigest string @@ -45,7 +34,7 @@ var _ = Describe("RenderedJobListArchive", func() { fs = fakeboshsys.NewFakeFileSystem() - mockRenderedJobList = mock_template.NewMockRenderedJobList(mockCtrl) + mockRenderedJobList = &templatescompilerfakes.FakeRenderedJobList{} renderedJobListArchivePath = "fake-archive-path" renderedJobListArchiveDigest = "fake-sha1" diff --git a/templatescompiler/rendered_job_list_compressor.go b/templatescompiler/rendered_job_list_compressor.go index dfae4c21e5..e4a4ec0877 100644 --- a/templatescompiler/rendered_job_list_compressor.go +++ b/templatescompiler/rendered_job_list_compressor.go @@ -11,6 +11,8 @@ import ( bicrypto "github.com/cloudfoundry/bosh-cli/v7/crypto" ) +//counterfeiter:generate . RenderedJobListCompressor + type RenderedJobListCompressor interface { Compress(RenderedJobList) (RenderedJobListArchive, error) } diff --git a/templatescompiler/templatescompilerfakes/fake_job_list_renderer.go b/templatescompiler/templatescompilerfakes/fake_job_list_renderer.go new file mode 100644 index 0000000000..f56d30361b --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_job_list_renderer.go @@ -0,0 +1,131 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" + "github.com/cloudfoundry/bosh-utils/property" +) + +type FakeJobListRenderer struct { + RenderStub func([]job.Job, map[string]*property.Map, property.Map, property.Map, string, string) (templatescompiler.RenderedJobList, error) + renderMutex sync.RWMutex + renderArgsForCall []struct { + arg1 []job.Job + arg2 map[string]*property.Map + arg3 property.Map + arg4 property.Map + arg5 string + arg6 string + } + renderReturns struct { + result1 templatescompiler.RenderedJobList + result2 error + } + renderReturnsOnCall map[int]struct { + result1 templatescompiler.RenderedJobList + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeJobListRenderer) Render(arg1 []job.Job, arg2 map[string]*property.Map, arg3 property.Map, arg4 property.Map, arg5 string, arg6 string) (templatescompiler.RenderedJobList, error) { + var arg1Copy []job.Job + if arg1 != nil { + arg1Copy = make([]job.Job, len(arg1)) + copy(arg1Copy, arg1) + } + fake.renderMutex.Lock() + ret, specificReturn := fake.renderReturnsOnCall[len(fake.renderArgsForCall)] + fake.renderArgsForCall = append(fake.renderArgsForCall, struct { + arg1 []job.Job + arg2 map[string]*property.Map + arg3 property.Map + arg4 property.Map + arg5 string + arg6 string + }{arg1Copy, arg2, arg3, arg4, arg5, arg6}) + stub := fake.RenderStub + fakeReturns := fake.renderReturns + fake.recordInvocation("Render", []interface{}{arg1Copy, arg2, arg3, arg4, arg5, arg6}) + fake.renderMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeJobListRenderer) RenderCallCount() int { + fake.renderMutex.RLock() + defer fake.renderMutex.RUnlock() + return len(fake.renderArgsForCall) +} + +func (fake *FakeJobListRenderer) RenderCalls(stub func([]job.Job, map[string]*property.Map, property.Map, property.Map, string, string) (templatescompiler.RenderedJobList, error)) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = stub +} + +func (fake *FakeJobListRenderer) RenderArgsForCall(i int) ([]job.Job, map[string]*property.Map, property.Map, property.Map, string, string) { + fake.renderMutex.RLock() + defer fake.renderMutex.RUnlock() + argsForCall := fake.renderArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *FakeJobListRenderer) RenderReturns(result1 templatescompiler.RenderedJobList, result2 error) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = nil + fake.renderReturns = struct { + result1 templatescompiler.RenderedJobList + result2 error + }{result1, result2} +} + +func (fake *FakeJobListRenderer) RenderReturnsOnCall(i int, result1 templatescompiler.RenderedJobList, result2 error) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = nil + if fake.renderReturnsOnCall == nil { + fake.renderReturnsOnCall = make(map[int]struct { + result1 templatescompiler.RenderedJobList + result2 error + }) + } + fake.renderReturnsOnCall[i] = struct { + result1 templatescompiler.RenderedJobList + result2 error + }{result1, result2} +} + +func (fake *FakeJobListRenderer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeJobListRenderer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.JobListRenderer = new(FakeJobListRenderer) diff --git a/templatescompiler/templatescompilerfakes/fake_job_renderer.go b/templatescompiler/templatescompilerfakes/fake_job_renderer.go new file mode 100644 index 0000000000..2cf3474b4d --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_job_renderer.go @@ -0,0 +1,126 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" + "github.com/cloudfoundry/bosh-utils/property" +) + +type FakeJobRenderer struct { + RenderStub func(job.Job, *property.Map, property.Map, property.Map, string, string) (templatescompiler.RenderedJob, error) + renderMutex sync.RWMutex + renderArgsForCall []struct { + arg1 job.Job + arg2 *property.Map + arg3 property.Map + arg4 property.Map + arg5 string + arg6 string + } + renderReturns struct { + result1 templatescompiler.RenderedJob + result2 error + } + renderReturnsOnCall map[int]struct { + result1 templatescompiler.RenderedJob + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeJobRenderer) Render(arg1 job.Job, arg2 *property.Map, arg3 property.Map, arg4 property.Map, arg5 string, arg6 string) (templatescompiler.RenderedJob, error) { + fake.renderMutex.Lock() + ret, specificReturn := fake.renderReturnsOnCall[len(fake.renderArgsForCall)] + fake.renderArgsForCall = append(fake.renderArgsForCall, struct { + arg1 job.Job + arg2 *property.Map + arg3 property.Map + arg4 property.Map + arg5 string + arg6 string + }{arg1, arg2, arg3, arg4, arg5, arg6}) + stub := fake.RenderStub + fakeReturns := fake.renderReturns + fake.recordInvocation("Render", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6}) + fake.renderMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4, arg5, arg6) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeJobRenderer) RenderCallCount() int { + fake.renderMutex.RLock() + defer fake.renderMutex.RUnlock() + return len(fake.renderArgsForCall) +} + +func (fake *FakeJobRenderer) RenderCalls(stub func(job.Job, *property.Map, property.Map, property.Map, string, string) (templatescompiler.RenderedJob, error)) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = stub +} + +func (fake *FakeJobRenderer) RenderArgsForCall(i int) (job.Job, *property.Map, property.Map, property.Map, string, string) { + fake.renderMutex.RLock() + defer fake.renderMutex.RUnlock() + argsForCall := fake.renderArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6 +} + +func (fake *FakeJobRenderer) RenderReturns(result1 templatescompiler.RenderedJob, result2 error) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = nil + fake.renderReturns = struct { + result1 templatescompiler.RenderedJob + result2 error + }{result1, result2} +} + +func (fake *FakeJobRenderer) RenderReturnsOnCall(i int, result1 templatescompiler.RenderedJob, result2 error) { + fake.renderMutex.Lock() + defer fake.renderMutex.Unlock() + fake.RenderStub = nil + if fake.renderReturnsOnCall == nil { + fake.renderReturnsOnCall = make(map[int]struct { + result1 templatescompiler.RenderedJob + result2 error + }) + } + fake.renderReturnsOnCall[i] = struct { + result1 templatescompiler.RenderedJob + result2 error + }{result1, result2} +} + +func (fake *FakeJobRenderer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeJobRenderer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.JobRenderer = new(FakeJobRenderer) diff --git a/templatescompiler/templatescompilerfakes/fake_rendered_job.go b/templatescompiler/templatescompilerfakes/fake_rendered_job.go new file mode 100644 index 0000000000..3bec25d3bd --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_rendered_job.go @@ -0,0 +1,255 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release/job" + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" +) + +type FakeRenderedJob struct { + DeleteStub func() error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteSilentlyStub func() + deleteSilentlyMutex sync.RWMutex + deleteSilentlyArgsForCall []struct { + } + JobStub func() job.Job + jobMutex sync.RWMutex + jobArgsForCall []struct { + } + jobReturns struct { + result1 job.Job + } + jobReturnsOnCall map[int]struct { + result1 job.Job + } + PathStub func() string + pathMutex sync.RWMutex + pathArgsForCall []struct { + } + pathReturns struct { + result1 string + } + pathReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeRenderedJob) Delete() error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + }{}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJob) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeRenderedJob) DeleteCalls(stub func() error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeRenderedJob) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJob) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJob) DeleteSilently() { + fake.deleteSilentlyMutex.Lock() + fake.deleteSilentlyArgsForCall = append(fake.deleteSilentlyArgsForCall, struct { + }{}) + stub := fake.DeleteSilentlyStub + fake.recordInvocation("DeleteSilently", []interface{}{}) + fake.deleteSilentlyMutex.Unlock() + if stub != nil { + fake.DeleteSilentlyStub() + } +} + +func (fake *FakeRenderedJob) DeleteSilentlyCallCount() int { + fake.deleteSilentlyMutex.RLock() + defer fake.deleteSilentlyMutex.RUnlock() + return len(fake.deleteSilentlyArgsForCall) +} + +func (fake *FakeRenderedJob) DeleteSilentlyCalls(stub func()) { + fake.deleteSilentlyMutex.Lock() + defer fake.deleteSilentlyMutex.Unlock() + fake.DeleteSilentlyStub = stub +} + +func (fake *FakeRenderedJob) Job() job.Job { + fake.jobMutex.Lock() + ret, specificReturn := fake.jobReturnsOnCall[len(fake.jobArgsForCall)] + fake.jobArgsForCall = append(fake.jobArgsForCall, struct { + }{}) + stub := fake.JobStub + fakeReturns := fake.jobReturns + fake.recordInvocation("Job", []interface{}{}) + fake.jobMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJob) JobCallCount() int { + fake.jobMutex.RLock() + defer fake.jobMutex.RUnlock() + return len(fake.jobArgsForCall) +} + +func (fake *FakeRenderedJob) JobCalls(stub func() job.Job) { + fake.jobMutex.Lock() + defer fake.jobMutex.Unlock() + fake.JobStub = stub +} + +func (fake *FakeRenderedJob) JobReturns(result1 job.Job) { + fake.jobMutex.Lock() + defer fake.jobMutex.Unlock() + fake.JobStub = nil + fake.jobReturns = struct { + result1 job.Job + }{result1} +} + +func (fake *FakeRenderedJob) JobReturnsOnCall(i int, result1 job.Job) { + fake.jobMutex.Lock() + defer fake.jobMutex.Unlock() + fake.JobStub = nil + if fake.jobReturnsOnCall == nil { + fake.jobReturnsOnCall = make(map[int]struct { + result1 job.Job + }) + } + fake.jobReturnsOnCall[i] = struct { + result1 job.Job + }{result1} +} + +func (fake *FakeRenderedJob) Path() string { + fake.pathMutex.Lock() + ret, specificReturn := fake.pathReturnsOnCall[len(fake.pathArgsForCall)] + fake.pathArgsForCall = append(fake.pathArgsForCall, struct { + }{}) + stub := fake.PathStub + fakeReturns := fake.pathReturns + fake.recordInvocation("Path", []interface{}{}) + fake.pathMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJob) PathCallCount() int { + fake.pathMutex.RLock() + defer fake.pathMutex.RUnlock() + return len(fake.pathArgsForCall) +} + +func (fake *FakeRenderedJob) PathCalls(stub func() string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = stub +} + +func (fake *FakeRenderedJob) PathReturns(result1 string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = nil + fake.pathReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJob) PathReturnsOnCall(i int, result1 string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = nil + if fake.pathReturnsOnCall == nil { + fake.pathReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.pathReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJob) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeRenderedJob) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.RenderedJob = new(FakeRenderedJob) diff --git a/templatescompiler/templatescompilerfakes/fake_rendered_job_list.go b/templatescompiler/templatescompilerfakes/fake_rendered_job_list.go new file mode 100644 index 0000000000..445a047093 --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_rendered_job_list.go @@ -0,0 +1,228 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" +) + +type FakeRenderedJobList struct { + AddStub func(templatescompiler.RenderedJob) + addMutex sync.RWMutex + addArgsForCall []struct { + arg1 templatescompiler.RenderedJob + } + AllStub func() []templatescompiler.RenderedJob + allMutex sync.RWMutex + allArgsForCall []struct { + } + allReturns struct { + result1 []templatescompiler.RenderedJob + } + allReturnsOnCall map[int]struct { + result1 []templatescompiler.RenderedJob + } + DeleteStub func() error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteSilentlyStub func() + deleteSilentlyMutex sync.RWMutex + deleteSilentlyArgsForCall []struct { + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeRenderedJobList) Add(arg1 templatescompiler.RenderedJob) { + fake.addMutex.Lock() + fake.addArgsForCall = append(fake.addArgsForCall, struct { + arg1 templatescompiler.RenderedJob + }{arg1}) + stub := fake.AddStub + fake.recordInvocation("Add", []interface{}{arg1}) + fake.addMutex.Unlock() + if stub != nil { + fake.AddStub(arg1) + } +} + +func (fake *FakeRenderedJobList) AddCallCount() int { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + return len(fake.addArgsForCall) +} + +func (fake *FakeRenderedJobList) AddCalls(stub func(templatescompiler.RenderedJob)) { + fake.addMutex.Lock() + defer fake.addMutex.Unlock() + fake.AddStub = stub +} + +func (fake *FakeRenderedJobList) AddArgsForCall(i int) templatescompiler.RenderedJob { + fake.addMutex.RLock() + defer fake.addMutex.RUnlock() + argsForCall := fake.addArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeRenderedJobList) All() []templatescompiler.RenderedJob { + fake.allMutex.Lock() + ret, specificReturn := fake.allReturnsOnCall[len(fake.allArgsForCall)] + fake.allArgsForCall = append(fake.allArgsForCall, struct { + }{}) + stub := fake.AllStub + fakeReturns := fake.allReturns + fake.recordInvocation("All", []interface{}{}) + fake.allMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobList) AllCallCount() int { + fake.allMutex.RLock() + defer fake.allMutex.RUnlock() + return len(fake.allArgsForCall) +} + +func (fake *FakeRenderedJobList) AllCalls(stub func() []templatescompiler.RenderedJob) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = stub +} + +func (fake *FakeRenderedJobList) AllReturns(result1 []templatescompiler.RenderedJob) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + fake.allReturns = struct { + result1 []templatescompiler.RenderedJob + }{result1} +} + +func (fake *FakeRenderedJobList) AllReturnsOnCall(i int, result1 []templatescompiler.RenderedJob) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + if fake.allReturnsOnCall == nil { + fake.allReturnsOnCall = make(map[int]struct { + result1 []templatescompiler.RenderedJob + }) + } + fake.allReturnsOnCall[i] = struct { + result1 []templatescompiler.RenderedJob + }{result1} +} + +func (fake *FakeRenderedJobList) Delete() error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + }{}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobList) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeRenderedJobList) DeleteCalls(stub func() error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeRenderedJobList) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJobList) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJobList) DeleteSilently() { + fake.deleteSilentlyMutex.Lock() + fake.deleteSilentlyArgsForCall = append(fake.deleteSilentlyArgsForCall, struct { + }{}) + stub := fake.DeleteSilentlyStub + fake.recordInvocation("DeleteSilently", []interface{}{}) + fake.deleteSilentlyMutex.Unlock() + if stub != nil { + fake.DeleteSilentlyStub() + } +} + +func (fake *FakeRenderedJobList) DeleteSilentlyCallCount() int { + fake.deleteSilentlyMutex.RLock() + defer fake.deleteSilentlyMutex.RUnlock() + return len(fake.deleteSilentlyArgsForCall) +} + +func (fake *FakeRenderedJobList) DeleteSilentlyCalls(stub func()) { + fake.deleteSilentlyMutex.Lock() + defer fake.deleteSilentlyMutex.Unlock() + fake.DeleteSilentlyStub = stub +} + +func (fake *FakeRenderedJobList) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeRenderedJobList) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.RenderedJobList = new(FakeRenderedJobList) diff --git a/templatescompiler/templatescompilerfakes/fake_rendered_job_list_archive.go b/templatescompiler/templatescompilerfakes/fake_rendered_job_list_archive.go new file mode 100644 index 0000000000..0a2def3d6c --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_rendered_job_list_archive.go @@ -0,0 +1,317 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" +) + +type FakeRenderedJobListArchive struct { + DeleteStub func() error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DeleteSilentlyStub func() + deleteSilentlyMutex sync.RWMutex + deleteSilentlyArgsForCall []struct { + } + ListStub func() templatescompiler.RenderedJobList + listMutex sync.RWMutex + listArgsForCall []struct { + } + listReturns struct { + result1 templatescompiler.RenderedJobList + } + listReturnsOnCall map[int]struct { + result1 templatescompiler.RenderedJobList + } + PathStub func() string + pathMutex sync.RWMutex + pathArgsForCall []struct { + } + pathReturns struct { + result1 string + } + pathReturnsOnCall map[int]struct { + result1 string + } + SHA1Stub func() string + sHA1Mutex sync.RWMutex + sHA1ArgsForCall []struct { + } + sHA1Returns struct { + result1 string + } + sHA1ReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeRenderedJobListArchive) Delete() error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + }{}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobListArchive) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeRenderedJobListArchive) DeleteCalls(stub func() error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeRenderedJobListArchive) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJobListArchive) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeRenderedJobListArchive) DeleteSilently() { + fake.deleteSilentlyMutex.Lock() + fake.deleteSilentlyArgsForCall = append(fake.deleteSilentlyArgsForCall, struct { + }{}) + stub := fake.DeleteSilentlyStub + fake.recordInvocation("DeleteSilently", []interface{}{}) + fake.deleteSilentlyMutex.Unlock() + if stub != nil { + fake.DeleteSilentlyStub() + } +} + +func (fake *FakeRenderedJobListArchive) DeleteSilentlyCallCount() int { + fake.deleteSilentlyMutex.RLock() + defer fake.deleteSilentlyMutex.RUnlock() + return len(fake.deleteSilentlyArgsForCall) +} + +func (fake *FakeRenderedJobListArchive) DeleteSilentlyCalls(stub func()) { + fake.deleteSilentlyMutex.Lock() + defer fake.deleteSilentlyMutex.Unlock() + fake.DeleteSilentlyStub = stub +} + +func (fake *FakeRenderedJobListArchive) List() templatescompiler.RenderedJobList { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + }{}) + stub := fake.ListStub + fakeReturns := fake.listReturns + fake.recordInvocation("List", []interface{}{}) + fake.listMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobListArchive) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeRenderedJobListArchive) ListCalls(stub func() templatescompiler.RenderedJobList) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeRenderedJobListArchive) ListReturns(result1 templatescompiler.RenderedJobList) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 templatescompiler.RenderedJobList + }{result1} +} + +func (fake *FakeRenderedJobListArchive) ListReturnsOnCall(i int, result1 templatescompiler.RenderedJobList) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 templatescompiler.RenderedJobList + }) + } + fake.listReturnsOnCall[i] = struct { + result1 templatescompiler.RenderedJobList + }{result1} +} + +func (fake *FakeRenderedJobListArchive) Path() string { + fake.pathMutex.Lock() + ret, specificReturn := fake.pathReturnsOnCall[len(fake.pathArgsForCall)] + fake.pathArgsForCall = append(fake.pathArgsForCall, struct { + }{}) + stub := fake.PathStub + fakeReturns := fake.pathReturns + fake.recordInvocation("Path", []interface{}{}) + fake.pathMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobListArchive) PathCallCount() int { + fake.pathMutex.RLock() + defer fake.pathMutex.RUnlock() + return len(fake.pathArgsForCall) +} + +func (fake *FakeRenderedJobListArchive) PathCalls(stub func() string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = stub +} + +func (fake *FakeRenderedJobListArchive) PathReturns(result1 string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = nil + fake.pathReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJobListArchive) PathReturnsOnCall(i int, result1 string) { + fake.pathMutex.Lock() + defer fake.pathMutex.Unlock() + fake.PathStub = nil + if fake.pathReturnsOnCall == nil { + fake.pathReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.pathReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJobListArchive) SHA1() string { + fake.sHA1Mutex.Lock() + ret, specificReturn := fake.sHA1ReturnsOnCall[len(fake.sHA1ArgsForCall)] + fake.sHA1ArgsForCall = append(fake.sHA1ArgsForCall, struct { + }{}) + stub := fake.SHA1Stub + fakeReturns := fake.sHA1Returns + fake.recordInvocation("SHA1", []interface{}{}) + fake.sHA1Mutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeRenderedJobListArchive) SHA1CallCount() int { + fake.sHA1Mutex.RLock() + defer fake.sHA1Mutex.RUnlock() + return len(fake.sHA1ArgsForCall) +} + +func (fake *FakeRenderedJobListArchive) SHA1Calls(stub func() string) { + fake.sHA1Mutex.Lock() + defer fake.sHA1Mutex.Unlock() + fake.SHA1Stub = stub +} + +func (fake *FakeRenderedJobListArchive) SHA1Returns(result1 string) { + fake.sHA1Mutex.Lock() + defer fake.sHA1Mutex.Unlock() + fake.SHA1Stub = nil + fake.sHA1Returns = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJobListArchive) SHA1ReturnsOnCall(i int, result1 string) { + fake.sHA1Mutex.Lock() + defer fake.sHA1Mutex.Unlock() + fake.SHA1Stub = nil + if fake.sHA1ReturnsOnCall == nil { + fake.sHA1ReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.sHA1ReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeRenderedJobListArchive) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeRenderedJobListArchive) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.RenderedJobListArchive = new(FakeRenderedJobListArchive) diff --git a/templatescompiler/templatescompilerfakes/fake_rendered_job_list_compressor.go b/templatescompiler/templatescompilerfakes/fake_rendered_job_list_compressor.go new file mode 100644 index 0000000000..cc30919c9e --- /dev/null +++ b/templatescompiler/templatescompilerfakes/fake_rendered_job_list_compressor.go @@ -0,0 +1,114 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package templatescompilerfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" +) + +type FakeRenderedJobListCompressor struct { + CompressStub func(templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error) + compressMutex sync.RWMutex + compressArgsForCall []struct { + arg1 templatescompiler.RenderedJobList + } + compressReturns struct { + result1 templatescompiler.RenderedJobListArchive + result2 error + } + compressReturnsOnCall map[int]struct { + result1 templatescompiler.RenderedJobListArchive + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeRenderedJobListCompressor) Compress(arg1 templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error) { + fake.compressMutex.Lock() + ret, specificReturn := fake.compressReturnsOnCall[len(fake.compressArgsForCall)] + fake.compressArgsForCall = append(fake.compressArgsForCall, struct { + arg1 templatescompiler.RenderedJobList + }{arg1}) + stub := fake.CompressStub + fakeReturns := fake.compressReturns + fake.recordInvocation("Compress", []interface{}{arg1}) + fake.compressMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeRenderedJobListCompressor) CompressCallCount() int { + fake.compressMutex.RLock() + defer fake.compressMutex.RUnlock() + return len(fake.compressArgsForCall) +} + +func (fake *FakeRenderedJobListCompressor) CompressCalls(stub func(templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error)) { + fake.compressMutex.Lock() + defer fake.compressMutex.Unlock() + fake.CompressStub = stub +} + +func (fake *FakeRenderedJobListCompressor) CompressArgsForCall(i int) templatescompiler.RenderedJobList { + fake.compressMutex.RLock() + defer fake.compressMutex.RUnlock() + argsForCall := fake.compressArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeRenderedJobListCompressor) CompressReturns(result1 templatescompiler.RenderedJobListArchive, result2 error) { + fake.compressMutex.Lock() + defer fake.compressMutex.Unlock() + fake.CompressStub = nil + fake.compressReturns = struct { + result1 templatescompiler.RenderedJobListArchive + result2 error + }{result1, result2} +} + +func (fake *FakeRenderedJobListCompressor) CompressReturnsOnCall(i int, result1 templatescompiler.RenderedJobListArchive, result2 error) { + fake.compressMutex.Lock() + defer fake.compressMutex.Unlock() + fake.CompressStub = nil + if fake.compressReturnsOnCall == nil { + fake.compressReturnsOnCall = make(map[int]struct { + result1 templatescompiler.RenderedJobListArchive + result2 error + }) + } + fake.compressReturnsOnCall[i] = struct { + result1 templatescompiler.RenderedJobListArchive + result2 error + }{result1, result2} +} + +func (fake *FakeRenderedJobListCompressor) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeRenderedJobListCompressor) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ templatescompiler.RenderedJobListCompressor = new(FakeRenderedJobListCompressor) diff --git a/test_support/mocks/mocks.go b/test_support/mocks/mocks.go deleted file mode 100644 index 243cb41a5e..0000000000 --- a/test_support/mocks/mocks.go +++ /dev/null @@ -1,46 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: github.com/cloudfoundry/bosh-cli/v7/test_support (interfaces: Spy) - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - gomock "github.com/golang/mock/gomock" -) - -// MockSpy is a mock of Spy interface. -type MockSpy struct { - ctrl *gomock.Controller - recorder *MockSpyMockRecorder -} - -// MockSpyMockRecorder is the mock recorder for MockSpy. -type MockSpyMockRecorder struct { - mock *MockSpy -} - -// NewMockSpy creates a new mock instance. -func NewMockSpy(ctrl *gomock.Controller) *MockSpy { - mock := &MockSpy{ctrl: ctrl} - mock.recorder = &MockSpyMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockSpy) EXPECT() *MockSpyMockRecorder { - return m.recorder -} - -// Record mocks base method. -func (m *MockSpy) Record() { - m.ctrl.T.Helper() - m.ctrl.Call(m, "Record") -} - -// Record indicates an expected call of Record. -func (mr *MockSpyMockRecorder) Record() *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Record", reflect.TypeOf((*MockSpy)(nil).Record)) -} diff --git a/testutils/mocks/mocks.go b/testutils/mocks/mocks.go deleted file mode 100644 index 440385a510..0000000000 --- a/testutils/mocks/mocks.go +++ /dev/null @@ -1,37 +0,0 @@ -// Automatically generated by MockGen. DO NOT EDIT! -// Source: github.com/cloudfoundry/bosh-cli/v7/test_support (interfaces: Spy) - -package mocks - -import ( - gomock "github.com/golang/mock/gomock" -) - -// Mock of Spy interface -type MockSpy struct { - ctrl *gomock.Controller - recorder *_MockSpyRecorder -} - -// Recorder for MockSpy (not exported) -type _MockSpyRecorder struct { - mock *MockSpy -} - -func NewMockSpy(ctrl *gomock.Controller) *MockSpy { - mock := &MockSpy{ctrl: ctrl} - mock.recorder = &_MockSpyRecorder{mock} - return mock -} - -func (_m *MockSpy) EXPECT() *_MockSpyRecorder { - return _m.recorder -} - -func (_m *MockSpy) Record() { - _m.ctrl.Call(_m, "Record") -} - -func (_mr *_MockSpyRecorder) Record() *gomock.Call { - return _mr.mock.ctrl.RecordCall(_mr.mock, "Record") -} diff --git a/tools/tools.go b/tools/tools.go index 5115e81b39..404adc0979 100644 --- a/tools/tools.go +++ b/tools/tools.go @@ -4,7 +4,6 @@ package tools import ( - _ "github.com/golang/mock/mockgen/model" _ "github.com/maxbrunsfeld/counterfeiter/v6" _ "github.com/onsi/ginkgo/v2/ginkgo" _ "golang.org/x/tools/cmd/goimports" diff --git a/vendor/github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks/mocks.go b/vendor/github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks/mocks.go deleted file mode 100644 index eb90a63231..0000000000 --- a/vendor/github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks/mocks.go +++ /dev/null @@ -1,50 +0,0 @@ -// Code generated by MockGen. DO NOT EDIT. -// Source: agent_client_factory.go - -// Package mocks is a generated GoMock package. -package mocks - -import ( - reflect "reflect" - - agentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - gomock "github.com/golang/mock/gomock" -) - -// MockAgentClientFactory is a mock of AgentClientFactory interface. -type MockAgentClientFactory struct { - ctrl *gomock.Controller - recorder *MockAgentClientFactoryMockRecorder -} - -// MockAgentClientFactoryMockRecorder is the mock recorder for MockAgentClientFactory. -type MockAgentClientFactoryMockRecorder struct { - mock *MockAgentClientFactory -} - -// NewMockAgentClientFactory creates a new mock instance. -func NewMockAgentClientFactory(ctrl *gomock.Controller) *MockAgentClientFactory { - mock := &MockAgentClientFactory{ctrl: ctrl} - mock.recorder = &MockAgentClientFactoryMockRecorder{mock} - return mock -} - -// EXPECT returns an object that allows the caller to indicate expected use. -func (m *MockAgentClientFactory) EXPECT() *MockAgentClientFactoryMockRecorder { - return m.recorder -} - -// NewAgentClient mocks base method. -func (m *MockAgentClientFactory) NewAgentClient(directorID, mbusURL, caCert string) (agentclient.AgentClient, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "NewAgentClient", directorID, mbusURL, caCert) - ret0, _ := ret[0].(agentclient.AgentClient) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// NewAgentClient indicates an expected call of NewAgentClient. -func (mr *MockAgentClientFactoryMockRecorder) NewAgentClient(directorID, mbusURL, caCert interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAgentClient", reflect.TypeOf((*MockAgentClientFactory)(nil).NewAgentClient), directorID, mbusURL, caCert) -} diff --git a/vendor/github.com/golang/mock/AUTHORS b/vendor/github.com/golang/mock/AUTHORS deleted file mode 100644 index 660b8ccc8a..0000000000 --- a/vendor/github.com/golang/mock/AUTHORS +++ /dev/null @@ -1,12 +0,0 @@ -# This is the official list of GoMock authors for copyright purposes. -# This file is distinct from the CONTRIBUTORS files. -# See the latter for an explanation. - -# Names should be added to this file as -# Name or Organization -# The email address is not required for organizations. - -# Please keep the list sorted. - -Alex Reece -Google Inc. diff --git a/vendor/github.com/golang/mock/CONTRIBUTORS b/vendor/github.com/golang/mock/CONTRIBUTORS deleted file mode 100644 index def849cab1..0000000000 --- a/vendor/github.com/golang/mock/CONTRIBUTORS +++ /dev/null @@ -1,37 +0,0 @@ -# This is the official list of people who can contribute (and typically -# have contributed) code to the gomock repository. -# The AUTHORS file lists the copyright holders; this file -# lists people. For example, Google employees are listed here -# but not in AUTHORS, because Google holds the copyright. -# -# The submission process automatically checks to make sure -# that people submitting code are listed in this file (by email address). -# -# Names should be added to this file only after verifying that -# the individual or the individual's organization has agreed to -# the appropriate Contributor License Agreement, found here: -# -# http://code.google.com/legal/individual-cla-v1.0.html -# http://code.google.com/legal/corporate-cla-v1.0.html -# -# The agreement for individuals can be filled out on the web. -# -# When adding J Random Contributor's name to this file, -# either J's name or J's organization's name should be -# added to the AUTHORS file, depending on whether the -# individual or corporate CLA was used. - -# Names should be added to this file like so: -# Name -# -# An entry with two email addresses specifies that the -# first address should be used in the submit logs and -# that the second address should be recognized as the -# same person when interacting with Rietveld. - -# Please keep the list sorted. - -Aaron Jacobs -Alex Reece -David Symonds -Ryan Barrett diff --git a/vendor/github.com/golang/mock/LICENSE b/vendor/github.com/golang/mock/LICENSE deleted file mode 100644 index d645695673..0000000000 --- a/vendor/github.com/golang/mock/LICENSE +++ /dev/null @@ -1,202 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright [yyyy] [name of copyright owner] - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/vendor/github.com/golang/mock/gomock/call.go b/vendor/github.com/golang/mock/gomock/call.go deleted file mode 100644 index 13c9f44b1e..0000000000 --- a/vendor/github.com/golang/mock/gomock/call.go +++ /dev/null @@ -1,445 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -import ( - "fmt" - "reflect" - "strconv" - "strings" -) - -// Call represents an expected call to a mock. -type Call struct { - t TestHelper // for triggering test failures on invalid call setup - - receiver interface{} // the receiver of the method call - method string // the name of the method - methodType reflect.Type // the type of the method - args []Matcher // the args - origin string // file and line number of call setup - - preReqs []*Call // prerequisite calls - - // Expectations - minCalls, maxCalls int - - numCalls int // actual number made - - // actions are called when this Call is called. Each action gets the args and - // can set the return values by returning a non-nil slice. Actions run in the - // order they are created. - actions []func([]interface{}) []interface{} -} - -// newCall creates a *Call. It requires the method type in order to support -// unexported methods. -func newCall(t TestHelper, receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call { - t.Helper() - - // TODO: check arity, types. - mArgs := make([]Matcher, len(args)) - for i, arg := range args { - if m, ok := arg.(Matcher); ok { - mArgs[i] = m - } else if arg == nil { - // Handle nil specially so that passing a nil interface value - // will match the typed nils of concrete args. - mArgs[i] = Nil() - } else { - mArgs[i] = Eq(arg) - } - } - - // callerInfo's skip should be updated if the number of calls between the user's test - // and this line changes, i.e. this code is wrapped in another anonymous function. - // 0 is us, 1 is RecordCallWithMethodType(), 2 is the generated recorder, and 3 is the user's test. - origin := callerInfo(3) - actions := []func([]interface{}) []interface{}{func([]interface{}) []interface{} { - // Synthesize the zero value for each of the return args' types. - rets := make([]interface{}, methodType.NumOut()) - for i := 0; i < methodType.NumOut(); i++ { - rets[i] = reflect.Zero(methodType.Out(i)).Interface() - } - return rets - }} - return &Call{t: t, receiver: receiver, method: method, methodType: methodType, - args: mArgs, origin: origin, minCalls: 1, maxCalls: 1, actions: actions} -} - -// AnyTimes allows the expectation to be called 0 or more times -func (c *Call) AnyTimes() *Call { - c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity - return c -} - -// MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called or if MaxTimes -// was previously called with 1, MinTimes also sets the maximum number of calls to infinity. -func (c *Call) MinTimes(n int) *Call { - c.minCalls = n - if c.maxCalls == 1 { - c.maxCalls = 1e8 - } - return c -} - -// MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called or if MinTimes was -// previously called with 1, MaxTimes also sets the minimum number of calls to 0. -func (c *Call) MaxTimes(n int) *Call { - c.maxCalls = n - if c.minCalls == 1 { - c.minCalls = 0 - } - return c -} - -// DoAndReturn declares the action to run when the call is matched. -// The return values from this function are returned by the mocked function. -// It takes an interface{} argument to support n-arity functions. -func (c *Call) DoAndReturn(f interface{}) *Call { - // TODO: Check arity and types here, rather than dying badly elsewhere. - v := reflect.ValueOf(f) - - c.addAction(func(args []interface{}) []interface{} { - c.t.Helper() - vArgs := make([]reflect.Value, len(args)) - ft := v.Type() - if c.methodType.NumIn() != ft.NumIn() { - c.t.Fatalf("wrong number of arguments in DoAndReturn func for %T.%v: got %d, want %d [%s]", - c.receiver, c.method, ft.NumIn(), c.methodType.NumIn(), c.origin) - return nil - } - for i := 0; i < len(args); i++ { - if args[i] != nil { - vArgs[i] = reflect.ValueOf(args[i]) - } else { - // Use the zero value for the arg. - vArgs[i] = reflect.Zero(ft.In(i)) - } - } - vRets := v.Call(vArgs) - rets := make([]interface{}, len(vRets)) - for i, ret := range vRets { - rets[i] = ret.Interface() - } - return rets - }) - return c -} - -// Do declares the action to run when the call is matched. The function's -// return values are ignored to retain backward compatibility. To use the -// return values call DoAndReturn. -// It takes an interface{} argument to support n-arity functions. -func (c *Call) Do(f interface{}) *Call { - // TODO: Check arity and types here, rather than dying badly elsewhere. - v := reflect.ValueOf(f) - - c.addAction(func(args []interface{}) []interface{} { - c.t.Helper() - if c.methodType.NumIn() != v.Type().NumIn() { - c.t.Fatalf("wrong number of arguments in Do func for %T.%v: got %d, want %d [%s]", - c.receiver, c.method, v.Type().NumIn(), c.methodType.NumIn(), c.origin) - return nil - } - vArgs := make([]reflect.Value, len(args)) - ft := v.Type() - for i := 0; i < len(args); i++ { - if args[i] != nil { - vArgs[i] = reflect.ValueOf(args[i]) - } else { - // Use the zero value for the arg. - vArgs[i] = reflect.Zero(ft.In(i)) - } - } - v.Call(vArgs) - return nil - }) - return c -} - -// Return declares the values to be returned by the mocked function call. -func (c *Call) Return(rets ...interface{}) *Call { - c.t.Helper() - - mt := c.methodType - if len(rets) != mt.NumOut() { - c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d [%s]", - c.receiver, c.method, len(rets), mt.NumOut(), c.origin) - } - for i, ret := range rets { - if got, want := reflect.TypeOf(ret), mt.Out(i); got == want { - // Identical types; nothing to do. - } else if got == nil { - // Nil needs special handling. - switch want.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: - // ok - default: - c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable [%s]", - i, c.receiver, c.method, want, c.origin) - } - } else if got.AssignableTo(want) { - // Assignable type relation. Make the assignment now so that the generated code - // can return the values with a type assertion. - v := reflect.New(want).Elem() - v.Set(reflect.ValueOf(ret)) - rets[i] = v.Interface() - } else { - c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v [%s]", - i, c.receiver, c.method, got, want, c.origin) - } - } - - c.addAction(func([]interface{}) []interface{} { - return rets - }) - - return c -} - -// Times declares the exact number of times a function call is expected to be executed. -func (c *Call) Times(n int) *Call { - c.minCalls, c.maxCalls = n, n - return c -} - -// SetArg declares an action that will set the nth argument's value, -// indirected through a pointer. Or, in the case of a slice, SetArg -// will copy value's elements into the nth argument. -func (c *Call) SetArg(n int, value interface{}) *Call { - c.t.Helper() - - mt := c.methodType - // TODO: This will break on variadic methods. - // We will need to check those at invocation time. - if n < 0 || n >= mt.NumIn() { - c.t.Fatalf("SetArg(%d, ...) called for a method with %d args [%s]", - n, mt.NumIn(), c.origin) - } - // Permit setting argument through an interface. - // In the interface case, we don't (nay, can't) check the type here. - at := mt.In(n) - switch at.Kind() { - case reflect.Ptr: - dt := at.Elem() - if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) { - c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v [%s]", - n, vt, dt, c.origin) - } - case reflect.Interface: - // nothing to do - case reflect.Slice: - // nothing to do - default: - c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface non-slice type %v [%s]", - n, at, c.origin) - } - - c.addAction(func(args []interface{}) []interface{} { - v := reflect.ValueOf(value) - switch reflect.TypeOf(args[n]).Kind() { - case reflect.Slice: - setSlice(args[n], v) - default: - reflect.ValueOf(args[n]).Elem().Set(v) - } - return nil - }) - return c -} - -// isPreReq returns true if other is a direct or indirect prerequisite to c. -func (c *Call) isPreReq(other *Call) bool { - for _, preReq := range c.preReqs { - if other == preReq || preReq.isPreReq(other) { - return true - } - } - return false -} - -// After declares that the call may only match after preReq has been exhausted. -func (c *Call) After(preReq *Call) *Call { - c.t.Helper() - - if c == preReq { - c.t.Fatalf("A call isn't allowed to be its own prerequisite") - } - if preReq.isPreReq(c) { - c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq) - } - - c.preReqs = append(c.preReqs, preReq) - return c -} - -// Returns true if the minimum number of calls have been made. -func (c *Call) satisfied() bool { - return c.numCalls >= c.minCalls -} - -// Returns true if the maximum number of calls have been made. -func (c *Call) exhausted() bool { - return c.numCalls >= c.maxCalls -} - -func (c *Call) String() string { - args := make([]string, len(c.args)) - for i, arg := range c.args { - args[i] = arg.String() - } - arguments := strings.Join(args, ", ") - return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin) -} - -// Tests if the given call matches the expected call. -// If yes, returns nil. If no, returns error with message explaining why it does not match. -func (c *Call) matches(args []interface{}) error { - if !c.methodType.IsVariadic() { - if len(args) != len(c.args) { - return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d", - c.origin, len(args), len(c.args)) - } - - for i, m := range c.args { - if !m.Matches(args[i]) { - return fmt.Errorf( - "expected call at %s doesn't match the argument at index %d.\nGot: %v\nWant: %v", - c.origin, i, formatGottenArg(m, args[i]), m, - ) - } - } - } else { - if len(c.args) < c.methodType.NumIn()-1 { - return fmt.Errorf("expected call at %s has the wrong number of matchers. Got: %d, want: %d", - c.origin, len(c.args), c.methodType.NumIn()-1) - } - if len(c.args) != c.methodType.NumIn() && len(args) != len(c.args) { - return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d", - c.origin, len(args), len(c.args)) - } - if len(args) < len(c.args)-1 { - return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d", - c.origin, len(args), len(c.args)-1) - } - - for i, m := range c.args { - if i < c.methodType.NumIn()-1 { - // Non-variadic args - if !m.Matches(args[i]) { - return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v", - c.origin, strconv.Itoa(i), formatGottenArg(m, args[i]), m) - } - continue - } - // The last arg has a possibility of a variadic argument, so let it branch - - // sample: Foo(a int, b int, c ...int) - if i < len(c.args) && i < len(args) { - if m.Matches(args[i]) { - // Got Foo(a, b, c) want Foo(matcherA, matcherB, gomock.Any()) - // Got Foo(a, b, c) want Foo(matcherA, matcherB, someSliceMatcher) - // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC) - // Got Foo(a, b) want Foo(matcherA, matcherB) - // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD) - continue - } - } - - // The number of actual args don't match the number of matchers, - // or the last matcher is a slice and the last arg is not. - // If this function still matches it is because the last matcher - // matches all the remaining arguments or the lack of any. - // Convert the remaining arguments, if any, into a slice of the - // expected type. - vArgsType := c.methodType.In(c.methodType.NumIn() - 1) - vArgs := reflect.MakeSlice(vArgsType, 0, len(args)-i) - for _, arg := range args[i:] { - vArgs = reflect.Append(vArgs, reflect.ValueOf(arg)) - } - if m.Matches(vArgs.Interface()) { - // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, gomock.Any()) - // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, someSliceMatcher) - // Got Foo(a, b) want Foo(matcherA, matcherB, gomock.Any()) - // Got Foo(a, b) want Foo(matcherA, matcherB, someEmptySliceMatcher) - break - } - // Wrong number of matchers or not match. Fail. - // Got Foo(a, b) want Foo(matcherA, matcherB, matcherC, matcherD) - // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC, matcherD) - // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD, matcherE) - // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, matcherC, matcherD) - // Got Foo(a, b, c) want Foo(matcherA, matcherB) - - return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v", - c.origin, strconv.Itoa(i), formatGottenArg(m, args[i:]), c.args[i]) - } - } - - // Check that all prerequisite calls have been satisfied. - for _, preReqCall := range c.preReqs { - if !preReqCall.satisfied() { - return fmt.Errorf("expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v", - c.origin, preReqCall, c) - } - } - - // Check that the call is not exhausted. - if c.exhausted() { - return fmt.Errorf("expected call at %s has already been called the max number of times", c.origin) - } - - return nil -} - -// dropPrereqs tells the expected Call to not re-check prerequisite calls any -// longer, and to return its current set. -func (c *Call) dropPrereqs() (preReqs []*Call) { - preReqs = c.preReqs - c.preReqs = nil - return -} - -func (c *Call) call() []func([]interface{}) []interface{} { - c.numCalls++ - return c.actions -} - -// InOrder declares that the given calls should occur in order. -func InOrder(calls ...*Call) { - for i := 1; i < len(calls); i++ { - calls[i].After(calls[i-1]) - } -} - -func setSlice(arg interface{}, v reflect.Value) { - va := reflect.ValueOf(arg) - for i := 0; i < v.Len(); i++ { - va.Index(i).Set(v.Index(i)) - } -} - -func (c *Call) addAction(action func([]interface{}) []interface{}) { - c.actions = append(c.actions, action) -} - -func formatGottenArg(m Matcher, arg interface{}) string { - got := fmt.Sprintf("%v (%T)", arg, arg) - if gs, ok := m.(GotFormatter); ok { - got = gs.Got(arg) - } - return got -} diff --git a/vendor/github.com/golang/mock/gomock/callset.go b/vendor/github.com/golang/mock/gomock/callset.go deleted file mode 100644 index 49dba787a4..0000000000 --- a/vendor/github.com/golang/mock/gomock/callset.go +++ /dev/null @@ -1,113 +0,0 @@ -// Copyright 2011 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -import ( - "bytes" - "errors" - "fmt" -) - -// callSet represents a set of expected calls, indexed by receiver and method -// name. -type callSet struct { - // Calls that are still expected. - expected map[callSetKey][]*Call - // Calls that have been exhausted. - exhausted map[callSetKey][]*Call -} - -// callSetKey is the key in the maps in callSet -type callSetKey struct { - receiver interface{} - fname string -} - -func newCallSet() *callSet { - return &callSet{make(map[callSetKey][]*Call), make(map[callSetKey][]*Call)} -} - -// Add adds a new expected call. -func (cs callSet) Add(call *Call) { - key := callSetKey{call.receiver, call.method} - m := cs.expected - if call.exhausted() { - m = cs.exhausted - } - m[key] = append(m[key], call) -} - -// Remove removes an expected call. -func (cs callSet) Remove(call *Call) { - key := callSetKey{call.receiver, call.method} - calls := cs.expected[key] - for i, c := range calls { - if c == call { - // maintain order for remaining calls - cs.expected[key] = append(calls[:i], calls[i+1:]...) - cs.exhausted[key] = append(cs.exhausted[key], call) - break - } - } -} - -// FindMatch searches for a matching call. Returns error with explanation message if no call matched. -func (cs callSet) FindMatch(receiver interface{}, method string, args []interface{}) (*Call, error) { - key := callSetKey{receiver, method} - - // Search through the expected calls. - expected := cs.expected[key] - var callsErrors bytes.Buffer - for _, call := range expected { - err := call.matches(args) - if err != nil { - _, _ = fmt.Fprintf(&callsErrors, "\n%v", err) - } else { - return call, nil - } - } - - // If we haven't found a match then search through the exhausted calls so we - // get useful error messages. - exhausted := cs.exhausted[key] - for _, call := range exhausted { - if err := call.matches(args); err != nil { - _, _ = fmt.Fprintf(&callsErrors, "\n%v", err) - continue - } - _, _ = fmt.Fprintf( - &callsErrors, "all expected calls for method %q have been exhausted", method, - ) - } - - if len(expected)+len(exhausted) == 0 { - _, _ = fmt.Fprintf(&callsErrors, "there are no expected calls of the method %q for that receiver", method) - } - - return nil, errors.New(callsErrors.String()) -} - -// Failures returns the calls that are not satisfied. -func (cs callSet) Failures() []*Call { - failures := make([]*Call, 0, len(cs.expected)) - for _, calls := range cs.expected { - for _, call := range calls { - if !call.satisfied() { - failures = append(failures, call) - } - } - } - return failures -} diff --git a/vendor/github.com/golang/mock/gomock/controller.go b/vendor/github.com/golang/mock/gomock/controller.go deleted file mode 100644 index f054200d56..0000000000 --- a/vendor/github.com/golang/mock/gomock/controller.go +++ /dev/null @@ -1,336 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package gomock is a mock framework for Go. -// -// Standard usage: -// (1) Define an interface that you wish to mock. -// type MyInterface interface { -// SomeMethod(x int64, y string) -// } -// (2) Use mockgen to generate a mock from the interface. -// (3) Use the mock in a test: -// func TestMyThing(t *testing.T) { -// mockCtrl := gomock.NewController(t) -// defer mockCtrl.Finish() -// -// mockObj := something.NewMockMyInterface(mockCtrl) -// mockObj.EXPECT().SomeMethod(4, "blah") -// // pass mockObj to a real object and play with it. -// } -// -// By default, expected calls are not enforced to run in any particular order. -// Call order dependency can be enforced by use of InOrder and/or Call.After. -// Call.After can create more varied call order dependencies, but InOrder is -// often more convenient. -// -// The following examples create equivalent call order dependencies. -// -// Example of using Call.After to chain expected call order: -// -// firstCall := mockObj.EXPECT().SomeMethod(1, "first") -// secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall) -// mockObj.EXPECT().SomeMethod(3, "third").After(secondCall) -// -// Example of using InOrder to declare expected call order: -// -// gomock.InOrder( -// mockObj.EXPECT().SomeMethod(1, "first"), -// mockObj.EXPECT().SomeMethod(2, "second"), -// mockObj.EXPECT().SomeMethod(3, "third"), -// ) -package gomock - -import ( - "context" - "fmt" - "reflect" - "runtime" - "sync" -) - -// A TestReporter is something that can be used to report test failures. It -// is satisfied by the standard library's *testing.T. -type TestReporter interface { - Errorf(format string, args ...interface{}) - Fatalf(format string, args ...interface{}) -} - -// TestHelper is a TestReporter that has the Helper method. It is satisfied -// by the standard library's *testing.T. -type TestHelper interface { - TestReporter - Helper() -} - -// cleanuper is used to check if TestHelper also has the `Cleanup` method. A -// common pattern is to pass in a `*testing.T` to -// `NewController(t TestReporter)`. In Go 1.14+, `*testing.T` has a cleanup -// method. This can be utilized to call `Finish()` so the caller of this library -// does not have to. -type cleanuper interface { - Cleanup(func()) -} - -// A Controller represents the top-level control of a mock ecosystem. It -// defines the scope and lifetime of mock objects, as well as their -// expectations. It is safe to call Controller's methods from multiple -// goroutines. Each test should create a new Controller and invoke Finish via -// defer. -// -// func TestFoo(t *testing.T) { -// ctrl := gomock.NewController(t) -// defer ctrl.Finish() -// // .. -// } -// -// func TestBar(t *testing.T) { -// t.Run("Sub-Test-1", st) { -// ctrl := gomock.NewController(st) -// defer ctrl.Finish() -// // .. -// }) -// t.Run("Sub-Test-2", st) { -// ctrl := gomock.NewController(st) -// defer ctrl.Finish() -// // .. -// }) -// }) -type Controller struct { - // T should only be called within a generated mock. It is not intended to - // be used in user code and may be changed in future versions. T is the - // TestReporter passed in when creating the Controller via NewController. - // If the TestReporter does not implement a TestHelper it will be wrapped - // with a nopTestHelper. - T TestHelper - mu sync.Mutex - expectedCalls *callSet - finished bool -} - -// NewController returns a new Controller. It is the preferred way to create a -// Controller. -// -// New in go1.14+, if you are passing a *testing.T into this function you no -// longer need to call ctrl.Finish() in your test methods. -func NewController(t TestReporter) *Controller { - h, ok := t.(TestHelper) - if !ok { - h = &nopTestHelper{t} - } - ctrl := &Controller{ - T: h, - expectedCalls: newCallSet(), - } - if c, ok := isCleanuper(ctrl.T); ok { - c.Cleanup(func() { - ctrl.T.Helper() - ctrl.finish(true, nil) - }) - } - - return ctrl -} - -type cancelReporter struct { - t TestHelper - cancel func() -} - -func (r *cancelReporter) Errorf(format string, args ...interface{}) { - r.t.Errorf(format, args...) -} -func (r *cancelReporter) Fatalf(format string, args ...interface{}) { - defer r.cancel() - r.t.Fatalf(format, args...) -} - -func (r *cancelReporter) Helper() { - r.t.Helper() -} - -// WithContext returns a new Controller and a Context, which is cancelled on any -// fatal failure. -func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context) { - h, ok := t.(TestHelper) - if !ok { - h = &nopTestHelper{t: t} - } - - ctx, cancel := context.WithCancel(ctx) - return NewController(&cancelReporter{t: h, cancel: cancel}), ctx -} - -type nopTestHelper struct { - t TestReporter -} - -func (h *nopTestHelper) Errorf(format string, args ...interface{}) { - h.t.Errorf(format, args...) -} -func (h *nopTestHelper) Fatalf(format string, args ...interface{}) { - h.t.Fatalf(format, args...) -} - -func (h nopTestHelper) Helper() {} - -// RecordCall is called by a mock. It should not be called by user code. -func (ctrl *Controller) RecordCall(receiver interface{}, method string, args ...interface{}) *Call { - ctrl.T.Helper() - - recv := reflect.ValueOf(receiver) - for i := 0; i < recv.Type().NumMethod(); i++ { - if recv.Type().Method(i).Name == method { - return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...) - } - } - ctrl.T.Fatalf("gomock: failed finding method %s on %T", method, receiver) - panic("unreachable") -} - -// RecordCallWithMethodType is called by a mock. It should not be called by user code. -func (ctrl *Controller) RecordCallWithMethodType(receiver interface{}, method string, methodType reflect.Type, args ...interface{}) *Call { - ctrl.T.Helper() - - call := newCall(ctrl.T, receiver, method, methodType, args...) - - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - ctrl.expectedCalls.Add(call) - - return call -} - -// Call is called by a mock. It should not be called by user code. -func (ctrl *Controller) Call(receiver interface{}, method string, args ...interface{}) []interface{} { - ctrl.T.Helper() - - // Nest this code so we can use defer to make sure the lock is released. - actions := func() []func([]interface{}) []interface{} { - ctrl.T.Helper() - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - - expected, err := ctrl.expectedCalls.FindMatch(receiver, method, args) - if err != nil { - // callerInfo's skip should be updated if the number of calls between the user's test - // and this line changes, i.e. this code is wrapped in another anonymous function. - // 0 is us, 1 is controller.Call(), 2 is the generated mock, and 3 is the user's test. - origin := callerInfo(3) - ctrl.T.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, args, origin, err) - } - - // Two things happen here: - // * the matching call no longer needs to check prerequite calls, - // * and the prerequite calls are no longer expected, so remove them. - preReqCalls := expected.dropPrereqs() - for _, preReqCall := range preReqCalls { - ctrl.expectedCalls.Remove(preReqCall) - } - - actions := expected.call() - if expected.exhausted() { - ctrl.expectedCalls.Remove(expected) - } - return actions - }() - - var rets []interface{} - for _, action := range actions { - if r := action(args); r != nil { - rets = r - } - } - - return rets -} - -// Finish checks to see if all the methods that were expected to be called -// were called. It should be invoked for each Controller. It is not idempotent -// and therefore can only be invoked once. -// -// New in go1.14+, if you are passing a *testing.T into NewController function you no -// longer need to call ctrl.Finish() in your test methods. -func (ctrl *Controller) Finish() { - // If we're currently panicking, probably because this is a deferred call. - // This must be recovered in the deferred function. - err := recover() - ctrl.finish(false, err) -} - -func (ctrl *Controller) finish(cleanup bool, panicErr interface{}) { - ctrl.T.Helper() - - ctrl.mu.Lock() - defer ctrl.mu.Unlock() - - if ctrl.finished { - if _, ok := isCleanuper(ctrl.T); !ok { - ctrl.T.Fatalf("Controller.Finish was called more than once. It has to be called exactly once.") - } - return - } - ctrl.finished = true - - // Short-circuit, pass through the panic. - if panicErr != nil { - panic(panicErr) - } - - // Check that all remaining expected calls are satisfied. - failures := ctrl.expectedCalls.Failures() - for _, call := range failures { - ctrl.T.Errorf("missing call(s) to %v", call) - } - if len(failures) != 0 { - if !cleanup { - ctrl.T.Fatalf("aborting test due to missing call(s)") - return - } - ctrl.T.Errorf("aborting test due to missing call(s)") - } -} - -// callerInfo returns the file:line of the call site. skip is the number -// of stack frames to skip when reporting. 0 is callerInfo's call site. -func callerInfo(skip int) string { - if _, file, line, ok := runtime.Caller(skip + 1); ok { - return fmt.Sprintf("%s:%d", file, line) - } - return "unknown file" -} - -// isCleanuper checks it if t's base TestReporter has a Cleanup method. -func isCleanuper(t TestReporter) (cleanuper, bool) { - tr := unwrapTestReporter(t) - c, ok := tr.(cleanuper) - return c, ok -} - -// unwrapTestReporter unwraps TestReporter to the base implementation. -func unwrapTestReporter(t TestReporter) TestReporter { - tr := t - switch nt := t.(type) { - case *cancelReporter: - tr = nt.t - if h, check := tr.(*nopTestHelper); check { - tr = h.t - } - case *nopTestHelper: - tr = nt.t - default: - // not wrapped - } - return tr -} diff --git a/vendor/github.com/golang/mock/gomock/matchers.go b/vendor/github.com/golang/mock/gomock/matchers.go deleted file mode 100644 index 2822fb2c8c..0000000000 --- a/vendor/github.com/golang/mock/gomock/matchers.go +++ /dev/null @@ -1,341 +0,0 @@ -// Copyright 2010 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -package gomock - -import ( - "fmt" - "reflect" - "strings" -) - -// A Matcher is a representation of a class of values. -// It is used to represent the valid or expected arguments to a mocked method. -type Matcher interface { - // Matches returns whether x is a match. - Matches(x interface{}) bool - - // String describes what the matcher matches. - String() string -} - -// WantFormatter modifies the given Matcher's String() method to the given -// Stringer. This allows for control on how the "Want" is formatted when -// printing . -func WantFormatter(s fmt.Stringer, m Matcher) Matcher { - type matcher interface { - Matches(x interface{}) bool - } - - return struct { - matcher - fmt.Stringer - }{ - matcher: m, - Stringer: s, - } -} - -// StringerFunc type is an adapter to allow the use of ordinary functions as -// a Stringer. If f is a function with the appropriate signature, -// StringerFunc(f) is a Stringer that calls f. -type StringerFunc func() string - -// String implements fmt.Stringer. -func (f StringerFunc) String() string { - return f() -} - -// GotFormatter is used to better print failure messages. If a matcher -// implements GotFormatter, it will use the result from Got when printing -// the failure message. -type GotFormatter interface { - // Got is invoked with the received value. The result is used when - // printing the failure message. - Got(got interface{}) string -} - -// GotFormatterFunc type is an adapter to allow the use of ordinary -// functions as a GotFormatter. If f is a function with the appropriate -// signature, GotFormatterFunc(f) is a GotFormatter that calls f. -type GotFormatterFunc func(got interface{}) string - -// Got implements GotFormatter. -func (f GotFormatterFunc) Got(got interface{}) string { - return f(got) -} - -// GotFormatterAdapter attaches a GotFormatter to a Matcher. -func GotFormatterAdapter(s GotFormatter, m Matcher) Matcher { - return struct { - GotFormatter - Matcher - }{ - GotFormatter: s, - Matcher: m, - } -} - -type anyMatcher struct{} - -func (anyMatcher) Matches(interface{}) bool { - return true -} - -func (anyMatcher) String() string { - return "is anything" -} - -type eqMatcher struct { - x interface{} -} - -func (e eqMatcher) Matches(x interface{}) bool { - // In case, some value is nil - if e.x == nil || x == nil { - return reflect.DeepEqual(e.x, x) - } - - // Check if types assignable and convert them to common type - x1Val := reflect.ValueOf(e.x) - x2Val := reflect.ValueOf(x) - - if x1Val.Type().AssignableTo(x2Val.Type()) { - x1ValConverted := x1Val.Convert(x2Val.Type()) - return reflect.DeepEqual(x1ValConverted.Interface(), x2Val.Interface()) - } - - return false -} - -func (e eqMatcher) String() string { - return fmt.Sprintf("is equal to %v (%T)", e.x, e.x) -} - -type nilMatcher struct{} - -func (nilMatcher) Matches(x interface{}) bool { - if x == nil { - return true - } - - v := reflect.ValueOf(x) - switch v.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, - reflect.Ptr, reflect.Slice: - return v.IsNil() - } - - return false -} - -func (nilMatcher) String() string { - return "is nil" -} - -type notMatcher struct { - m Matcher -} - -func (n notMatcher) Matches(x interface{}) bool { - return !n.m.Matches(x) -} - -func (n notMatcher) String() string { - return "not(" + n.m.String() + ")" -} - -type assignableToTypeOfMatcher struct { - targetType reflect.Type -} - -func (m assignableToTypeOfMatcher) Matches(x interface{}) bool { - return reflect.TypeOf(x).AssignableTo(m.targetType) -} - -func (m assignableToTypeOfMatcher) String() string { - return "is assignable to " + m.targetType.Name() -} - -type allMatcher struct { - matchers []Matcher -} - -func (am allMatcher) Matches(x interface{}) bool { - for _, m := range am.matchers { - if !m.Matches(x) { - return false - } - } - return true -} - -func (am allMatcher) String() string { - ss := make([]string, 0, len(am.matchers)) - for _, matcher := range am.matchers { - ss = append(ss, matcher.String()) - } - return strings.Join(ss, "; ") -} - -type lenMatcher struct { - i int -} - -func (m lenMatcher) Matches(x interface{}) bool { - v := reflect.ValueOf(x) - switch v.Kind() { - case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String: - return v.Len() == m.i - default: - return false - } -} - -func (m lenMatcher) String() string { - return fmt.Sprintf("has length %d", m.i) -} - -type inAnyOrderMatcher struct { - x interface{} -} - -func (m inAnyOrderMatcher) Matches(x interface{}) bool { - given, ok := m.prepareValue(x) - if !ok { - return false - } - wanted, ok := m.prepareValue(m.x) - if !ok { - return false - } - - if given.Len() != wanted.Len() { - return false - } - - usedFromGiven := make([]bool, given.Len()) - foundFromWanted := make([]bool, wanted.Len()) - for i := 0; i < wanted.Len(); i++ { - wantedMatcher := Eq(wanted.Index(i).Interface()) - for j := 0; j < given.Len(); j++ { - if usedFromGiven[j] { - continue - } - if wantedMatcher.Matches(given.Index(j).Interface()) { - foundFromWanted[i] = true - usedFromGiven[j] = true - break - } - } - } - - missingFromWanted := 0 - for _, found := range foundFromWanted { - if !found { - missingFromWanted++ - } - } - extraInGiven := 0 - for _, used := range usedFromGiven { - if !used { - extraInGiven++ - } - } - - return extraInGiven == 0 && missingFromWanted == 0 -} - -func (m inAnyOrderMatcher) prepareValue(x interface{}) (reflect.Value, bool) { - xValue := reflect.ValueOf(x) - switch xValue.Kind() { - case reflect.Slice, reflect.Array: - return xValue, true - default: - return reflect.Value{}, false - } -} - -func (m inAnyOrderMatcher) String() string { - return fmt.Sprintf("has the same elements as %v", m.x) -} - -// Constructors - -// All returns a composite Matcher that returns true if and only all of the -// matchers return true. -func All(ms ...Matcher) Matcher { return allMatcher{ms} } - -// Any returns a matcher that always matches. -func Any() Matcher { return anyMatcher{} } - -// Eq returns a matcher that matches on equality. -// -// Example usage: -// Eq(5).Matches(5) // returns true -// Eq(5).Matches(4) // returns false -func Eq(x interface{}) Matcher { return eqMatcher{x} } - -// Len returns a matcher that matches on length. This matcher returns false if -// is compared to a type that is not an array, chan, map, slice, or string. -func Len(i int) Matcher { - return lenMatcher{i} -} - -// Nil returns a matcher that matches if the received value is nil. -// -// Example usage: -// var x *bytes.Buffer -// Nil().Matches(x) // returns true -// x = &bytes.Buffer{} -// Nil().Matches(x) // returns false -func Nil() Matcher { return nilMatcher{} } - -// Not reverses the results of its given child matcher. -// -// Example usage: -// Not(Eq(5)).Matches(4) // returns true -// Not(Eq(5)).Matches(5) // returns false -func Not(x interface{}) Matcher { - if m, ok := x.(Matcher); ok { - return notMatcher{m} - } - return notMatcher{Eq(x)} -} - -// AssignableToTypeOf is a Matcher that matches if the parameter to the mock -// function is assignable to the type of the parameter to this function. -// -// Example usage: -// var s fmt.Stringer = &bytes.Buffer{} -// AssignableToTypeOf(s).Matches(time.Second) // returns true -// AssignableToTypeOf(s).Matches(99) // returns false -// -// var ctx = reflect.TypeOf((*context.Context)(nil)).Elem() -// AssignableToTypeOf(ctx).Matches(context.Background()) // returns true -func AssignableToTypeOf(x interface{}) Matcher { - if xt, ok := x.(reflect.Type); ok { - return assignableToTypeOfMatcher{xt} - } - return assignableToTypeOfMatcher{reflect.TypeOf(x)} -} - -// InAnyOrder is a Matcher that returns true for collections of the same elements ignoring the order. -// -// Example usage: -// InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 3, 2}) // returns true -// InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 2}) // returns false -func InAnyOrder(x interface{}) Matcher { - return inAnyOrderMatcher{x} -} diff --git a/vendor/github.com/golang/mock/mockgen/model/model.go b/vendor/github.com/golang/mock/mockgen/model/model.go deleted file mode 100644 index 2c6a62ceb2..0000000000 --- a/vendor/github.com/golang/mock/mockgen/model/model.go +++ /dev/null @@ -1,495 +0,0 @@ -// Copyright 2012 Google Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// Package model contains the data model necessary for generating mock implementations. -package model - -import ( - "encoding/gob" - "fmt" - "io" - "reflect" - "strings" -) - -// pkgPath is the importable path for package model -const pkgPath = "github.com/golang/mock/mockgen/model" - -// Package is a Go package. It may be a subset. -type Package struct { - Name string - PkgPath string - Interfaces []*Interface - DotImports []string -} - -// Print writes the package name and its exported interfaces. -func (pkg *Package) Print(w io.Writer) { - _, _ = fmt.Fprintf(w, "package %s\n", pkg.Name) - for _, intf := range pkg.Interfaces { - intf.Print(w) - } -} - -// Imports returns the imports needed by the Package as a set of import paths. -func (pkg *Package) Imports() map[string]bool { - im := make(map[string]bool) - for _, intf := range pkg.Interfaces { - intf.addImports(im) - } - return im -} - -// Interface is a Go interface. -type Interface struct { - Name string - Methods []*Method -} - -// Print writes the interface name and its methods. -func (intf *Interface) Print(w io.Writer) { - _, _ = fmt.Fprintf(w, "interface %s\n", intf.Name) - for _, m := range intf.Methods { - m.Print(w) - } -} - -func (intf *Interface) addImports(im map[string]bool) { - for _, m := range intf.Methods { - m.addImports(im) - } -} - -// AddMethod adds a new method, de-duplicating by method name. -func (intf *Interface) AddMethod(m *Method) { - for _, me := range intf.Methods { - if me.Name == m.Name { - return - } - } - intf.Methods = append(intf.Methods, m) -} - -// Method is a single method of an interface. -type Method struct { - Name string - In, Out []*Parameter - Variadic *Parameter // may be nil -} - -// Print writes the method name and its signature. -func (m *Method) Print(w io.Writer) { - _, _ = fmt.Fprintf(w, " - method %s\n", m.Name) - if len(m.In) > 0 { - _, _ = fmt.Fprintf(w, " in:\n") - for _, p := range m.In { - p.Print(w) - } - } - if m.Variadic != nil { - _, _ = fmt.Fprintf(w, " ...:\n") - m.Variadic.Print(w) - } - if len(m.Out) > 0 { - _, _ = fmt.Fprintf(w, " out:\n") - for _, p := range m.Out { - p.Print(w) - } - } -} - -func (m *Method) addImports(im map[string]bool) { - for _, p := range m.In { - p.Type.addImports(im) - } - if m.Variadic != nil { - m.Variadic.Type.addImports(im) - } - for _, p := range m.Out { - p.Type.addImports(im) - } -} - -// Parameter is an argument or return parameter of a method. -type Parameter struct { - Name string // may be empty - Type Type -} - -// Print writes a method parameter. -func (p *Parameter) Print(w io.Writer) { - n := p.Name - if n == "" { - n = `""` - } - _, _ = fmt.Fprintf(w, " - %v: %v\n", n, p.Type.String(nil, "")) -} - -// Type is a Go type. -type Type interface { - String(pm map[string]string, pkgOverride string) string - addImports(im map[string]bool) -} - -func init() { - gob.Register(&ArrayType{}) - gob.Register(&ChanType{}) - gob.Register(&FuncType{}) - gob.Register(&MapType{}) - gob.Register(&NamedType{}) - gob.Register(&PointerType{}) - - // Call gob.RegisterName to make sure it has the consistent name registered - // for both gob decoder and encoder. - // - // For a non-pointer type, gob.Register will try to get package full path by - // calling rt.PkgPath() for a name to register. If your project has vendor - // directory, it is possible that PkgPath will get a path like this: - // ../../../vendor/github.com/golang/mock/mockgen/model - gob.RegisterName(pkgPath+".PredeclaredType", PredeclaredType("")) -} - -// ArrayType is an array or slice type. -type ArrayType struct { - Len int // -1 for slices, >= 0 for arrays - Type Type -} - -func (at *ArrayType) String(pm map[string]string, pkgOverride string) string { - s := "[]" - if at.Len > -1 { - s = fmt.Sprintf("[%d]", at.Len) - } - return s + at.Type.String(pm, pkgOverride) -} - -func (at *ArrayType) addImports(im map[string]bool) { at.Type.addImports(im) } - -// ChanType is a channel type. -type ChanType struct { - Dir ChanDir // 0, 1 or 2 - Type Type -} - -func (ct *ChanType) String(pm map[string]string, pkgOverride string) string { - s := ct.Type.String(pm, pkgOverride) - if ct.Dir == RecvDir { - return "<-chan " + s - } - if ct.Dir == SendDir { - return "chan<- " + s - } - return "chan " + s -} - -func (ct *ChanType) addImports(im map[string]bool) { ct.Type.addImports(im) } - -// ChanDir is a channel direction. -type ChanDir int - -// Constants for channel directions. -const ( - RecvDir ChanDir = 1 - SendDir ChanDir = 2 -) - -// FuncType is a function type. -type FuncType struct { - In, Out []*Parameter - Variadic *Parameter // may be nil -} - -func (ft *FuncType) String(pm map[string]string, pkgOverride string) string { - args := make([]string, len(ft.In)) - for i, p := range ft.In { - args[i] = p.Type.String(pm, pkgOverride) - } - if ft.Variadic != nil { - args = append(args, "..."+ft.Variadic.Type.String(pm, pkgOverride)) - } - rets := make([]string, len(ft.Out)) - for i, p := range ft.Out { - rets[i] = p.Type.String(pm, pkgOverride) - } - retString := strings.Join(rets, ", ") - if nOut := len(ft.Out); nOut == 1 { - retString = " " + retString - } else if nOut > 1 { - retString = " (" + retString + ")" - } - return "func(" + strings.Join(args, ", ") + ")" + retString -} - -func (ft *FuncType) addImports(im map[string]bool) { - for _, p := range ft.In { - p.Type.addImports(im) - } - if ft.Variadic != nil { - ft.Variadic.Type.addImports(im) - } - for _, p := range ft.Out { - p.Type.addImports(im) - } -} - -// MapType is a map type. -type MapType struct { - Key, Value Type -} - -func (mt *MapType) String(pm map[string]string, pkgOverride string) string { - return "map[" + mt.Key.String(pm, pkgOverride) + "]" + mt.Value.String(pm, pkgOverride) -} - -func (mt *MapType) addImports(im map[string]bool) { - mt.Key.addImports(im) - mt.Value.addImports(im) -} - -// NamedType is an exported type in a package. -type NamedType struct { - Package string // may be empty - Type string -} - -func (nt *NamedType) String(pm map[string]string, pkgOverride string) string { - if pkgOverride == nt.Package { - return nt.Type - } - prefix := pm[nt.Package] - if prefix != "" { - return prefix + "." + nt.Type - } - - return nt.Type -} - -func (nt *NamedType) addImports(im map[string]bool) { - if nt.Package != "" { - im[nt.Package] = true - } -} - -// PointerType is a pointer to another type. -type PointerType struct { - Type Type -} - -func (pt *PointerType) String(pm map[string]string, pkgOverride string) string { - return "*" + pt.Type.String(pm, pkgOverride) -} -func (pt *PointerType) addImports(im map[string]bool) { pt.Type.addImports(im) } - -// PredeclaredType is a predeclared type such as "int". -type PredeclaredType string - -func (pt PredeclaredType) String(map[string]string, string) string { return string(pt) } -func (pt PredeclaredType) addImports(map[string]bool) {} - -// The following code is intended to be called by the program generated by ../reflect.go. - -// InterfaceFromInterfaceType returns a pointer to an interface for the -// given reflection interface type. -func InterfaceFromInterfaceType(it reflect.Type) (*Interface, error) { - if it.Kind() != reflect.Interface { - return nil, fmt.Errorf("%v is not an interface", it) - } - intf := &Interface{} - - for i := 0; i < it.NumMethod(); i++ { - mt := it.Method(i) - // TODO: need to skip unexported methods? or just raise an error? - m := &Method{ - Name: mt.Name, - } - - var err error - m.In, m.Variadic, m.Out, err = funcArgsFromType(mt.Type) - if err != nil { - return nil, err - } - - intf.AddMethod(m) - } - - return intf, nil -} - -// t's Kind must be a reflect.Func. -func funcArgsFromType(t reflect.Type) (in []*Parameter, variadic *Parameter, out []*Parameter, err error) { - nin := t.NumIn() - if t.IsVariadic() { - nin-- - } - var p *Parameter - for i := 0; i < nin; i++ { - p, err = parameterFromType(t.In(i)) - if err != nil { - return - } - in = append(in, p) - } - if t.IsVariadic() { - p, err = parameterFromType(t.In(nin).Elem()) - if err != nil { - return - } - variadic = p - } - for i := 0; i < t.NumOut(); i++ { - p, err = parameterFromType(t.Out(i)) - if err != nil { - return - } - out = append(out, p) - } - return -} - -func parameterFromType(t reflect.Type) (*Parameter, error) { - tt, err := typeFromType(t) - if err != nil { - return nil, err - } - return &Parameter{Type: tt}, nil -} - -var errorType = reflect.TypeOf((*error)(nil)).Elem() - -var byteType = reflect.TypeOf(byte(0)) - -func typeFromType(t reflect.Type) (Type, error) { - // Hack workaround for https://golang.org/issue/3853. - // This explicit check should not be necessary. - if t == byteType { - return PredeclaredType("byte"), nil - } - - if imp := t.PkgPath(); imp != "" { - return &NamedType{ - Package: impPath(imp), - Type: t.Name(), - }, nil - } - - // only unnamed or predeclared types after here - - // Lots of types have element types. Let's do the parsing and error checking for all of them. - var elemType Type - switch t.Kind() { - case reflect.Array, reflect.Chan, reflect.Map, reflect.Ptr, reflect.Slice: - var err error - elemType, err = typeFromType(t.Elem()) - if err != nil { - return nil, err - } - } - - switch t.Kind() { - case reflect.Array: - return &ArrayType{ - Len: t.Len(), - Type: elemType, - }, nil - case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, - reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, - reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.String: - return PredeclaredType(t.Kind().String()), nil - case reflect.Chan: - var dir ChanDir - switch t.ChanDir() { - case reflect.RecvDir: - dir = RecvDir - case reflect.SendDir: - dir = SendDir - } - return &ChanType{ - Dir: dir, - Type: elemType, - }, nil - case reflect.Func: - in, variadic, out, err := funcArgsFromType(t) - if err != nil { - return nil, err - } - return &FuncType{ - In: in, - Out: out, - Variadic: variadic, - }, nil - case reflect.Interface: - // Two special interfaces. - if t.NumMethod() == 0 { - return PredeclaredType("interface{}"), nil - } - if t == errorType { - return PredeclaredType("error"), nil - } - case reflect.Map: - kt, err := typeFromType(t.Key()) - if err != nil { - return nil, err - } - return &MapType{ - Key: kt, - Value: elemType, - }, nil - case reflect.Ptr: - return &PointerType{ - Type: elemType, - }, nil - case reflect.Slice: - return &ArrayType{ - Len: -1, - Type: elemType, - }, nil - case reflect.Struct: - if t.NumField() == 0 { - return PredeclaredType("struct{}"), nil - } - } - - // TODO: Struct, UnsafePointer - return nil, fmt.Errorf("can't yet turn %v (%v) into a model.Type", t, t.Kind()) -} - -// impPath sanitizes the package path returned by `PkgPath` method of a reflect Type so that -// it is importable. PkgPath might return a path that includes "vendor". These paths do not -// compile, so we need to remove everything up to and including "/vendor/". -// See https://github.com/golang/go/issues/12019. -func impPath(imp string) string { - if strings.HasPrefix(imp, "vendor/") { - imp = "/" + imp - } - if i := strings.LastIndex(imp, "/vendor/"); i != -1 { - imp = imp[i+len("/vendor/"):] - } - return imp -} - -// ErrorInterface represent built-in error interface. -var ErrorInterface = Interface{ - Name: "error", - Methods: []*Method{ - { - Name: "Error", - Out: []*Parameter{ - { - Name: "", - Type: PredeclaredType("string"), - }, - }, - }, - }, -} diff --git a/vendor/modules.txt b/vendor/modules.txt index 53d6aa9b83..316ed33ef4 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -231,7 +231,6 @@ github.com/cloudfoundry/bosh-agent/v2/agentclient github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec github.com/cloudfoundry/bosh-agent/v2/agentclient/fakes github.com/cloudfoundry/bosh-agent/v2/agentclient/http -github.com/cloudfoundry/bosh-agent/v2/agentclient/http/mocks # github.com/cloudfoundry/bosh-davcli v0.0.502 ## explicit; go 1.25.0 github.com/cloudfoundry/bosh-davcli/client @@ -362,10 +361,6 @@ github.com/go-logr/stdr # github.com/go-task/slim-sprig/v3 v3.0.0 ## explicit; go 1.20 github.com/go-task/slim-sprig/v3 -# github.com/golang/mock v1.6.0 -## explicit; go 1.11 -github.com/golang/mock/gomock -github.com/golang/mock/mockgen/model # github.com/google/btree v1.1.3 ## explicit; go 1.18 github.com/google/btree From eae30d1ac448e9691e963606aa20920cafad544e Mon Sep 17 00:00:00 2001 From: aram price Date: Thu, 20 Aug 2026 15:21:10 -0700 Subject: [PATCH 02/13] Remove unused hand-crafted fakes --- blobstore/fakes/fake_blobstore.go | 40 ----------------------- blobstore/fakes/fake_blobstore_factory.go | 20 ------------ 2 files changed, 60 deletions(-) delete mode 100644 blobstore/fakes/fake_blobstore.go delete mode 100644 blobstore/fakes/fake_blobstore_factory.go diff --git a/blobstore/fakes/fake_blobstore.go b/blobstore/fakes/fake_blobstore.go deleted file mode 100644 index 4dd1a6b343..0000000000 --- a/blobstore/fakes/fake_blobstore.go +++ /dev/null @@ -1,40 +0,0 @@ -package fakes - -type FakeBlobstore struct { - GetInputs []GetInput - GetErr error - - AddInputs []AddInput - AddBlobID string - AddErr error -} - -type GetInput struct { - BlobID string - DestinationPath string -} - -type AddInput struct { - SourcePath string -} - -func NewFakeBlobstore() *FakeBlobstore { - return &FakeBlobstore{} -} - -func (b *FakeBlobstore) Get(blobID string, destinationPath string) error { - b.GetInputs = append(b.GetInputs, GetInput{ - BlobID: blobID, - DestinationPath: destinationPath, - }) - - return b.GetErr -} - -func (b *FakeBlobstore) Add(sourcePath string) (blobID string, err error) { - b.AddInputs = append(b.AddInputs, AddInput{ - SourcePath: sourcePath, - }) - - return b.AddBlobID, b.AddErr -} diff --git a/blobstore/fakes/fake_blobstore_factory.go b/blobstore/fakes/fake_blobstore_factory.go deleted file mode 100644 index 09e956ac49..0000000000 --- a/blobstore/fakes/fake_blobstore_factory.go +++ /dev/null @@ -1,20 +0,0 @@ -package fakes - -import ( - biblobstore "github.com/cloudfoundry/bosh-cli/v7/blobstore" -) - -type FakeBlobstoreFactory struct { - CreateBlobstoreURL string - CreateBlobstore biblobstore.Blobstore - CreateErr error -} - -func NewFakeBlobstoreFactory() *FakeBlobstoreFactory { - return &FakeBlobstoreFactory{} -} - -func (f *FakeBlobstoreFactory) Create(blobstoreURL string) (biblobstore.Blobstore, error) { - f.CreateBlobstoreURL = blobstoreURL - return f.CreateBlobstore, f.CreateErr -} From 0f797fad0e3d64369acb204b13f2c53f7a817412 Mon Sep 17 00:00:00 2001 From: aram price Date: Fri, 21 Aug 2026 18:17:11 -0700 Subject: [PATCH 03/13] Replace hand-crafted `cloud/fakes/` with counterfeiter --- cloud/cloud_test.go | 432 ++++++++++--------------- cloud/cloudfakes/fake_cpicmd_runner.go | 120 +++++++ cloud/cpi_cmd_runner.go | 2 +- cloud/fakes/fake_cloud.go | 212 ------------ cloud/fakes/fake_cpi_cmd_runner.go | 60 ---- deployment/deployer_test.go | 6 +- deployment/disk/disk_test.go | 24 +- deployment/disk/manager_test.go | 18 +- deployment/instance/manager_test.go | 7 +- deployment/vm/disk_deployer_test.go | 6 +- deployment/vm/manager_test.go | 76 +++-- deployment/vm/vm_test.go | 63 ++-- stemcell/cloud_stemcell_test.go | 24 +- stemcell/manager_test.go | 31 +- 14 files changed, 407 insertions(+), 674 deletions(-) create mode 100644 cloud/cloudfakes/fake_cpicmd_runner.go delete mode 100644 cloud/fakes/fake_cloud.go delete mode 100644 cloud/fakes/fake_cpi_cmd_runner.go diff --git a/cloud/cloud_test.go b/cloud/cloud_test.go index cc91b7d7f9..8964b0d607 100644 --- a/cloud/cloud_test.go +++ b/cloud/cloud_test.go @@ -8,7 +8,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" . "github.com/cloudfoundry/bosh-cli/v7/cloud" ) @@ -17,7 +17,7 @@ var _ = Describe("Cloud", func() { var ( cloud Cloud expectedContext CmdContext - fakeCPICmdRunner *fakebicloud.FakeCPICmdRunner + fakeCPICmdRunner *cloudfakes.FakeCPICmdRunner logger boshlog.Logger stemcellApiVersion = 1 cpiApiVersion = 1 @@ -26,7 +26,7 @@ var _ = Describe("Cloud", func() { ) BeforeEach(func() { - fakeCPICmdRunner = fakebicloud.NewFakeCPICmdRunner() + fakeCPICmdRunner = &cloudfakes.FakeCPICmdRunner{} logger = boshlog.NewLogger(boshlog.LevelNone) infoResult = map[string]interface{}{ "stemcell_formats": []interface{}{"aws-raw", "aws-light"}, @@ -44,20 +44,11 @@ var _ = Describe("Cloud", func() { var itHandlesCPIErrors = func(method string, exec func() error) { It("returns a cloud.Error when the CPI command returns an error", func() { - - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - } - - fakeCPICmdRunner.RunCmdOutputs = append( - fakeCPICmdRunner.RunCmdOutputs, - CmdOutput{ - Error: &CmdError{ - Type: "Bosh::Cloud::CloudError", - Message: "fake-cpi-error-msg", - }, - }, - ) + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Error: &CmdError{ + Type: "Bosh::Cloud::CloudError", + Message: "fake-cpi-error-msg", + }}, nil) err := exec() Expect(err).To(HaveOccurred()) @@ -83,27 +74,17 @@ var _ = Describe("Cloud", func() { StemcellFormats: []string{"aws-raw", "aws-light"}, ApiVersion: 2, } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ - Result: infoResultWithApiV2, - }} + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) cpiInfo, err := cloud.Info() Expect(cpiInfo).To(Equal(infoParsed)) Expect(err).ToNot(HaveOccurred()) - inputs := fakeCPICmdRunner.CurrentRunInput - Expect(inputs).To(HaveLen(1)) - input := inputs[0] - expectedInput := fakebicloud.RunInput{ - Context: expectedContext, - Method: "info", - // The correct answer should be `[]interface{}{}` but because of https://github.com/golang/go/issues/4133 we have to use nil. - Arguments: nil, - ApiVersion: 1, - } - Expect(input.ApiVersion).To(Equal(expectedInput.ApiVersion)) - Expect(input.Method).To(Equal(expectedInput.Method)) - Expect(input.Context).To(Equal(expectedInput.Context)) - Expect(input.Arguments).To(Equal(expectedInput.Arguments)) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(1)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(0) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("info")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(BeNil()) }) It("uses a default cpi api version if an old cpi does not have api version", func() { @@ -111,9 +92,7 @@ var _ = Describe("Cloud", func() { StemcellFormats: []string{"aws-raw", "aws-light"}, ApiVersion: 1, } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ - Result: infoResult, - }} + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResult}, nil) cpiInfo, err := cloud.Info() Expect(cpiInfo).To(Equal(infoParsed)) Expect(err).ToNot(HaveOccurred()) @@ -121,7 +100,7 @@ var _ = Describe("Cloud", func() { Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("info")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("info")) }) It("returns an error", func() { @@ -140,9 +119,7 @@ var _ = Describe("Cloud", func() { StemcellFormats: []string{"aws-raw", "aws-light"}, ApiVersion: 2, } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ - Result: infoResult, - }} + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResult}, nil) cpiInfo, err := cloud.Info() Expect(err).ToNot(HaveOccurred()) Expect(cpiInfo).To(Equal(infoParsed)) @@ -157,9 +134,7 @@ var _ = Describe("Cloud", func() { "api_version": "57", } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ - Result: infoResultWithApiV2, - }} + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) }) It("returns an error", func() { @@ -168,15 +143,14 @@ var _ = Describe("Cloud", func() { Expect(err.Error()).To(ContainSubstring("Extracting api_version")) }) }) + Context("when stemcell formats is not a []string", func() { BeforeEach(func() { infoResultWithApiV2 = map[string]interface{}{ "stemcell_formats": "aws-raw", "api_version": stemcellApiVersion, } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ - Result: infoResultWithApiV2, - }} + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) }) It("returns an error", func() { @@ -189,13 +163,13 @@ var _ = Describe("Cloud", func() { Context("when info method is not implemented in CPI", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{ + fakeCPICmdRunner.RunReturns(CmdOutput{ Result: nil, Error: &CmdError{ Type: "InvalidCall", Message: "Method is not known, got 'info'", }, - }} + }, nil) }) It("should return default APIVersion", func() { @@ -219,30 +193,23 @@ var _ = Describe("Cloud", func() { "fake-key": "fake-value", } - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - {Result: 1}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) }) Context("when the cpi successfully creates the stemcell", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs[1] = CmdOutput{Result: "fake-cid"} + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: "fake-cid"}, nil) }) It("executes the cpi job script with stemcell image path & cloud_properties", func() { _, err := cloud.CreateStemcell(stemcellImagePath, cloudProperties) Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "create_stemcell", - Arguments: []interface{}{ - stemcellImagePath, - cloudProperties, - }, - ApiVersion: 1, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("create_stemcell")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{stemcellImagePath, cloudProperties})) }) It("returns the cid returned from executing the cpi script", func() { @@ -253,6 +220,10 @@ var _ = Describe("Cloud", func() { }) Context("when the result is of an unexpected type", func() { + BeforeEach(func() { + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: 1}, nil) + }) + It("returns an error", func() { _, err := cloud.CreateStemcell(stemcellImagePath, cloudProperties) Expect(err).To(HaveOccurred()) @@ -262,7 +233,7 @@ var _ = Describe("Cloud", func() { Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{nil, errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -280,28 +251,23 @@ var _ = Describe("Cloud", func() { Describe("DeleteStemcell", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) }) It("executes the delete_stemcell method on the CPI with stemcell cid", func() { err := cloud.DeleteStemcell("fake-stemcell-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "delete_stemcell", - Arguments: []interface{}{ - "fake-stemcell-cid", - }, - ApiVersion: 1, - })) + + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("delete_stemcell")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{"fake-stemcell-cid"})) }) Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{nil, errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -318,28 +284,23 @@ var _ = Describe("Cloud", func() { Describe("HasVM", func() { It("return true when VM exists", func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - {Result: true}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: true}, nil) found, err := cloud.HasVM("fake-vm-cid") Expect(err).ToNot(HaveOccurred()) Expect(found).To(BeTrue()) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "has_vm", - Arguments: []interface{}{"fake-vm-cid"}, - ApiVersion: 1, - })) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("has_vm")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{"fake-vm-cid"})) }) It("return false when VM does not exist", func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - {Result: false}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: false}, nil) found, err := cloud.HasVM("fake-vm-cid") Expect(err).ToNot(HaveOccurred()) @@ -348,10 +309,8 @@ var _ = Describe("Cloud", func() { Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - } - fakeCPICmdRunner.RunErrs = []error{nil, errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error when executing the CPI command fails", func() { @@ -399,32 +358,25 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully creates the vm", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - { - Result: infoResult, - }, - { - Result: "fake-vm-cid", - }, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: "fake-vm-cid"}, nil) }) It("executes the cpi job script with the director UUID and stemcell CID", func() { _, err := cloud.CreateVM(agentID, stemcellCID, cloudProperties, diskCIDs, networkInterfaces, env) Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "create_vm", - Arguments: []interface{}{ - agentID, - stemcellCID, - cloudProperties, - networkInterfaces, - diskCIDs, - env, - }, - ApiVersion: 1, + + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("create_vm")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{ + agentID, + stemcellCID, + cloudProperties, + networkInterfaces, + diskCIDs, + env, })) }) @@ -438,14 +390,8 @@ var _ = Describe("Cloud", func() { BeforeEach(func() { var networks interface{} - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - { - Result: infoResultWithApiV2, - }, - { - Result: []interface{}{"fake-vm-cid", networks}, - }, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResultWithApiV2}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: []interface{}{"fake-vm-cid", networks}}, nil) stemcellApiVersion = 2 }) @@ -458,15 +404,9 @@ var _ = Describe("Cloud", func() { Context("when the cpi's response is unexpected", func() { BeforeEach(func() { var networkHash = "can be anything, not checked right now" - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - { - Result: infoResultWithApiV2, - }, - { - // result: [vm-cid, network-hash{}] - Result: []interface{}{1, networkHash}, - }, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResultWithApiV2}, nil) + // result: [vm-cid, network-hash{}] + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: []interface{}{1, networkHash}}, nil) }) It("returns error", func() { @@ -480,14 +420,8 @@ var _ = Describe("Cloud", func() { Context("when the result is of an unexpected type", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - { - Result: infoResult, - }, - { - Result: 1, - }, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: 1}, nil) }) It("returns an error", func() { @@ -499,7 +433,7 @@ var _ = Describe("Cloud", func() { Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -517,37 +451,45 @@ var _ = Describe("Cloud", func() { }) Describe("SetDiskMetadata", func() { + var metadata DiskMetadata BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + + metadata = DiskMetadata{ + "director": "bosh-init", + "deployment": "some-deployment", + "instance_group": "some-instance_group", + "instance_index": "0", + "attached_at": "2017-03-22T10:17:04Z", } }) - metadata := DiskMetadata{ - "director": "bosh-init", - "deployment": "some-deployment", - "instance_group": "some-instance_group", - "instance_index": "0", - "attached_at": "2017-03-22T10:17:04Z", - } + It("calls the set_disk_metadata CPI method", func() { diskCID := "fake-disk-cid" err := cloud.SetDiskMetadata(diskCID, metadata) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "set_disk_metadata", - Arguments: []interface{}{ - diskCID, - metadata, - }, - ApiVersion: 1, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("set_disk_metadata")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{diskCID, metadata})) + + //Expect(cloudfakes.CurrentRunInput).To(HaveLen(2)) + //Expect(cloudfakes.CurrentRunInput[1]).To(Equal(cloudfakes.RunInput{ + // Context: expectedContext, + // Method: "set_disk_metadata", + // Arguments: []interface{}{ + // diskCID, + // metadata, + // }, + // ApiVersion: 1, + //})) }) It("returns the error if running fails", func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) diskCID := "fake-disk-cid" err := cloud.SetDiskMetadata(diskCID, metadata) @@ -563,10 +505,9 @@ var _ = Describe("Cloud", func() { Describe("SetVMMetadata", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) }) + It("calls the set_vm_metadata CPI method", func() { vmCID := "fake-vm-cid" metadata := VMMetadata{ @@ -579,20 +520,16 @@ var _ = Describe("Cloud", func() { err := cloud.SetVMMetadata(vmCID, metadata) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "set_vm_metadata", - Arguments: []interface{}{ - vmCID, - metadata, - }, - ApiVersion: 1, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("set_vm_metadata")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{vmCID, metadata})) }) It("returns the error if running fails", func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) vmCID := "fake-vm-cid" metadata := VMMetadata{ "director": "bosh-init", @@ -636,26 +573,19 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully creates the disk", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResultWithApiV2}, - {Result: "fake-disk-cid"}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResultWithApiV2}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: "fake-disk-cid"}, nil) }) It("executes the cpi job script with the correct arguments", func() { _, err := cloud.CreateDisk(size, cloudProperties, instanceID) Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "create_disk", - Arguments: []interface{}{ - size, - cloudProperties, - instanceID, - }, - ApiVersion: 2, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("create_disk")) + Expect(apiVersion).To(Equal(2)) + Expect(args).To(Equal([]interface{}{size, cloudProperties, instanceID})) }) It("returns the cid returned from executing the cpi script", func() { @@ -667,10 +597,8 @@ var _ = Describe("Cloud", func() { Context("when the result is of an unexpected type", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - {Result: 1}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: 1}, nil) }) It("returns an error", func() { @@ -682,7 +610,7 @@ var _ = Describe("Cloud", func() { Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -702,24 +630,18 @@ var _ = Describe("Cloud", func() { Context("when stemcell api version and cpi api version are 2", func() { DescribeTable("parsing disk hints as different types", func(inputHint interface{}, expected interface{}) { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResultWithApiV2}, - {Result: inputHint}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResultWithApiV2}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{Result: inputHint}, nil) stemcellApiVersion = 2 diskHint, err := cloud.AttachDisk("fake-vm-cid", "fake-disk-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "attach_disk", - Arguments: []interface{}{ - "fake-vm-cid", - "fake-disk-cid", - }, - ApiVersion: 2, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("attach_disk")) + Expect(apiVersion).To(Equal(2)) + Expect(args).To(Equal([]interface{}{"fake-vm-cid", "fake-disk-cid"})) Expect(diskHint).To(Equal(expected)) }, Entry("string", "/dev/sdf", "/dev/sdf"), @@ -735,30 +657,24 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully attaches the disk", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResult}, - } + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) }) It("executes the cpi job script with the correct arguments", func() { _, err := cloud.AttachDisk("fake-vm-cid", "fake-disk-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "attach_disk", - Arguments: []interface{}{ - "fake-vm-cid", - "fake-disk-cid", - }, - ApiVersion: 1, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("attach_disk")) + Expect(apiVersion).To(Equal(1)) + Expect(args).To(Equal([]interface{}{"fake-vm-cid", "fake-disk-cid"})) }) }) Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -778,28 +694,22 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully detaches the disk", func() { It("executes the cpi job script with the correct arguments", func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResultWithApiV2}, - } + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) err := cloud.DetachDisk("fake-vm-cid", "fake-disk-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "detach_disk", - Arguments: []interface{}{ - "fake-vm-cid", - "fake-disk-cid", - }, - ApiVersion: 2, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("detach_disk")) + Expect(apiVersion).To(Equal(2)) + Expect(args).To(Equal([]interface{}{"fake-vm-cid", "fake-disk-cid"})) }) }) Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -818,27 +728,22 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully deletes vm", func() { It("executes the cpi job script with the correct arguments", func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResultWithApiV2}, - } + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) err := cloud.DeleteVM("fake-vm-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "delete_vm", - Arguments: []interface{}{ - "fake-vm-cid", - }, - ApiVersion: 2, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("delete_vm")) + Expect(apiVersion).To(Equal(2)) + Expect(args).To(Equal([]interface{}{"fake-vm-cid"})) }) }) Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunErrs = []error{errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturns(CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { @@ -857,28 +762,23 @@ var _ = Describe("Cloud", func() { Context("when the cpi successfully deletes disk", func() { It("executes the cpi job script with the correct arguments", func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{ - {Result: infoResultWithApiV2}, - } + fakeCPICmdRunner.RunReturns(CmdOutput{Result: infoResultWithApiV2}, nil) err := cloud.DeleteDisk("fake-disk-cid") Expect(err).NotTo(HaveOccurred()) - Expect(fakeCPICmdRunner.CurrentRunInput).To(HaveLen(2)) - Expect(fakeCPICmdRunner.CurrentRunInput[1]).To(Equal(fakebicloud.RunInput{ - Context: expectedContext, - Method: "delete_disk", - Arguments: []interface{}{ - "fake-disk-cid", - }, - ApiVersion: 2, - })) + Expect(fakeCPICmdRunner.RunCallCount()).To(Equal(2)) + context, method, apiVersion, args := fakeCPICmdRunner.RunArgsForCall(1) + Expect(context).To(Equal(expectedContext)) + Expect(method).To(Equal("delete_disk")) + Expect(apiVersion).To(Equal(2)) + Expect(args).To(Equal([]interface{}{"fake-disk-cid"})) }) }) Context("when the cpi command execution fails", func() { BeforeEach(func() { - fakeCPICmdRunner.RunCmdOutputs = []CmdOutput{{Result: infoResult}} - fakeCPICmdRunner.RunErrs = []error{nil, errors.New("fake-run-error")} + fakeCPICmdRunner.RunReturnsOnCall(0, CmdOutput{Result: infoResult}, nil) + fakeCPICmdRunner.RunReturnsOnCall(1, CmdOutput{}, errors.New("fake-run-error")) }) It("returns an error", func() { diff --git a/cloud/cloudfakes/fake_cpicmd_runner.go b/cloud/cloudfakes/fake_cpicmd_runner.go new file mode 100644 index 0000000000..bcfc6e12cd --- /dev/null +++ b/cloud/cloudfakes/fake_cpicmd_runner.go @@ -0,0 +1,120 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cloudfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cloud" +) + +type FakeCPICmdRunner struct { + RunStub func(cloud.CmdContext, string, int, ...interface{}) (cloud.CmdOutput, error) + runMutex sync.RWMutex + runArgsForCall []struct { + arg1 cloud.CmdContext + arg2 string + arg3 int + arg4 []interface{} + } + runReturns struct { + result1 cloud.CmdOutput + result2 error + } + runReturnsOnCall map[int]struct { + result1 cloud.CmdOutput + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeCPICmdRunner) Run(arg1 cloud.CmdContext, arg2 string, arg3 int, arg4 ...interface{}) (cloud.CmdOutput, error) { + fake.runMutex.Lock() + ret, specificReturn := fake.runReturnsOnCall[len(fake.runArgsForCall)] + fake.runArgsForCall = append(fake.runArgsForCall, struct { + arg1 cloud.CmdContext + arg2 string + arg3 int + arg4 []interface{} + }{arg1, arg2, arg3, arg4}) + stub := fake.RunStub + fakeReturns := fake.runReturns + fake.recordInvocation("Run", []interface{}{arg1, arg2, arg3, arg4}) + fake.runMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4...) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeCPICmdRunner) RunCallCount() int { + fake.runMutex.RLock() + defer fake.runMutex.RUnlock() + return len(fake.runArgsForCall) +} + +func (fake *FakeCPICmdRunner) RunCalls(stub func(cloud.CmdContext, string, int, ...interface{}) (cloud.CmdOutput, error)) { + fake.runMutex.Lock() + defer fake.runMutex.Unlock() + fake.RunStub = stub +} + +func (fake *FakeCPICmdRunner) RunArgsForCall(i int) (cloud.CmdContext, string, int, []interface{}) { + fake.runMutex.RLock() + defer fake.runMutex.RUnlock() + argsForCall := fake.runArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeCPICmdRunner) RunReturns(result1 cloud.CmdOutput, result2 error) { + fake.runMutex.Lock() + defer fake.runMutex.Unlock() + fake.RunStub = nil + fake.runReturns = struct { + result1 cloud.CmdOutput + result2 error + }{result1, result2} +} + +func (fake *FakeCPICmdRunner) RunReturnsOnCall(i int, result1 cloud.CmdOutput, result2 error) { + fake.runMutex.Lock() + defer fake.runMutex.Unlock() + fake.RunStub = nil + if fake.runReturnsOnCall == nil { + fake.runReturnsOnCall = make(map[int]struct { + result1 cloud.CmdOutput + result2 error + }) + } + fake.runReturnsOnCall[i] = struct { + result1 cloud.CmdOutput + result2 error + }{result1, result2} +} + +func (fake *FakeCPICmdRunner) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeCPICmdRunner) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ cloud.CPICmdRunner = new(FakeCPICmdRunner) diff --git a/cloud/cpi_cmd_runner.go b/cloud/cpi_cmd_runner.go index eee31560bc..97ab7e8ee6 100644 --- a/cloud/cpi_cmd_runner.go +++ b/cloud/cpi_cmd_runner.go @@ -58,7 +58,7 @@ type CmdOutput struct { Log string `json:"log"` } -//#go:generate counterfeiter -o fakes/fake_cpi_cmd_runner.go . CPICmdRunner +//counterfeiter:generate . CPICmdRunner type CPICmdRunner interface { Run(context CmdContext, method string, apiVersion int, args ...interface{}) (CmdOutput, error) diff --git a/cloud/fakes/fake_cloud.go b/cloud/fakes/fake_cloud.go deleted file mode 100644 index 44850ce793..0000000000 --- a/cloud/fakes/fake_cloud.go +++ /dev/null @@ -1,212 +0,0 @@ -package fakes - -import ( - biproperty "github.com/cloudfoundry/bosh-utils/property" - - "github.com/cloudfoundry/bosh-cli/v7/cloud" -) - -type FakeCloud struct { - CreateStemcellInputs []CreateStemcellInput - CreateStemcellCID string - CreateStemcellErr error - - HasVMInput HasVMInput - HasVMFound bool - HasVMErr error - - CreateVMInput CreateVMInput - CreateVMCID string - CreateVMErr error - - CreateDiskInput CreateDiskInput - CreateDiskCID string - CreateDiskErr error - - AttachDiskInput AttachDiskInput - AttachDiskHints interface{} - AttachDiskErr error - - DetachDiskInput DetachDiskInput - DetachDiskErr error - - DeleteVMInput DeleteVMInput - DeleteVMErr error - - DeleteDiskInputs []DeleteDiskInput - DeleteDiskErr error - - DeleteStemcellInputs []DeleteStemcellInput - DeleteStemcellErr error - - SetVMMetadataCid string - SetVMMetadataMetadata cloud.VMMetadata - SetVMMetadataError error - - SetDiskMetadataCid string - SetDiskMetadataMetadata cloud.DiskMetadata - SetDiskMetadataError error - - InfoResult cloud.CpiInfo - InfoError error -} - -type CreateStemcellInput struct { - ImagePath string - CloudProperties biproperty.Map -} - -type HasVMInput struct { - VMCID string -} - -type CreateVMInput struct { - AgentID string - StemcellCID string - CloudProperties biproperty.Map - DiskCIDs []string - NetworksInterfaces map[string]biproperty.Map - Env biproperty.Map -} - -type CreateDiskInput struct { - Size int - CloudProperties biproperty.Map - InstanceID string -} - -type AttachDiskInput struct { - VMCID string - DiskCID string -} - -type DetachDiskInput struct { - VMCID string - DiskCID string -} - -type DeleteVMInput struct { - VMCID string -} - -type DeleteDiskInput struct { - DiskCID string -} - -type DeleteStemcellInput struct { - StemcellCID string -} - -func NewFakeCloud() *FakeCloud { - return &FakeCloud{ - CreateStemcellInputs: []CreateStemcellInput{}, - DeleteDiskInputs: []DeleteDiskInput{}, - } -} - -func (c *FakeCloud) CreateStemcell(imagePath string, cloudProperties biproperty.Map) (string, error) { - c.CreateStemcellInputs = append(c.CreateStemcellInputs, CreateStemcellInput{ - ImagePath: imagePath, - CloudProperties: cloudProperties, - }) - - return c.CreateStemcellCID, c.CreateStemcellErr -} - -func (c *FakeCloud) DeleteStemcell(stemcellCID string) error { - c.DeleteStemcellInputs = append(c.DeleteStemcellInputs, DeleteStemcellInput{ - StemcellCID: stemcellCID, - }) - return c.DeleteStemcellErr -} - -func (c *FakeCloud) HasVM(vmCID string) (bool, error) { - c.HasVMInput = HasVMInput{ - VMCID: vmCID, - } - return c.HasVMFound, c.HasVMErr -} - -func (c *FakeCloud) CreateVM( - agentID string, - stemcellCID string, - cloudProperties biproperty.Map, - diskCIDs []string, - networksInterfaces map[string]biproperty.Map, - env biproperty.Map, -) (string, error) { - c.CreateVMInput = CreateVMInput{ - AgentID: agentID, - StemcellCID: stemcellCID, - CloudProperties: cloudProperties, - DiskCIDs: diskCIDs, - NetworksInterfaces: networksInterfaces, - Env: env, - } - - return c.CreateVMCID, c.CreateVMErr -} - -func (c *FakeCloud) SetVMMetadata(cid string, metadata cloud.VMMetadata) error { - c.SetVMMetadataCid = cid - c.SetVMMetadataMetadata = metadata - return c.SetVMMetadataError -} - -func (c *FakeCloud) SetDiskMetadata(cid string, metadata cloud.DiskMetadata) error { - c.SetDiskMetadataCid = cid - c.SetDiskMetadataMetadata = metadata - return c.SetDiskMetadataError -} - -func (c *FakeCloud) CreateDisk( - size int, - cloudProperties biproperty.Map, - instanceID string, -) (string, error) { - c.CreateDiskInput = CreateDiskInput{ - Size: size, - CloudProperties: cloudProperties, - InstanceID: instanceID, - } - - return c.CreateDiskCID, c.CreateDiskErr -} - -func (c *FakeCloud) AttachDisk(vmCID, diskCID string) (interface{}, error) { - c.AttachDiskInput = AttachDiskInput{ - VMCID: vmCID, - DiskCID: diskCID, - } - return c.AttachDiskHints, c.AttachDiskErr -} - -func (c *FakeCloud) DetachDisk(vmCID, diskCID string) error { - c.DetachDiskInput = DetachDiskInput{ - VMCID: vmCID, - DiskCID: diskCID, - } - return c.DetachDiskErr -} - -func (c *FakeCloud) DeleteVM(vmCID string) error { - c.DeleteVMInput = DeleteVMInput{ - VMCID: vmCID, - } - return c.DeleteVMErr -} - -func (c *FakeCloud) DeleteDisk(diskCID string) error { - c.DeleteDiskInputs = append(c.DeleteDiskInputs, DeleteDiskInput{ - DiskCID: diskCID, - }) - return c.DeleteDiskErr -} - -func (c *FakeCloud) Info() (cpiInfo cloud.CpiInfo, err error) { - return c.InfoResult, c.InfoError -} - -func (c *FakeCloud) String() string { - return "FakeCloud{}" -} diff --git a/cloud/fakes/fake_cpi_cmd_runner.go b/cloud/fakes/fake_cpi_cmd_runner.go deleted file mode 100644 index eb656341dd..0000000000 --- a/cloud/fakes/fake_cpi_cmd_runner.go +++ /dev/null @@ -1,60 +0,0 @@ -package fakes - -import ( - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" -) - -type FakeCPICmdRunner struct { - CurrentRunInput []RunInput - CurrentRunCmdOutput bicloud.CmdOutput - CurrentRunError error - RunInputs [][]RunInput - RunCmdOutputs []bicloud.CmdOutput - RunErrs []error -} - -type RunInput struct { - Context bicloud.CmdContext - Method string - Arguments []interface{} - ApiVersion int -} - -func NewFakeCPICmdRunner() *FakeCPICmdRunner { - return &FakeCPICmdRunner{} -} - -func (r *FakeCPICmdRunner) Run(context bicloud.CmdContext, method string, apiVersion int, args ...interface{}) (bicloud.CmdOutput, error) { - if len(r.RunCmdOutputs) > 0 { - r.CurrentRunCmdOutput = r.RunCmdOutputs[0] - - if len(r.RunCmdOutputs) > 1 { - r.RunCmdOutputs = r.RunCmdOutputs[1:] - } - } - - if len(r.RunInputs) > 0 { - r.CurrentRunInput = r.RunInputs[0] - - if len(r.RunInputs) > 1 { - r.RunInputs = r.RunInputs[1:] - } - } - - if len(r.RunErrs) > 0 { - r.CurrentRunError = r.RunErrs[0] - - if len(r.RunErrs) > 1 { - r.RunErrs = r.RunErrs[1:] - } - } - - r.CurrentRunInput = append(r.CurrentRunInput, RunInput{ - Context: context, - Method: method, - Arguments: args, - ApiVersion: apiVersion, - }) - - return r.CurrentRunCmdOutput, r.CurrentRunError -} diff --git a/deployment/deployer_test.go b/deployment/deployer_test.go index 4391ca7ad7..4fcb7bd837 100644 --- a/deployment/deployer_test.go +++ b/deployment/deployer_test.go @@ -13,7 +13,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" @@ -37,7 +37,7 @@ var _ = Describe("Deployer", func() { mockAgentClientFactory *cmdfakes.FakeAgentClientFactory fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory fakeSSHTunnel *fakebisshtunnel.FakeTunnel - cloud *fakebicloud.FakeCloud + cloud *cloudfakes.FakeCloud deploymentManifest bideplmanifest.Manifest diskPool bideplmanifest.DiskPool fakeStage *fakebiui.FakeStage @@ -85,7 +85,7 @@ var _ = Describe("Deployer", func() { skipDrain = false diskCIDs = []string{"fake-disk-cid-1"} - cloud = fakebicloud.NewFakeCloud() + cloud = &cloudfakes.FakeCloud{} mockAgentClientFactory = &cmdfakes.FakeAgentClientFactory{} mockAgentClient = &agentclientfakes.FakeAgentClient{} diff --git a/deployment/disk/disk_test.go b/deployment/disk/disk_test.go index 1b502aab55..d8ca4595fb 100644 --- a/deployment/disk/disk_test.go +++ b/deployment/disk/disk_test.go @@ -11,7 +11,7 @@ import ( . "github.com/onsi/gomega" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" . "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" ) @@ -20,7 +20,7 @@ var _ = Describe("Disk", func() { var ( disk Disk diskCloudProperties biproperty.Map - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud diskRepo biconfig.DiskRepo fakeUUIDGenerator *fakeuuid.FakeGenerator ) @@ -30,7 +30,7 @@ var _ = Describe("Disk", func() { "fake-cloud-property-key": "fake-cloud-property-value", "list-property": []interface{}{"list-item"}, } - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} diskRecord := biconfig.DiskRecord{ CID: "fake-disk-cid", @@ -94,11 +94,8 @@ var _ = Describe("Disk", func() { It("deletes disk from cloud", func() { err := disk.Delete() Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DeleteDiskInputs).To(Equal([]fakebicloud.DeleteDiskInput{ - { - DiskCID: "fake-disk-cid", - }, - })) + Expect(fakeCloud.DeleteDiskCallCount()).To(Equal(1)) + Expect(fakeCloud.DeleteDiskArgsForCall(0)).To(Equal("fake-disk-cid")) }) It("deletes disk from repo", func() { @@ -133,7 +130,7 @@ var _ = Describe("Disk", func() { Context("when deleting disk in the cloud fails", func() { BeforeEach(func() { - fakeCloud.DeleteDiskErr = errors.New("fake-delete-disk-error") + fakeCloud.DeleteDiskReturns(errors.New("fake-delete-disk-error")) }) It("returns an error", func() { @@ -156,7 +153,7 @@ var _ = Describe("Disk", func() { err = diskRepo.UpdateCurrent(diskRecord.ID) Expect(err).ToNot(HaveOccurred()) - fakeCloud.DeleteDiskErr = deleteErr + fakeCloud.DeleteDiskReturns(deleteErr) }) It("deletes disk in the cloud", func() { @@ -164,11 +161,8 @@ var _ = Describe("Disk", func() { Expect(err).To(HaveOccurred()) Expect(err).To(Equal(deleteErr)) - Expect(fakeCloud.DeleteDiskInputs).To(Equal([]fakebicloud.DeleteDiskInput{ - { - DiskCID: "fake-disk-cid", - }, - })) + Expect(fakeCloud.DeleteDiskCallCount()).To(Equal(1)) + Expect(fakeCloud.DeleteDiskArgsForCall(0)).To(Equal("fake-disk-cid")) }) It("deletes disk in the disk repo", func() { diff --git a/deployment/disk/manager_test.go b/deployment/disk/manager_test.go index a58891d6ff..7d79e57958 100644 --- a/deployment/disk/manager_test.go +++ b/deployment/disk/manager_test.go @@ -10,7 +10,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -20,7 +20,7 @@ import ( var _ = Describe("Manager", func() { var ( manager bidisk.Manager - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud fakeFs *fakesys.FakeFileSystem fakeUUIDGenerator *fakeuuid.FakeGenerator diskRepo biconfig.DiskRepo @@ -33,7 +33,7 @@ var _ = Describe("Manager", func() { deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fakeFs, fakeUUIDGenerator, logger, "/fake/path") diskRepo = biconfig.NewDiskRepo(deploymentStateService, fakeUUIDGenerator) managerFactory := bidisk.NewManagerFactory(diskRepo, logger) - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} manager = managerFactory.NewManager(fakeCloud) fakeUUIDGenerator.GeneratedUUID = "fake-uuid" }) @@ -44,7 +44,6 @@ var _ = Describe("Manager", func() { ) BeforeEach(func() { - diskPool = bideplmanifest.DiskPool{ Name: "fake-disk-pool-name", DiskSize: 1024, @@ -56,7 +55,7 @@ var _ = Describe("Manager", func() { Context("when creating disk succeeds", func() { BeforeEach(func() { - fakeCloud.CreateDiskCID = "fake-disk-cid" + fakeCloud.CreateDiskReturns("fake-disk-cid", nil) }) It("returns a disk", func() { @@ -86,7 +85,7 @@ var _ = Describe("Manager", func() { Context("when creating disk fails", func() { BeforeEach(func() { - fakeCloud.CreateDiskErr = errors.New("fake-create-error") + fakeCloud.CreateDiskReturns("", errors.New("fake-create-error")) }) It("returns an error", func() { @@ -212,10 +211,9 @@ var _ = Describe("Manager", func() { err := manager.DeleteUnused(fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DeleteDiskInputs).To(Equal([]fakebicloud.DeleteDiskInput{ - {DiskCID: "fake-disk-cid-1"}, - {DiskCID: "fake-disk-cid-3"}, - })) + Expect(fakeCloud.DeleteDiskCallCount()).To(Equal(2)) + Expect(fakeCloud.DeleteDiskArgsForCall(0)).To(Equal("fake-disk-cid-1")) + Expect(fakeCloud.DeleteDiskArgsForCall(1)).To(Equal("fake-disk-cid-3")) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Deleting unused disk 'fake-disk-cid-1'"}, diff --git a/deployment/instance/manager_test.go b/deployment/instance/manager_test.go index d37f792f90..9c72ea6a24 100644 --- a/deployment/instance/manager_test.go +++ b/deployment/instance/manager_test.go @@ -13,7 +13,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/agentclient/agentclientfakes" "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" @@ -31,7 +31,7 @@ var _ = Describe("Manager", func() { ) var ( - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud mockStateBuilderFactory *statefakes.FakeBuilderFactory mockStateBuilder *statefakes.FakeBuilder @@ -50,8 +50,7 @@ var _ = Describe("Manager", func() { ) BeforeEach(func() { - fakeCloud = fakebicloud.NewFakeCloud() - + fakeCloud = &cloudfakes.FakeCloud{} fakeVMManager = fakebivm.NewFakeManager() fakeSSHTunnelFactory = fakebisshtunnel.NewFakeFactory() diff --git a/deployment/vm/disk_deployer_test.go b/deployment/vm/disk_deployer_test.go index 3cd8512084..401bbbbeac 100644 --- a/deployment/vm/disk_deployer_test.go +++ b/deployment/vm/disk_deployer_test.go @@ -7,7 +7,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" @@ -23,7 +23,7 @@ var _ = Describe("DiskDeployer", func() { diskDeployer DiskDeployer fakeDiskManager *fakebidisk.FakeManager diskPool bideplmanifest.DiskPool - cloud *fakebicloud.FakeCloud + cloud *cloudfakes.FakeCloud fakeStage *fakebiui.FakeStage fakeVM *fakebivm.FakeVM fakeDisk *fakebidisk.FakeDisk @@ -33,7 +33,7 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - cloud = fakebicloud.NewFakeCloud() + cloud = &cloudfakes.FakeCloud{} fakeVM = fakebivm.NewFakeVM("fake-vm-cid") fakeDiskManagerFactory = fakebidisk.NewFakeManagerFactory() diff --git a/deployment/vm/manager_test.go b/deployment/vm/manager_test.go index 9bd8184116..5a9ecf9616 100644 --- a/deployment/vm/manager_test.go +++ b/deployment/vm/manager_test.go @@ -14,7 +14,7 @@ import ( . "github.com/onsi/gomega" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -25,7 +25,7 @@ import ( var _ = Describe("Manager", func() { var ( - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud manager Manager logger boshlog.Logger expectedNetworkInterfaces map[string]biproperty.Map @@ -45,7 +45,7 @@ var _ = Describe("Manager", func() { BeforeEach(func() { logger = boshlog.NewLogger(boshlog.LevelNone) fs = fakesys.NewFakeFileSystem() - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} fakeAgentClient = &fakebiagentclient.FakeAgentClient{} fakeVMRepo = fakebiconfig.NewFakeVMRepo() @@ -70,7 +70,7 @@ var _ = Describe("Manager", func() { fakeTimeService, ) - fakeCloud.CreateVMCID = "fake-vm-cid" + fakeCloud.CreateVMReturns("fake-vm-cid", nil) expectedNetworkInterfaces = map[string]biproperty.Map{ "fake-network-name": biproperty.Map{ "type": "dynamic", @@ -149,23 +149,25 @@ var _ = Describe("Manager", func() { ) Expect(vm).To(Equal(expectedVM)) - Expect(fakeCloud.CreateVMInput).To(Equal( - fakebicloud.CreateVMInput{ - AgentID: "fake-uuid-0", - StemcellCID: "fake-stemcell-cid", - CloudProperties: expectedCloudProperties, - DiskCIDs: diskCIDs, - NetworksInterfaces: expectedNetworkInterfaces, - Env: expectedEnv, - }, - )) + Expect(fakeCloud.CreateVMCallCount()).To(Equal(1)) + agentID, stemcellCID, cloudProperties, diskCIDS, networksInterfaces, env := + fakeCloud.CreateVMArgsForCall(0) + Expect(agentID).To(Equal("fake-uuid-0")) + Expect(stemcellCID).To(Equal("fake-stemcell-cid")) + Expect(cloudProperties).To(Equal(expectedCloudProperties)) + Expect(diskCIDS).To(Equal(diskCIDs)) + Expect(networksInterfaces).To(Equal(expectedNetworkInterfaces)) + Expect(env).To(Equal(expectedEnv)) }) It("sets the vm metadata", func() { _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) - Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.SetVMMetadataCid).To(Equal("fake-vm-cid")) - Expect(fakeCloud.SetVMMetadataMetadata).To(Equal(bicloud.VMMetadata{ + Expect(err).NotTo(HaveOccurred()) + + Expect(fakeCloud.SetVMMetadataCallCount()).To(Equal(1)) + vmCid, metadata := fakeCloud.SetVMMetadataArgsForCall(0) + Expect(vmCid).To(Equal("fake-vm-cid")) + Expect(metadata).To(Equal(bicloud.VMMetadata{ "deployment": "fake-deployment", "job": "fake-job", "instance_group": "fake-job", @@ -196,18 +198,20 @@ var _ = Describe("Manager", func() { _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.CreateVMInput).To(Equal( - fakebicloud.CreateVMInput{ - AgentID: "fake-uuid-0", - StemcellCID: "fake-stemcell-cid", - CloudProperties: expectedCloudProperties, - DiskCIDs: diskCIDs, - NetworksInterfaces: expectedNetworkInterfaces, - Env: expectedEnv, - }, - )) + Expect(fakeCloud.CreateVMCallCount()).To(Equal(1)) + agentID, stemcellCID, cloudProperties, diskCIDS, networksInterfaces, env := + fakeCloud.CreateVMArgsForCall(0) + Expect(agentID).To(Equal("fake-uuid-0")) + Expect(stemcellCID).To(Equal("fake-stemcell-cid")) + Expect(cloudProperties).To(Equal(expectedCloudProperties)) + Expect(diskCIDS).To(Equal(diskCIDs)) + Expect(networksInterfaces).To(Equal(expectedNetworkInterfaces)) + Expect(env).To(Equal(expectedEnv)) - Expect(fakeCloud.SetVMMetadataMetadata).To(Equal(bicloud.VMMetadata{ + Expect(fakeCloud.SetVMMetadataCallCount()).To(Equal(1)) + vmCid, metadata := fakeCloud.SetVMMetadataArgsForCall(0) + Expect(vmCid).To(Equal("fake-vm-cid")) + Expect(metadata).To(Equal(bicloud.VMMetadata{ "deployment": "fake-deployment", "job": "fake-job", "name": "fake-job/0", @@ -234,7 +238,10 @@ var _ = Describe("Manager", func() { _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.SetVMMetadataMetadata).To(Equal(bicloud.VMMetadata{ + Expect(fakeCloud.SetVMMetadataCallCount()).To(Equal(1)) + vmCid, metadata := fakeCloud.SetVMMetadataArgsForCall(0) + Expect(vmCid).To(Equal("fake-vm-cid")) + Expect(metadata).To(Equal(bicloud.VMMetadata{ "deployment": "manifest-deployment", "job": "manifest-job", "name": "awesome-name", @@ -255,17 +262,16 @@ var _ = Describe("Manager", func() { }) Context("when setting vm metadata fails", func() { - BeforeEach(func() { - fakeCloud.SetVMMetadataError = errors.New("fake-set-metadata-error") - }) - It("returns an error", func() { + fakeCloud.SetVMMetadataReturns(errors.New("fake-set-metadata-error")) + _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-metadata-error")) }) It("still updates the current vm record", func() { + fakeCloud.SetVMMetadataReturns(errors.New("fake-set-metadata-error")) _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).To(HaveOccurred()) Expect(fakeVMRepo.UpdateCurrentCID).To(Equal("fake-vm-cid")) @@ -277,7 +283,7 @@ var _ = Describe("Manager", func() { Message: "set_vm_metadata is not implemented by VCloudCloud::Cloud", OkToRetry: false, }) - fakeCloud.SetVMMetadataError = notImplementedCloudError + fakeCloud.SetVMMetadataReturns(notImplementedCloudError) _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).ToNot(HaveOccurred()) @@ -286,7 +292,7 @@ var _ = Describe("Manager", func() { Context("when creating the vm fails", func() { BeforeEach(func() { - fakeCloud.CreateVMErr = errors.New("fake-create-error") + fakeCloud.CreateVMReturns("", errors.New("fake-create-error")) }) It("returns an error", func() { diff --git a/deployment/vm/vm_test.go b/deployment/vm/vm_test.go index c2626c1a50..b212276c94 100644 --- a/deployment/vm/vm_test.go +++ b/deployment/vm/vm_test.go @@ -14,7 +14,7 @@ import ( . "github.com/onsi/gomega" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" @@ -32,7 +32,7 @@ var _ = Describe("VM", func() { fakeStemcellRepo *fakebiconfig.FakeStemcellRepo fakeDiskDeployer *fakebivm.FakeDiskDeployer fakeAgentClient *fakebiagentclient.FakeAgentClient - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud applySpec bias.ApplySpec diskPool bideplmanifest.DiskPool timeService *FakeClock @@ -59,7 +59,7 @@ var _ = Describe("VM", func() { logger = &loggerfakes.FakeLogger{} fs = fakesys.NewFakeFileSystem() - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} fakeVMRepo = fakebiconfig.NewFakeVMRepo() fakeStemcellRepo = fakebiconfig.NewFakeStemcellRepo() fakeDiskDeployer = fakebivm.NewFakeDiskDeployer() @@ -78,7 +78,7 @@ var _ = Describe("VM", func() { Describe("Exists", func() { It("returns true when the vm exists", func() { - fakeCloud.HasVMFound = true + fakeCloud.HasVMReturns(true, nil) exists, err := vm.Exists() Expect(err).ToNot(HaveOccurred()) @@ -86,7 +86,7 @@ var _ = Describe("VM", func() { }) It("returns false when the vm does not exist", func() { - fakeCloud.HasVMFound = false + fakeCloud.HasVMReturns(false, nil) exists, err := vm.Exists() Expect(err).ToNot(HaveOccurred()) @@ -94,7 +94,7 @@ var _ = Describe("VM", func() { }) It("returns error when checking fails", func() { - fakeCloud.HasVMErr = errors.New("fake-has-vm-error") + fakeCloud.HasVMReturns(false, errors.New("fake-has-vm-error")) _, err := vm.Exists() Expect(err).To(HaveOccurred()) @@ -302,14 +302,14 @@ var _ = Describe("VM", func() { It("attaches disk to vm in the cloud", func() { err := vm.AttachDisk(disk) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.AttachDiskInput).To(Equal(fakebicloud.AttachDiskInput{ - VMCID: "fake-vm-cid", - DiskCID: "fake-disk-cid", - })) + Expect(fakeCloud.AttachDiskCallCount()).To(Equal(1)) + vmCid, diskCid := fakeCloud.AttachDiskArgsForCall(0) + Expect(vmCid).To(Equal("fake-vm-cid")) + Expect(diskCid).To(Equal("fake-disk-cid")) }) It("does not call agent AddPersistentDisk when diskHints are nil", func() { - fakeCloud.AttachDiskHints = nil + fakeCloud.AttachDiskReturns(nil, nil) err := vm.AttachDisk(disk) @@ -318,7 +318,7 @@ var _ = Describe("VM", func() { }) It("adds the persistent disk to the agent", func() { - fakeCloud.AttachDiskHints = "/dev/sdb" + fakeCloud.AttachDiskReturns("/dev/sdb", nil) err := vm.AttachDisk(disk) @@ -351,8 +351,10 @@ var _ = Describe("VM", func() { err := vm.AttachDisk(disk) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.SetDiskMetadataCid).To(Equal("fake-disk-cid")) - Expect(fakeCloud.SetDiskMetadataMetadata).To(Equal(expectedDiskMetadata)) + Expect(fakeCloud.SetDiskMetadataCallCount()).To(Equal(1)) + diskCid, diskMetadata := fakeCloud.SetDiskMetadataArgsForCall(0) + Expect(diskCid).To(Equal("fake-disk-cid")) + Expect(diskMetadata).To(Equal(expectedDiskMetadata)) }) Context("when setting metadata is not supported by the CPI", func() { @@ -360,7 +362,7 @@ var _ = Describe("VM", func() { cmdError := bicloud.CmdError{ Type: bicloud.NotImplementedError, } - fakeCloud.SetDiskMetadataError = bicloud.NewCPIError("set_disk_metadata", cmdError) + fakeCloud.SetDiskMetadataReturns(bicloud.NewCPIError("set_disk_metadata", cmdError)) }) It("logs a warning", func() { @@ -379,7 +381,7 @@ var _ = Describe("VM", func() { cmdError := bicloud.CmdError{ Message: "some error", } - fakeCloud.SetDiskMetadataError = bicloud.NewCPIError("set_disk_metadata", cmdError) + fakeCloud.SetDiskMetadataReturns(bicloud.NewCPIError("set_disk_metadata", cmdError)) }) It("returns an error", func() { @@ -393,7 +395,7 @@ var _ = Describe("VM", func() { Context("when AddPersistentDisk returns 'unknown message add_persistent_disk'", func() { BeforeEach(func() { - fakeCloud.AttachDiskHints = "/dev/sdb" + fakeCloud.AttachDiskReturns("/dev/sdb", nil) fakeAgentClient.AddPersistentDiskReturns(errors.New("Agent responded with error: unknown message add_persistent_disk")) }) @@ -405,7 +407,7 @@ var _ = Describe("VM", func() { Context("when AddPersistentDisk returns anything other than 'unknown message add_persistent_disk'", func() { BeforeEach(func() { - fakeCloud.AttachDiskHints = "/dev/sdb" + fakeCloud.AttachDiskReturns("/dev/sdb", nil) fakeAgentClient.AddPersistentDiskReturns(errors.New("fake-agent-error")) }) @@ -418,7 +420,7 @@ var _ = Describe("VM", func() { Context("when attaching disk to cloud fails", func() { BeforeEach(func() { - fakeCloud.AttachDiskErr = errors.New("fake-attach-error") + fakeCloud.AttachDiskReturns(nil, errors.New("fake-attach-error")) }) It("returns an error", func() { @@ -470,10 +472,10 @@ var _ = Describe("VM", func() { It("detaches disk from vm in the cloud", func() { err := vm.DetachDisk(disk) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DetachDiskInput).To(Equal(fakebicloud.DetachDiskInput{ - VMCID: "fake-vm-cid", - DiskCID: "fake-disk-cid", - })) + Expect(fakeCloud.DetachDiskCallCount()).To(Equal(1)) + vmCid, diskCid := fakeCloud.DetachDiskArgsForCall(0) + Expect(vmCid).To(Equal("fake-vm-cid")) + Expect(diskCid).To(Equal("fake-disk-cid")) Expect(fakeAgentClient.PingCallCount()).To(Equal(1)) }) @@ -502,7 +504,7 @@ var _ = Describe("VM", func() { Context("when detaching disk to cloud fails", func() { BeforeEach(func() { - fakeCloud.DetachDiskErr = errors.New("fake-detach-error") + fakeCloud.DetachDiskReturns(errors.New("fake-detach-error")) }) It("returns an error", func() { @@ -579,9 +581,8 @@ var _ = Describe("VM", func() { It("deletes vm in the cloud", func() { err := vm.Delete() Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DeleteVMInput).To(Equal(fakebicloud.DeleteVMInput{ - VMCID: "fake-vm-cid", - })) + Expect(fakeCloud.DeleteVMCallCount()).To(Equal(1)) + Expect(fakeCloud.DeleteVMArgsForCall(0)).To(Equal("fake-vm-cid")) }) It("deletes VM in the vm repo", func() { @@ -598,7 +599,7 @@ var _ = Describe("VM", func() { Context("when deleting vm in the cloud fails", func() { BeforeEach(func() { - fakeCloud.DeleteVMErr = errors.New("fake-delete-vm-error") + fakeCloud.DeleteVMReturns(errors.New("fake-delete-vm-error")) }) It("returns an error", func() { @@ -615,16 +616,14 @@ var _ = Describe("VM", func() { }) BeforeEach(func() { - fakeCloud.DeleteVMErr = deleteErr + fakeCloud.DeleteVMReturns(deleteErr) }) It("deletes vm in the cloud", func() { err := vm.Delete() Expect(err).To(HaveOccurred()) Expect(err).To(Equal(deleteErr)) - Expect(fakeCloud.DeleteVMInput).To(Equal(fakebicloud.DeleteVMInput{ - VMCID: "fake-vm-cid", - })) + Expect(fakeCloud.DeleteVMArgsForCall(0)).To(Equal("fake-vm-cid")) }) It("deletes VM in the vm repo", func() { diff --git a/stemcell/cloud_stemcell_test.go b/stemcell/cloud_stemcell_test.go index cd052d570e..b8e4df31de 100644 --- a/stemcell/cloud_stemcell_test.go +++ b/stemcell/cloud_stemcell_test.go @@ -10,7 +10,7 @@ import ( . "github.com/onsi/gomega" bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" . "github.com/cloudfoundry/bosh-cli/v7/stemcell" ) @@ -19,7 +19,7 @@ var _ = Describe("CloudStemcell", func() { var ( stemcellRepo biconfig.StemcellRepo fakeUUIDGenerator *fakeuuid.FakeGenerator - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud cloudStemcell CloudStemcell stemcellApiVersion = 2 ) @@ -35,7 +35,7 @@ var _ = Describe("CloudStemcell", func() { fakeUUIDGenerator = &fakeuuid.FakeGenerator{} deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, "/fake/path") stemcellRepo = biconfig.NewStemcellRepo(deploymentStateService, fakeUUIDGenerator) - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} cloudStemcell = NewCloudStemcell(stemcellRecord, stemcellRepo, fakeCloud) }) @@ -77,11 +77,8 @@ var _ = Describe("CloudStemcell", func() { It("deletes stemcell from cloud", func() { err := cloudStemcell.Delete() Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DeleteStemcellInputs).To(Equal([]fakebicloud.DeleteStemcellInput{ - { - StemcellCID: "fake-stemcell-cid", - }, - })) + Expect(fakeCloud.DeleteStemcellCallCount()).To(Equal(1)) + Expect(fakeCloud.DeleteStemcellArgsForCall(0)).To(Equal("fake-stemcell-cid")) }) It("deletes stemcell from repo", func() { @@ -116,7 +113,7 @@ var _ = Describe("CloudStemcell", func() { Context("when deleting stemcell in the cloud fails", func() { BeforeEach(func() { - fakeCloud.DeleteStemcellErr = errors.New("fake-delete-stemcell-error") + fakeCloud.DeleteStemcellReturns(errors.New("fake-delete-stemcell-error")) }) It("returns an error", func() { @@ -139,7 +136,7 @@ var _ = Describe("CloudStemcell", func() { err = stemcellRepo.UpdateCurrent(stemcellRecord.ID) Expect(err).ToNot(HaveOccurred()) - fakeCloud.DeleteStemcellErr = deleteErr + fakeCloud.DeleteStemcellReturns(deleteErr) }) It("deletes stemcell in the cloud", func() { @@ -147,11 +144,8 @@ var _ = Describe("CloudStemcell", func() { Expect(err).To(HaveOccurred()) Expect(err).To(Equal(deleteErr)) - Expect(fakeCloud.DeleteStemcellInputs).To(Equal([]fakebicloud.DeleteStemcellInput{ - { - StemcellCID: "fake-stemcell-cid", - }, - })) + Expect(fakeCloud.DeleteStemcellCallCount()).To(Equal(1)) + Expect(fakeCloud.DeleteStemcellArgsForCall(0)).To(Equal("fake-stemcell-cid")) }) It("deletes stemcell in the disk repo", func() { diff --git a/stemcell/manager_test.go b/stemcell/manager_test.go index 127e02d0ad..0911c78484 100644 --- a/stemcell/manager_test.go +++ b/stemcell/manager_test.go @@ -11,7 +11,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakebicloud "github.com/cloudfoundry/bosh-cli/v7/cloud/fakes" + "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" . "github.com/cloudfoundry/bosh-cli/v7/stemcell" fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" @@ -25,7 +25,7 @@ var _ = Describe("Manager", func() { manager Manager fs *fakesys.FakeFileSystem reader *fakebistemcell.FakeStemcellReader - fakeCloud *fakebicloud.FakeCloud + fakeCloud *cloudfakes.FakeCloud fakeStage *fakebiui.FakeStage stemcellTarballPath string tempExtractionDir string @@ -43,7 +43,7 @@ var _ = Describe("Manager", func() { fakeUUIDGenerator.GeneratedUUID = "fake-stemcell-id-1" stemcellRepo = biconfig.NewStemcellRepo(deploymentStateService, fakeUUIDGenerator) fakeStage = fakebiui.NewFakeStage() - fakeCloud = fakebicloud.NewFakeCloud() + fakeCloud = &cloudfakes.FakeCloud{} manager = NewManager(stemcellRepo, fakeCloud) stemcellTarballPath = filepath.Join("/", "stemcell", "tarball", "path") tempExtractionDir = filepath.Join("/", "path", "to", "dest") @@ -70,7 +70,7 @@ var _ = Describe("Manager", func() { ) BeforeEach(func() { - fakeCloud.CreateStemcellCID = "fake-stemcell-cid" + fakeCloud.CreateStemcellReturns("fake-stemcell-cid", nil) stemcellRecord := biconfig.StemcellRecord{ CID: "fake-stemcell-cid", Name: "fake-stemcell-name", @@ -84,14 +84,10 @@ var _ = Describe("Manager", func() { Expect(err).ToNot(HaveOccurred()) Expect(cloudStemcell).To(Equal(expectedCloudStemcell)) - Expect(fakeCloud.CreateStemcellInputs).To(Equal([]fakebicloud.CreateStemcellInput{ - { - ImagePath: filepath.Join(tempExtractionDir, "image"), - CloudProperties: biproperty.Map{ - "fake-prop-key": "fake-prop-value", - }, - }, - })) + Expect(fakeCloud.CreateStemcellCallCount()).To(Equal(1)) + imagePath, cloudProperties := fakeCloud.CreateStemcellArgsForCall(0) + Expect(imagePath).To(Equal(filepath.Join(tempExtractionDir, "image"))) + Expect(cloudProperties).To(Equal(biproperty.Map{"fake-prop-key": "fake-prop-value"})) }) It("saves the stemcell record in the stemcellRepo", func() { @@ -121,7 +117,7 @@ var _ = Describe("Manager", func() { }) It("when the upload fails, prints failed uploading ui stage", func() { - fakeCloud.CreateStemcellErr = errors.New("fake-create-error") + fakeCloud.CreateStemcellReturns("", errors.New("fake-create-error")) _, err := manager.Upload(expectedExtractedStemcell, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-create-error")) @@ -163,7 +159,7 @@ var _ = Describe("Manager", func() { It("does not re-upload the stemcell to the infrastructure", func() { _, err := manager.Upload(expectedExtractedStemcell, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.CreateStemcellInputs).To(HaveLen(0)) + Expect(fakeCloud.CreateStemcellCallCount()).To(Equal(0)) }) It("logs skipping uploading events to the eventLogger", func() { @@ -276,10 +272,9 @@ var _ = Describe("Manager", func() { err := manager.DeleteUnused(fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeCloud.DeleteStemcellInputs).To(Equal([]fakebicloud.DeleteStemcellInput{ - {StemcellCID: "fake-stemcell-cid-1"}, - {StemcellCID: "fake-stemcell-cid-3"}, - })) + Expect(fakeCloud.DeleteStemcellCallCount()).To(Equal(2)) + Expect(fakeCloud.DeleteStemcellArgsForCall(0)).To(Equal("fake-stemcell-cid-1")) + Expect(fakeCloud.DeleteStemcellArgsForCall(1)).To(Equal("fake-stemcell-cid-3")) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Deleting unused stemcell 'fake-stemcell-cid-1'"}, From 5aeb9883dbf86e78330cac4fd29f5f16d9ab3dad Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 08:54:43 -0700 Subject: [PATCH 04/13] Replace hand-crafted `config/fakes/` with counterfeiter --- config/configfakes/fake_deployment_repo.go | 182 +++++++ config/configfakes/fake_disk_repo.go | 549 ++++++++++++++++++++ config/configfakes/fake_release_repo.go | 183 +++++++ config/configfakes/fake_stemcell_repo.go | 552 +++++++++++++++++++++ config/configfakes/fake_vmrepo.go | 245 +++++++++ config/deployment_repo.go | 2 + config/disk_repo.go | 2 + config/fakes/fake_deployment_repo.go | 35 -- config/fakes/fake_disk_repo.go | 144 ------ config/fakes/fake_release_repo.go | 84 ---- config/fakes/fake_stemcell_repo.go | 184 ------- config/fakes/fake_vm_repo.go | 43 -- config/release_repo.go | 2 + config/stemcell_repo.go | 2 + config/vm_repo.go | 2 + deployment/deployer_test.go | 7 +- deployment/record_test.go | 43 +- deployment/vm/disk_deployer_test.go | 28 +- deployment/vm/manager_test.go | 10 +- deployment/vm/vm_test.go | 18 +- 20 files changed, 1766 insertions(+), 551 deletions(-) create mode 100644 config/configfakes/fake_deployment_repo.go create mode 100644 config/configfakes/fake_disk_repo.go create mode 100644 config/configfakes/fake_release_repo.go create mode 100644 config/configfakes/fake_stemcell_repo.go create mode 100644 config/configfakes/fake_vmrepo.go delete mode 100644 config/fakes/fake_deployment_repo.go delete mode 100644 config/fakes/fake_disk_repo.go delete mode 100644 config/fakes/fake_release_repo.go delete mode 100644 config/fakes/fake_stemcell_repo.go delete mode 100644 config/fakes/fake_vm_repo.go diff --git a/config/configfakes/fake_deployment_repo.go b/config/configfakes/fake_deployment_repo.go new file mode 100644 index 0000000000..d7aa0c6097 --- /dev/null +++ b/config/configfakes/fake_deployment_repo.go @@ -0,0 +1,182 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" +) + +type FakeDeploymentRepo struct { + FindCurrentStub func() (string, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 string + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 string + result2 bool + result3 error + } + UpdateCurrentStub func(string) error + updateCurrentMutex sync.RWMutex + updateCurrentArgsForCall []struct { + arg1 string + } + updateCurrentReturns struct { + result1 error + } + updateCurrentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDeploymentRepo) FindCurrent() (string, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeDeploymentRepo) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeDeploymentRepo) FindCurrentCalls(stub func() (string, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeDeploymentRepo) FindCurrentReturns(result1 string, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDeploymentRepo) FindCurrentReturnsOnCall(i int, result1 string, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 string + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDeploymentRepo) UpdateCurrent(arg1 string) error { + fake.updateCurrentMutex.Lock() + ret, specificReturn := fake.updateCurrentReturnsOnCall[len(fake.updateCurrentArgsForCall)] + fake.updateCurrentArgsForCall = append(fake.updateCurrentArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.UpdateCurrentStub + fakeReturns := fake.updateCurrentReturns + fake.recordInvocation("UpdateCurrent", []interface{}{arg1}) + fake.updateCurrentMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDeploymentRepo) UpdateCurrentCallCount() int { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + return len(fake.updateCurrentArgsForCall) +} + +func (fake *FakeDeploymentRepo) UpdateCurrentCalls(stub func(string) error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = stub +} + +func (fake *FakeDeploymentRepo) UpdateCurrentArgsForCall(i int) string { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + argsForCall := fake.updateCurrentArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDeploymentRepo) UpdateCurrentReturns(result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + fake.updateCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentRepo) UpdateCurrentReturnsOnCall(i int, result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + if fake.updateCurrentReturnsOnCall == nil { + fake.updateCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDeploymentRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDeploymentRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.DeploymentRepo = new(FakeDeploymentRepo) diff --git a/config/configfakes/fake_disk_repo.go b/config/configfakes/fake_disk_repo.go new file mode 100644 index 0000000000..8fcc0c78a7 --- /dev/null +++ b/config/configfakes/fake_disk_repo.go @@ -0,0 +1,549 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" + "github.com/cloudfoundry/bosh-utils/property" +) + +type FakeDiskRepo struct { + AllStub func() ([]config.DiskRecord, error) + allMutex sync.RWMutex + allArgsForCall []struct { + } + allReturns struct { + result1 []config.DiskRecord + result2 error + } + allReturnsOnCall map[int]struct { + result1 []config.DiskRecord + result2 error + } + ClearCurrentStub func() error + clearCurrentMutex sync.RWMutex + clearCurrentArgsForCall []struct { + } + clearCurrentReturns struct { + result1 error + } + clearCurrentReturnsOnCall map[int]struct { + result1 error + } + DeleteStub func(config.DiskRecord) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + arg1 config.DiskRecord + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + FindStub func(string) (config.DiskRecord, bool, error) + findMutex sync.RWMutex + findArgsForCall []struct { + arg1 string + } + findReturns struct { + result1 config.DiskRecord + result2 bool + result3 error + } + findReturnsOnCall map[int]struct { + result1 config.DiskRecord + result2 bool + result3 error + } + FindCurrentStub func() (config.DiskRecord, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 config.DiskRecord + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 config.DiskRecord + result2 bool + result3 error + } + SaveStub func(string, int, property.Map) (config.DiskRecord, error) + saveMutex sync.RWMutex + saveArgsForCall []struct { + arg1 string + arg2 int + arg3 property.Map + } + saveReturns struct { + result1 config.DiskRecord + result2 error + } + saveReturnsOnCall map[int]struct { + result1 config.DiskRecord + result2 error + } + UpdateCurrentStub func(string) error + updateCurrentMutex sync.RWMutex + updateCurrentArgsForCall []struct { + arg1 string + } + updateCurrentReturns struct { + result1 error + } + updateCurrentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDiskRepo) All() ([]config.DiskRecord, error) { + fake.allMutex.Lock() + ret, specificReturn := fake.allReturnsOnCall[len(fake.allArgsForCall)] + fake.allArgsForCall = append(fake.allArgsForCall, struct { + }{}) + stub := fake.AllStub + fakeReturns := fake.allReturns + fake.recordInvocation("All", []interface{}{}) + fake.allMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDiskRepo) AllCallCount() int { + fake.allMutex.RLock() + defer fake.allMutex.RUnlock() + return len(fake.allArgsForCall) +} + +func (fake *FakeDiskRepo) AllCalls(stub func() ([]config.DiskRecord, error)) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = stub +} + +func (fake *FakeDiskRepo) AllReturns(result1 []config.DiskRecord, result2 error) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + fake.allReturns = struct { + result1 []config.DiskRecord + result2 error + }{result1, result2} +} + +func (fake *FakeDiskRepo) AllReturnsOnCall(i int, result1 []config.DiskRecord, result2 error) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + if fake.allReturnsOnCall == nil { + fake.allReturnsOnCall = make(map[int]struct { + result1 []config.DiskRecord + result2 error + }) + } + fake.allReturnsOnCall[i] = struct { + result1 []config.DiskRecord + result2 error + }{result1, result2} +} + +func (fake *FakeDiskRepo) ClearCurrent() error { + fake.clearCurrentMutex.Lock() + ret, specificReturn := fake.clearCurrentReturnsOnCall[len(fake.clearCurrentArgsForCall)] + fake.clearCurrentArgsForCall = append(fake.clearCurrentArgsForCall, struct { + }{}) + stub := fake.ClearCurrentStub + fakeReturns := fake.clearCurrentReturns + fake.recordInvocation("ClearCurrent", []interface{}{}) + fake.clearCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDiskRepo) ClearCurrentCallCount() int { + fake.clearCurrentMutex.RLock() + defer fake.clearCurrentMutex.RUnlock() + return len(fake.clearCurrentArgsForCall) +} + +func (fake *FakeDiskRepo) ClearCurrentCalls(stub func() error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = stub +} + +func (fake *FakeDiskRepo) ClearCurrentReturns(result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + fake.clearCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) ClearCurrentReturnsOnCall(i int, result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + if fake.clearCurrentReturnsOnCall == nil { + fake.clearCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.clearCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) Delete(arg1 config.DiskRecord) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + arg1 config.DiskRecord + }{arg1}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{arg1}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDiskRepo) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeDiskRepo) DeleteCalls(stub func(config.DiskRecord) error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeDiskRepo) DeleteArgsForCall(i int) config.DiskRecord { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + argsForCall := fake.deleteArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDiskRepo) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) Find(arg1 string) (config.DiskRecord, bool, error) { + fake.findMutex.Lock() + ret, specificReturn := fake.findReturnsOnCall[len(fake.findArgsForCall)] + fake.findArgsForCall = append(fake.findArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.FindStub + fakeReturns := fake.findReturns + fake.recordInvocation("Find", []interface{}{arg1}) + fake.findMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeDiskRepo) FindCallCount() int { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + return len(fake.findArgsForCall) +} + +func (fake *FakeDiskRepo) FindCalls(stub func(string) (config.DiskRecord, bool, error)) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = stub +} + +func (fake *FakeDiskRepo) FindArgsForCall(i int) string { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + argsForCall := fake.findArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDiskRepo) FindReturns(result1 config.DiskRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + fake.findReturns = struct { + result1 config.DiskRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDiskRepo) FindReturnsOnCall(i int, result1 config.DiskRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + if fake.findReturnsOnCall == nil { + fake.findReturnsOnCall = make(map[int]struct { + result1 config.DiskRecord + result2 bool + result3 error + }) + } + fake.findReturnsOnCall[i] = struct { + result1 config.DiskRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDiskRepo) FindCurrent() (config.DiskRecord, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeDiskRepo) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeDiskRepo) FindCurrentCalls(stub func() (config.DiskRecord, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeDiskRepo) FindCurrentReturns(result1 config.DiskRecord, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 config.DiskRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDiskRepo) FindCurrentReturnsOnCall(i int, result1 config.DiskRecord, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 config.DiskRecord + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 config.DiskRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeDiskRepo) Save(arg1 string, arg2 int, arg3 property.Map) (config.DiskRecord, error) { + fake.saveMutex.Lock() + ret, specificReturn := fake.saveReturnsOnCall[len(fake.saveArgsForCall)] + fake.saveArgsForCall = append(fake.saveArgsForCall, struct { + arg1 string + arg2 int + arg3 property.Map + }{arg1, arg2, arg3}) + stub := fake.SaveStub + fakeReturns := fake.saveReturns + fake.recordInvocation("Save", []interface{}{arg1, arg2, arg3}) + fake.saveMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDiskRepo) SaveCallCount() int { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + return len(fake.saveArgsForCall) +} + +func (fake *FakeDiskRepo) SaveCalls(stub func(string, int, property.Map) (config.DiskRecord, error)) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = stub +} + +func (fake *FakeDiskRepo) SaveArgsForCall(i int) (string, int, property.Map) { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + argsForCall := fake.saveArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeDiskRepo) SaveReturns(result1 config.DiskRecord, result2 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + fake.saveReturns = struct { + result1 config.DiskRecord + result2 error + }{result1, result2} +} + +func (fake *FakeDiskRepo) SaveReturnsOnCall(i int, result1 config.DiskRecord, result2 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + if fake.saveReturnsOnCall == nil { + fake.saveReturnsOnCall = make(map[int]struct { + result1 config.DiskRecord + result2 error + }) + } + fake.saveReturnsOnCall[i] = struct { + result1 config.DiskRecord + result2 error + }{result1, result2} +} + +func (fake *FakeDiskRepo) UpdateCurrent(arg1 string) error { + fake.updateCurrentMutex.Lock() + ret, specificReturn := fake.updateCurrentReturnsOnCall[len(fake.updateCurrentArgsForCall)] + fake.updateCurrentArgsForCall = append(fake.updateCurrentArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.UpdateCurrentStub + fakeReturns := fake.updateCurrentReturns + fake.recordInvocation("UpdateCurrent", []interface{}{arg1}) + fake.updateCurrentMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDiskRepo) UpdateCurrentCallCount() int { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + return len(fake.updateCurrentArgsForCall) +} + +func (fake *FakeDiskRepo) UpdateCurrentCalls(stub func(string) error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = stub +} + +func (fake *FakeDiskRepo) UpdateCurrentArgsForCall(i int) string { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + argsForCall := fake.updateCurrentArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDiskRepo) UpdateCurrentReturns(result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + fake.updateCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) UpdateCurrentReturnsOnCall(i int, result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + if fake.updateCurrentReturnsOnCall == nil { + fake.updateCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeDiskRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDiskRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.DiskRepo = new(FakeDiskRepo) diff --git a/config/configfakes/fake_release_repo.go b/config/configfakes/fake_release_repo.go new file mode 100644 index 0000000000..6ee3d3a871 --- /dev/null +++ b/config/configfakes/fake_release_repo.go @@ -0,0 +1,183 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" + "github.com/cloudfoundry/bosh-cli/v7/release" +) + +type FakeReleaseRepo struct { + ListStub func() ([]config.ReleaseRecord, error) + listMutex sync.RWMutex + listArgsForCall []struct { + } + listReturns struct { + result1 []config.ReleaseRecord + result2 error + } + listReturnsOnCall map[int]struct { + result1 []config.ReleaseRecord + result2 error + } + UpdateStub func([]release.Release) error + updateMutex sync.RWMutex + updateArgsForCall []struct { + arg1 []release.Release + } + updateReturns struct { + result1 error + } + updateReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeReleaseRepo) List() ([]config.ReleaseRecord, error) { + fake.listMutex.Lock() + ret, specificReturn := fake.listReturnsOnCall[len(fake.listArgsForCall)] + fake.listArgsForCall = append(fake.listArgsForCall, struct { + }{}) + stub := fake.ListStub + fakeReturns := fake.listReturns + fake.recordInvocation("List", []interface{}{}) + fake.listMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeReleaseRepo) ListCallCount() int { + fake.listMutex.RLock() + defer fake.listMutex.RUnlock() + return len(fake.listArgsForCall) +} + +func (fake *FakeReleaseRepo) ListCalls(stub func() ([]config.ReleaseRecord, error)) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = stub +} + +func (fake *FakeReleaseRepo) ListReturns(result1 []config.ReleaseRecord, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + fake.listReturns = struct { + result1 []config.ReleaseRecord + result2 error + }{result1, result2} +} + +func (fake *FakeReleaseRepo) ListReturnsOnCall(i int, result1 []config.ReleaseRecord, result2 error) { + fake.listMutex.Lock() + defer fake.listMutex.Unlock() + fake.ListStub = nil + if fake.listReturnsOnCall == nil { + fake.listReturnsOnCall = make(map[int]struct { + result1 []config.ReleaseRecord + result2 error + }) + } + fake.listReturnsOnCall[i] = struct { + result1 []config.ReleaseRecord + result2 error + }{result1, result2} +} + +func (fake *FakeReleaseRepo) Update(arg1 []release.Release) error { + var arg1Copy []release.Release + if arg1 != nil { + arg1Copy = make([]release.Release, len(arg1)) + copy(arg1Copy, arg1) + } + fake.updateMutex.Lock() + ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)] + fake.updateArgsForCall = append(fake.updateArgsForCall, struct { + arg1 []release.Release + }{arg1Copy}) + stub := fake.UpdateStub + fakeReturns := fake.updateReturns + fake.recordInvocation("Update", []interface{}{arg1Copy}) + fake.updateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeReleaseRepo) UpdateCallCount() int { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + return len(fake.updateArgsForCall) +} + +func (fake *FakeReleaseRepo) UpdateCalls(stub func([]release.Release) error) { + fake.updateMutex.Lock() + defer fake.updateMutex.Unlock() + fake.UpdateStub = stub +} + +func (fake *FakeReleaseRepo) UpdateArgsForCall(i int) []release.Release { + fake.updateMutex.RLock() + defer fake.updateMutex.RUnlock() + argsForCall := fake.updateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeReleaseRepo) UpdateReturns(result1 error) { + fake.updateMutex.Lock() + defer fake.updateMutex.Unlock() + fake.UpdateStub = nil + fake.updateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeReleaseRepo) UpdateReturnsOnCall(i int, result1 error) { + fake.updateMutex.Lock() + defer fake.updateMutex.Unlock() + fake.UpdateStub = nil + if fake.updateReturnsOnCall == nil { + fake.updateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeReleaseRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeReleaseRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.ReleaseRepo = new(FakeReleaseRepo) diff --git a/config/configfakes/fake_stemcell_repo.go b/config/configfakes/fake_stemcell_repo.go new file mode 100644 index 0000000000..7c96447cb8 --- /dev/null +++ b/config/configfakes/fake_stemcell_repo.go @@ -0,0 +1,552 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" +) + +type FakeStemcellRepo struct { + AllStub func() ([]config.StemcellRecord, error) + allMutex sync.RWMutex + allArgsForCall []struct { + } + allReturns struct { + result1 []config.StemcellRecord + result2 error + } + allReturnsOnCall map[int]struct { + result1 []config.StemcellRecord + result2 error + } + ClearCurrentStub func() error + clearCurrentMutex sync.RWMutex + clearCurrentArgsForCall []struct { + } + clearCurrentReturns struct { + result1 error + } + clearCurrentReturnsOnCall map[int]struct { + result1 error + } + DeleteStub func(config.StemcellRecord) error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + arg1 config.StemcellRecord + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + FindStub func(string, string) (config.StemcellRecord, bool, error) + findMutex sync.RWMutex + findArgsForCall []struct { + arg1 string + arg2 string + } + findReturns struct { + result1 config.StemcellRecord + result2 bool + result3 error + } + findReturnsOnCall map[int]struct { + result1 config.StemcellRecord + result2 bool + result3 error + } + FindCurrentStub func() (config.StemcellRecord, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 config.StemcellRecord + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 config.StemcellRecord + result2 bool + result3 error + } + SaveStub func(string, string, string, int) (config.StemcellRecord, error) + saveMutex sync.RWMutex + saveArgsForCall []struct { + arg1 string + arg2 string + arg3 string + arg4 int + } + saveReturns struct { + result1 config.StemcellRecord + result2 error + } + saveReturnsOnCall map[int]struct { + result1 config.StemcellRecord + result2 error + } + UpdateCurrentStub func(string) error + updateCurrentMutex sync.RWMutex + updateCurrentArgsForCall []struct { + arg1 string + } + updateCurrentReturns struct { + result1 error + } + updateCurrentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeStemcellRepo) All() ([]config.StemcellRecord, error) { + fake.allMutex.Lock() + ret, specificReturn := fake.allReturnsOnCall[len(fake.allArgsForCall)] + fake.allArgsForCall = append(fake.allArgsForCall, struct { + }{}) + stub := fake.AllStub + fakeReturns := fake.allReturns + fake.recordInvocation("All", []interface{}{}) + fake.allMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeStemcellRepo) AllCallCount() int { + fake.allMutex.RLock() + defer fake.allMutex.RUnlock() + return len(fake.allArgsForCall) +} + +func (fake *FakeStemcellRepo) AllCalls(stub func() ([]config.StemcellRecord, error)) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = stub +} + +func (fake *FakeStemcellRepo) AllReturns(result1 []config.StemcellRecord, result2 error) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + fake.allReturns = struct { + result1 []config.StemcellRecord + result2 error + }{result1, result2} +} + +func (fake *FakeStemcellRepo) AllReturnsOnCall(i int, result1 []config.StemcellRecord, result2 error) { + fake.allMutex.Lock() + defer fake.allMutex.Unlock() + fake.AllStub = nil + if fake.allReturnsOnCall == nil { + fake.allReturnsOnCall = make(map[int]struct { + result1 []config.StemcellRecord + result2 error + }) + } + fake.allReturnsOnCall[i] = struct { + result1 []config.StemcellRecord + result2 error + }{result1, result2} +} + +func (fake *FakeStemcellRepo) ClearCurrent() error { + fake.clearCurrentMutex.Lock() + ret, specificReturn := fake.clearCurrentReturnsOnCall[len(fake.clearCurrentArgsForCall)] + fake.clearCurrentArgsForCall = append(fake.clearCurrentArgsForCall, struct { + }{}) + stub := fake.ClearCurrentStub + fakeReturns := fake.clearCurrentReturns + fake.recordInvocation("ClearCurrent", []interface{}{}) + fake.clearCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeStemcellRepo) ClearCurrentCallCount() int { + fake.clearCurrentMutex.RLock() + defer fake.clearCurrentMutex.RUnlock() + return len(fake.clearCurrentArgsForCall) +} + +func (fake *FakeStemcellRepo) ClearCurrentCalls(stub func() error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = stub +} + +func (fake *FakeStemcellRepo) ClearCurrentReturns(result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + fake.clearCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) ClearCurrentReturnsOnCall(i int, result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + if fake.clearCurrentReturnsOnCall == nil { + fake.clearCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.clearCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) Delete(arg1 config.StemcellRecord) error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + arg1 config.StemcellRecord + }{arg1}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{arg1}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeStemcellRepo) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeStemcellRepo) DeleteCalls(stub func(config.StemcellRecord) error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeStemcellRepo) DeleteArgsForCall(i int) config.StemcellRecord { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + argsForCall := fake.deleteArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeStemcellRepo) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) Find(arg1 string, arg2 string) (config.StemcellRecord, bool, error) { + fake.findMutex.Lock() + ret, specificReturn := fake.findReturnsOnCall[len(fake.findArgsForCall)] + fake.findArgsForCall = append(fake.findArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + stub := fake.FindStub + fakeReturns := fake.findReturns + fake.recordInvocation("Find", []interface{}{arg1, arg2}) + fake.findMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeStemcellRepo) FindCallCount() int { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + return len(fake.findArgsForCall) +} + +func (fake *FakeStemcellRepo) FindCalls(stub func(string, string) (config.StemcellRecord, bool, error)) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = stub +} + +func (fake *FakeStemcellRepo) FindArgsForCall(i int) (string, string) { + fake.findMutex.RLock() + defer fake.findMutex.RUnlock() + argsForCall := fake.findArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeStemcellRepo) FindReturns(result1 config.StemcellRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + fake.findReturns = struct { + result1 config.StemcellRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeStemcellRepo) FindReturnsOnCall(i int, result1 config.StemcellRecord, result2 bool, result3 error) { + fake.findMutex.Lock() + defer fake.findMutex.Unlock() + fake.FindStub = nil + if fake.findReturnsOnCall == nil { + fake.findReturnsOnCall = make(map[int]struct { + result1 config.StemcellRecord + result2 bool + result3 error + }) + } + fake.findReturnsOnCall[i] = struct { + result1 config.StemcellRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeStemcellRepo) FindCurrent() (config.StemcellRecord, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeStemcellRepo) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeStemcellRepo) FindCurrentCalls(stub func() (config.StemcellRecord, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeStemcellRepo) FindCurrentReturns(result1 config.StemcellRecord, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 config.StemcellRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeStemcellRepo) FindCurrentReturnsOnCall(i int, result1 config.StemcellRecord, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 config.StemcellRecord + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 config.StemcellRecord + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeStemcellRepo) Save(arg1 string, arg2 string, arg3 string, arg4 int) (config.StemcellRecord, error) { + fake.saveMutex.Lock() + ret, specificReturn := fake.saveReturnsOnCall[len(fake.saveArgsForCall)] + fake.saveArgsForCall = append(fake.saveArgsForCall, struct { + arg1 string + arg2 string + arg3 string + arg4 int + }{arg1, arg2, arg3, arg4}) + stub := fake.SaveStub + fakeReturns := fake.saveReturns + fake.recordInvocation("Save", []interface{}{arg1, arg2, arg3, arg4}) + fake.saveMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeStemcellRepo) SaveCallCount() int { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + return len(fake.saveArgsForCall) +} + +func (fake *FakeStemcellRepo) SaveCalls(stub func(string, string, string, int) (config.StemcellRecord, error)) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = stub +} + +func (fake *FakeStemcellRepo) SaveArgsForCall(i int) (string, string, string, int) { + fake.saveMutex.RLock() + defer fake.saveMutex.RUnlock() + argsForCall := fake.saveArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeStemcellRepo) SaveReturns(result1 config.StemcellRecord, result2 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + fake.saveReturns = struct { + result1 config.StemcellRecord + result2 error + }{result1, result2} +} + +func (fake *FakeStemcellRepo) SaveReturnsOnCall(i int, result1 config.StemcellRecord, result2 error) { + fake.saveMutex.Lock() + defer fake.saveMutex.Unlock() + fake.SaveStub = nil + if fake.saveReturnsOnCall == nil { + fake.saveReturnsOnCall = make(map[int]struct { + result1 config.StemcellRecord + result2 error + }) + } + fake.saveReturnsOnCall[i] = struct { + result1 config.StemcellRecord + result2 error + }{result1, result2} +} + +func (fake *FakeStemcellRepo) UpdateCurrent(arg1 string) error { + fake.updateCurrentMutex.Lock() + ret, specificReturn := fake.updateCurrentReturnsOnCall[len(fake.updateCurrentArgsForCall)] + fake.updateCurrentArgsForCall = append(fake.updateCurrentArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.UpdateCurrentStub + fakeReturns := fake.updateCurrentReturns + fake.recordInvocation("UpdateCurrent", []interface{}{arg1}) + fake.updateCurrentMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeStemcellRepo) UpdateCurrentCallCount() int { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + return len(fake.updateCurrentArgsForCall) +} + +func (fake *FakeStemcellRepo) UpdateCurrentCalls(stub func(string) error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = stub +} + +func (fake *FakeStemcellRepo) UpdateCurrentArgsForCall(i int) string { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + argsForCall := fake.updateCurrentArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeStemcellRepo) UpdateCurrentReturns(result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + fake.updateCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) UpdateCurrentReturnsOnCall(i int, result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + if fake.updateCurrentReturnsOnCall == nil { + fake.updateCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeStemcellRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeStemcellRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.StemcellRepo = new(FakeStemcellRepo) diff --git a/config/configfakes/fake_vmrepo.go b/config/configfakes/fake_vmrepo.go new file mode 100644 index 0000000000..5de81dcc6a --- /dev/null +++ b/config/configfakes/fake_vmrepo.go @@ -0,0 +1,245 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package configfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/config" +) + +type FakeVMRepo struct { + ClearCurrentStub func() error + clearCurrentMutex sync.RWMutex + clearCurrentArgsForCall []struct { + } + clearCurrentReturns struct { + result1 error + } + clearCurrentReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() (string, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 string + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 string + result2 bool + result3 error + } + UpdateCurrentStub func(string) error + updateCurrentMutex sync.RWMutex + updateCurrentArgsForCall []struct { + arg1 string + } + updateCurrentReturns struct { + result1 error + } + updateCurrentReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeVMRepo) ClearCurrent() error { + fake.clearCurrentMutex.Lock() + ret, specificReturn := fake.clearCurrentReturnsOnCall[len(fake.clearCurrentArgsForCall)] + fake.clearCurrentArgsForCall = append(fake.clearCurrentArgsForCall, struct { + }{}) + stub := fake.ClearCurrentStub + fakeReturns := fake.clearCurrentReturns + fake.recordInvocation("ClearCurrent", []interface{}{}) + fake.clearCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVMRepo) ClearCurrentCallCount() int { + fake.clearCurrentMutex.RLock() + defer fake.clearCurrentMutex.RUnlock() + return len(fake.clearCurrentArgsForCall) +} + +func (fake *FakeVMRepo) ClearCurrentCalls(stub func() error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = stub +} + +func (fake *FakeVMRepo) ClearCurrentReturns(result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + fake.clearCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVMRepo) ClearCurrentReturnsOnCall(i int, result1 error) { + fake.clearCurrentMutex.Lock() + defer fake.clearCurrentMutex.Unlock() + fake.ClearCurrentStub = nil + if fake.clearCurrentReturnsOnCall == nil { + fake.clearCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.clearCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVMRepo) FindCurrent() (string, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeVMRepo) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeVMRepo) FindCurrentCalls(stub func() (string, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeVMRepo) FindCurrentReturns(result1 string, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeVMRepo) FindCurrentReturnsOnCall(i int, result1 string, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 string + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 string + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeVMRepo) UpdateCurrent(arg1 string) error { + fake.updateCurrentMutex.Lock() + ret, specificReturn := fake.updateCurrentReturnsOnCall[len(fake.updateCurrentArgsForCall)] + fake.updateCurrentArgsForCall = append(fake.updateCurrentArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.UpdateCurrentStub + fakeReturns := fake.updateCurrentReturns + fake.recordInvocation("UpdateCurrent", []interface{}{arg1}) + fake.updateCurrentMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVMRepo) UpdateCurrentCallCount() int { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + return len(fake.updateCurrentArgsForCall) +} + +func (fake *FakeVMRepo) UpdateCurrentCalls(stub func(string) error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = stub +} + +func (fake *FakeVMRepo) UpdateCurrentArgsForCall(i int) string { + fake.updateCurrentMutex.RLock() + defer fake.updateCurrentMutex.RUnlock() + argsForCall := fake.updateCurrentArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVMRepo) UpdateCurrentReturns(result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + fake.updateCurrentReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVMRepo) UpdateCurrentReturnsOnCall(i int, result1 error) { + fake.updateCurrentMutex.Lock() + defer fake.updateCurrentMutex.Unlock() + fake.UpdateCurrentStub = nil + if fake.updateCurrentReturnsOnCall == nil { + fake.updateCurrentReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.updateCurrentReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVMRepo) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeVMRepo) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ config.VMRepo = new(FakeVMRepo) diff --git a/config/deployment_repo.go b/config/deployment_repo.go index cd0ce5fa7a..8789417140 100644 --- a/config/deployment_repo.go +++ b/config/deployment_repo.go @@ -4,6 +4,8 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" ) +//counterfeiter:generate . DeploymentRepo + type DeploymentRepo interface { UpdateCurrent(manifestSHA string) error FindCurrent() (manifestSHA string, found bool, err error) diff --git a/config/disk_repo.go b/config/disk_repo.go index a1903838f5..18402c96c7 100644 --- a/config/disk_repo.go +++ b/config/disk_repo.go @@ -6,6 +6,8 @@ import ( boshuuid "github.com/cloudfoundry/bosh-utils/uuid" ) +//counterfeiter:generate . DiskRepo + type DiskRepo interface { UpdateCurrent(diskID string) error FindCurrent() (DiskRecord, bool, error) diff --git a/config/fakes/fake_deployment_repo.go b/config/fakes/fake_deployment_repo.go deleted file mode 100644 index 4e98e8034a..0000000000 --- a/config/fakes/fake_deployment_repo.go +++ /dev/null @@ -1,35 +0,0 @@ -package fakes - -type FakeDeploymentRepo struct { - UpdateCurrentManifestSHA string - UpdateCurrentErr error - - findCurrentOutput deploymentRepoFindCurrentOutput -} - -type deploymentRepoFindCurrentOutput struct { - manifestSHA string - found bool - err error -} - -func NewFakeDeploymentRepo() *FakeDeploymentRepo { - return &FakeDeploymentRepo{} -} - -func (r *FakeDeploymentRepo) UpdateCurrent(manifestSHA string) error { - r.UpdateCurrentManifestSHA = manifestSHA - return r.UpdateCurrentErr -} - -func (r *FakeDeploymentRepo) FindCurrent() (manifestSHA string, found bool, err error) { - return r.findCurrentOutput.manifestSHA, r.findCurrentOutput.found, r.findCurrentOutput.err -} - -func (r *FakeDeploymentRepo) SetFindCurrentBehavior(manifestSHA string, found bool, err error) { - r.findCurrentOutput = deploymentRepoFindCurrentOutput{ - manifestSHA: manifestSHA, - found: found, - err: err, - } -} diff --git a/config/fakes/fake_disk_repo.go b/config/fakes/fake_disk_repo.go deleted file mode 100644 index c4ee410a2d..0000000000 --- a/config/fakes/fake_disk_repo.go +++ /dev/null @@ -1,144 +0,0 @@ -package fakes - -import ( - biproperty "github.com/cloudfoundry/bosh-utils/property" - - biconfig "github.com/cloudfoundry/bosh-cli/v7/config" -) - -type FakeDiskRepo struct { - UpdateCurrentInputs []DiskRepoUpdateCurrentInput - updateErr error - - findCurrentOutput diskRepoFindCurrentOutput - - SaveInputs []DiskRepoSaveInput - saveOutput diskRepoSaveOutput - - findOutput map[string]diskRepoFindOutput - - DeleteInputs []DiskRepoDeleteInput - DeleteErr error - - allOutput diskRepoAllOutput -} - -type DiskRepoUpdateCurrentInput struct { - DiskID string -} - -type diskRepoFindCurrentOutput struct { - diskRecord biconfig.DiskRecord - found bool - err error -} - -type DiskRepoSaveInput struct { - CID string - Size int - CloudProperties biproperty.Map -} - -type diskRepoSaveOutput struct { - diskRecord biconfig.DiskRecord - err error -} - -type DiskRepoDeleteInput struct { - DiskRecord biconfig.DiskRecord -} - -type diskRepoFindOutput struct { - diskRecord biconfig.DiskRecord - found bool - err error -} - -type diskRepoAllOutput struct { - diskRecords []biconfig.DiskRecord - err error -} - -func NewFakeDiskRepo() *FakeDiskRepo { - return &FakeDiskRepo{ - UpdateCurrentInputs: []DiskRepoUpdateCurrentInput{}, - SaveInputs: []DiskRepoSaveInput{}, - DeleteInputs: []DiskRepoDeleteInput{}, - findOutput: map[string]diskRepoFindOutput{}, - } -} - -func (r *FakeDiskRepo) UpdateCurrent(diskID string) error { - r.UpdateCurrentInputs = append(r.UpdateCurrentInputs, DiskRepoUpdateCurrentInput{ - DiskID: diskID, - }) - return r.updateErr -} - -func (r *FakeDiskRepo) FindCurrent() (biconfig.DiskRecord, bool, error) { - return r.findCurrentOutput.diskRecord, r.findCurrentOutput.found, r.findCurrentOutput.err -} - -func (r *FakeDiskRepo) ClearCurrent() error { - return nil -} - -func (r *FakeDiskRepo) Save(cid string, size int, cloudProperties biproperty.Map) (biconfig.DiskRecord, error) { - r.SaveInputs = append(r.SaveInputs, DiskRepoSaveInput{ - CID: cid, - Size: size, - CloudProperties: cloudProperties, - }) - - return r.saveOutput.diskRecord, r.saveOutput.err -} - -func (r *FakeDiskRepo) Find(cid string) (biconfig.DiskRecord, bool, error) { - return r.findOutput[cid].diskRecord, r.findOutput[cid].found, r.findOutput[cid].err -} - -func (r *FakeDiskRepo) All() ([]biconfig.DiskRecord, error) { - return r.allOutput.diskRecords, r.allOutput.err -} - -func (r *FakeDiskRepo) Delete(diskRecord biconfig.DiskRecord) error { - r.DeleteInputs = append(r.DeleteInputs, DiskRepoDeleteInput{ - DiskRecord: diskRecord, - }) - - return r.DeleteErr -} - -func (r *FakeDiskRepo) SetUpdateBehavior(err error) { - r.updateErr = err -} - -func (r *FakeDiskRepo) SetFindCurrentBehavior(diskRecord biconfig.DiskRecord, found bool, err error) { - r.findCurrentOutput = diskRepoFindCurrentOutput{ - diskRecord: diskRecord, - found: found, - err: err, - } -} - -func (r *FakeDiskRepo) SetSaveBehavior(diskRecord biconfig.DiskRecord, found bool, err error) { - r.saveOutput = diskRepoSaveOutput{ - diskRecord: diskRecord, - err: err, - } -} - -func (r *FakeDiskRepo) SetFindBehavior(cid string, diskRecord biconfig.DiskRecord, found bool, err error) { - r.findOutput[cid] = diskRepoFindOutput{ - diskRecord: diskRecord, - found: found, - err: err, - } -} - -func (r *FakeDiskRepo) SetAllBehavior(diskRecords []biconfig.DiskRecord, err error) { - r.allOutput = diskRepoAllOutput{ - diskRecords: diskRecords, - err: err, - } -} diff --git a/config/fakes/fake_release_repo.go b/config/fakes/fake_release_repo.go deleted file mode 100644 index 3adecfa911..0000000000 --- a/config/fakes/fake_release_repo.go +++ /dev/null @@ -1,84 +0,0 @@ -package fakes - -import ( - "sync" - - "github.com/cloudfoundry/bosh-cli/v7/config" - "github.com/cloudfoundry/bosh-cli/v7/release" -) - -// FakeReleaseRepo was generated by counterfeiter -type FakeReleaseRepo struct { - ListStub func() ([]config.ReleaseRecord, error) - listMutex sync.RWMutex - listArgsForCall []struct{} - listReturns struct { - result1 []config.ReleaseRecord - result2 error - } - UpdateStub func([]release.Release) error - updateMutex sync.RWMutex - updateArgsForCall []struct { - arg1 []release.Release - } - updateReturns struct { - result1 error - } -} - -func (fake *FakeReleaseRepo) List() ([]config.ReleaseRecord, error) { - fake.listMutex.Lock() - fake.listArgsForCall = append(fake.listArgsForCall, struct{}{}) - fake.listMutex.Unlock() - if fake.ListStub != nil { - return fake.ListStub() - } - return fake.listReturns.result1, fake.listReturns.result2 -} - -func (fake *FakeReleaseRepo) ListCallCount() int { - fake.listMutex.RLock() - defer fake.listMutex.RUnlock() - return len(fake.listArgsForCall) -} - -func (fake *FakeReleaseRepo) ListReturns(result1 []config.ReleaseRecord, result2 error) { - fake.ListStub = nil - fake.listReturns = struct { - result1 []config.ReleaseRecord - result2 error - }{result1, result2} -} - -func (fake *FakeReleaseRepo) Update(arg1 []release.Release) error { - fake.updateMutex.Lock() - fake.updateArgsForCall = append(fake.updateArgsForCall, struct { - arg1 []release.Release - }{arg1}) - fake.updateMutex.Unlock() - if fake.UpdateStub != nil { - return fake.UpdateStub(arg1) - } - return fake.updateReturns.result1 -} - -func (fake *FakeReleaseRepo) UpdateCallCount() int { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return len(fake.updateArgsForCall) -} - -func (fake *FakeReleaseRepo) UpdateArgsForCall(i int) []release.Release { - fake.updateMutex.RLock() - defer fake.updateMutex.RUnlock() - return fake.updateArgsForCall[i].arg1 -} - -func (fake *FakeReleaseRepo) UpdateReturns(result1 error) { - fake.UpdateStub = nil - fake.updateReturns = struct { - result1 error - }{result1} -} - -var _ config.ReleaseRepo = new(FakeReleaseRepo) diff --git a/config/fakes/fake_stemcell_repo.go b/config/fakes/fake_stemcell_repo.go deleted file mode 100644 index 288dadff78..0000000000 --- a/config/fakes/fake_stemcell_repo.go +++ /dev/null @@ -1,184 +0,0 @@ -package fakes - -import ( - "fmt" - - bosherr "github.com/cloudfoundry/bosh-utils/errors" - - biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - bitestutils "github.com/cloudfoundry/bosh-cli/v7/testutils" -) - -type StemcellRepoSaveInput struct { - Name string - Version string - CID string - ApiVersion int -} - -type StemcellRepoSaveOutput struct { - stemcellRecord biconfig.StemcellRecord - err error -} - -type StemcellRepoFindInput struct { - Name string - Version string -} - -type StemcellRepoFindOutput struct { - stemcellRecord biconfig.StemcellRecord - found bool - err error -} - -type FindCurrentOutput struct { - stemcellRecord biconfig.StemcellRecord - found bool - err error -} - -type FakeStemcellRepo struct { - SaveBehavior map[string]StemcellRepoSaveOutput - SaveInputs []StemcellRepoSaveInput - FindBehavior map[string]StemcellRepoFindOutput - FindInputs []StemcellRepoFindInput - - UpdateCurrentRecordID string - UpdateCurrentErr error - - findCurrentOutput FindCurrentOutput - - ClearCurrentCalled bool - ClearCurrentErr error - - DeleteStemcellRecords []biconfig.StemcellRecord - DeleteErr error - - AllStemcellRecords []biconfig.StemcellRecord - AllErr error -} - -func NewFakeStemcellRepo() *FakeStemcellRepo { - return &FakeStemcellRepo{ - FindBehavior: map[string]StemcellRepoFindOutput{}, - FindInputs: []StemcellRepoFindInput{}, - SaveBehavior: map[string]StemcellRepoSaveOutput{}, - SaveInputs: []StemcellRepoSaveInput{}, - } -} - -func (fr *FakeStemcellRepo) UpdateCurrent(recordID string) error { - fr.UpdateCurrentRecordID = recordID - return fr.UpdateCurrentErr -} - -func (fr *FakeStemcellRepo) FindCurrent() (biconfig.StemcellRecord, bool, error) { - return fr.findCurrentOutput.stemcellRecord, fr.findCurrentOutput.found, fr.findCurrentOutput.err -} - -func (fr *FakeStemcellRepo) ClearCurrent() error { - fr.ClearCurrentCalled = true - return fr.ClearCurrentErr -} - -func (fr *FakeStemcellRepo) Delete(stemcellRecord biconfig.StemcellRecord) error { - fr.DeleteStemcellRecords = append(fr.DeleteStemcellRecords, stemcellRecord) - return fr.DeleteErr -} - -func (fr *FakeStemcellRepo) All() ([]biconfig.StemcellRecord, error) { - return fr.AllStemcellRecords, fr.AllErr -} - -func (fr *FakeStemcellRepo) Save(name, version, cid string, apiVersion int) (biconfig.StemcellRecord, error) { - input := StemcellRepoSaveInput{ - Name: name, - Version: version, - CID: cid, - ApiVersion: apiVersion, - } - fr.SaveInputs = append(fr.SaveInputs, input) - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - return biconfig.StemcellRecord{}, bosherr.WrapError(marshalErr, "Marshaling Save input") - } - - output, found := fr.SaveBehavior[inputString] - if !found { - return biconfig.StemcellRecord{}, fmt.Errorf("Unsupported Save Input: %s", inputString) //nolint:staticcheck - } - - return output.stemcellRecord, output.err -} - -func (fr *FakeStemcellRepo) SetSaveBehavior(name, version, cid string, stemcellRecord biconfig.StemcellRecord, err error) error { - input := StemcellRepoSaveInput{ - Name: name, - Version: version, - CID: cid, - } - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - return bosherr.WrapError(marshalErr, "Marshaling Save input") - } - - fr.SaveBehavior[inputString] = StemcellRepoSaveOutput{ - stemcellRecord: stemcellRecord, - err: err, - } - - return nil -} - -func (fr *FakeStemcellRepo) Find(name, version string) (biconfig.StemcellRecord, bool, error) { - input := StemcellRepoFindInput{ - Name: name, - Version: version, - } - fr.FindInputs = append(fr.FindInputs, input) - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - return biconfig.StemcellRecord{}, false, bosherr.WrapError(marshalErr, "Marshaling Find input") - } - - output, found := fr.FindBehavior[inputString] - if !found { - return biconfig.StemcellRecord{}, false, fmt.Errorf("Unsupported Find Input: %s", inputString) //nolint:staticcheck - } - - return output.stemcellRecord, output.found, output.err -} - -func (fr *FakeStemcellRepo) SetFindBehavior(name, version string, foundRecord biconfig.StemcellRecord, found bool, err error) error { - input := StemcellRepoFindInput{ - Name: name, - Version: version, - } - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - return bosherr.WrapError(marshalErr, "Marshaling Find input") - } - - fr.FindBehavior[inputString] = StemcellRepoFindOutput{ - stemcellRecord: foundRecord, - found: found, - err: err, - } - - return nil -} - -func (fr *FakeStemcellRepo) SetFindCurrentBehavior(foundRecord biconfig.StemcellRecord, found bool, err error) error { - fr.findCurrentOutput = FindCurrentOutput{ - stemcellRecord: foundRecord, - found: found, - err: err, - } - - return nil -} diff --git a/config/fakes/fake_vm_repo.go b/config/fakes/fake_vm_repo.go deleted file mode 100644 index 9b3ec60eb4..0000000000 --- a/config/fakes/fake_vm_repo.go +++ /dev/null @@ -1,43 +0,0 @@ -package fakes - -type FakeVMRepo struct { - UpdateCurrentCID string - UpdateCurrentErr error - - ClearCurrentCalled bool - ClearCurrentErr error - - findCurrentOutput vmRepoFindCurrentOutput -} - -type vmRepoFindCurrentOutput struct { - cid string - found bool - err error -} - -func NewFakeVMRepo() *FakeVMRepo { - return &FakeVMRepo{} -} - -func (r *FakeVMRepo) FindCurrent() (cid string, found bool, err error) { - return r.findCurrentOutput.cid, r.findCurrentOutput.found, r.findCurrentOutput.err -} - -func (r *FakeVMRepo) SetFindCurrentBehavior(cid string, found bool, err error) { - r.findCurrentOutput = vmRepoFindCurrentOutput{ - cid: cid, - found: found, - err: err, - } -} - -func (r *FakeVMRepo) UpdateCurrent(cid string) error { - r.UpdateCurrentCID = cid - return r.UpdateCurrentErr -} - -func (r *FakeVMRepo) ClearCurrent() error { - r.ClearCurrentCalled = true - return r.ClearCurrentErr -} diff --git a/config/release_repo.go b/config/release_repo.go index 26a56143e6..bd26b04a46 100644 --- a/config/release_repo.go +++ b/config/release_repo.go @@ -7,6 +7,8 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/release" ) +//counterfeiter:generate . ReleaseRepo + // ReleaseRepo persists releases metadata type ReleaseRepo interface { List() ([]ReleaseRecord, error) diff --git a/config/stemcell_repo.go b/config/stemcell_repo.go index 201505682d..75edc418ac 100644 --- a/config/stemcell_repo.go +++ b/config/stemcell_repo.go @@ -5,6 +5,8 @@ import ( boshuuid "github.com/cloudfoundry/bosh-utils/uuid" ) +//counterfeiter:generate . StemcellRepo + type StemcellRepo interface // StemcellRepo persists stemcells metadata { UpdateCurrent(recordID string) error diff --git a/config/vm_repo.go b/config/vm_repo.go index 65aa4ed468..44b0775dd0 100644 --- a/config/vm_repo.go +++ b/config/vm_repo.go @@ -4,6 +4,8 @@ import ( bosherr "github.com/cloudfoundry/bosh-utils/errors" ) +//counterfeiter:generate . VMRepo + type VMRepo interface { FindCurrent() (cid string, found bool, err error) UpdateCurrent(cid string) error diff --git a/deployment/deployer_test.go b/deployment/deployer_test.go index 4fcb7bd837..8d2b6b21ac 100644 --- a/deployment/deployer_test.go +++ b/deployment/deployer_test.go @@ -16,7 +16,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" "github.com/cloudfoundry/bosh-cli/v7/cmd/cmdfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" @@ -108,15 +108,14 @@ var _ = Describe("Deployer", func() { logger := boshlog.NewLogger(boshlog.LevelNone) fakeStage = fakebiui.NewFakeStage() - fakeStemcellRepo := fakebiconfig.NewFakeStemcellRepo() + fakeStemcellRepo := &configfakes.FakeStemcellRepo{} stemcellRecord := biconfig.StemcellRecord{ ID: "fake-stemcell-id", Name: "fake-stemcell-name", Version: "fake-stemcell-version", CID: "fake-stemcell-cid", } - err := fakeStemcellRepo.SetFindBehavior("fake-stemcell-name", "fake-stemcell-version", stemcellRecord, true, nil) - Expect(err).ToNot(HaveOccurred()) + fakeStemcellRepo.FindReturns(stemcellRecord, true, nil) cloudStemcell = bistemcell.NewCloudStemcell(stemcellRecord, fakeStemcellRepo, cloud) diff --git a/deployment/record_test.go b/deployment/record_test.go index 3c9f09c93c..6af3678b13 100644 --- a/deployment/record_test.go +++ b/deployment/record_test.go @@ -8,7 +8,7 @@ import ( . "github.com/onsi/gomega" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment" boshrel "github.com/cloudfoundry/bosh-cli/v7/release" fakerel "github.com/cloudfoundry/bosh-cli/v7/release/releasefakes" @@ -19,9 +19,9 @@ var _ = Describe("Record", func() { var ( release *fakerel.FakeRelease stemcell bistemcell.ExtractedStemcell - deploymentRepo *fakebiconfig.FakeDeploymentRepo - releaseRepo *fakebiconfig.FakeReleaseRepo - stemcellRepo *fakebiconfig.FakeStemcellRepo + deploymentRepo *configfakes.FakeDeploymentRepo + releaseRepo *configfakes.FakeReleaseRepo + stemcellRepo *configfakes.FakeStemcellRepo deploymentRecord Record releases []boshrel.Release ) @@ -42,9 +42,9 @@ var _ = Describe("Record", func() { nil, fakeFS, ) - deploymentRepo = fakebiconfig.NewFakeDeploymentRepo() - releaseRepo = &fakebiconfig.FakeReleaseRepo{} - stemcellRepo = fakebiconfig.NewFakeStemcellRepo() + deploymentRepo = &configfakes.FakeDeploymentRepo{} + releaseRepo = &configfakes.FakeReleaseRepo{} + stemcellRepo = &configfakes.FakeStemcellRepo{} deploymentRecord = NewRecord(deploymentRepo, releaseRepo, stemcellRepo) }) @@ -56,10 +56,8 @@ var _ = Describe("Record", func() { Version: "fake-stemcell-version", CID: "fake-stemcell-cid", } - err := stemcellRepo.SetFindCurrentBehavior(stemcellRecord, true, nil) - Expect(err).ToNot(HaveOccurred()) - - deploymentRepo.SetFindCurrentBehavior("fake-manifest-sha1", true, nil) + stemcellRepo.FindCurrentReturns(stemcellRecord, true, nil) + deploymentRepo.FindCurrentReturns("fake-manifest-sha1", true, nil) }) Context("when the stemcell and manifest do not change", func() { @@ -201,7 +199,7 @@ var _ = Describe("Record", func() { Context("when no deployment is set", func() { BeforeEach(func() { - deploymentRepo.SetFindCurrentBehavior("", false, nil) + deploymentRepo.FindCurrentReturns("", false, nil) }) It("returns false", func() { @@ -213,7 +211,7 @@ var _ = Describe("Record", func() { Context("when a different deployment manifest is currently deployed", func() { BeforeEach(func() { - deploymentRepo.SetFindCurrentBehavior("fake-manifest-sha1-2", true, nil) + deploymentRepo.FindCurrentReturns("fake-manifest-sha1-2", true, nil) }) It("returns false", func() { @@ -225,8 +223,7 @@ var _ = Describe("Record", func() { Context("when finding the currently deployed stemcell fails", func() { BeforeEach(func() { - err := stemcellRepo.SetFindCurrentBehavior(biconfig.StemcellRecord{}, false, errors.New("fake-find-error")) - Expect(err).ToNot(HaveOccurred()) + stemcellRepo.FindCurrentReturns(biconfig.StemcellRecord{}, false, errors.New("fake-find-error")) }) It("returns an error", func() { @@ -238,8 +235,7 @@ var _ = Describe("Record", func() { Context("when no stemcell is currently deployed", func() { BeforeEach(func() { - err := stemcellRepo.SetFindCurrentBehavior(biconfig.StemcellRecord{}, false, nil) - Expect(err).ToNot(HaveOccurred()) + stemcellRepo.FindCurrentReturns(biconfig.StemcellRecord{}, false, nil) }) It("returns false", func() { @@ -257,8 +253,7 @@ var _ = Describe("Record", func() { Version: "fake-stemcell-version-2", CID: "fake-stemcell-cid-2", } - err := stemcellRepo.SetFindCurrentBehavior(stemcellRecord, true, nil) - Expect(err).ToNot(HaveOccurred()) + stemcellRepo.FindReturns(stemcellRecord, true, nil) }) It("returns false", func() { @@ -285,7 +280,7 @@ var _ = Describe("Record", func() { It("calculates and updates sha1 of currently deployed manifest", func() { err := deploymentRecord.Update("fake-manifest-sha1", releases) Expect(err).ToNot(HaveOccurred()) - Expect(deploymentRepo.UpdateCurrentManifestSHA).To(Equal("fake-manifest-sha1")) + Expect(deploymentRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-manifest-sha1")) }) It("passes the releases to the release repo", func() { @@ -297,7 +292,7 @@ var _ = Describe("Record", func() { Context("when updating currently deployed manifest sha1 fails", func() { BeforeEach(func() { - deploymentRepo.UpdateCurrentErr = errors.New("fake-update-error") + deploymentRepo.UpdateCurrentReturns(errors.New("fake-update-error")) }) It("returns an error", func() { @@ -328,11 +323,9 @@ var _ = Describe("Record", func() { Describe("Clear", func() { It("clears manifest hash", func() { - deploymentRepo.UpdateCurrentManifestSHA = "initial-sha" - err := deploymentRecord.Clear() Expect(err).ToNot(HaveOccurred()) - Expect(deploymentRepo.UpdateCurrentManifestSHA).To(Equal("")) + Expect(deploymentRepo.UpdateCurrentArgsForCall(0)).To(Equal("")) }) It("clears releases list", func() { @@ -344,7 +337,7 @@ var _ = Describe("Record", func() { Context("when clearing manifest hash fails", func() { BeforeEach(func() { - deploymentRepo.UpdateCurrentErr = errors.New("fake-update-error") + deploymentRepo.UpdateCurrentReturns(errors.New("fake-update-error")) }) It("returns an error", func() { diff --git a/deployment/vm/disk_deployer_test.go b/deployment/vm/disk_deployer_test.go index 401bbbbeac..f6fe3f4606 100644 --- a/deployment/vm/disk_deployer_test.go +++ b/deployment/vm/disk_deployer_test.go @@ -9,7 +9,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -27,7 +27,7 @@ var _ = Describe("DiskDeployer", func() { fakeStage *fakebiui.FakeStage fakeVM *fakebivm.FakeVM fakeDisk *fakebidisk.FakeDisk - fakeDiskRepo *fakebiconfig.FakeDiskRepo + fakeDiskRepo *configfakes.FakeDiskRepo fakeDiskManagerFactory *fakebidisk.FakeManagerFactory logger boshlog.Logger ) @@ -44,7 +44,7 @@ var _ = Describe("DiskDeployer", func() { logger = boshlog.NewLogger(boshlog.LevelNone) fakeStage = fakebiui.NewFakeStage() - fakeDiskRepo = fakebiconfig.NewFakeDiskRepo() + fakeDiskRepo = &configfakes.FakeDiskRepo{} diskDeployer = NewDiskDeployer( fakeDiskManagerFactory, fakeDiskRepo, @@ -57,7 +57,7 @@ var _ = Describe("DiskDeployer", func() { newDiskRecord := biconfig.DiskRecord{ ID: "fake-new-disk-id", } - fakeDiskRepo.SetFindBehavior("fake-new-disk-cid", newDiskRecord, true, nil) + fakeDiskRepo.FindReturnsOnCall(0, newDiskRecord, true, nil) }) Context("when the disk pool size is > 0", func() { @@ -81,7 +81,7 @@ var _ = Describe("DiskDeployer", func() { existingDiskRecord := biconfig.DiskRecord{ ID: "fake-existing-disk-id", } - fakeDiskRepo.SetFindBehavior("fake-existing-disk-cid", existingDiskRecord, true, nil) + fakeDiskRepo.FindReturnsOnCall(1, existingDiskRecord, true, nil) }) It("does not create primary disk", func() { @@ -126,7 +126,7 @@ var _ = Describe("DiskDeployer", func() { ID: "fake-secondary-disk-id", } - fakeDiskRepo.SetFindBehavior("fake-secondary-disk-cid", secondaryDiskRecord, true, nil) + fakeDiskRepo.FindReturnsOnCall(0, secondaryDiskRecord, true, nil) }) It("creates secondary disk", func() { @@ -186,10 +186,7 @@ var _ = Describe("DiskDeployer", func() { Expect(err).NotTo(HaveOccurred()) // existing disk must be current until after migration - Expect(fakeDiskRepo.UpdateCurrentInputs).To(Equal([]fakebiconfig.DiskRepoUpdateCurrentInput{ - // { DiskID: "fake-existing-disk-id" }, - {DiskID: "fake-secondary-disk-id"}, - })) + Expect(fakeDiskRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-secondary-disk-id")) }) Context("when disk creation fails", func() { @@ -298,7 +295,7 @@ var _ = Describe("DiskDeployer", func() { ID: "fake-secondary-disk-id", } - fakeDiskRepo.SetFindBehavior("fake-secondary-disk-cid", secondaryDiskRecord, true, nil) + fakeDiskRepo.FindReturnsOnCall(0, secondaryDiskRecord, true, nil) }) It("creates secondary disk", func() { @@ -358,10 +355,7 @@ var _ = Describe("DiskDeployer", func() { Expect(err).NotTo(HaveOccurred()) // existing disk must be current until after migration - Expect(fakeDiskRepo.UpdateCurrentInputs).To(Equal([]fakebiconfig.DiskRepoUpdateCurrentInput{ - // { DiskID: "fake-existing-disk-id" }, - {DiskID: "fake-secondary-disk-id"}, - })) + Expect(fakeDiskRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-secondary-disk-id")) }) Context("when disk creation fails", func() { @@ -477,9 +471,7 @@ var _ = Describe("DiskDeployer", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeDiskRepo.UpdateCurrentInputs).To(Equal([]fakebiconfig.DiskRepoUpdateCurrentInput{ - {DiskID: "fake-new-disk-id"}, - })) + Expect(fakeDiskRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-new-disk-id")) }) It("logs the create disk event", func() { diff --git a/deployment/vm/manager_test.go b/deployment/vm/manager_test.go index 5a9ecf9616..25775c5c11 100644 --- a/deployment/vm/manager_test.go +++ b/deployment/vm/manager_test.go @@ -16,7 +16,7 @@ import ( bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" @@ -32,7 +32,7 @@ var _ = Describe("Manager", func() { expectedCloudProperties biproperty.Map expectedEnv biproperty.Map deploymentManifest bideplmanifest.Manifest - fakeVMRepo *fakebiconfig.FakeVMRepo + fakeVMRepo *configfakes.FakeVMRepo stemcellRepo biconfig.StemcellRepo fakeDiskDeployer *fakebivm.FakeDiskDeployer fakeAgentClient *fakebiagentclient.FakeAgentClient @@ -47,7 +47,7 @@ var _ = Describe("Manager", func() { fs = fakesys.NewFakeFileSystem() fakeCloud = &cloudfakes.FakeCloud{} fakeAgentClient = &fakebiagentclient.FakeAgentClient{} - fakeVMRepo = fakebiconfig.NewFakeVMRepo() + fakeVMRepo = &configfakes.FakeVMRepo{} fakeUUIDGenerator := &fakeuuid.FakeGenerator{} deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, "/fake/path") @@ -258,7 +258,7 @@ var _ = Describe("Manager", func() { _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVMRepo.UpdateCurrentCID).To(Equal("fake-vm-cid")) + Expect(fakeVMRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-vm-cid")) }) Context("when setting vm metadata fails", func() { @@ -274,7 +274,7 @@ var _ = Describe("Manager", func() { fakeCloud.SetVMMetadataReturns(errors.New("fake-set-metadata-error")) _, err := manager.Create(stemcell, deploymentManifest, diskCIDs) Expect(err).To(HaveOccurred()) - Expect(fakeVMRepo.UpdateCurrentCID).To(Equal("fake-vm-cid")) + Expect(fakeVMRepo.UpdateCurrentArgsForCall(0)).To(Equal("fake-vm-cid")) }) It("ignores not implemented error", func() { diff --git a/deployment/vm/vm_test.go b/deployment/vm/vm_test.go index b212276c94..37b03428c8 100644 --- a/deployment/vm/vm_test.go +++ b/deployment/vm/vm_test.go @@ -16,7 +16,7 @@ import ( bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" - fakebiconfig "github.com/cloudfoundry/bosh-cli/v7/config/fakes" + "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -28,8 +28,8 @@ import ( var _ = Describe("VM", func() { var ( vm VM - fakeVMRepo *fakebiconfig.FakeVMRepo - fakeStemcellRepo *fakebiconfig.FakeStemcellRepo + fakeVMRepo *configfakes.FakeVMRepo + fakeStemcellRepo *configfakes.FakeStemcellRepo fakeDiskDeployer *fakebivm.FakeDiskDeployer fakeAgentClient *fakebiagentclient.FakeAgentClient fakeCloud *cloudfakes.FakeCloud @@ -60,8 +60,8 @@ var _ = Describe("VM", func() { logger = &loggerfakes.FakeLogger{} fs = fakesys.NewFakeFileSystem() fakeCloud = &cloudfakes.FakeCloud{} - fakeVMRepo = fakebiconfig.NewFakeVMRepo() - fakeStemcellRepo = fakebiconfig.NewFakeStemcellRepo() + fakeVMRepo = &configfakes.FakeVMRepo{} + fakeStemcellRepo = &configfakes.FakeStemcellRepo{} fakeDiskDeployer = fakebivm.NewFakeDiskDeployer() vm = NewVM( "fake-vm-cid", @@ -588,13 +588,13 @@ var _ = Describe("VM", func() { It("deletes VM in the vm repo", func() { err := vm.Delete() Expect(err).ToNot(HaveOccurred()) - Expect(fakeVMRepo.ClearCurrentCalled).To(BeTrue()) + Expect(fakeVMRepo.ClearCurrentCallCount()).To(Equal(1)) }) It("clears current stemcell in the stemcell repo", func() { err := vm.Delete() Expect(err).ToNot(HaveOccurred()) - Expect(fakeStemcellRepo.ClearCurrentCalled).To(BeTrue()) + Expect(fakeVMRepo.ClearCurrentCallCount()).To(Equal(1)) }) Context("when deleting vm in the cloud fails", func() { @@ -630,14 +630,14 @@ var _ = Describe("VM", func() { err := vm.Delete() Expect(err).To(HaveOccurred()) Expect(err).To(Equal(deleteErr)) - Expect(fakeVMRepo.ClearCurrentCalled).To(BeTrue()) + Expect(fakeVMRepo.ClearCurrentCallCount()).To(Equal(1)) }) It("clears current stemcell in the stemcell repo", func() { err := vm.Delete() Expect(err).To(HaveOccurred()) Expect(err).To(Equal(deleteErr)) - Expect(fakeStemcellRepo.ClearCurrentCalled).To(BeTrue()) + Expect(fakeVMRepo.ClearCurrentCallCount()).To(Equal(1)) }) }) }) From d0f19513ce6c78373bb87f5e1344d0810f64dbab Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 10:09:39 -0700 Subject: [PATCH 05/13] Replace hand-crafted `crypto/fakes/` with counterfeiter --- cmd/redigest_release_test.go | 125 ++++++++---- crypto/cryptofakes/fake_digest_calculator.go | 186 ++++++++++++++++++ crypto/digest_calculator.go | 4 + crypto/fakes/fake_digest_calculator.go | 42 ---- integration/create_env_test.go | 29 ++- release/pkg/compiled_package_test.go | 42 ++-- release/resource/archive_test.go | 6 +- release/resource/fingerprint_test.go | 113 ++++++++--- release/resource/resource_test.go | 18 +- releasedir/fs_blobs_dir_test.go | 28 ++- .../rendered_job_list_compressor_test.go | 18 +- 11 files changed, 453 insertions(+), 158 deletions(-) create mode 100644 crypto/cryptofakes/fake_digest_calculator.go delete mode 100644 crypto/fakes/fake_digest_calculator.go diff --git a/cmd/redigest_release_test.go b/cmd/redigest_release_test.go index 49fb8eb9e2..a5b70d8e46 100644 --- a/cmd/redigest_release_test.go +++ b/cmd/redigest_release_test.go @@ -1,6 +1,8 @@ package cmd_test import ( + "fmt" + "github.com/cloudfoundry/bosh-utils/errors" fakefu "github.com/cloudfoundry/bosh-utils/fileutil/fakes" fakes2 "github.com/cloudfoundry/bosh-utils/system/fakes" @@ -9,7 +11,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/cmd" "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" - fakecrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" boshrel "github.com/cloudfoundry/bosh-cli/v7/release" boshjob "github.com/cloudfoundry/bosh-cli/v7/release/job" "github.com/cloudfoundry/bosh-cli/v7/release/license" @@ -28,7 +30,7 @@ var _ = Describe("RedigestRelease", func() { releaseWriter *fakerel.FakeWriter command cmd.RedigestReleaseCmd args opts.RedigestReleaseArgs - fakeDigestCalculator *fakecrypto.FakeDigestCalculator + fakeDigestCalculator *cryptofakes.FakeDigestCalculator releaseWriterTempDestination string fakeSha128Release *fakerel.FakeRelease fs *fakes2.FakeFileSystem @@ -47,7 +49,7 @@ var _ = Describe("RedigestRelease", func() { fmv = &fakefu.FakeMover{} fs = fakes2.NewFakeFileSystem() - fakeDigestCalculator = fakecrypto.NewFakeDigestCalculator() + fakeDigestCalculator = &cryptofakes.FakeDigestCalculator{} command = cmd.NewRedigestReleaseCmd(releaseReader, releaseWriter, fakeDigestCalculator, fmv, fs, ui) args = opts.RedigestReleaseArgs{ Path: "/some/release_128.tgz", @@ -89,12 +91,20 @@ var _ = Describe("RedigestRelease", func() { return fakeSha256Release } - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {DigestStr: "sha256:jobsha256"}, - pkg1ResourcePath: {DigestStr: "sha256:pkgsha256"}, - licenseResourcePath: {DigestStr: "sha256:licsha256"}, - compiledPackage1ResourcePath: {DigestStr: "sha256:compiledpkgsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "sha256:jobsha256", nil + case pkg1ResourcePath: + return "sha256:pkgsha256", nil + case licenseResourcePath: + return "sha256:licsha256", nil + case compiledPackage1ResourcePath: + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } releaseReader.ReadReturns(fakeSha128Release, nil) releaseWriterTempDestination = "/some/temp/release_256.tgz" @@ -167,12 +177,20 @@ var _ = Describe("RedigestRelease", func() { Context("when rehashing a licence fails", func() { BeforeEach(func() { - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {DigestStr: "sha256:jobsha256"}, - pkg1ResourcePath: {DigestStr: "sha256:pkgsha256"}, - compiledPackage1ResourcePath: {DigestStr: "sha256:compiledpkgsha256"}, - licenseResourcePath: {Err: errors.Error("Unknown algorithm")}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "sha256:jobsha256", nil + case pkg1ResourcePath: + return "sha256:pkgsha256", nil + case licenseResourcePath: + return "", errors.Error("Unknown algorithm") + case compiledPackage1ResourcePath: + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("should return an error", func() { @@ -184,12 +202,20 @@ var _ = Describe("RedigestRelease", func() { Context("when rehashing compiled packages fails", func() { BeforeEach(func() { - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {DigestStr: "sha256:jobsha256"}, - pkg1ResourcePath: {DigestStr: "sha256:pkgsha256"}, - compiledPackage1ResourcePath: {Err: errors.Error("Unknown algorithm")}, - licenseResourcePath: {DigestStr: "sha256:licsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "sha256:jobsha256", nil + case pkg1ResourcePath: + return "sha256:pkgsha256", nil + case licenseResourcePath: + return "sha256:licsha256", nil + case compiledPackage1ResourcePath: + return "", errors.Error("Unknown algorithm") + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("should return an error", func() { @@ -201,12 +227,20 @@ var _ = Describe("RedigestRelease", func() { Context("when rehashing packages fails", func() { BeforeEach(func() { - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {DigestStr: "sha256:jobsha256"}, - pkg1ResourcePath: {Err: errors.Error("Unknown algorithm")}, - compiledPackage1ResourcePath: {DigestStr: "sha256:compiledpkgsha256"}, - licenseResourcePath: {DigestStr: "sha256:licsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "sha256:jobsha256", nil + case pkg1ResourcePath: + return "", errors.Error("Unknown algorithm") + case licenseResourcePath: + return "sha256:licsha256", nil + case compiledPackage1ResourcePath: + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("should return an error", func() { @@ -218,12 +252,20 @@ var _ = Describe("RedigestRelease", func() { Context("when rehashing jobs fails", func() { BeforeEach(func() { - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {Err: errors.Error("Unknown algorithm")}, - pkg1ResourcePath: {DigestStr: "sha256:pkgsha256"}, - compiledPackage1ResourcePath: {DigestStr: "sha256:compiledpkgsha256"}, - licenseResourcePath: {DigestStr: "sha256:licsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "", errors.Error("Unknown algorithm") + case pkg1ResourcePath: + return "sha256:pkgsha256", nil + case licenseResourcePath: + return "sha256:licsha256", nil + case compiledPackage1ResourcePath: + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("should return an error", func() { @@ -236,11 +278,18 @@ var _ = Describe("RedigestRelease", func() { Context("when no licence is provided", func() { BeforeEach(func() { fakeSha128Release.LicenseReturns(nil) - fakeDigestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - job1ResourcePath: {DigestStr: "sha256:jobsha256"}, - pkg1ResourcePath: {DigestStr: "sha256:pkgsha256"}, - compiledPackage1ResourcePath: {DigestStr: "sha256:compiledpkgsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case job1ResourcePath: + return "sha256:jobsha256", nil + case pkg1ResourcePath: + return "sha256:pkgsha256", nil + case compiledPackage1ResourcePath: + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("should not return an error", func() { diff --git a/crypto/cryptofakes/fake_digest_calculator.go b/crypto/cryptofakes/fake_digest_calculator.go new file mode 100644 index 0000000000..804c4192da --- /dev/null +++ b/crypto/cryptofakes/fake_digest_calculator.go @@ -0,0 +1,186 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package cryptofakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/crypto" +) + +type FakeDigestCalculator struct { + CalculateStub func(string) (string, error) + calculateMutex sync.RWMutex + calculateArgsForCall []struct { + arg1 string + } + calculateReturns struct { + result1 string + result2 error + } + calculateReturnsOnCall map[int]struct { + result1 string + result2 error + } + CalculateStringStub func(string) string + calculateStringMutex sync.RWMutex + calculateStringArgsForCall []struct { + arg1 string + } + calculateStringReturns struct { + result1 string + } + calculateStringReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDigestCalculator) Calculate(arg1 string) (string, error) { + fake.calculateMutex.Lock() + ret, specificReturn := fake.calculateReturnsOnCall[len(fake.calculateArgsForCall)] + fake.calculateArgsForCall = append(fake.calculateArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.CalculateStub + fakeReturns := fake.calculateReturns + fake.recordInvocation("Calculate", []interface{}{arg1}) + fake.calculateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDigestCalculator) CalculateCallCount() int { + fake.calculateMutex.RLock() + defer fake.calculateMutex.RUnlock() + return len(fake.calculateArgsForCall) +} + +func (fake *FakeDigestCalculator) CalculateCalls(stub func(string) (string, error)) { + fake.calculateMutex.Lock() + defer fake.calculateMutex.Unlock() + fake.CalculateStub = stub +} + +func (fake *FakeDigestCalculator) CalculateArgsForCall(i int) string { + fake.calculateMutex.RLock() + defer fake.calculateMutex.RUnlock() + argsForCall := fake.calculateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDigestCalculator) CalculateReturns(result1 string, result2 error) { + fake.calculateMutex.Lock() + defer fake.calculateMutex.Unlock() + fake.CalculateStub = nil + fake.calculateReturns = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeDigestCalculator) CalculateReturnsOnCall(i int, result1 string, result2 error) { + fake.calculateMutex.Lock() + defer fake.calculateMutex.Unlock() + fake.CalculateStub = nil + if fake.calculateReturnsOnCall == nil { + fake.calculateReturnsOnCall = make(map[int]struct { + result1 string + result2 error + }) + } + fake.calculateReturnsOnCall[i] = struct { + result1 string + result2 error + }{result1, result2} +} + +func (fake *FakeDigestCalculator) CalculateString(arg1 string) string { + fake.calculateStringMutex.Lock() + ret, specificReturn := fake.calculateStringReturnsOnCall[len(fake.calculateStringArgsForCall)] + fake.calculateStringArgsForCall = append(fake.calculateStringArgsForCall, struct { + arg1 string + }{arg1}) + stub := fake.CalculateStringStub + fakeReturns := fake.calculateStringReturns + fake.recordInvocation("CalculateString", []interface{}{arg1}) + fake.calculateStringMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeDigestCalculator) CalculateStringCallCount() int { + fake.calculateStringMutex.RLock() + defer fake.calculateStringMutex.RUnlock() + return len(fake.calculateStringArgsForCall) +} + +func (fake *FakeDigestCalculator) CalculateStringCalls(stub func(string) string) { + fake.calculateStringMutex.Lock() + defer fake.calculateStringMutex.Unlock() + fake.CalculateStringStub = stub +} + +func (fake *FakeDigestCalculator) CalculateStringArgsForCall(i int) string { + fake.calculateStringMutex.RLock() + defer fake.calculateStringMutex.RUnlock() + argsForCall := fake.calculateStringArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeDigestCalculator) CalculateStringReturns(result1 string) { + fake.calculateStringMutex.Lock() + defer fake.calculateStringMutex.Unlock() + fake.CalculateStringStub = nil + fake.calculateStringReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeDigestCalculator) CalculateStringReturnsOnCall(i int, result1 string) { + fake.calculateStringMutex.Lock() + defer fake.calculateStringMutex.Unlock() + fake.CalculateStringStub = nil + if fake.calculateStringReturnsOnCall == nil { + fake.calculateStringReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.calculateStringReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeDigestCalculator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDigestCalculator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ crypto.DigestCalculator = new(FakeDigestCalculator) diff --git a/crypto/digest_calculator.go b/crypto/digest_calculator.go index d1b5b94b21..f35a596253 100644 --- a/crypto/digest_calculator.go +++ b/crypto/digest_calculator.go @@ -8,6 +8,10 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . DigestCalculator + type DigestCalculator interface { Calculate(string) (string, error) CalculateString(string) string diff --git a/crypto/fakes/fake_digest_calculator.go b/crypto/fakes/fake_digest_calculator.go deleted file mode 100644 index 31395a75ce..0000000000 --- a/crypto/fakes/fake_digest_calculator.go +++ /dev/null @@ -1,42 +0,0 @@ -package fakes - -import ( - "fmt" - "strings" -) - -type FakeDigestCalculator struct { - calculateInputs map[string]CalculateInput - CalculateStringInputs map[string]string -} - -func NewFakeDigestCalculator() *FakeDigestCalculator { - return &FakeDigestCalculator{} -} - -type CalculateInput struct { - DigestStr string - Err error -} - -func (c *FakeDigestCalculator) Calculate(path string) (string, error) { - calculateInput := c.calculateInputs[path] - return calculateInput.DigestStr, calculateInput.Err -} - -func (c *FakeDigestCalculator) CalculateString(data string) string { - if sha1, found := c.CalculateStringInputs[data]; found { - return sha1 - } - - var availableData []string - for key := range c.CalculateStringInputs { - availableData = append(availableData, key) - } - - panic(fmt.Sprintf("Did not find SHA1 result for '%s'. Available result keys:'%s'", data, strings.Join(availableData, ", "))) -} - -func (c *FakeDigestCalculator) SetCalculateBehavior(calculateInputs map[string]CalculateInput) { - c.calculateInputs = calculateInputs -} diff --git a/integration/create_env_test.go b/integration/create_env_test.go index a888d02870..a68f31483f 100644 --- a/integration/create_env_test.go +++ b/integration/create_env_test.go @@ -2,6 +2,7 @@ package integration_test import ( "bytes" + "fmt" "os" "path/filepath" "text/template" @@ -29,7 +30,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/cmd/opts" biconfig "github.com/cloudfoundry/bosh-cli/v7/config" bicpirel "github.com/cloudfoundry/bosh-cli/v7/cpi/release" - fakebicrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" bidepl "github.com/cloudfoundry/bosh-cli/v7/deployment" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" @@ -86,7 +87,7 @@ var _ = Describe("bosh", func() { fakeUUIDGenerator *fakeuuid.FakeGenerator fakeRepoUUIDGenerator *fakeuuid.FakeGenerator fakeAgentIDGenerator *fakeuuid.FakeGenerator - fakeDigestCalculator *fakebicrypto.FakeDigestCalculator + fakeDigestCalculator *cryptofakes.FakeDigestCalculator legacyDeploymentStateMigrator biconfig.LegacyDeploymentStateMigrator deploymentStateService biconfig.DeploymentStateService vmRepo biconfig.VMRepo @@ -231,9 +232,14 @@ cloud_provider: } updateManifest(context) - fakeDigestCalculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{ - deploymentManifestPath: {DigestStr: "fake-deployment-sha1-1"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case deploymentManifestPath: + return "fake-deployment-sha1-1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } } var writeDeploymentManifestWithLargerDisk = func() { @@ -242,9 +248,14 @@ cloud_provider: } updateManifest(context) - fakeDigestCalculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{ - deploymentManifestPath: {DigestStr: "fake-deployment-sha1-2"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case deploymentManifestPath: + return "fake-deployment-sha1-2", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } } var writeCPIReleaseTarball = func() { @@ -858,7 +869,7 @@ cloud_provider: fakeAgentIDGenerator = fakeuuid.NewFakeGenerator() - fakeDigestCalculator = fakebicrypto.NewFakeDigestCalculator() + fakeDigestCalculator = &cryptofakes.FakeDigestCalculator{} mockInstaller = &installationfakes.FakeInstaller{} mockInstallerFactory = &installationfakes.FakeInstallerFactory{} diff --git a/release/pkg/compiled_package_test.go b/release/pkg/compiled_package_test.go index b8a459b765..a0906c0142 100644 --- a/release/pkg/compiled_package_test.go +++ b/release/pkg/compiled_package_test.go @@ -2,14 +2,15 @@ package pkg_test import ( "errors" + "fmt" "strings" - "github.com/cloudfoundry/bosh-utils/crypto/cryptofakes" - fakes2 "github.com/cloudfoundry/bosh-utils/system/fakes" + fakecrypto "github.com/cloudfoundry/bosh-utils/crypto/cryptofakes" + fakessys "github.com/cloudfoundry/bosh-utils/system/fakes" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" . "github.com/cloudfoundry/bosh-cli/v7/release/pkg" ) @@ -61,9 +62,9 @@ var _ = Describe("NewCompiledPackageWithoutArchive", func() { var _ = Describe("NewCompiledPackageWithArchive", func() { var ( compiledPkg *CompiledPackage - fakeDigestCalculator *fakes.FakeDigestCalculator - fakeArchiveReader *cryptofakes.FakeArchiveDigestFilePathReader - fakeFile *fakes2.FakeFile + fakeDigestCalculator *cryptofakes.FakeDigestCalculator + fakeArchiveReader *fakecrypto.FakeArchiveDigestFilePathReader + fakeFile *fakessys.FakeFile fakeFileContentSha1 string ) @@ -109,17 +110,22 @@ var _ = Describe("NewCompiledPackageWithArchive", func() { Describe("RehashWithCalculator", func() { BeforeEach(func() { - fakeDigestCalculator = fakes.NewFakeDigestCalculator() - fakeArchiveReader = &cryptofakes.FakeArchiveDigestFilePathReader{} - fakeFile = &fakes2.FakeFile{Contents: []byte("hello world")} + fakeDigestCalculator = &cryptofakes.FakeDigestCalculator{} + fakeArchiveReader = &fakecrypto.FakeArchiveDigestFilePathReader{} + fakeFile = &fakessys.FakeFile{Contents: []byte("hello world")} fakeFileContentSha1 = "2aae6c35c94fcfb415dbe95f408b9ce91ee846ed" }) Context("When compiled package can be rehashed", func() { BeforeEach(func() { - fakeDigestCalculator.SetCalculateBehavior(map[string]fakes.CalculateInput{ - "path": {DigestStr: "sha256:compiledpkgsha256"}, - }) + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case "path": + return "sha256:compiledpkgsha256", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } fakeArchiveReader.OpenFileReturns(fakeFile, nil) @@ -165,9 +171,15 @@ var _ = Describe("NewCompiledPackageWithArchive", func() { "name", "fp", "os-slug", "path", fakeFileContentSha1, []string{"pkg1", "pkg2"}) fakeArchiveReader.OpenFileReturns(fakeFile, nil) - fakeDigestCalculator.SetCalculateBehavior(map[string]fakes.CalculateInput{ - "path": {Err: errors.New("fake-digest-calculator-error")}, - }) + + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case "path": + return "", errors.New("fake-digest-calculator-error") + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("returns an error calculating the sha 256 digest", func() { diff --git a/release/resource/archive_test.go b/release/resource/archive_test.go index 639faafa0b..107c828a39 100644 --- a/release/resource/archive_test.go +++ b/release/resource/archive_test.go @@ -18,7 +18,7 @@ import ( . "github.com/onsi/gomega" bicrypto "github.com/cloudfoundry/bosh-cli/v7/crypto" - fakecrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" fakeres "github.com/cloudfoundry/bosh-cli/v7/release/resource/resourcefakes" ) @@ -35,7 +35,7 @@ var _ = Describe("Archive", func() { Describe("Fingerprint", func() { var ( fingerprinter *fakeres.FakeFingerprinter - digestCalculator *fakecrypto.FakeDigestCalculator + digestCalculator *cryptofakes.FakeDigestCalculator compressor *fakecmd.FakeCompressor cmdRunner *fakesys.FakeCmdRunner fs *fakesys.FakeFileSystem @@ -44,7 +44,7 @@ var _ = Describe("Archive", func() { BeforeEach(func() { releaseDirPath := filepath.Join("/", "tmp", "release") fingerprinter = &fakeres.FakeFingerprinter{} - digestCalculator = fakecrypto.NewFakeDigestCalculator() + digestCalculator = &cryptofakes.FakeDigestCalculator{} compressor = fakecmd.NewFakeCompressor() cmdRunner = fakesys.NewFakeCmdRunner() fs = fakesys.NewFakeFileSystem() diff --git a/release/resource/fingerprint_test.go b/release/resource/fingerprint_test.go index a5870181d2..ae2ed87b29 100644 --- a/release/resource/fingerprint_test.go +++ b/release/resource/fingerprint_test.go @@ -2,6 +2,7 @@ package resource_test import ( "errors" + "fmt" "os" "path/filepath" "strings" @@ -10,20 +11,20 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakecrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" ) var _ = Describe("FingerprinterImpl", func() { var ( - digestCalculator *fakecrypto.FakeDigestCalculator + digestCalculator *cryptofakes.FakeDigestCalculator fs *fakesys.FakeFileSystem fingerprinter FingerprinterImpl followSymlinks bool ) BeforeEach(func() { - digestCalculator = fakecrypto.NewFakeDigestCalculator() + digestCalculator = &cryptofakes.FakeDigestCalculator{} fs = fakesys.NewFakeFileSystem() }) @@ -80,14 +81,25 @@ var _ = Describe("FingerprinterImpl", func() { Stats: &fakesys.FakeFileStats{FileType: fakesys.FakeFileTypeFile}, }) - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { // file1 directory is not sha1-ed - filepath.Join("/", "tmp", "file2"): {DigestStr: "file2-sha1"}, - filepath.Join("/", "tmp", "file3"): {DigestStr: "file3-sha1"}, - filepath.Join("/", "tmp", "rel", "file4"): {DigestStr: "file4-sha1"}, - filepath.Join("/", "tmp", "file5"): {DigestStr: "file5-sha1"}, - filepath.Join("/", "tmp", "rel", "file6"): {DigestStr: "file6-sha1"}, - }) + case filepath.Join("/", "tmp", "file1"): + return "", nil + case filepath.Join("/", "tmp", "file2"): + return "file2-sha1", nil + case filepath.Join("/", "tmp", "file3"): + return "file3-sha1", nil + case filepath.Join("/", "tmp", "rel", "file4"): + return "file4-sha1", nil + case filepath.Join("/", "tmp", "file5"): + return "file5-sha1", nil + case filepath.Join("/", "tmp", "rel", "file6"): + return "file6-sha1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } chunks = []string{ "v2", // version @@ -102,8 +114,13 @@ var _ = Describe("FingerprinterImpl", func() { }) It("fingerprints all files", func() { - digestCalculator.CalculateStringInputs = map[string]string{ - strings.Join(chunks, ""): "fp", + digestCalculator.CalculateStringStub = func(input string) string { + switch input { + case strings.Join(chunks, ""): + return "fp" + default: + panic(fmt.Sprintf("unexpected input: '%s'", input)) + } } fp, err := fingerprinter.Calculate(files, []string{"chunk2", "chunk1"}) @@ -112,8 +129,13 @@ var _ = Describe("FingerprinterImpl", func() { }) It("trims `sha256` algorithm info from resulting fingerprint string", func() { - digestCalculator.CalculateStringInputs = map[string]string{ - strings.Join(chunks, ""): "sha256:asdfasdfasdfasdf", + digestCalculator.CalculateStringStub = func(input string) string { + switch input { + case strings.Join(chunks, ""): + return "sha256:asdfasdfasdfasdf" + default: + panic(fmt.Sprintf("unexpected input: '%s'", input)) + } } fp, err := fingerprinter.Calculate(files, []string{"chunk2", "chunk1"}) @@ -127,8 +149,13 @@ var _ = Describe("FingerprinterImpl", func() { err := fs.WriteFileString(filepath.Join("/", "tmp", "file"), "stuff") Expect(err).ToNot(HaveOccurred()) - digestCalculator.CalculateStringInputs = map[string]string{ - strings.Join([]string{"v2", "file", "100644"}, ""): "whatTheAlgorithmIsThat!:asdfasdfasdfasdf", + digestCalculator.CalculateStringStub = func(input string) string { + switch input { + case strings.Join([]string{"v2", "file", "100644"}, ""): + return "whatTheAlgorithmIsThat!:asdfasdfasdfasdf" + default: + panic(fmt.Sprintf("unexpected input: '%s'", input)) + } } _, err = fingerprinter.Calculate(files, []string{}) @@ -153,9 +180,14 @@ var _ = Describe("FingerprinterImpl", func() { err = fs.Symlink(filepath.Join("/", "tmp", "regular"), filepath.Join("/", "tmp", "symlink")) Expect(err).ToNot(HaveOccurred()) - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - filepath.Join("/", "tmp", "regular"): {DigestStr: "regular-sha1"}, - }) + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filepath.Join("/", "tmp", "regular"): + return "regular-sha1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } chunks := []string{ "v2", // version @@ -164,8 +196,13 @@ var _ = Describe("FingerprinterImpl", func() { "chunk1", ",chunk2", // sorted chunks } - digestCalculator.CalculateStringInputs = map[string]string{ - strings.Join(chunks, ""): "fp", + digestCalculator.CalculateStringStub = func(input string) string { + switch input { + case strings.Join(chunks, ""): + return "fp" + default: + panic(fmt.Sprintf("unexpected input: '%s'", input)) + } } fp, err := fingerprinter.Calculate(files, []string{"chunk2", "chunk1"}) @@ -190,9 +227,14 @@ var _ = Describe("FingerprinterImpl", func() { err = fs.Symlink("nothing", filepath.Join("/", "tmp", "symlink")) Expect(err).ToNot(HaveOccurred()) - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - filepath.Join("/", "tmp", "regular"): {DigestStr: "regular-sha1"}, - }) + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filepath.Join("/", "tmp", "regular"): + return "regular-sha1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } chunks := []string{ "v2", // version @@ -201,9 +243,15 @@ var _ = Describe("FingerprinterImpl", func() { "chunk1", ",chunk2", // sorted chunks } - digestCalculator.CalculateStringInputs = map[string]string{ - "nothing": "symlink-target-sha1", - strings.Join(chunks, ""): "fp", + digestCalculator.CalculateStringStub = func(input string) string { + switch input { + case "nothing": + return "symlink-target-sha1" + case strings.Join(chunks, ""): + return "fp" + default: + panic(fmt.Sprintf("unexpected input: '%s'", input)) + } } fp, err := fingerprinter.Calculate(files, []string{"chunk2", "chunk1"}) @@ -227,9 +275,14 @@ var _ = Describe("FingerprinterImpl", func() { Stats: &fakesys.FakeFileStats{FileType: fakesys.FakeFileTypeFile}, }) - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - filepath.Join("/", "tmp", "file2"): {Err: errors.New("fake-err")}, - }) + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filepath.Join("/", "tmp", "file2"): + return "", errors.New("fake-err") + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } _, err := fingerprinter.Calculate([]File{NewFile(filepath.Join("/", "tmp", "file2"), filepath.Join("/", "tmp"))}, nil) Expect(err).To(HaveOccurred()) diff --git a/release/resource/resource_test.go b/release/resource/resource_test.go index 2888e21790..14dbeb6e1f 100644 --- a/release/resource/resource_test.go +++ b/release/resource/resource_test.go @@ -2,6 +2,7 @@ package resource_test import ( "errors" + "fmt" "strings" boshcrypto "github.com/cloudfoundry/bosh-utils/crypto" @@ -9,7 +10,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" fakeres "github.com/cloudfoundry/bosh-cli/v7/release/resource/resourcefakes" ) @@ -446,13 +447,18 @@ var _ = Describe("NewResourceWithBuiltArchive", func() { Describe("RehashWithCalculator", func() { Context("Given a sha256 calculator", func() { - var fakeDigestCalculator *fakes.FakeDigestCalculator + var fakeDigestCalculator *cryptofakes.FakeDigestCalculator BeforeEach(func() { - fakeDigestCalculator = fakes.NewFakeDigestCalculator() - fakeDigestCalculator.SetCalculateBehavior(map[string]fakes.CalculateInput{ - filePathName: {DigestStr: "sha256:new_resource_sha"}, - }) + fakeDigestCalculator = &cryptofakes.FakeDigestCalculator{} + fakeDigestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filePathName: + return "sha256:new_resource_sha", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) Context("Given a resource with a valid sha128", func() { diff --git a/releasedir/fs_blobs_dir_test.go b/releasedir/fs_blobs_dir_test.go index 82c37db6a3..1b2d008a5a 100644 --- a/releasedir/fs_blobs_dir_test.go +++ b/releasedir/fs_blobs_dir_test.go @@ -15,7 +15,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakecrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" . "github.com/cloudfoundry/bosh-cli/v7/releasedir" fakereldir "github.com/cloudfoundry/bosh-cli/v7/releasedir/releasedirfakes" ) @@ -25,7 +25,7 @@ var _ = Describe("FSBlobsDir", func() { fs *fakesys.FakeFileSystem reporter *fakereldir.FakeBlobsDirReporter blobstore *fakereldir.FakeDigestBlobstore - digestCalculator *fakecrypto.FakeDigestCalculator + digestCalculator *cryptofakes.FakeDigestCalculator blobsDir FSBlobsDir logger *fakelogger.FakeLogger ) @@ -34,7 +34,7 @@ var _ = Describe("FSBlobsDir", func() { fs = fakesys.NewFakeFileSystem() reporter = &fakereldir.FakeBlobsDirReporter{} blobstore = &fakereldir.FakeDigestBlobstore{} - digestCalculator = fakecrypto.NewFakeDigestCalculator() + digestCalculator = &cryptofakes.FakeDigestCalculator{} logger = &fakelogger.FakeLogger{} blobsDir = NewFSBlobsDir(filepath.Join("/", "dir"), reporter, blobstore, digestCalculator, fs, logger) }) @@ -526,9 +526,14 @@ bad-sha-blob.tgz: Expect(err).ToNot(HaveOccurred()) fs.ReturnTempFile = fakesys.NewFakeFile(filepath.Join("/", "tmp-file"), fs) - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - filepath.Join("/", "tmp-file"): {DigestStr: "contentsha1"}, - }) + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filepath.Join("/", "tmp-file"): + return "contentsha1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } }) It("adds a blob to the list if it's not already tracked", func() { @@ -618,9 +623,14 @@ file2.tgz: }) It("returns error and does not update blobs.yml if calculating sha1 fails", func() { - digestCalculator.SetCalculateBehavior(map[string]fakecrypto.CalculateInput{ - filepath.Join("/", "tmp-file"): {Err: errors.New("fake-err")}, - }) + digestCalculator.CalculateStub = func(path string) (string, error) { + switch path { + case filepath.Join("/", "tmp-file"): + return "", errors.New("fake-err") + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } _, err := act() Expect(err).To(HaveOccurred()) diff --git a/templatescompiler/rendered_job_list_compressor_test.go b/templatescompiler/rendered_job_list_compressor_test.go index a7ada84b94..00eaac0524 100644 --- a/templatescompiler/rendered_job_list_compressor_test.go +++ b/templatescompiler/rendered_job_list_compressor_test.go @@ -2,6 +2,7 @@ package templatescompiler_test import ( "bytes" + "fmt" "os" "path/filepath" @@ -13,7 +14,7 @@ import ( . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" - fakebicrypto "github.com/cloudfoundry/bosh-cli/v7/crypto/fakes" + "github.com/cloudfoundry/bosh-cli/v7/crypto/cryptofakes" bireljob "github.com/cloudfoundry/bosh-cli/v7/release/job" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" . "github.com/cloudfoundry/bosh-cli/v7/templatescompiler" @@ -24,7 +25,7 @@ var _ = Describe("RenderedJobListCompressor", func() { outBuffer *bytes.Buffer logger boshlog.Logger - fakeSHA1Calculator *fakebicrypto.FakeDigestCalculator + fakeSHA1Calculator *cryptofakes.FakeDigestCalculator renderedJobList RenderedJobList @@ -35,7 +36,7 @@ var _ = Describe("RenderedJobListCompressor", func() { outBuffer = bytes.NewBufferString("") logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuffer) - fakeSHA1Calculator = fakebicrypto.NewFakeDigestCalculator() + fakeSHA1Calculator = &cryptofakes.FakeDigestCalculator{} renderedJobList = NewRenderedJobList() }) @@ -124,9 +125,14 @@ var _ = Describe("RenderedJobListCompressor", func() { It("calculates the SHA1 of the archive", func() { fakeCompressor.CompressFilesInDirTarballPath = "fake-archive-path" - fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{ - "fake-archive-path": fakebicrypto.CalculateInput{DigestStr: "fake-sha1"}, - }) + fakeSHA1Calculator.CalculateStub = func(path string) (string, error) { + switch path { + case "fake-archive-path": + return "fake-sha1", nil + default: + return "", fmt.Errorf("unexpected input '%s'", path) + } + } archive, err := renderedJobListCompressor.Compress(renderedJobList) Expect(err).ToNot(HaveOccurred()) From e9009895040ceec3c5d0f99da92a05c5cc424784 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 10:17:45 -0700 Subject: [PATCH 06/13] Remove unused `deployment/fakes/` --- deployment/fakes/fake_vm_deployer.go | 81 ---------------------------- 1 file changed, 81 deletions(-) delete mode 100644 deployment/fakes/fake_vm_deployer.go diff --git a/deployment/fakes/fake_vm_deployer.go b/deployment/fakes/fake_vm_deployer.go deleted file mode 100644 index 8448b6545c..0000000000 --- a/deployment/fakes/fake_vm_deployer.go +++ /dev/null @@ -1,81 +0,0 @@ -package fakes - -import ( - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" - bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - biui "github.com/cloudfoundry/bosh-cli/v7/ui" -) - -type FakeVMDeployer struct { - DeployInputs []VMDeployInput - DeployOutputs []vmDeployOutput - - WaitUntilReadyInputs []WaitUntilReadyInput - WaitUntilReadyErr error -} - -type VMDeployInput struct { - Cloud bicloud.Cloud - Manifest bideplmanifest.Manifest - Stemcell bistemcell.CloudStemcell - MbusURL string - EventLoggerStage biui.Stage -} - -type WaitUntilReadyInput struct { - VM bivm.VM - SSHTunnelOptions bisshtunnel.Options - EventLoggerStage biui.Stage -} - -type vmDeployOutput struct { - vm bivm.VM - err error -} - -func NewFakeVMDeployer() *FakeVMDeployer { - return &FakeVMDeployer{ - DeployInputs: []VMDeployInput{}, - DeployOutputs: []vmDeployOutput{}, - } -} - -func (m *FakeVMDeployer) Deploy( - cloud bicloud.Cloud, - deploymentManifest bideplmanifest.Manifest, - stemcell bistemcell.CloudStemcell, - mbusURL string, - eventLoggerStage biui.Stage, -) (bivm.VM, error) { - input := VMDeployInput{ - Cloud: cloud, - Manifest: deploymentManifest, - Stemcell: stemcell, - MbusURL: mbusURL, - EventLoggerStage: eventLoggerStage, - } - m.DeployInputs = append(m.DeployInputs, input) - - output := m.DeployOutputs[0] - m.DeployOutputs = m.DeployOutputs[1:] - - return output.vm, output.err -} - -func (m *FakeVMDeployer) WaitUntilReady(vm bivm.VM, sshTunnelOptions bisshtunnel.Options, eventLoggerStage biui.Stage) error { - input := WaitUntilReadyInput{ - VM: vm, - SSHTunnelOptions: sshTunnelOptions, - EventLoggerStage: eventLoggerStage, - } - m.WaitUntilReadyInputs = append(m.WaitUntilReadyInputs, input) - - return m.WaitUntilReadyErr -} - -func (m *FakeVMDeployer) SetDeployBehavior(vm bivm.VM, err error) { - m.DeployOutputs = append(m.DeployOutputs, vmDeployOutput{vm: vm, err: err}) -} From b9d3e99fc2260da6deed01b04b7599eae7f3d153 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 10:52:14 -0700 Subject: [PATCH 07/13] Replace hand-crafted `deployment/disk/fakes/` with counterfeiter --- .../disk/diskfakes/fake_manager_factory.go | 110 ++++++++++++++++++ deployment/disk/fakes/fake_disk.go | 59 ---------- deployment/disk/fakes/fake_manager.go | 79 ------------- deployment/disk/fakes/fake_manager_factory.go | 30 ----- deployment/disk/manager_factory.go | 2 + deployment/instance/instance_test.go | 12 +- deployment/instance/manager_test.go | 6 +- deployment/vm/disk_deployer_test.go | 100 ++++++++-------- deployment/vm/vm_test.go | 16 +-- 9 files changed, 182 insertions(+), 232 deletions(-) create mode 100644 deployment/disk/diskfakes/fake_manager_factory.go delete mode 100644 deployment/disk/fakes/fake_disk.go delete mode 100644 deployment/disk/fakes/fake_manager.go delete mode 100644 deployment/disk/fakes/fake_manager_factory.go diff --git a/deployment/disk/diskfakes/fake_manager_factory.go b/deployment/disk/diskfakes/fake_manager_factory.go new file mode 100644 index 0000000000..d3c48b7945 --- /dev/null +++ b/deployment/disk/diskfakes/fake_manager_factory.go @@ -0,0 +1,110 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package diskfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" +) + +type FakeManagerFactory struct { + NewManagerStub func(cloud.Cloud) disk.Manager + newManagerMutex sync.RWMutex + newManagerArgsForCall []struct { + arg1 cloud.Cloud + } + newManagerReturns struct { + result1 disk.Manager + } + newManagerReturnsOnCall map[int]struct { + result1 disk.Manager + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManagerFactory) NewManager(arg1 cloud.Cloud) disk.Manager { + fake.newManagerMutex.Lock() + ret, specificReturn := fake.newManagerReturnsOnCall[len(fake.newManagerArgsForCall)] + fake.newManagerArgsForCall = append(fake.newManagerArgsForCall, struct { + arg1 cloud.Cloud + }{arg1}) + stub := fake.NewManagerStub + fakeReturns := fake.newManagerReturns + fake.recordInvocation("NewManager", []interface{}{arg1}) + fake.newManagerMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeManagerFactory) NewManagerCallCount() int { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + return len(fake.newManagerArgsForCall) +} + +func (fake *FakeManagerFactory) NewManagerCalls(stub func(cloud.Cloud) disk.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = stub +} + +func (fake *FakeManagerFactory) NewManagerArgsForCall(i int) cloud.Cloud { + fake.newManagerMutex.RLock() + defer fake.newManagerMutex.RUnlock() + argsForCall := fake.newManagerArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeManagerFactory) NewManagerReturns(result1 disk.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + fake.newManagerReturns = struct { + result1 disk.Manager + }{result1} +} + +func (fake *FakeManagerFactory) NewManagerReturnsOnCall(i int, result1 disk.Manager) { + fake.newManagerMutex.Lock() + defer fake.newManagerMutex.Unlock() + fake.NewManagerStub = nil + if fake.newManagerReturnsOnCall == nil { + fake.newManagerReturnsOnCall = make(map[int]struct { + result1 disk.Manager + }) + } + fake.newManagerReturnsOnCall[i] = struct { + result1 disk.Manager + }{result1} +} + +func (fake *FakeManagerFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManagerFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ disk.ManagerFactory = new(FakeManagerFactory) diff --git a/deployment/disk/fakes/fake_disk.go b/deployment/disk/fakes/fake_disk.go deleted file mode 100644 index d1507dd4e5..0000000000 --- a/deployment/disk/fakes/fake_disk.go +++ /dev/null @@ -1,59 +0,0 @@ -package fakes - -import ( - biproperty "github.com/cloudfoundry/bosh-utils/property" -) - -type FakeDisk struct { - cid string - - NeedsMigrationInputs []NeedsMigrationInput - needsMigrationOutput needsMigrationOutput - - DeleteCalledTimes int - deleteErr error -} - -type NeedsMigrationInput struct { - Size int - CloudProperties biproperty.Map -} - -type needsMigrationOutput struct { - needsMigration bool -} - -func NewFakeDisk(cid string) *FakeDisk { - return &FakeDisk{ - cid: cid, - NeedsMigrationInputs: []NeedsMigrationInput{}, - } -} - -func (d *FakeDisk) CID() string { - return d.cid -} - -func (d *FakeDisk) NeedsMigration(size int, cloudProperties biproperty.Map) (bool, error) { - d.NeedsMigrationInputs = append(d.NeedsMigrationInputs, NeedsMigrationInput{ - Size: size, - CloudProperties: cloudProperties, - }) - - return d.needsMigrationOutput.needsMigration, nil -} - -func (d *FakeDisk) Delete() error { - d.DeleteCalledTimes++ - return d.deleteErr -} - -func (d *FakeDisk) SetNeedsMigrationBehavior(needsMigration bool) { - d.needsMigrationOutput = needsMigrationOutput{ - needsMigration: needsMigration, - } -} - -func (d *FakeDisk) SetDeleteBehavior(err error) { - d.deleteErr = err -} diff --git a/deployment/disk/fakes/fake_manager.go b/deployment/disk/fakes/fake_manager.go deleted file mode 100644 index 5a7952fd7f..0000000000 --- a/deployment/disk/fakes/fake_manager.go +++ /dev/null @@ -1,79 +0,0 @@ -package fakes - -import ( - bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - biui "github.com/cloudfoundry/bosh-cli/v7/ui" -) - -type FakeManager struct { - CreateInputs []CreateInput - CreateDisk bidisk.Disk - CreateErr error - - findCurrentOutput findCurrentOutput - - DeleteUnusedCalledTimes int - DeleteUnusedErr error - - findUnusedOutput findUnusedOutput -} - -type CreateInput struct { - DiskPool bideplmanifest.DiskPool - InstanceID string -} - -type findCurrentOutput struct { - Disks []bidisk.Disk - Err error -} - -type findUnusedOutput struct { - disks []bidisk.Disk - err error -} - -func NewFakeManager() *FakeManager { - return &FakeManager{} -} - -func (m *FakeManager) Create(diskPool bideplmanifest.DiskPool, instanceID string) (bidisk.Disk, error) { - input := CreateInput{ - DiskPool: diskPool, - InstanceID: instanceID, - } - m.CreateInputs = append(m.CreateInputs, input) - - return m.CreateDisk, m.CreateErr -} - -func (m *FakeManager) FindCurrent() ([]bidisk.Disk, error) { - return m.findCurrentOutput.Disks, m.findCurrentOutput.Err -} - -func (m *FakeManager) FindUnused() ([]bidisk.Disk, error) { - return m.findUnusedOutput.disks, m.findUnusedOutput.err -} - -func (m *FakeManager) DeleteUnused(eventLogStage biui.Stage) error { - m.DeleteUnusedCalledTimes++ - return m.DeleteUnusedErr -} - -func (m *FakeManager) SetFindCurrentBehavior(disks []bidisk.Disk, err error) { - m.findCurrentOutput = findCurrentOutput{ - Disks: disks, - Err: err, - } -} - -func (m *FakeManager) SetFindUnusedBehavior( - disks []bidisk.Disk, - err error, -) { - m.findUnusedOutput = findUnusedOutput{ - disks: disks, - err: err, - } -} diff --git a/deployment/disk/fakes/fake_manager_factory.go b/deployment/disk/fakes/fake_manager_factory.go deleted file mode 100644 index 23751358aa..0000000000 --- a/deployment/disk/fakes/fake_manager_factory.go +++ /dev/null @@ -1,30 +0,0 @@ -package fakes - -import ( - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" -) - -type NewManagerInput struct { - Cloud bicloud.Cloud -} - -type FakeManagerFactory struct { - NewManagerInputs []NewManagerInput - NewManagerManager bidisk.Manager -} - -func NewFakeManagerFactory() *FakeManagerFactory { - return &FakeManagerFactory{ - NewManagerInputs: []NewManagerInput{}, - } -} - -func (f *FakeManagerFactory) NewManager(cloud bicloud.Cloud) bidisk.Manager { - input := NewManagerInput{ - Cloud: cloud, - } - f.NewManagerInputs = append(f.NewManagerInputs, input) - - return f.NewManagerManager -} diff --git a/deployment/disk/manager_factory.go b/deployment/disk/manager_factory.go index d2e0c59dec..6f35ec1f49 100644 --- a/deployment/disk/manager_factory.go +++ b/deployment/disk/manager_factory.go @@ -7,6 +7,8 @@ import ( biconfig "github.com/cloudfoundry/bosh-cli/v7/config" ) +//counterfeiter:generate . ManagerFactory + type ManagerFactory interface { NewManager(bicloud.Cloud) Manager } diff --git a/deployment/instance/instance_test.go b/deployment/instance/instance_test.go index 80ebc9c4f9..6dbf89a6cd 100644 --- a/deployment/instance/instance_test.go +++ b/deployment/instance/instance_test.go @@ -12,7 +12,7 @@ import ( bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -139,8 +139,8 @@ var _ = Describe("Instance", func() { }) It("unmounts vm disks", func() { - firstDisk := fakebidisk.NewFakeDisk("fake-disk-1") - secondDisk := fakebidisk.NewFakeDisk("fake-disk-2") + firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }} + secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }} fakeVM.ListDisksDisks = []bidisk.Disk{firstDisk, secondDisk} err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) @@ -185,7 +185,7 @@ var _ = Describe("Instance", func() { Context("when unmounting disk fails", func() { BeforeEach(func() { - fakeVM.ListDisksDisks = []bidisk.Disk{fakebidisk.NewFakeDisk("fake-disk")} + fakeVM.ListDisksDisks = []bidisk.Disk{&diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk" }}} fakeVM.UnmountDiskErr = bosherr.Error("fake-unmount-error") }) @@ -570,8 +570,8 @@ var _ = Describe("Instance", func() { }) It("does not unmount vm disks", func() { - firstDisk := fakebidisk.NewFakeDisk("fake-disk-1") - secondDisk := fakebidisk.NewFakeDisk("fake-disk-2") + firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }} + secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }} fakeVM.ListDisksDisks = []bidisk.Disk{firstDisk, secondDisk} err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) diff --git a/deployment/instance/manager_test.go b/deployment/instance/manager_test.go index 9c72ea6a24..c2186f663b 100644 --- a/deployment/instance/manager_test.go +++ b/deployment/instance/manager_test.go @@ -15,7 +15,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/blobstore/blobstorefakes" "github.com/cloudfoundry/bosh-cli/v7/cloud/cloudfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" @@ -90,7 +90,7 @@ var _ = Describe("Manager", func() { diskCIDs []string expectedInstance Instance - expectedDisk *fakebidisk.FakeDisk + expectedDisk *diskfakes.FakeDisk ) var allowApplySpecToBeCreated = func() { @@ -172,7 +172,7 @@ var _ = Describe("Manager", func() { logger, ) - expectedDisk = fakebidisk.NewFakeDisk("fake-disk-cid") + expectedDisk = &diskfakes.FakeDisk{} fakeVM.UpdateDisksDisks = []bidisk.Disk{expectedDisk} }) diff --git a/deployment/vm/disk_deployer_test.go b/deployment/vm/disk_deployer_test.go index f6fe3f4606..8771574d8b 100644 --- a/deployment/vm/disk_deployer_test.go +++ b/deployment/vm/disk_deployer_test.go @@ -1,6 +1,7 @@ package vm_test import ( + bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" bosherr "github.com/cloudfoundry/bosh-utils/errors" boshlog "github.com/cloudfoundry/bosh-utils/logger" biproperty "github.com/cloudfoundry/bosh-utils/property" @@ -11,7 +12,7 @@ import ( biconfig "github.com/cloudfoundry/bosh-cli/v7/config" "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" @@ -21,14 +22,14 @@ import ( var _ = Describe("DiskDeployer", func() { var ( diskDeployer DiskDeployer - fakeDiskManager *fakebidisk.FakeManager + fakeDiskManager *diskfakes.FakeManager diskPool bideplmanifest.DiskPool cloud *cloudfakes.FakeCloud fakeStage *fakebiui.FakeStage fakeVM *fakebivm.FakeVM - fakeDisk *fakebidisk.FakeDisk + fakeDisk *diskfakes.FakeDisk fakeDiskRepo *configfakes.FakeDiskRepo - fakeDiskManagerFactory *fakebidisk.FakeManagerFactory + fakeDiskManagerFactory *diskfakes.FakeManagerFactory logger boshlog.Logger ) @@ -36,11 +37,19 @@ var _ = Describe("DiskDeployer", func() { cloud = &cloudfakes.FakeCloud{} fakeVM = fakebivm.NewFakeVM("fake-vm-cid") - fakeDiskManagerFactory = fakebidisk.NewFakeManagerFactory() - fakeDiskManager = fakebidisk.NewFakeManager() - fakeDisk = fakebidisk.NewFakeDisk("fake-new-disk-cid") - fakeDiskManager.CreateDisk = fakeDisk - fakeDiskManagerFactory.NewManagerManager = fakeDiskManager + fakeDiskManagerFactory = &diskfakes.FakeManagerFactory{ + NewManagerStub: func(cloud bicloud.Cloud) bidisk.Manager { + return fakeDiskManager + }, + } + fakeDiskManager = &diskfakes.FakeManager{ + CreateStub: func(pool bideplmanifest.DiskPool, s string) (bidisk.Disk, error) { + return fakeDisk, nil + }, + } + fakeDisk = &diskfakes.FakeDisk{ + CIDStub: func() string { return "fake-new-disk-cid" }, + } logger = boshlog.NewLogger(boshlog.LevelNone) fakeStage = fakebiui.NewFakeStage() @@ -52,7 +61,7 @@ var _ = Describe("DiskDeployer", func() { false, ) - fakeDiskManager.SetFindCurrentBehavior([]bidisk.Disk{}, nil) + fakeDiskManager.FindCurrentReturns([]bidisk.Disk{}, nil) fakeVM.SetAttachDiskBehavior(fakeDisk, nil) newDiskRecord := biconfig.DiskRecord{ ID: "fake-new-disk-id", @@ -72,11 +81,13 @@ var _ = Describe("DiskDeployer", func() { }) Context("when primary disk already exists", func() { - var existingDisk *fakebidisk.FakeDisk + var existingDisk *diskfakes.FakeDisk BeforeEach(func() { - existingDisk = fakebidisk.NewFakeDisk("fake-existing-disk-cid") - fakeDiskManager.SetFindCurrentBehavior([]bidisk.Disk{existingDisk}, nil) + existingDisk = &diskfakes.FakeDisk{CIDStub: func() string { + return "fake-existing-disk-cid" + }} + fakeDiskManager.FindCurrentReturns([]bidisk.Disk{existingDisk}, nil) fakeVM.SetAttachDiskBehavior(existingDisk, nil) existingDiskRecord := biconfig.DiskRecord{ ID: "fake-existing-disk-id", @@ -88,13 +99,13 @@ var _ = Describe("DiskDeployer", func() { disks, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeDiskManager.CreateInputs).To(BeEmpty()) + Expect(fakeDiskManager.CreateCallCount()).To(Equal(0)) Expect(disks).To(Equal([]bidisk.Disk{existingDisk})) }) Context("when disk does not need migration", func() { BeforeEach(func() { - existingDisk.SetNeedsMigrationBehavior(false) + existingDisk.NeedsMigrationReturns(false, nil) }) It("does not log the create disk event", func() { @@ -109,7 +120,7 @@ var _ = Describe("DiskDeployer", func() { }) Context("when disk is forced to be recreated", func() { - var secondaryDisk *fakebidisk.FakeDisk + var secondaryDisk *diskfakes.FakeDisk BeforeEach(func() { diskDeployer = NewDiskDeployer( @@ -118,10 +129,12 @@ var _ = Describe("DiskDeployer", func() { logger, true, ) - existingDisk.SetNeedsMigrationBehavior(false) + existingDisk.NeedsMigrationReturns(false, nil) - secondaryDisk = fakebidisk.NewFakeDisk("fake-secondary-disk-cid") - fakeDiskManager.CreateDisk = secondaryDisk + secondaryDisk = &diskfakes.FakeDisk{CIDStub: func() string { + return "fake-secondary-disk-cid" + }} + fakeDiskManager.CreateReturns(secondaryDisk, nil) secondaryDiskRecord := biconfig.DiskRecord{ ID: "fake-secondary-disk-id", } @@ -134,12 +147,9 @@ var _ = Describe("DiskDeployer", func() { Expect(err).ToNot(HaveOccurred()) Expect(disks).To(Equal([]bidisk.Disk{secondaryDisk})) - Expect(fakeDiskManager.CreateInputs).To(Equal([]fakebidisk.CreateInput{ - { - DiskPool: diskPool, - InstanceID: "fake-vm-cid", - }, - })) + pool, diskCid := fakeDiskManager.CreateArgsForCall(0) + Expect(pool).To(Equal(diskPool)) + Expect(diskCid).To(Equal("fake-vm-cid")) Expect(fakeStage.PerformCalls[1]).To(Equal(&fakebiui.PerformCall{ Name: "Creating disk", @@ -191,7 +201,7 @@ var _ = Describe("DiskDeployer", func() { Context("when disk creation fails", func() { BeforeEach(func() { - fakeDiskManager.CreateErr = bosherr.Error("fake-create-disk-error") + fakeDiskManager.CreateReturns(nil, bosherr.Error("fake-create-disk-error")) }) It("returns error and leaves the existing disk attached", func() { @@ -284,13 +294,15 @@ var _ = Describe("DiskDeployer", func() { }) Context("when disk needs migration", func() { - var secondaryDisk *fakebidisk.FakeDisk + var secondaryDisk *diskfakes.FakeDisk BeforeEach(func() { - existingDisk.SetNeedsMigrationBehavior(true) + existingDisk.NeedsMigrationReturns(true, nil) - secondaryDisk = fakebidisk.NewFakeDisk("fake-secondary-disk-cid") - fakeDiskManager.CreateDisk = secondaryDisk + secondaryDisk = &diskfakes.FakeDisk{CIDStub: func() string { + return "fake-secondary-disk-cid" + }} + fakeDiskManager.CreateReturns(secondaryDisk, nil) secondaryDiskRecord := biconfig.DiskRecord{ ID: "fake-secondary-disk-id", } @@ -303,12 +315,9 @@ var _ = Describe("DiskDeployer", func() { Expect(err).ToNot(HaveOccurred()) Expect(disks).To(Equal([]bidisk.Disk{secondaryDisk})) - Expect(fakeDiskManager.CreateInputs).To(Equal([]fakebidisk.CreateInput{ - { - DiskPool: diskPool, - InstanceID: "fake-vm-cid", - }, - })) + pool, diskCid := fakeDiskManager.CreateArgsForCall(0) + Expect(pool).To(Equal(diskPool)) + Expect(diskCid).To(Equal("fake-vm-cid")) Expect(fakeStage.PerformCalls[1]).To(Equal(&fakebiui.PerformCall{ Name: "Creating disk", @@ -360,7 +369,7 @@ var _ = Describe("DiskDeployer", func() { Context("when disk creation fails", func() { BeforeEach(func() { - fakeDiskManager.CreateErr = bosherr.Error("fake-create-disk-error") + fakeDiskManager.CreateReturns(nil, bosherr.Error("fake-create-disk-error")) }) It("returns error and leaves the existing disk attached", func() { @@ -459,12 +468,9 @@ var _ = Describe("DiskDeployer", func() { Expect(err).NotTo(HaveOccurred()) Expect(disks).To(Equal([]bidisk.Disk{fakeDisk})) - Expect(fakeDiskManager.CreateInputs).To(Equal([]fakebidisk.CreateInput{ - { - DiskPool: diskPool, - InstanceID: "fake-vm-cid", - }, - })) + pool, diskCid := fakeDiskManager.CreateArgsForCall(0) + Expect(pool).To(Equal(diskPool)) + Expect(diskCid).To(Equal("fake-vm-cid")) }) It("sets the new disk as current", func() { @@ -508,12 +514,12 @@ var _ = Describe("DiskDeployer", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeDiskManager.DeleteUnusedCalledTimes).To(Equal(1)) + Expect(fakeDiskManager.DeleteUnusedCallCount()).To(Equal(1)) }) Context("when removing unused disk fails", func() { BeforeEach(func() { - fakeDiskManager.DeleteUnusedErr = bosherr.Error("fake-delete-error") + fakeDiskManager.DeleteUnusedReturns(bosherr.Error("fake-delete-error")) }) It("returns an error", func() { @@ -529,7 +535,7 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeDiskManager.CreateErr = createDiskError + fakeDiskManager.CreateReturns(nil, createDiskError) }) It("return an error", func() { @@ -591,7 +597,7 @@ var _ = Describe("DiskDeployer", func() { Expect(err).NotTo(HaveOccurred()) Expect(disks).To(Equal([]bidisk.Disk{})) - Expect(fakeDiskManager.CreateInputs).To(BeEmpty()) + Expect(fakeDiskManager.CreateCallCount()).To(Equal(0)) }) }) }) diff --git a/deployment/vm/vm_test.go b/deployment/vm/vm_test.go index 37b03428c8..0249f5b43a 100644 --- a/deployment/vm/vm_test.go +++ b/deployment/vm/vm_test.go @@ -18,7 +18,7 @@ import ( biconfig "github.com/cloudfoundry/bosh-cli/v7/config" "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - fakebidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" @@ -106,7 +106,7 @@ var _ = Describe("VM", func() { var expectedDisks []bidisk.Disk BeforeEach(func() { - fakeDisk := fakebidisk.NewFakeDisk("fake-disk-cid") + fakeDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-cid" }} expectedDisks = []bidisk.Disk{fakeDisk} fakeDiskDeployer.SetDeployBehavior(expectedDisks, nil) }) @@ -268,12 +268,12 @@ var _ = Describe("VM", func() { }) Describe("AttachDisk", func() { - var disk *fakebidisk.FakeDisk + var disk *diskfakes.FakeDisk BeforeEach(func() { fakeTime := time.Date(2016, time.November, 10, 23, 0, 0, 0, time.UTC) timeService = &FakeClock{Times: []time.Time{fakeTime, time.Now(), time.Now().Add(10 * time.Minute)}} - disk = fakebidisk.NewFakeDisk("fake-disk-cid") + disk = &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-cid" }} metadata := bicloud.VMMetadata{ "director": "bosh-init", @@ -456,10 +456,10 @@ var _ = Describe("VM", func() { }) Describe("DetachDisk", func() { - var disk *fakebidisk.FakeDisk + var disk *diskfakes.FakeDisk BeforeEach(func() { - disk = fakebidisk.NewFakeDisk("fake-disk-cid") + disk = &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-cid" }} }) It("removes the disk from the vm", func() { @@ -526,10 +526,10 @@ var _ = Describe("VM", func() { }) Describe("UnmountDisk", func() { - var disk *fakebidisk.FakeDisk + var disk *diskfakes.FakeDisk BeforeEach(func() { - disk = fakebidisk.NewFakeDisk("fake-disk-cid") + disk = &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-cid" }} }) It("sends unmount disk to the agent", func() { From 70c80cea9ee09f82b793db9376361892a198a050 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 11:05:06 -0700 Subject: [PATCH 08/13] Replace hand-crafted `deployment/sshtunnel/fakes/` with counterfeiter --- deployment/deployer_test.go | 18 +-- deployment/instance/instance_test.go | 18 +-- deployment/instance/manager_test.go | 18 +-- deployment/sshtunnel/fakes/fake_ssh_tunnel.go | 31 ----- .../fakes/fake_ssh_tunnel_factory.go | 20 ---- deployment/sshtunnel/ssh_tunnel.go | 4 + deployment/sshtunnel/ssh_tunnel_factory.go | 2 + .../sshtunnel/sshtunnelfakes/fake_factory.go | 109 ++++++++++++++++++ .../sshtunnelfakes/fake_sshtunnel.go | 76 ++++++++++++ 9 files changed, 224 insertions(+), 72 deletions(-) delete mode 100644 deployment/sshtunnel/fakes/fake_ssh_tunnel.go delete mode 100644 deployment/sshtunnel/fakes/fake_ssh_tunnel_factory.go create mode 100644 deployment/sshtunnel/sshtunnelfakes/fake_factory.go create mode 100644 deployment/sshtunnel/sshtunnelfakes/fake_sshtunnel.go diff --git a/deployment/deployer_test.go b/deployment/deployer_test.go index 8d2b6b21ac..d5ae9d359c 100644 --- a/deployment/deployer_test.go +++ b/deployment/deployer_test.go @@ -21,7 +21,7 @@ import ( biinstance "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" @@ -35,8 +35,8 @@ var _ = Describe("Deployer", func() { fakeVMManager *fakebivm.FakeManager mockAgentClient *agentclientfakes.FakeAgentClient mockAgentClientFactory *cmdfakes.FakeAgentClientFactory - fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory - fakeSSHTunnel *fakebisshtunnel.FakeTunnel + fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory + fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel cloud *cloudfakes.FakeCloud deploymentManifest bideplmanifest.Manifest diskPool bideplmanifest.DiskPool @@ -95,10 +95,14 @@ var _ = Describe("Deployer", func() { fakeVMManager = fakebivm.NewFakeManager() mockVMManagerFactory.NewManagerReturns(fakeVMManager) - fakeSSHTunnelFactory = fakebisshtunnel.NewFakeFactory() - fakeSSHTunnel = fakebisshtunnel.NewFakeTunnel() - fakeSSHTunnelFactory.SSHTunnel = fakeSSHTunnel - fakeSSHTunnel.SetStartBehavior(nil, nil) + fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ + StartStub: func(readyErrCh chan<- error, errCh chan<- error) { + readyErrCh <- nil + errCh <- nil + }, + } + fakeSSHTunnelFactory = &sshtunnelfakes.FakeFactory{} + fakeSSHTunnelFactory.NewSSHTunnelReturns(fakeSSHTunnel) fakeVM = fakebivm.NewFakeVM("fake-vm-cid") fakeVMManager.CreateVM = fakeVM diff --git a/deployment/instance/instance_test.go b/deployment/instance/instance_test.go index 6dbf89a6cd..6610de7e22 100644 --- a/deployment/instance/instance_test.go +++ b/deployment/instance/instance_test.go @@ -16,7 +16,7 @@ import ( . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -29,8 +29,8 @@ var _ = Describe("Instance", func() { fakeVMManager *fakebivm.FakeManager fakeVM *fakebivm.FakeVM - fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory - fakeSSHTunnel *fakebisshtunnel.FakeTunnel + fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory + fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel fakeStage *fakebiui.FakeStage logger *loggerfakes.FakeLogger @@ -49,10 +49,14 @@ var _ = Describe("Instance", func() { fakeVMManager = fakebivm.NewFakeManager() fakeVM = fakebivm.NewFakeVM("fake-vm-cid") - fakeSSHTunnelFactory = fakebisshtunnel.NewFakeFactory() - fakeSSHTunnel = fakebisshtunnel.NewFakeTunnel() - fakeSSHTunnel.SetStartBehavior(nil, nil) - fakeSSHTunnelFactory.SSHTunnel = fakeSSHTunnel + fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ + StartStub: func(readyErrCh chan<- error, errCh chan<- error) { + readyErrCh <- nil + errCh <- nil + }, + } + fakeSSHTunnelFactory = &sshtunnelfakes.FakeFactory{} + fakeSSHTunnelFactory.NewSSHTunnelReturns(fakeSSHTunnel) mockStateBuilder = &statefakes.FakeBuilder{} mockState = &statefakes.FakeState{} diff --git a/deployment/instance/manager_test.go b/deployment/instance/manager_test.go index c2186f663b..9a90f1f5c4 100644 --- a/deployment/instance/manager_test.go +++ b/deployment/instance/manager_test.go @@ -19,7 +19,7 @@ import ( . "github.com/cloudfoundry/bosh-cli/v7/deployment/instance" "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - fakebisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" @@ -40,8 +40,8 @@ var _ = Describe("Manager", func() { mockBlobstore *blobstorefakes.FakeBlobstore fakeVMManager *fakebivm.FakeManager - fakeSSHTunnelFactory *fakebisshtunnel.FakeFactory - fakeSSHTunnel *fakebisshtunnel.FakeTunnel + fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory + fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel instanceFactory Factory logger boshlog.Logger fakeStage *fakebiui.FakeStage @@ -53,10 +53,14 @@ var _ = Describe("Manager", func() { fakeCloud = &cloudfakes.FakeCloud{} fakeVMManager = fakebivm.NewFakeManager() - fakeSSHTunnelFactory = fakebisshtunnel.NewFakeFactory() - fakeSSHTunnel = fakebisshtunnel.NewFakeTunnel() - fakeSSHTunnel.SetStartBehavior(nil, nil) - fakeSSHTunnelFactory.SSHTunnel = fakeSSHTunnel + fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ + StartStub: func(readyErrCh chan<- error, errCh chan<- error) { + readyErrCh <- nil + errCh <- nil + }, + } + fakeSSHTunnelFactory = &sshtunnelfakes.FakeFactory{} + fakeSSHTunnelFactory.NewSSHTunnelReturns(fakeSSHTunnel) mockStateBuilderFactory = &statefakes.FakeBuilderFactory{} mockStateBuilder = &statefakes.FakeBuilder{} diff --git a/deployment/sshtunnel/fakes/fake_ssh_tunnel.go b/deployment/sshtunnel/fakes/fake_ssh_tunnel.go deleted file mode 100644 index ff974e4e7f..0000000000 --- a/deployment/sshtunnel/fakes/fake_ssh_tunnel.go +++ /dev/null @@ -1,31 +0,0 @@ -package fakes - -type FakeTunnel struct { - startOutput *startOutput - Started bool -} - -type startOutput struct { - ReadyErrChOutput error - ErrChOutput error -} - -func NewFakeTunnel() *FakeTunnel { - return &FakeTunnel{} -} - -func (s *FakeTunnel) Start(readyErrCh chan<- error, errCh chan<- error) { - s.Started = true - - if s.startOutput != nil { - readyErrCh <- s.startOutput.ReadyErrChOutput - errCh <- s.startOutput.ErrChOutput - } -} - -func (s *FakeTunnel) SetStartBehavior(readyErrChOutput error, errChOutput error) { - s.startOutput = &startOutput{ - ReadyErrChOutput: readyErrChOutput, - ErrChOutput: errChOutput, - } -} diff --git a/deployment/sshtunnel/fakes/fake_ssh_tunnel_factory.go b/deployment/sshtunnel/fakes/fake_ssh_tunnel_factory.go deleted file mode 100644 index 4806ee8670..0000000000 --- a/deployment/sshtunnel/fakes/fake_ssh_tunnel_factory.go +++ /dev/null @@ -1,20 +0,0 @@ -package fakes - -import ( - bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" -) - -type FakeFactory struct { - SSHTunnel bisshtunnel.SSHTunnel - NewSSHTunnelOptions bisshtunnel.Options -} - -func NewFakeFactory() *FakeFactory { - return &FakeFactory{} -} - -func (f *FakeFactory) NewSSHTunnel(options bisshtunnel.Options) bisshtunnel.SSHTunnel { - f.NewSSHTunnelOptions = options - - return f.SSHTunnel -} diff --git a/deployment/sshtunnel/ssh_tunnel.go b/deployment/sshtunnel/ssh_tunnel.go index 654058afe7..156c47470a 100644 --- a/deployment/sshtunnel/ssh_tunnel.go +++ b/deployment/sshtunnel/ssh_tunnel.go @@ -11,6 +11,10 @@ import ( boshssh "github.com/cloudfoundry/bosh-cli/v7/ssh" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . SSHTunnel + type SSHTunnel interface { Start(chan<- error, chan<- error) } diff --git a/deployment/sshtunnel/ssh_tunnel_factory.go b/deployment/sshtunnel/ssh_tunnel_factory.go index 89d101ac95..50efab003a 100644 --- a/deployment/sshtunnel/ssh_tunnel_factory.go +++ b/deployment/sshtunnel/ssh_tunnel_factory.go @@ -22,6 +22,8 @@ func (o Options) IsEmpty() bool { return o == Options{} } +//counterfeiter:generate . Factory + type Factory interface { NewSSHTunnel(Options) SSHTunnel } diff --git a/deployment/sshtunnel/sshtunnelfakes/fake_factory.go b/deployment/sshtunnel/sshtunnelfakes/fake_factory.go new file mode 100644 index 0000000000..a52e816602 --- /dev/null +++ b/deployment/sshtunnel/sshtunnelfakes/fake_factory.go @@ -0,0 +1,109 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package sshtunnelfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" +) + +type FakeFactory struct { + NewSSHTunnelStub func(sshtunnel.Options) sshtunnel.SSHTunnel + newSSHTunnelMutex sync.RWMutex + newSSHTunnelArgsForCall []struct { + arg1 sshtunnel.Options + } + newSSHTunnelReturns struct { + result1 sshtunnel.SSHTunnel + } + newSSHTunnelReturnsOnCall map[int]struct { + result1 sshtunnel.SSHTunnel + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeFactory) NewSSHTunnel(arg1 sshtunnel.Options) sshtunnel.SSHTunnel { + fake.newSSHTunnelMutex.Lock() + ret, specificReturn := fake.newSSHTunnelReturnsOnCall[len(fake.newSSHTunnelArgsForCall)] + fake.newSSHTunnelArgsForCall = append(fake.newSSHTunnelArgsForCall, struct { + arg1 sshtunnel.Options + }{arg1}) + stub := fake.NewSSHTunnelStub + fakeReturns := fake.newSSHTunnelReturns + fake.recordInvocation("NewSSHTunnel", []interface{}{arg1}) + fake.newSSHTunnelMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeFactory) NewSSHTunnelCallCount() int { + fake.newSSHTunnelMutex.RLock() + defer fake.newSSHTunnelMutex.RUnlock() + return len(fake.newSSHTunnelArgsForCall) +} + +func (fake *FakeFactory) NewSSHTunnelCalls(stub func(sshtunnel.Options) sshtunnel.SSHTunnel) { + fake.newSSHTunnelMutex.Lock() + defer fake.newSSHTunnelMutex.Unlock() + fake.NewSSHTunnelStub = stub +} + +func (fake *FakeFactory) NewSSHTunnelArgsForCall(i int) sshtunnel.Options { + fake.newSSHTunnelMutex.RLock() + defer fake.newSSHTunnelMutex.RUnlock() + argsForCall := fake.newSSHTunnelArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeFactory) NewSSHTunnelReturns(result1 sshtunnel.SSHTunnel) { + fake.newSSHTunnelMutex.Lock() + defer fake.newSSHTunnelMutex.Unlock() + fake.NewSSHTunnelStub = nil + fake.newSSHTunnelReturns = struct { + result1 sshtunnel.SSHTunnel + }{result1} +} + +func (fake *FakeFactory) NewSSHTunnelReturnsOnCall(i int, result1 sshtunnel.SSHTunnel) { + fake.newSSHTunnelMutex.Lock() + defer fake.newSSHTunnelMutex.Unlock() + fake.NewSSHTunnelStub = nil + if fake.newSSHTunnelReturnsOnCall == nil { + fake.newSSHTunnelReturnsOnCall = make(map[int]struct { + result1 sshtunnel.SSHTunnel + }) + } + fake.newSSHTunnelReturnsOnCall[i] = struct { + result1 sshtunnel.SSHTunnel + }{result1} +} + +func (fake *FakeFactory) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeFactory) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ sshtunnel.Factory = new(FakeFactory) diff --git a/deployment/sshtunnel/sshtunnelfakes/fake_sshtunnel.go b/deployment/sshtunnel/sshtunnelfakes/fake_sshtunnel.go new file mode 100644 index 0000000000..81bb2b800c --- /dev/null +++ b/deployment/sshtunnel/sshtunnelfakes/fake_sshtunnel.go @@ -0,0 +1,76 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package sshtunnelfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" +) + +type FakeSSHTunnel struct { + StartStub func(chan<- error, chan<- error) + startMutex sync.RWMutex + startArgsForCall []struct { + arg1 chan<- error + arg2 chan<- error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeSSHTunnel) Start(arg1 chan<- error, arg2 chan<- error) { + fake.startMutex.Lock() + fake.startArgsForCall = append(fake.startArgsForCall, struct { + arg1 chan<- error + arg2 chan<- error + }{arg1, arg2}) + stub := fake.StartStub + fake.recordInvocation("Start", []interface{}{arg1, arg2}) + fake.startMutex.Unlock() + if stub != nil { + fake.StartStub(arg1, arg2) + } +} + +func (fake *FakeSSHTunnel) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeSSHTunnel) StartCalls(stub func(chan<- error, chan<- error)) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + +func (fake *FakeSSHTunnel) StartArgsForCall(i int) (chan<- error, chan<- error) { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + argsForCall := fake.startArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeSSHTunnel) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeSSHTunnel) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ sshtunnel.SSHTunnel = new(FakeSSHTunnel) From caf447c797f43c17daf2b6aefad2b91c27b3df4a Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 14:30:19 -0700 Subject: [PATCH 09/13] Replace hand-crafted `deployment/vm/fakes/` with counterfeiter --- cmd/create_env_test.go | 5 +- deployment/deployer_test.go | 70 +- deployment/instance/instance_test.go | 166 +-- deployment/instance/manager_test.go | 49 +- deployment/vm/disk_deployer.go | 2 + deployment/vm/disk_deployer_test.go | 84 +- deployment/vm/fakes/fake_disk_deployer.go | 55 - deployment/vm/fakes/fake_manager.go | 54 - deployment/vm/fakes/fake_manager_factory.go | 66 - deployment/vm/fakes/fake_vm.go | 233 ---- deployment/vm/manager.go | 2 + deployment/vm/manager_test.go | 6 +- deployment/vm/vm.go | 2 + deployment/vm/vm_test.go | 21 +- deployment/vm/vmfakes/fake_disk_deployer.go | 124 ++ deployment/vm/vmfakes/fake_manager.go | 198 +++ deployment/vm/vmfakes/fake_vm.go | 1277 +++++++++++++++++++ 17 files changed, 1808 insertions(+), 606 deletions(-) delete mode 100644 deployment/vm/fakes/fake_disk_deployer.go delete mode 100644 deployment/vm/fakes/fake_manager.go delete mode 100644 deployment/vm/fakes/fake_manager_factory.go delete mode 100644 deployment/vm/fakes/fake_vm.go create mode 100644 deployment/vm/vmfakes/fake_disk_deployer.go create mode 100644 deployment/vm/vmfakes/fake_manager.go create mode 100644 deployment/vm/vmfakes/fake_vm.go diff --git a/cmd/create_env_test.go b/cmd/create_env_test.go index 5a94fd5b67..3291f855e0 100644 --- a/cmd/create_env_test.go +++ b/cmd/create_env_test.go @@ -35,7 +35,6 @@ import ( bidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template" fakebidepltpl "github.com/cloudfoundry/bosh-cli/v7/deployment/template/templatefakes" bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" @@ -90,7 +89,7 @@ var _ = Describe("CreateEnvCmd", func() { mockBlobstore *blobstorefakes.FakeBlobstore mockVMManagerFactory *vmfakes.FakeManagerFactory - fakeVMManager *fakebivm.FakeManager + fakeVMManager *vmfakes.FakeManager fakeStemcellExtractor *fakebistemcell.FakeExtractor mockStemcellManager *mockfakes.FakeManager fakeStemcellManagerFactory *fakebistemcell.FakeManagerFactory @@ -166,7 +165,7 @@ var _ = Describe("CreateEnvCmd", func() { mockBlobstoreFactory.CreateReturns(mockBlobstore, nil) mockVMManagerFactory = &vmfakes.FakeManagerFactory{} - fakeVMManager = fakebivm.NewFakeManager() + fakeVMManager = &vmfakes.FakeManager{} mockVMManagerFactory.NewManagerReturns(fakeVMManager) fakeStemcellExtractor = fakebistemcell.NewFakeExtractor() diff --git a/deployment/deployer_test.go b/deployment/deployer_test.go index d5ae9d359c..1de8e1164e 100644 --- a/deployment/deployer_test.go +++ b/deployment/deployer_test.go @@ -22,7 +22,6 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" @@ -32,7 +31,7 @@ var _ = Describe("Deployer", func() { var ( deployer Deployer mockVMManagerFactory *vmfakes.FakeManagerFactory - fakeVMManager *fakebivm.FakeManager + fakeVMManager *vmfakes.FakeManager mockAgentClient *agentclientfakes.FakeAgentClient mockAgentClientFactory *cmdfakes.FakeAgentClientFactory fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory @@ -41,7 +40,7 @@ var _ = Describe("Deployer", func() { deploymentManifest bideplmanifest.Manifest diskPool bideplmanifest.DiskPool fakeStage *fakebiui.FakeStage - fakeVM *fakebivm.FakeVM + fakeVM *vmfakes.FakeVM skipDrain bool diskCIDs []string @@ -92,7 +91,7 @@ var _ = Describe("Deployer", func() { mockAgentClientFactory.NewAgentClientReturns(mockAgentClient, nil) mockVMManagerFactory = &vmfakes.FakeManagerFactory{} - fakeVMManager = fakebivm.NewFakeManager() + fakeVMManager = &vmfakes.FakeManager{} mockVMManagerFactory.NewManagerReturns(fakeVMManager) fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ @@ -104,10 +103,10 @@ var _ = Describe("Deployer", func() { fakeSSHTunnelFactory = &sshtunnelfakes.FakeFactory{} fakeSSHTunnelFactory.NewSSHTunnelReturns(fakeSSHTunnel) - fakeVM = fakebivm.NewFakeVM("fake-vm-cid") - fakeVMManager.CreateVM = fakeVM + fakeVM = &vmfakes.FakeVM{CIDStub: func() string { return "fake-vm-cid" }} + fakeVMManager.CreateReturns(fakeVM, nil) - fakeVM.AgentClientReturn = mockAgentClient + fakeVM.AgentClientReturns(mockAgentClient) logger := boshlog.NewLogger(boshlog.LevelNone) fakeStage = fakebiui.NewFakeStage() @@ -151,7 +150,7 @@ var _ = Describe("Deployer", func() { } fakeAgentState := agentclient.AgentState{} - fakeVM.GetStateResult = fakeAgentState + fakeVM.GetStateReturns(fakeAgentState, nil) mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) mockStateBuilder.BuildReturns(mockState, nil) @@ -160,19 +159,22 @@ var _ = Describe("Deployer", func() { }) Context("when a previous instance exists", func() { - var fakeExistingVM *fakebivm.FakeVM + var fakeExistingVM *vmfakes.FakeVM BeforeEach(func() { - fakeExistingVM = fakebivm.NewFakeVM("existing-vm-cid") - fakeVMManager.SetFindCurrentBehavior(fakeExistingVM, true, nil) - fakeExistingVM.AgentClientReturn = mockAgentClient + fakeExistingVM = &vmfakes.FakeVM{ + CIDStub: func() string { return "existing-vm-cid" }, + ExistsStub: func() (bool, error) { return true, nil }, + } + fakeVMManager.FindCurrentReturns(fakeExistingVM, true, nil) + fakeExistingVM.AgentClientReturns(mockAgentClient) }) It("deletes existing vm", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeExistingVM.DeleteCalled).To(Equal(1)) + Expect(fakeExistingVM.DeleteCallCount()).To(Equal(1)) Expect(fakeStage.PerformCalls[:6]).To(Equal([]*fakebiui.PerformCall{ {Name: "Waiting for the agent on VM 'existing-vm-cid'"}, @@ -190,7 +192,7 @@ var _ = Describe("Deployer", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeExistingVM.DeleteCalled).To(Equal(1)) + Expect(fakeExistingVM.DeleteCallCount()).To(Equal(1)) Expect(fakeStage.PerformCalls[:5]).To(Equal([]*fakebiui.PerformCall{ {Name: "Waiting for the agent on VM 'existing-vm-cid'"}, @@ -207,20 +209,19 @@ var _ = Describe("Deployer", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVMManager.CreateInput).To(Equal(fakebivm.CreateInput{ - Stemcell: cloudStemcell, - Manifest: deploymentManifest, - DiskCIDs: diskCIDs, - })) + stemcellArg, manifestArg, diskCIDsArg := fakeVMManager.CreateArgsForCall(0) + Expect(stemcellArg).To(Equal(cloudStemcell)) + Expect(manifestArg).To(Equal(deploymentManifest)) + Expect(diskCIDsArg).To(Equal(diskCIDs)) + }) It("waits for the vm", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(ContainElement(fakebivm.WaitUntilReadyInput{ - Timeout: 10 * time.Minute, - Delay: 500 * time.Millisecond, - })) + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(10 * time.Minute)) + Expect(delay).To(Equal(500 * time.Millisecond)) }) It("logs start and stop events to the eventLogger", func() { @@ -238,7 +239,7 @@ var _ = Describe("Deployer", func() { ) BeforeEach(func() { - fakeVM.WaitUntilReadyErr = waitError + fakeVM.WaitUntilReadyReturns(waitError) }) It("logs start and stop events to the eventLogger", func() { @@ -257,27 +258,24 @@ var _ = Describe("Deployer", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.ApplyInputs).To(Equal([]fakebivm.ApplyInput{ - {ApplySpec: applySpec}, - {ApplySpec: applySpec}, - })) + Expect(fakeVM.ApplyArgsForCall(0)).To(Equal(applySpec)) + Expect(fakeVM.ApplyArgsForCall(1)).To(Equal(applySpec)) }) It("starts the agent", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.StartCalled).To(Equal(1)) + Expect(fakeVM.StartCallCount()).To(Equal(1)) }) It("waits until agent reports state as running", func() { _, err := deployer.Deploy(cloud, deploymentManifest, cloudStemcell, fakeVMManager, mockBlobstore, skipDrain, diskCIDs, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitToBeRunningInputs).To(ContainElement(fakebivm.WaitInput{ - MaxAttempts: 5, - Delay: 1 * time.Second, - })) + attemptsArg, delayArg := fakeVM.WaitToBeRunningArgsForCall(0) + Expect(attemptsArg).To(Equal(5)) + Expect(delayArg).To(Equal(1 * time.Second)) }) Context("when the deployment has an invalid disk pool specification", func() { @@ -303,7 +301,7 @@ var _ = Describe("Deployer", func() { Context("when applying instance spec fails", func() { BeforeEach(func() { - fakeVM.ApplyErr = bosherr.Error("fake-apply-error") + fakeVM.ApplyReturns(bosherr.Error("fake-apply-error")) }) It("fails with descriptive error", func() { @@ -315,7 +313,7 @@ var _ = Describe("Deployer", func() { Context("when starting agent services fails", func() { BeforeEach(func() { - fakeVM.StartErr = bosherr.Error("fake-start-error") + fakeVM.StartReturns(bosherr.Error("fake-start-error")) }) It("logs start and stop events to the eventLogger", func() { @@ -335,7 +333,7 @@ var _ = Describe("Deployer", func() { ) BeforeEach(func() { - fakeVM.WaitToBeRunningErr = waitError + fakeVM.WaitToBeRunningReturns(waitError) }) It("logs start and stop events to the eventLogger", func() { diff --git a/deployment/instance/instance_test.go b/deployment/instance/instance_test.go index 6610de7e22..a46984dc2a 100644 --- a/deployment/instance/instance_test.go +++ b/deployment/instance/instance_test.go @@ -5,11 +5,6 @@ import ( "github.com/cloudfoundry/bosh-agent/v2/agentclient" bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - bosherr "github.com/cloudfoundry/bosh-utils/errors" - "github.com/cloudfoundry/bosh-utils/logger/loggerfakes" - . "github.com/onsi/ginkgo/v2" - . "github.com/onsi/gomega" - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" @@ -17,8 +12,12 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" + bosherr "github.com/cloudfoundry/bosh-utils/errors" + "github.com/cloudfoundry/bosh-utils/logger/loggerfakes" + . "github.com/onsi/ginkgo/v2" + . "github.com/onsi/gomega" ) var _ = Describe("Instance", func() { @@ -27,8 +26,8 @@ var _ = Describe("Instance", func() { mockStateBuilder *statefakes.FakeBuilder mockState *statefakes.FakeState - fakeVMManager *fakebivm.FakeManager - fakeVM *fakebivm.FakeVM + fakeVMManager *vmfakes.FakeManager + fakeVM *vmfakes.FakeVM fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel fakeStage *fakebiui.FakeStage @@ -46,8 +45,11 @@ var _ = Describe("Instance", func() { ) BeforeEach(func() { - fakeVMManager = fakebivm.NewFakeManager() - fakeVM = fakebivm.NewFakeVM("fake-vm-cid") + fakeVMManager = &vmfakes.FakeManager{} + fakeVM = &vmfakes.FakeVM{ + CIDStub: func() string { return "fake-vm-cid" }, + ExistsStub: func() (bool, error) { return true, nil }, + } fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ StartStub: func(readyErrCh chan<- error, errCh chan<- error) { @@ -83,17 +85,16 @@ var _ = Describe("Instance", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(ContainElement(fakebivm.WaitUntilReadyInput{ - Timeout: pingTimeout, - Delay: pingDelay, - })) + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(pingTimeout)) + Expect(delay).To(Equal(pingDelay)) }) It("deletes existing vm", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.DeleteCalled).To(Equal(1)) + Expect(fakeVM.DeleteCallCount()).To(Equal(1)) }) It("logs start and stop events", func() { @@ -124,7 +125,7 @@ var _ = Describe("Instance", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.DrainCalled).To(Equal(1)) + Expect(fakeVM.DrainCallCount()).To(Equal(1)) }) It("can skip draining", func() { @@ -132,28 +133,26 @@ var _ = Describe("Instance", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.DrainCalled).To(Equal(0)) + Expect(fakeVM.DrainCallCount()).To(Equal(0)) }) It("stops vm", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.StopCalled).To(Equal(1)) + Expect(fakeVM.StopCallCount()).To(Equal(1)) }) It("unmounts vm disks", func() { firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }} secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }} - fakeVM.ListDisksDisks = []bidisk.Disk{firstDisk, secondDisk} + fakeVM.DisksReturns([]bidisk.Disk{firstDisk, secondDisk}, nil) err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.UnmountDiskInputs).To(Equal([]fakebivm.UnmountDiskInput{ - {Disk: firstDisk}, - {Disk: secondDisk}, - })) + Expect(fakeVM.UnmountDiskArgsForCall(0)).To(Equal(firstDisk)) + Expect(fakeVM.UnmountDiskArgsForCall(1)).To(Equal(secondDisk)) Expect(fakeStage.PerformCalls[5:7]).To(Equal([]*fakebiui.PerformCall{ {Name: "Unmounting disk 'fake-disk-1'"}, @@ -167,7 +166,7 @@ var _ = Describe("Instance", func() { ) BeforeEach(func() { - fakeVM.StopErr = stopError + fakeVM.StopReturns(stopError) }) It("returns an error", func() { @@ -189,8 +188,8 @@ var _ = Describe("Instance", func() { Context("when unmounting disk fails", func() { BeforeEach(func() { - fakeVM.ListDisksDisks = []bidisk.Disk{&diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk" }}} - fakeVM.UnmountDiskErr = bosherr.Error("fake-unmount-error") + fakeVM.DisksReturns([]bidisk.Disk{&diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk" }}}, nil) + fakeVM.UnmountDiskReturns(bosherr.Error("fake-unmount-error")) }) It("returns an error", func() { @@ -207,7 +206,7 @@ var _ = Describe("Instance", func() { Context("when agent fails to respond", func() { BeforeEach(func() { - fakeVM.WaitUntilReadyErr = bosherr.Error("fake-wait-error") + fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error")) }) It("logs failed event", func() { @@ -225,7 +224,7 @@ var _ = Describe("Instance", func() { deleteError = bosherr.Error("fake-delete-error") ) BeforeEach(func() { - fakeVM.DeleteErr = deleteError + fakeVM.DeleteReturns(deleteError) }) It("returns an error", func() { @@ -249,27 +248,27 @@ var _ = Describe("Instance", func() { Context("when VM does not exist (deleted manually)", func() { BeforeEach(func() { - fakeVM.ExistsFound = false - fakeVM.DeleteErr = bicloud.NewCPIError("delete_vm", bicloud.CmdError{ + fakeVM.ExistsReturns(false, nil) + fakeVM.DeleteReturns(bicloud.NewCPIError("delete_vm", bicloud.CmdError{ Type: bicloud.VMNotFoundError, Message: "fake-vm-not-found-message", - }) + })) }) It("deletes existing vm", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.DeleteCalled).To(Equal(1)) + Expect(fakeVM.DeleteCallCount()).To(Equal(1)) }) It("does not contact the agent", func() { err := instance.Delete(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(HaveLen(0)) - Expect(fakeVM.StopCalled).To(Equal(0)) - Expect(fakeVM.UnmountDiskInputs).To(HaveLen(0)) + Expect(fakeVM.WaitUntilReadyCallCount()).To(Equal(0)) + Expect(fakeVM.StopCallCount()).To(Equal(0)) + Expect(fakeVM.UnmountDiskCallCount()).To(Equal(0)) }) It("logs vm delete as skipped", func() { @@ -309,7 +308,7 @@ var _ = Describe("Instance", func() { JustBeforeEach(func() { fakeAgentState := agentclient.AgentState{JobState: "testing"} - fakeVM.GetStateResult = fakeAgentState + fakeVM.GetStateReturns(fakeAgentState, nil) mockStateBuilder.BuildReturns(mockState, nil) mockStateBuilder.BuildInitialStateReturns(mockState, nil) @@ -339,23 +338,24 @@ var _ = Describe("Instance", func() { err := instance.UpdateJobs(deploymentManifest, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.StopCalled).To(Equal(1)) - Expect(fakeVM.ApplyInputs).To(Equal([]fakebivm.ApplyInput{ - {ApplySpec: applySpec}, - {ApplySpec: applySpec}, - })) - Expect(fakeVM.RunScriptInputs).To(Equal([]string{"pre-start", "post-start"})) - Expect(fakeVM.StartCalled).To(Equal(1)) + Expect(fakeVM.StopCallCount()).To(Equal(1)) + + Expect(fakeVM.ApplyArgsForCall(0)).To(Equal(applySpec)) + Expect(fakeVM.ApplyArgsForCall(1)).To(Equal(applySpec)) + script1, _ := fakeVM.RunScriptArgsForCall(0) + Expect(script1).To(Equal("pre-start")) + script2, _ := fakeVM.RunScriptArgsForCall(1) + Expect(script2).To(Equal("post-start")) + Expect(fakeVM.StartCallCount()).To(Equal(1)) }) It("waits until agent reports state as running", func() { err := instance.UpdateJobs(deploymentManifest, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitToBeRunningInputs).To(ContainElement(fakebivm.WaitInput{ - MaxAttempts: 5, - Delay: 1 * time.Second, - })) + maxAttempts, delay := fakeVM.WaitToBeRunningArgsForCall(0) + Expect(maxAttempts).To(Equal(5)) + Expect(delay).To(Equal(1 * time.Second)) }) It("logs start and stop events to the eventLogger", func() { @@ -383,7 +383,7 @@ var _ = Describe("Instance", func() { Context("when stopping vm fails", func() { BeforeEach(func() { - fakeVM.StopErr = bosherr.Error("fake-stop-error") + fakeVM.StopReturns(bosherr.Error("fake-stop-error")) }) It("logs start and stop events to the eventLogger", func() { @@ -399,7 +399,7 @@ var _ = Describe("Instance", func() { Context("when applying a new vm state fails", func() { BeforeEach(func() { - fakeVM.ApplyErr = bosherr.Error("fake-apply-error") + fakeVM.ApplyReturns(bosherr.Error("fake-apply-error")) }) It("fails with descriptive error", func() { @@ -411,7 +411,14 @@ var _ = Describe("Instance", func() { Context("when running the pre-start script fails", func() { BeforeEach(func() { - fakeVM.RunScriptErrors["pre-start"] = bosherr.Error("fake-run-script-error") + fakeVM.RunScriptStub = func(script string, _ map[string]interface{}) error { + switch script { + case "pre-start": + return bosherr.Error("fake-run-script-error") + default: + return nil + } + } }) It("returns the error", func() { @@ -423,7 +430,14 @@ var _ = Describe("Instance", func() { Context("when running the post-start script fails", func() { BeforeEach(func() { - fakeVM.RunScriptErrors["post-start"] = bosherr.Error("fake-run-script-error-poststart") + fakeVM.RunScriptStub = func(script string, _ map[string]interface{}) error { + switch script { + case "post-start": + return bosherr.Error("fake-run-script-error-poststart") + default: + return nil + } + } }) It("returns the error", func() { @@ -435,7 +449,7 @@ var _ = Describe("Instance", func() { Context("when starting vm fails", func() { BeforeEach(func() { - fakeVM.StartErr = bosherr.Error("fake-start-error") + fakeVM.StartReturns(bosherr.Error("fake-start-error")) }) It("logs start and stop events to the eventLogger", func() { @@ -455,7 +469,7 @@ var _ = Describe("Instance", func() { ) BeforeEach(func() { - fakeVM.WaitToBeRunningErr = waitError + fakeVM.WaitToBeRunningReturns(waitError) }) It("logs instance update stages", func() { @@ -478,10 +492,10 @@ var _ = Describe("Instance", func() { It("waits for the vm", func() { err := instance.WaitUntilReady(fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(ContainElement(fakebivm.WaitUntilReadyInput{ - Timeout: 10 * time.Minute, - Delay: 500 * time.Millisecond, - })) + + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(10 * time.Minute)) + Expect(delay).To(Equal(500 * time.Millisecond)) }) It("logs start and stop events to the eventLogger", func() { @@ -498,7 +512,7 @@ var _ = Describe("Instance", func() { waitError = bosherr.Error("fake-wait-error") ) BeforeEach(func() { - fakeVM.WaitUntilReadyErr = waitError + fakeVM.WaitUntilReadyReturns(waitError) }) It("logs start and stop events to the eventLogger", func() { @@ -514,7 +528,6 @@ var _ = Describe("Instance", func() { })) }) }) - }) Describe("Stop", func() { @@ -522,10 +535,9 @@ var _ = Describe("Instance", func() { err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(ContainElement(fakebivm.WaitUntilReadyInput{ - Timeout: pingTimeout, - Delay: pingDelay, - })) + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(pingTimeout)) + Expect(delay).To(Equal(pingDelay)) }) It("logs start and stop events", func() { @@ -555,7 +567,7 @@ var _ = Describe("Instance", func() { err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.DrainCalled).To(Equal(1)) + Expect(fakeVM.DrainCallCount()).To(Equal(1)) }) It("can skip draining", func() { @@ -563,31 +575,31 @@ var _ = Describe("Instance", func() { err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.DrainCalled).To(Equal(0)) + Expect(fakeVM.DrainCallCount()).To(Equal(0)) }) It("stops all jobs", func() { err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.StopCalled).To(Equal(1)) + Expect(fakeVM.StopCallCount()).To(Equal(1)) }) It("does not unmount vm disks", func() { firstDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-1" }} secondDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-2" }} - fakeVM.ListDisksDisks = []bidisk.Disk{firstDisk, secondDisk} + fakeVM.DisksReturns([]bidisk.Disk{firstDisk, secondDisk}, nil) err := instance.Stop(pingTimeout, pingDelay, skipDrain, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.UnmountDiskInputs).To(Equal([]fakebivm.UnmountDiskInput{})) + Expect(fakeVM.UnmountDiskCallCount()).To(Equal(0)) }) }) Context("when agent fails to respond", func() { BeforeEach(func() { - fakeVM.WaitUntilReadyErr = bosherr.Error("fake-wait-error") + fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error")) }) It("logs failed event", func() { @@ -620,10 +632,9 @@ var _ = Describe("Instance", func() { err := instance.Start(update, pingTimeout, pingDelay, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(ContainElement(fakebivm.WaitUntilReadyInput{ - Timeout: pingTimeout, - Delay: pingDelay, - })) + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(pingTimeout)) + Expect(delay).To(Equal(pingDelay)) }) It("logs start and stop events", func() { @@ -653,16 +664,15 @@ var _ = Describe("Instance", func() { err := instance.Start(update, pingTimeout, pingDelay, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitToBeRunningInputs).To(ContainElement(fakebivm.WaitInput{ - MaxAttempts: 5, - Delay: 1 * time.Second, - })) + maxAttempts, delay := fakeVM.WaitToBeRunningArgsForCall(0) + Expect(maxAttempts).To(Equal(5)) + Expect(delay).To(Equal(1 * time.Second)) }) }) Context("when agent fails to respond", func() { BeforeEach(func() { - fakeVM.WaitUntilReadyErr = bosherr.Error("fake-wait-error") + fakeVM.WaitUntilReadyReturns(bosherr.Error("fake-wait-error")) }) It("logs failed event", func() { diff --git a/deployment/instance/manager_test.go b/deployment/instance/manager_test.go index 9a90f1f5c4..504afe4f8b 100644 --- a/deployment/instance/manager_test.go +++ b/deployment/instance/manager_test.go @@ -20,7 +20,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/deployment/instance/state/statefakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel/sshtunnelfakes" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -39,7 +39,7 @@ var _ = Describe("Manager", func() { mockBlobstore *blobstorefakes.FakeBlobstore - fakeVMManager *fakebivm.FakeManager + fakeVMManager *vmfakes.FakeManager fakeSSHTunnelFactory *sshtunnelfakes.FakeFactory fakeSSHTunnel *sshtunnelfakes.FakeSSHTunnel instanceFactory Factory @@ -51,7 +51,7 @@ var _ = Describe("Manager", func() { BeforeEach(func() { fakeCloud = &cloudfakes.FakeCloud{} - fakeVMManager = fakebivm.NewFakeManager() + fakeVMManager = &vmfakes.FakeManager{} fakeSSHTunnel = &sshtunnelfakes.FakeSSHTunnel{ StartStub: func(readyErrCh chan<- error, errCh chan<- error) { @@ -87,7 +87,7 @@ var _ = Describe("Manager", func() { Describe("Create", func() { var ( mockAgentClient *agentclientfakes.FakeAgentClient - fakeVM *fakebivm.FakeVM + fakeVM *vmfakes.FakeVM diskPool bideplmanifest.DiskPool deploymentManifest bideplmanifest.Manifest fakeCloudStemcell *fakebistemcell.FakeCloudStemcell @@ -121,7 +121,7 @@ var _ = Describe("Manager", func() { } fakeAgentState := agentclient.AgentState{} - fakeVM.GetStateResult = fakeAgentState + fakeVM.GetStateReturns(fakeAgentState, nil) mockStateBuilderFactory.NewBuilderReturns(mockStateBuilder) mockStateBuilder.BuildReturns(mockState, nil) @@ -160,11 +160,11 @@ var _ = Describe("Manager", func() { diskCIDs = []string{"fake-disk-cid"} - fakeVM = fakebivm.NewFakeVM("fake-vm-cid") - fakeVMManager.CreateVM = fakeVM + fakeVM = &vmfakes.FakeVM{CIDStub: func() string { return "fake-vm-cid" }} + fakeVMManager.CreateReturns(fakeVM, nil) mockAgentClient = &agentclientfakes.FakeAgentClient{} - fakeVM.AgentClientReturn = mockAgentClient + fakeVM.AgentClientReturns(mockAgentClient) expectedInstance = NewInstance( "fake-job-name", @@ -177,7 +177,7 @@ var _ = Describe("Manager", func() { ) expectedDisk = &diskfakes.FakeDisk{} - fakeVM.UpdateDisksDisks = []bidisk.Disk{expectedDisk} + fakeVM.UpdateDisksReturns([]bidisk.Disk{expectedDisk}, nil) }) JustBeforeEach(func() { @@ -196,11 +196,11 @@ var _ = Describe("Manager", func() { Expect(err).NotTo(HaveOccurred()) Expect(instance).To(Equal(expectedInstance)) - Expect(fakeVMManager.CreateInput).To(Equal(fakebivm.CreateInput{ - Stemcell: fakeCloudStemcell, - Manifest: deploymentManifest, - DiskCIDs: diskCIDs, - })) + stemcell, manifest, diskCids := fakeVMManager.CreateArgsForCall(0) + + Expect(stemcell).To(Equal(fakeCloudStemcell)) + Expect(manifest).To(Equal(deploymentManifest)) + Expect(diskCids).To(Equal(diskCIDs)) }) It("updates the current stemcell", func() { @@ -244,12 +244,10 @@ var _ = Describe("Manager", func() { fakeStage, ) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.WaitUntilReadyInputs).To(Equal([]fakebivm.WaitUntilReadyInput{ - { - Timeout: 10 * time.Minute, - Delay: 500 * time.Millisecond, - }, - })) + + timeout, delay := fakeVM.WaitUntilReadyArgsForCall(0) + Expect(timeout).To(Equal(10 * time.Minute)) + Expect(delay).To(Equal(500 * time.Millisecond)) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Creating VM for instance 'fake-job-name/0' from stemcell 'fake-stemcell-cid'"}, @@ -269,17 +267,14 @@ var _ = Describe("Manager", func() { Expect(err).NotTo(HaveOccurred()) Expect(disks).To(Equal([]bidisk.Disk{expectedDisk})) - Expect(fakeVM.UpdateDisksInputs).To(Equal([]fakebivm.UpdateDisksInput{ - { - DiskPool: diskPool, - Stage: fakeStage, - }, - })) + pool, stage := fakeVM.UpdateDisksArgsForCall(0) + Expect(pool).To(Equal(diskPool)) + Expect(stage).To(Equal(fakeStage)) }) Context("when creating VM fails", func() { BeforeEach(func() { - fakeVMManager.CreateErr = errors.New("fake-create-vm-error") + fakeVMManager.CreateReturns(nil, errors.New("fake-create-vm-error")) }) It("returns an error", func() { diff --git a/deployment/vm/disk_deployer.go b/deployment/vm/disk_deployer.go index 192fcb0575..5064f177e4 100644 --- a/deployment/vm/disk_deployer.go +++ b/deployment/vm/disk_deployer.go @@ -13,6 +13,8 @@ import ( biui "github.com/cloudfoundry/bosh-cli/v7/ui" ) +//counterfeiter:generate . DiskDeployer + // DiskDeployer is in the vm package to avoid a [disk -> vm -> disk] dependency cycle type DiskDeployer interface { Deploy(diskPool bideplmanifest.DiskPool, cloud bicloud.Cloud, vm VM, eventLoggerStage biui.Stage) ([]bidisk.Disk, error) diff --git a/deployment/vm/disk_deployer_test.go b/deployment/vm/disk_deployer_test.go index 8771574d8b..027bae1249 100644 --- a/deployment/vm/disk_deployer_test.go +++ b/deployment/vm/disk_deployer_test.go @@ -15,7 +15,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -26,7 +26,7 @@ var _ = Describe("DiskDeployer", func() { diskPool bideplmanifest.DiskPool cloud *cloudfakes.FakeCloud fakeStage *fakebiui.FakeStage - fakeVM *fakebivm.FakeVM + fakeVM *vmfakes.FakeVM fakeDisk *diskfakes.FakeDisk fakeDiskRepo *configfakes.FakeDiskRepo fakeDiskManagerFactory *diskfakes.FakeManagerFactory @@ -35,7 +35,7 @@ var _ = Describe("DiskDeployer", func() { BeforeEach(func() { cloud = &cloudfakes.FakeCloud{} - fakeVM = fakebivm.NewFakeVM("fake-vm-cid") + fakeVM = &vmfakes.FakeVM{CIDStub: func() string { return "fake-vm-cid" }} fakeDiskManagerFactory = &diskfakes.FakeManagerFactory{ NewManagerStub: func(cloud bicloud.Cloud) bidisk.Manager { @@ -62,7 +62,7 @@ var _ = Describe("DiskDeployer", func() { ) fakeDiskManager.FindCurrentReturns([]bidisk.Disk{}, nil) - fakeVM.SetAttachDiskBehavior(fakeDisk, nil) + fakeVM.AttachDiskReturns(nil) newDiskRecord := biconfig.DiskRecord{ ID: "fake-new-disk-id", } @@ -82,13 +82,17 @@ var _ = Describe("DiskDeployer", func() { Context("when primary disk already exists", func() { var existingDisk *diskfakes.FakeDisk + var attachDiskResponses = map[bidisk.Disk]error{} BeforeEach(func() { existingDisk = &diskfakes.FakeDisk{CIDStub: func() string { return "fake-existing-disk-cid" }} fakeDiskManager.FindCurrentReturns([]bidisk.Disk{existingDisk}, nil) - fakeVM.SetAttachDiskBehavior(existingDisk, nil) + attachDiskResponses[existingDisk] = nil + fakeVM.AttachDiskStub = func(disk bidisk.Disk) error { + return attachDiskResponses[disk] + } existingDiskRecord := biconfig.DiskRecord{ ID: "fake-existing-disk-id", } @@ -159,10 +163,8 @@ var _ = Describe("DiskDeployer", func() { It("attaches secondary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.AttachDiskInputs).To(Equal([]fakebivm.AttachDiskInput{ - {Disk: existingDisk}, - {Disk: secondaryDisk}, - })) + Expect(fakeVM.AttachDiskArgsForCall(0)).To(Equal(existingDisk)) + Expect(fakeVM.AttachDiskArgsForCall(1)).To(Equal(secondaryDisk)) Expect(fakeStage.PerformCalls[2]).To(Equal(&fakebiui.PerformCall{ Name: "Attaching disk 'fake-secondary-disk-cid' to VM 'fake-vm-cid'", @@ -172,7 +174,7 @@ var _ = Describe("DiskDeployer", func() { It("migrates from primary to secondary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.MigrateDiskCalledTimes).To(Equal(1)) + Expect(fakeVM.MigrateDiskCallCount()).To(Equal(1)) Expect(fakeStage.PerformCalls[3]).To(Equal(&fakebiui.PerformCall{ Name: "Migrating disk content from 'fake-existing-disk-cid' to 'fake-secondary-disk-cid'", @@ -182,9 +184,7 @@ var _ = Describe("DiskDeployer", func() { It("detaches primary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{ - {Disk: existingDisk}, - })) + Expect(fakeVM.DetachDiskArgsForCall(0)).To(Equal(existingDisk)) Expect(fakeStage.PerformCalls[4]).To(Equal(&fakebiui.PerformCall{ Name: "Detaching disk 'fake-existing-disk-cid'", @@ -208,7 +208,7 @@ var _ = Describe("DiskDeployer", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-create-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) }) }) @@ -218,14 +218,14 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.SetAttachDiskBehavior(secondaryDisk, attachError) + attachDiskResponses[secondaryDisk] = attachError }) It("returns error and leaves the existing disk attached", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-attach-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Attaching disk 'fake-existing-disk-cid' to VM 'fake-vm-cid'"}, @@ -244,7 +244,14 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.SetDetachDiskBehavior(existingDisk, detachError) + fakeVM.DetachDiskStub = func(disk bidisk.Disk) error { + switch disk { + case existingDisk: + return detachError + default: + return nil + } + } }) It("returns error", func() { @@ -271,14 +278,14 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.MigrateDiskErr = migrateError + fakeVM.MigrateDiskReturns(migrateError) }) It("returns error and leaves the existing disk attached", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-migrate-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Attaching disk 'fake-existing-disk-cid' to VM 'fake-vm-cid'"}, @@ -327,10 +334,8 @@ var _ = Describe("DiskDeployer", func() { It("attaches secondary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.AttachDiskInputs).To(Equal([]fakebivm.AttachDiskInput{ - {Disk: existingDisk}, - {Disk: secondaryDisk}, - })) + Expect(fakeVM.AttachDiskArgsForCall(0)).To(Equal(existingDisk)) + Expect(fakeVM.AttachDiskArgsForCall(1)).To(Equal(secondaryDisk)) Expect(fakeStage.PerformCalls[2]).To(Equal(&fakebiui.PerformCall{ Name: "Attaching disk 'fake-secondary-disk-cid' to VM 'fake-vm-cid'", @@ -340,7 +345,7 @@ var _ = Describe("DiskDeployer", func() { It("migrates from primary to secondary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).ToNot(HaveOccurred()) - Expect(fakeVM.MigrateDiskCalledTimes).To(Equal(1)) + Expect(fakeVM.MigrateDiskCallCount()).To(Equal(1)) Expect(fakeStage.PerformCalls[3]).To(Equal(&fakebiui.PerformCall{ Name: "Migrating disk content from 'fake-existing-disk-cid' to 'fake-secondary-disk-cid'", @@ -350,9 +355,7 @@ var _ = Describe("DiskDeployer", func() { It("detaches primary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{ - {Disk: existingDisk}, - })) + Expect(fakeVM.DetachDiskArgsForCall(0)).To(Equal(existingDisk)) Expect(fakeStage.PerformCalls[4]).To(Equal(&fakebiui.PerformCall{ Name: "Detaching disk 'fake-existing-disk-cid'", @@ -376,7 +379,7 @@ var _ = Describe("DiskDeployer", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-create-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) }) }) @@ -386,14 +389,21 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.SetAttachDiskBehavior(secondaryDisk, attachError) + fakeVM.AttachDiskStub = func(disk bidisk.Disk) error { + switch disk { + case secondaryDisk: + return attachError + default: + return nil + } + } }) It("returns error and leaves the existing disk attached", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-attach-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Attaching disk 'fake-existing-disk-cid' to VM 'fake-vm-cid'"}, @@ -412,7 +422,7 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.SetDetachDiskBehavior(existingDisk, detachError) + fakeVM.DetachDiskReturns(detachError) }) It("returns error", func() { @@ -439,14 +449,14 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.MigrateDiskErr = migrateError + fakeVM.MigrateDiskReturns(migrateError) }) It("returns error and leaves the existing disk attached", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-migrate-disk-error")) - Expect(fakeVM.DetachDiskInputs).To(Equal([]fakebivm.DetachDiskInput{})) + Expect(fakeVM.DetachDiskCallCount()).To(Equal(0)) Expect(fakeStage.PerformCalls).To(Equal([]*fakebiui.PerformCall{ {Name: "Attaching disk 'fake-existing-disk-cid' to VM 'fake-vm-cid'"}, @@ -493,11 +503,7 @@ var _ = Describe("DiskDeployer", func() { It("attaches the primary disk", func() { _, err := diskDeployer.Deploy(diskPool, cloud, fakeVM, fakeStage) Expect(err).NotTo(HaveOccurred()) - Expect(fakeVM.AttachDiskInputs).To(Equal([]fakebivm.AttachDiskInput{ - { - Disk: fakeDisk, - }, - })) + Expect(fakeVM.AttachDiskArgsForCall(0)).To(Equal(fakeDisk)) }) It("logs attaching primary disk event", func() { @@ -563,7 +569,7 @@ var _ = Describe("DiskDeployer", func() { ) BeforeEach(func() { - fakeVM.SetAttachDiskBehavior(fakeDisk, attachDiskError) + fakeVM.AttachDiskReturns(attachDiskError) }) It("return an error", func() { diff --git a/deployment/vm/fakes/fake_disk_deployer.go b/deployment/vm/fakes/fake_disk_deployer.go deleted file mode 100644 index 53fb00f860..0000000000 --- a/deployment/vm/fakes/fake_disk_deployer.go +++ /dev/null @@ -1,55 +0,0 @@ -package fakes - -import ( - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - biui "github.com/cloudfoundry/bosh-cli/v7/ui" -) - -type FakeDiskDeployer struct { - DeployInputs []DeployInput - deployOutputs deployOutput -} - -type DeployInput struct { - DiskPool bideplmanifest.DiskPool - Cloud bicloud.Cloud - VM bivm.VM - EventLoggerStage biui.Stage -} - -type deployOutput struct { - disks []bidisk.Disk - err error -} - -func NewFakeDiskDeployer() *FakeDiskDeployer { - return &FakeDiskDeployer{ - DeployInputs: []DeployInput{}, - } -} - -func (d *FakeDiskDeployer) Deploy( - diskPool bideplmanifest.DiskPool, - cloud bicloud.Cloud, - vm bivm.VM, - eventLoggerStage biui.Stage, -) ([]bidisk.Disk, error) { - d.DeployInputs = append(d.DeployInputs, DeployInput{ - DiskPool: diskPool, - Cloud: cloud, - VM: vm, - EventLoggerStage: eventLoggerStage, - }) - - return d.deployOutputs.disks, d.deployOutputs.err -} - -func (d *FakeDiskDeployer) SetDeployBehavior(disks []bidisk.Disk, err error) { - d.deployOutputs = deployOutput{ - disks: disks, - err: err, - } -} diff --git a/deployment/vm/fakes/fake_manager.go b/deployment/vm/fakes/fake_manager.go deleted file mode 100644 index 2285566f2f..0000000000 --- a/deployment/vm/fakes/fake_manager.go +++ /dev/null @@ -1,54 +0,0 @@ -package fakes - -import ( - bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" -) - -type CreateInput struct { - Stemcell bistemcell.CloudStemcell - Manifest bideplmanifest.Manifest - DiskCIDs []string -} - -type FakeManager struct { - CreateInput CreateInput - CreateVM bivm.VM - CreateErr error - - findCurrentBehaviour findCurrentOutput -} - -type findCurrentOutput struct { - vm bivm.VM - found bool - err error -} - -func NewFakeManager() *FakeManager { - return &FakeManager{} -} - -func (m *FakeManager) FindCurrent() (bivm.VM, bool, error) { - return m.findCurrentBehaviour.vm, m.findCurrentBehaviour.found, m.findCurrentBehaviour.err -} - -func (m *FakeManager) Create(stemcell bistemcell.CloudStemcell, deploymentManifest bideplmanifest.Manifest, diskCIDs []string) (bivm.VM, error) { - input := CreateInput{ - Stemcell: stemcell, - Manifest: deploymentManifest, - DiskCIDs: diskCIDs, - } - m.CreateInput = input - - return m.CreateVM, m.CreateErr -} - -func (m *FakeManager) SetFindCurrentBehavior(vm bivm.VM, found bool, err error) { - m.findCurrentBehaviour = findCurrentOutput{ - vm: vm, - found: found, - err: err, - } -} diff --git a/deployment/vm/fakes/fake_manager_factory.go b/deployment/vm/fakes/fake_manager_factory.go deleted file mode 100644 index eaadb17101..0000000000 --- a/deployment/vm/fakes/fake_manager_factory.go +++ /dev/null @@ -1,66 +0,0 @@ -package fakes - -import ( - "fmt" - - bosherr "github.com/cloudfoundry/bosh-utils/errors" - - bicloud "github.com/cloudfoundry/bosh-cli/v7/cloud" - bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - bitestutils "github.com/cloudfoundry/bosh-cli/v7/testutils" -) - -type NewManagerInput struct { - Cloud bicloud.Cloud - MbusURL string -} - -type newManagerOutput struct { - manager bivm.Manager -} - -type FakeManagerFactory struct { - NewManagerInputs []NewManagerInput - newManagerBehavior map[string]newManagerOutput -} - -func NewFakeManagerFactory() *FakeManagerFactory { - return &FakeManagerFactory{ - NewManagerInputs: []NewManagerInput{}, - newManagerBehavior: map[string]newManagerOutput{}, - } -} - -func (f *FakeManagerFactory) NewManager(cloud bicloud.Cloud, mbusURL string) bivm.Manager { - input := NewManagerInput{ - Cloud: cloud, - MbusURL: mbusURL, - } - f.NewManagerInputs = append(f.NewManagerInputs, input) - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - panic(bosherr.WrapError(marshalErr, "Marshaling NewManager input")) - } - - output, found := f.newManagerBehavior[inputString] - if !found { - panic(fmt.Errorf("Unsupported NewManager Input: %#v\nExpected Behavior: %#v", input, f.newManagerBehavior)) //nolint:staticcheck - } - - return output.manager -} - -func (f *FakeManagerFactory) SetNewManagerBehavior(cloud bicloud.Cloud, mbusURL string, manager bivm.Manager) { - input := NewManagerInput{ - Cloud: cloud, - MbusURL: mbusURL, - } - - inputString, marshalErr := bitestutils.MarshalToString(input) - if marshalErr != nil { - panic(bosherr.WrapError(marshalErr, "Marshaling NewManager input")) - } - - f.newManagerBehavior[inputString] = newManagerOutput{manager: manager} -} diff --git a/deployment/vm/fakes/fake_vm.go b/deployment/vm/fakes/fake_vm.go deleted file mode 100644 index fe00b5abe6..0000000000 --- a/deployment/vm/fakes/fake_vm.go +++ /dev/null @@ -1,233 +0,0 @@ -package fakes - -import ( - "time" - - biagentclient "github.com/cloudfoundry/bosh-agent/v2/agentclient" - bias "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" - - bidisk "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" - bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" - biui "github.com/cloudfoundry/bosh-cli/v7/ui" -) - -type FakeVM struct { - cid string - - ExistsCalled int - ExistsFound bool - ExistsErr error - - AgentClientReturn biagentclient.AgentClient - - UpdateDisksInputs []UpdateDisksInput - UpdateDisksDisks []bidisk.Disk - UpdateDisksErr error - - ApplyInputs []ApplyInput - ApplyErr error - - StartCalled int - StartErr error - - DrainCalled int - DrainErr error - - AttachDiskInputs []AttachDiskInput - attachDiskBehavior map[string]error - - DetachDiskInputs []DetachDiskInput - detachDiskBehavior map[string]error - - WaitUntilReadyInputs []WaitUntilReadyInput - WaitUntilReadyErr error - - WaitToBeRunningInputs []WaitInput - WaitToBeRunningErr error - - DeleteCalled int - DeleteErr error - - StopCalled int - StopErr error - - ListDisksDisks []bidisk.Disk - ListDisksErr error - - UnmountDiskInputs []UnmountDiskInput - UnmountDiskErr error - - MigrateDiskCalledTimes int - MigrateDiskErr error - - RunScriptInputs []string - RunScriptErrors map[string]error - - GetStateResult biagentclient.AgentState - GetStateCalled int - GetStateErr error -} - -type UpdateDisksInput struct { - DiskPool bideplmanifest.DiskPool - Stage biui.Stage -} - -type ApplyInput struct { - ApplySpec bias.ApplySpec -} - -type WaitUntilReadyInput struct { - Timeout time.Duration - Delay time.Duration -} - -type WaitInput struct { - MaxAttempts int - Delay time.Duration -} - -type AttachDiskInput struct { - Disk bidisk.Disk -} - -type DetachDiskInput struct { - Disk bidisk.Disk -} - -type UnmountDiskInput struct { - Disk bidisk.Disk -} - -func NewFakeVM(cid string) *FakeVM { - return &FakeVM{ - ExistsFound: true, - ApplyInputs: []ApplyInput{}, - WaitUntilReadyInputs: []WaitUntilReadyInput{}, - WaitToBeRunningInputs: []WaitInput{}, - AttachDiskInputs: []AttachDiskInput{}, - DetachDiskInputs: []DetachDiskInput{}, - UnmountDiskInputs: []UnmountDiskInput{}, - attachDiskBehavior: map[string]error{}, - detachDiskBehavior: map[string]error{}, - cid: cid, - RunScriptErrors: map[string]error{}, - } -} - -func (vm *FakeVM) CID() string { - return vm.cid -} - -func (vm *FakeVM) Exists() (bool, error) { - vm.ExistsCalled++ - return vm.ExistsFound, vm.ExistsErr -} - -func (vm *FakeVM) AgentClient() biagentclient.AgentClient { - return vm.AgentClientReturn -} - -func (vm *FakeVM) WaitUntilReady(timeout time.Duration, delay time.Duration) error { - vm.WaitUntilReadyInputs = append(vm.WaitUntilReadyInputs, WaitUntilReadyInput{ - Timeout: timeout, - Delay: delay, - }) - return vm.WaitUntilReadyErr -} - -func (vm *FakeVM) UpdateDisks(diskPool bideplmanifest.DiskPool, eventLoggerStage biui.Stage) ([]bidisk.Disk, error) { - vm.UpdateDisksInputs = append(vm.UpdateDisksInputs, UpdateDisksInput{ - DiskPool: diskPool, - Stage: eventLoggerStage, - }) - return vm.UpdateDisksDisks, vm.UpdateDisksErr -} - -func (vm *FakeVM) Apply(applySpec bias.ApplySpec) error { - vm.ApplyInputs = append(vm.ApplyInputs, ApplyInput{ - ApplySpec: applySpec, - }) - - return vm.ApplyErr -} - -func (vm *FakeVM) Start() error { - vm.StartCalled++ - return vm.StartErr -} - -func (vm *FakeVM) Drain() error { - vm.DrainCalled++ - return vm.DrainErr -} - -func (vm *FakeVM) WaitToBeRunning(maxAttempts int, delay time.Duration) error { - vm.WaitToBeRunningInputs = append(vm.WaitToBeRunningInputs, WaitInput{ - MaxAttempts: maxAttempts, - Delay: delay, - }) - return vm.WaitToBeRunningErr -} - -func (vm *FakeVM) AttachDisk(disk bidisk.Disk) error { - vm.AttachDiskInputs = append(vm.AttachDiskInputs, AttachDiskInput{ - Disk: disk, - }) - - return vm.attachDiskBehavior[disk.CID()] -} - -func (vm *FakeVM) DetachDisk(disk bidisk.Disk) error { - vm.DetachDiskInputs = append(vm.DetachDiskInputs, DetachDiskInput{ - Disk: disk, - }) - - return vm.detachDiskBehavior[disk.CID()] -} - -func (vm *FakeVM) UnmountDisk(disk bidisk.Disk) error { - vm.UnmountDiskInputs = append(vm.UnmountDiskInputs, UnmountDiskInput{ - Disk: disk, - }) - - return vm.UnmountDiskErr -} - -func (vm *FakeVM) MigrateDisk() error { - vm.MigrateDiskCalledTimes++ - - return vm.MigrateDiskErr -} - -func (vm *FakeVM) Stop() error { - vm.StopCalled++ - return vm.StopErr -} - -func (vm *FakeVM) Disks() ([]bidisk.Disk, error) { - return vm.ListDisksDisks, vm.ListDisksErr -} - -func (vm *FakeVM) RunScript(script string, options map[string]interface{}) error { - vm.RunScriptInputs = append(vm.RunScriptInputs, script) - return vm.RunScriptErrors[script] -} - -func (vm *FakeVM) Delete() error { - vm.DeleteCalled++ - return vm.DeleteErr -} - -func (vm *FakeVM) SetAttachDiskBehavior(disk bidisk.Disk, err error) { - vm.attachDiskBehavior[disk.CID()] = err -} - -func (vm *FakeVM) SetDetachDiskBehavior(disk bidisk.Disk, err error) { - vm.detachDiskBehavior[disk.CID()] = err -} - -func (vm *FakeVM) GetState() (biagentclient.AgentState, error) { - vm.GetStateCalled++ - return vm.GetStateResult, vm.GetStateErr -} diff --git a/deployment/vm/manager.go b/deployment/vm/manager.go index 860f5ce10e..88c1d72639 100644 --- a/deployment/vm/manager.go +++ b/deployment/vm/manager.go @@ -19,6 +19,8 @@ import ( bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" ) +//counterfeiter:generate . Manager + type Manager interface { FindCurrent() (VM, bool, error) Create(stemcell bistemcell.CloudStemcell, deploymentManifest bideplmanifest.Manifest, diskCIDs []string) (VM, error) diff --git a/deployment/vm/manager_test.go b/deployment/vm/manager_test.go index 25775c5c11..3f37e5c638 100644 --- a/deployment/vm/manager_test.go +++ b/deployment/vm/manager_test.go @@ -19,7 +19,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/config/configfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" ) @@ -34,7 +34,7 @@ var _ = Describe("Manager", func() { deploymentManifest bideplmanifest.Manifest fakeVMRepo *configfakes.FakeVMRepo stemcellRepo biconfig.StemcellRepo - fakeDiskDeployer *fakebivm.FakeDiskDeployer + fakeDiskDeployer *vmfakes.FakeDiskDeployer fakeAgentClient *fakebiagentclient.FakeAgentClient stemcell bistemcell.CloudStemcell diskCIDs []string @@ -53,7 +53,7 @@ var _ = Describe("Manager", func() { deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, "/fake/path") stemcellRepo = biconfig.NewStemcellRepo(deploymentStateService, fakeUUIDGenerator) - fakeDiskDeployer = fakebivm.NewFakeDiskDeployer() + fakeDiskDeployer = &vmfakes.FakeDiskDeployer{} fakeTime := time.Date(2016, time.November, 10, 23, 0, 0, 0, time.UTC) fakeTimeService = &FakeClock{Times: []time.Time{fakeTime, time.Now().Add(10 * time.Minute)}} diskCIDs = []string{"fake-disk-cid-1"} diff --git a/deployment/vm/vm.go b/deployment/vm/vm.go index fc86dee572..e2860fc678 100644 --- a/deployment/vm/vm.go +++ b/deployment/vm/vm.go @@ -28,6 +28,8 @@ type Clock interface { // You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate +//counterfeiter:generate . VM + type VM interface { CID() string Exists() (bool, error) diff --git a/deployment/vm/vm_test.go b/deployment/vm/vm_test.go index 0249f5b43a..0bccad59c8 100644 --- a/deployment/vm/vm_test.go +++ b/deployment/vm/vm_test.go @@ -21,7 +21,7 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/deployment/disk/diskfakes" bideplmanifest "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" . "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" - fakebivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/fakes" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm/vmfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -30,7 +30,7 @@ var _ = Describe("VM", func() { vm VM fakeVMRepo *configfakes.FakeVMRepo fakeStemcellRepo *configfakes.FakeStemcellRepo - fakeDiskDeployer *fakebivm.FakeDiskDeployer + fakeDiskDeployer *vmfakes.FakeDiskDeployer fakeAgentClient *fakebiagentclient.FakeAgentClient fakeCloud *cloudfakes.FakeCloud applySpec bias.ApplySpec @@ -62,7 +62,7 @@ var _ = Describe("VM", func() { fakeCloud = &cloudfakes.FakeCloud{} fakeVMRepo = &configfakes.FakeVMRepo{} fakeStemcellRepo = &configfakes.FakeStemcellRepo{} - fakeDiskDeployer = fakebivm.NewFakeDiskDeployer() + fakeDiskDeployer = &vmfakes.FakeDiskDeployer{} vm = NewVM( "fake-vm-cid", fakeVMRepo, @@ -108,7 +108,7 @@ var _ = Describe("VM", func() { BeforeEach(func() { fakeDisk := &diskfakes.FakeDisk{CIDStub: func() string { return "fake-disk-cid" }} expectedDisks = []bidisk.Disk{fakeDisk} - fakeDiskDeployer.SetDeployBehavior(expectedDisks, nil) + fakeDiskDeployer.DeployReturns(expectedDisks, nil) }) It("delegates to DiskDeployer.Deploy", func() { @@ -118,14 +118,11 @@ var _ = Describe("VM", func() { Expect(err).NotTo(HaveOccurred()) Expect(disks).To(Equal(expectedDisks)) - Expect(fakeDiskDeployer.DeployInputs).To(Equal([]fakebivm.DeployInput{ - { - DiskPool: diskPool, - Cloud: fakeCloud, - VM: vm, - EventLoggerStage: fakeStage, - }, - })) + diskPoolArg, cloudArg, vmArg, stageArg := fakeDiskDeployer.DeployArgsForCall(0) + Expect(diskPoolArg).To(Equal(diskPool)) + Expect(cloudArg).To(Equal(fakeCloud)) + Expect(vmArg).To(Equal(vm)) + Expect(stageArg).To(Equal(fakeStage)) }) }) diff --git a/deployment/vm/vmfakes/fake_disk_deployer.go b/deployment/vm/vmfakes/fake_disk_deployer.go new file mode 100644 index 0000000000..a254c09e18 --- /dev/null +++ b/deployment/vm/vmfakes/fake_disk_deployer.go @@ -0,0 +1,124 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package vmfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/cloud" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeDiskDeployer struct { + DeployStub func(manifest.DiskPool, cloud.Cloud, vm.VM, ui.Stage) ([]disk.Disk, error) + deployMutex sync.RWMutex + deployArgsForCall []struct { + arg1 manifest.DiskPool + arg2 cloud.Cloud + arg3 vm.VM + arg4 ui.Stage + } + deployReturns struct { + result1 []disk.Disk + result2 error + } + deployReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeDiskDeployer) Deploy(arg1 manifest.DiskPool, arg2 cloud.Cloud, arg3 vm.VM, arg4 ui.Stage) ([]disk.Disk, error) { + fake.deployMutex.Lock() + ret, specificReturn := fake.deployReturnsOnCall[len(fake.deployArgsForCall)] + fake.deployArgsForCall = append(fake.deployArgsForCall, struct { + arg1 manifest.DiskPool + arg2 cloud.Cloud + arg3 vm.VM + arg4 ui.Stage + }{arg1, arg2, arg3, arg4}) + stub := fake.DeployStub + fakeReturns := fake.deployReturns + fake.recordInvocation("Deploy", []interface{}{arg1, arg2, arg3, arg4}) + fake.deployMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeDiskDeployer) DeployCallCount() int { + fake.deployMutex.RLock() + defer fake.deployMutex.RUnlock() + return len(fake.deployArgsForCall) +} + +func (fake *FakeDiskDeployer) DeployCalls(stub func(manifest.DiskPool, cloud.Cloud, vm.VM, ui.Stage) ([]disk.Disk, error)) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = stub +} + +func (fake *FakeDiskDeployer) DeployArgsForCall(i int) (manifest.DiskPool, cloud.Cloud, vm.VM, ui.Stage) { + fake.deployMutex.RLock() + defer fake.deployMutex.RUnlock() + argsForCall := fake.deployArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeDiskDeployer) DeployReturns(result1 []disk.Disk, result2 error) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = nil + fake.deployReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeDiskDeployer) DeployReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.deployMutex.Lock() + defer fake.deployMutex.Unlock() + fake.DeployStub = nil + if fake.deployReturnsOnCall == nil { + fake.deployReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.deployReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeDiskDeployer) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeDiskDeployer) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ vm.DiskDeployer = new(FakeDiskDeployer) diff --git a/deployment/vm/vmfakes/fake_manager.go b/deployment/vm/vmfakes/fake_manager.go new file mode 100644 index 0000000000..fd1a988549 --- /dev/null +++ b/deployment/vm/vmfakes/fake_manager.go @@ -0,0 +1,198 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package vmfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" + "github.com/cloudfoundry/bosh-cli/v7/stemcell" +) + +type FakeManager struct { + CreateStub func(stemcell.CloudStemcell, manifest.Manifest, []string) (vm.VM, error) + createMutex sync.RWMutex + createArgsForCall []struct { + arg1 stemcell.CloudStemcell + arg2 manifest.Manifest + arg3 []string + } + createReturns struct { + result1 vm.VM + result2 error + } + createReturnsOnCall map[int]struct { + result1 vm.VM + result2 error + } + FindCurrentStub func() (vm.VM, bool, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 vm.VM + result2 bool + result3 error + } + findCurrentReturnsOnCall map[int]struct { + result1 vm.VM + result2 bool + result3 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) Create(arg1 stemcell.CloudStemcell, arg2 manifest.Manifest, arg3 []string) (vm.VM, error) { + var arg3Copy []string + if arg3 != nil { + arg3Copy = make([]string, len(arg3)) + copy(arg3Copy, arg3) + } + fake.createMutex.Lock() + ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)] + fake.createArgsForCall = append(fake.createArgsForCall, struct { + arg1 stemcell.CloudStemcell + arg2 manifest.Manifest + arg3 []string + }{arg1, arg2, arg3Copy}) + stub := fake.CreateStub + fakeReturns := fake.createReturns + fake.recordInvocation("Create", []interface{}{arg1, arg2, arg3Copy}) + fake.createMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) CreateCallCount() int { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + return len(fake.createArgsForCall) +} + +func (fake *FakeManager) CreateCalls(stub func(stemcell.CloudStemcell, manifest.Manifest, []string) (vm.VM, error)) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = stub +} + +func (fake *FakeManager) CreateArgsForCall(i int) (stemcell.CloudStemcell, manifest.Manifest, []string) { + fake.createMutex.RLock() + defer fake.createMutex.RUnlock() + argsForCall := fake.createArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeManager) CreateReturns(result1 vm.VM, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + fake.createReturns = struct { + result1 vm.VM + result2 error + }{result1, result2} +} + +func (fake *FakeManager) CreateReturnsOnCall(i int, result1 vm.VM, result2 error) { + fake.createMutex.Lock() + defer fake.createMutex.Unlock() + fake.CreateStub = nil + if fake.createReturnsOnCall == nil { + fake.createReturnsOnCall = make(map[int]struct { + result1 vm.VM + result2 error + }) + } + fake.createReturnsOnCall[i] = struct { + result1 vm.VM + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindCurrent() (vm.VM, bool, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2, ret.result3 + } + return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() (vm.VM, bool, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub +} + +func (fake *FakeManager) FindCurrentReturns(result1 vm.VM, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 vm.VM + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 vm.VM, result2 bool, result3 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 vm.VM + result2 bool + result3 error + }) + } + fake.findCurrentReturnsOnCall[i] = struct { + result1 vm.VM + result2 bool + result3 error + }{result1, result2, result3} +} + +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ vm.Manager = new(FakeManager) diff --git a/deployment/vm/vmfakes/fake_vm.go b/deployment/vm/vmfakes/fake_vm.go new file mode 100644 index 0000000000..24780ea6a7 --- /dev/null +++ b/deployment/vm/vmfakes/fake_vm.go @@ -0,0 +1,1277 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package vmfakes + +import ( + "sync" + "time" + + "github.com/cloudfoundry/bosh-agent/v2/agentclient" + "github.com/cloudfoundry/bosh-agent/v2/agentclient/applyspec" + "github.com/cloudfoundry/bosh-cli/v7/deployment/disk" + "github.com/cloudfoundry/bosh-cli/v7/deployment/manifest" + "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" + "github.com/cloudfoundry/bosh-cli/v7/ui" +) + +type FakeVM struct { + AgentClientStub func() agentclient.AgentClient + agentClientMutex sync.RWMutex + agentClientArgsForCall []struct { + } + agentClientReturns struct { + result1 agentclient.AgentClient + } + agentClientReturnsOnCall map[int]struct { + result1 agentclient.AgentClient + } + ApplyStub func(applyspec.ApplySpec) error + applyMutex sync.RWMutex + applyArgsForCall []struct { + arg1 applyspec.ApplySpec + } + applyReturns struct { + result1 error + } + applyReturnsOnCall map[int]struct { + result1 error + } + AttachDiskStub func(disk.Disk) error + attachDiskMutex sync.RWMutex + attachDiskArgsForCall []struct { + arg1 disk.Disk + } + attachDiskReturns struct { + result1 error + } + attachDiskReturnsOnCall map[int]struct { + result1 error + } + CIDStub func() string + cIDMutex sync.RWMutex + cIDArgsForCall []struct { + } + cIDReturns struct { + result1 string + } + cIDReturnsOnCall map[int]struct { + result1 string + } + DeleteStub func() error + deleteMutex sync.RWMutex + deleteArgsForCall []struct { + } + deleteReturns struct { + result1 error + } + deleteReturnsOnCall map[int]struct { + result1 error + } + DetachDiskStub func(disk.Disk) error + detachDiskMutex sync.RWMutex + detachDiskArgsForCall []struct { + arg1 disk.Disk + } + detachDiskReturns struct { + result1 error + } + detachDiskReturnsOnCall map[int]struct { + result1 error + } + DisksStub func() ([]disk.Disk, error) + disksMutex sync.RWMutex + disksArgsForCall []struct { + } + disksReturns struct { + result1 []disk.Disk + result2 error + } + disksReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + DrainStub func() error + drainMutex sync.RWMutex + drainArgsForCall []struct { + } + drainReturns struct { + result1 error + } + drainReturnsOnCall map[int]struct { + result1 error + } + ExistsStub func() (bool, error) + existsMutex sync.RWMutex + existsArgsForCall []struct { + } + existsReturns struct { + result1 bool + result2 error + } + existsReturnsOnCall map[int]struct { + result1 bool + result2 error + } + GetStateStub func() (agentclient.AgentState, error) + getStateMutex sync.RWMutex + getStateArgsForCall []struct { + } + getStateReturns struct { + result1 agentclient.AgentState + result2 error + } + getStateReturnsOnCall map[int]struct { + result1 agentclient.AgentState + result2 error + } + MigrateDiskStub func() error + migrateDiskMutex sync.RWMutex + migrateDiskArgsForCall []struct { + } + migrateDiskReturns struct { + result1 error + } + migrateDiskReturnsOnCall map[int]struct { + result1 error + } + RunScriptStub func(string, map[string]interface{}) error + runScriptMutex sync.RWMutex + runScriptArgsForCall []struct { + arg1 string + arg2 map[string]interface{} + } + runScriptReturns struct { + result1 error + } + runScriptReturnsOnCall map[int]struct { + result1 error + } + StartStub func() error + startMutex sync.RWMutex + startArgsForCall []struct { + } + startReturns struct { + result1 error + } + startReturnsOnCall map[int]struct { + result1 error + } + StopStub func() error + stopMutex sync.RWMutex + stopArgsForCall []struct { + } + stopReturns struct { + result1 error + } + stopReturnsOnCall map[int]struct { + result1 error + } + UnmountDiskStub func(disk.Disk) error + unmountDiskMutex sync.RWMutex + unmountDiskArgsForCall []struct { + arg1 disk.Disk + } + unmountDiskReturns struct { + result1 error + } + unmountDiskReturnsOnCall map[int]struct { + result1 error + } + UpdateDisksStub func(manifest.DiskPool, ui.Stage) ([]disk.Disk, error) + updateDisksMutex sync.RWMutex + updateDisksArgsForCall []struct { + arg1 manifest.DiskPool + arg2 ui.Stage + } + updateDisksReturns struct { + result1 []disk.Disk + result2 error + } + updateDisksReturnsOnCall map[int]struct { + result1 []disk.Disk + result2 error + } + WaitToBeRunningStub func(int, time.Duration) error + waitToBeRunningMutex sync.RWMutex + waitToBeRunningArgsForCall []struct { + arg1 int + arg2 time.Duration + } + waitToBeRunningReturns struct { + result1 error + } + waitToBeRunningReturnsOnCall map[int]struct { + result1 error + } + WaitUntilReadyStub func(time.Duration, time.Duration) error + waitUntilReadyMutex sync.RWMutex + waitUntilReadyArgsForCall []struct { + arg1 time.Duration + arg2 time.Duration + } + waitUntilReadyReturns struct { + result1 error + } + waitUntilReadyReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeVM) AgentClient() agentclient.AgentClient { + fake.agentClientMutex.Lock() + ret, specificReturn := fake.agentClientReturnsOnCall[len(fake.agentClientArgsForCall)] + fake.agentClientArgsForCall = append(fake.agentClientArgsForCall, struct { + }{}) + stub := fake.AgentClientStub + fakeReturns := fake.agentClientReturns + fake.recordInvocation("AgentClient", []interface{}{}) + fake.agentClientMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) AgentClientCallCount() int { + fake.agentClientMutex.RLock() + defer fake.agentClientMutex.RUnlock() + return len(fake.agentClientArgsForCall) +} + +func (fake *FakeVM) AgentClientCalls(stub func() agentclient.AgentClient) { + fake.agentClientMutex.Lock() + defer fake.agentClientMutex.Unlock() + fake.AgentClientStub = stub +} + +func (fake *FakeVM) AgentClientReturns(result1 agentclient.AgentClient) { + fake.agentClientMutex.Lock() + defer fake.agentClientMutex.Unlock() + fake.AgentClientStub = nil + fake.agentClientReturns = struct { + result1 agentclient.AgentClient + }{result1} +} + +func (fake *FakeVM) AgentClientReturnsOnCall(i int, result1 agentclient.AgentClient) { + fake.agentClientMutex.Lock() + defer fake.agentClientMutex.Unlock() + fake.AgentClientStub = nil + if fake.agentClientReturnsOnCall == nil { + fake.agentClientReturnsOnCall = make(map[int]struct { + result1 agentclient.AgentClient + }) + } + fake.agentClientReturnsOnCall[i] = struct { + result1 agentclient.AgentClient + }{result1} +} + +func (fake *FakeVM) Apply(arg1 applyspec.ApplySpec) error { + fake.applyMutex.Lock() + ret, specificReturn := fake.applyReturnsOnCall[len(fake.applyArgsForCall)] + fake.applyArgsForCall = append(fake.applyArgsForCall, struct { + arg1 applyspec.ApplySpec + }{arg1}) + stub := fake.ApplyStub + fakeReturns := fake.applyReturns + fake.recordInvocation("Apply", []interface{}{arg1}) + fake.applyMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) ApplyCallCount() int { + fake.applyMutex.RLock() + defer fake.applyMutex.RUnlock() + return len(fake.applyArgsForCall) +} + +func (fake *FakeVM) ApplyCalls(stub func(applyspec.ApplySpec) error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = stub +} + +func (fake *FakeVM) ApplyArgsForCall(i int) applyspec.ApplySpec { + fake.applyMutex.RLock() + defer fake.applyMutex.RUnlock() + argsForCall := fake.applyArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVM) ApplyReturns(result1 error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = nil + fake.applyReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) ApplyReturnsOnCall(i int, result1 error) { + fake.applyMutex.Lock() + defer fake.applyMutex.Unlock() + fake.ApplyStub = nil + if fake.applyReturnsOnCall == nil { + fake.applyReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.applyReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) AttachDisk(arg1 disk.Disk) error { + fake.attachDiskMutex.Lock() + ret, specificReturn := fake.attachDiskReturnsOnCall[len(fake.attachDiskArgsForCall)] + fake.attachDiskArgsForCall = append(fake.attachDiskArgsForCall, struct { + arg1 disk.Disk + }{arg1}) + stub := fake.AttachDiskStub + fakeReturns := fake.attachDiskReturns + fake.recordInvocation("AttachDisk", []interface{}{arg1}) + fake.attachDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) AttachDiskCallCount() int { + fake.attachDiskMutex.RLock() + defer fake.attachDiskMutex.RUnlock() + return len(fake.attachDiskArgsForCall) +} + +func (fake *FakeVM) AttachDiskCalls(stub func(disk.Disk) error) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = stub +} + +func (fake *FakeVM) AttachDiskArgsForCall(i int) disk.Disk { + fake.attachDiskMutex.RLock() + defer fake.attachDiskMutex.RUnlock() + argsForCall := fake.attachDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVM) AttachDiskReturns(result1 error) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = nil + fake.attachDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) AttachDiskReturnsOnCall(i int, result1 error) { + fake.attachDiskMutex.Lock() + defer fake.attachDiskMutex.Unlock() + fake.AttachDiskStub = nil + if fake.attachDiskReturnsOnCall == nil { + fake.attachDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.attachDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) CID() string { + fake.cIDMutex.Lock() + ret, specificReturn := fake.cIDReturnsOnCall[len(fake.cIDArgsForCall)] + fake.cIDArgsForCall = append(fake.cIDArgsForCall, struct { + }{}) + stub := fake.CIDStub + fakeReturns := fake.cIDReturns + fake.recordInvocation("CID", []interface{}{}) + fake.cIDMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) CIDCallCount() int { + fake.cIDMutex.RLock() + defer fake.cIDMutex.RUnlock() + return len(fake.cIDArgsForCall) +} + +func (fake *FakeVM) CIDCalls(stub func() string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = stub +} + +func (fake *FakeVM) CIDReturns(result1 string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = nil + fake.cIDReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeVM) CIDReturnsOnCall(i int, result1 string) { + fake.cIDMutex.Lock() + defer fake.cIDMutex.Unlock() + fake.CIDStub = nil + if fake.cIDReturnsOnCall == nil { + fake.cIDReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.cIDReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeVM) Delete() error { + fake.deleteMutex.Lock() + ret, specificReturn := fake.deleteReturnsOnCall[len(fake.deleteArgsForCall)] + fake.deleteArgsForCall = append(fake.deleteArgsForCall, struct { + }{}) + stub := fake.DeleteStub + fakeReturns := fake.deleteReturns + fake.recordInvocation("Delete", []interface{}{}) + fake.deleteMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) DeleteCallCount() int { + fake.deleteMutex.RLock() + defer fake.deleteMutex.RUnlock() + return len(fake.deleteArgsForCall) +} + +func (fake *FakeVM) DeleteCalls(stub func() error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = stub +} + +func (fake *FakeVM) DeleteReturns(result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + fake.deleteReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) DeleteReturnsOnCall(i int, result1 error) { + fake.deleteMutex.Lock() + defer fake.deleteMutex.Unlock() + fake.DeleteStub = nil + if fake.deleteReturnsOnCall == nil { + fake.deleteReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) DetachDisk(arg1 disk.Disk) error { + fake.detachDiskMutex.Lock() + ret, specificReturn := fake.detachDiskReturnsOnCall[len(fake.detachDiskArgsForCall)] + fake.detachDiskArgsForCall = append(fake.detachDiskArgsForCall, struct { + arg1 disk.Disk + }{arg1}) + stub := fake.DetachDiskStub + fakeReturns := fake.detachDiskReturns + fake.recordInvocation("DetachDisk", []interface{}{arg1}) + fake.detachDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) DetachDiskCallCount() int { + fake.detachDiskMutex.RLock() + defer fake.detachDiskMutex.RUnlock() + return len(fake.detachDiskArgsForCall) +} + +func (fake *FakeVM) DetachDiskCalls(stub func(disk.Disk) error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = stub +} + +func (fake *FakeVM) DetachDiskArgsForCall(i int) disk.Disk { + fake.detachDiskMutex.RLock() + defer fake.detachDiskMutex.RUnlock() + argsForCall := fake.detachDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVM) DetachDiskReturns(result1 error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = nil + fake.detachDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) DetachDiskReturnsOnCall(i int, result1 error) { + fake.detachDiskMutex.Lock() + defer fake.detachDiskMutex.Unlock() + fake.DetachDiskStub = nil + if fake.detachDiskReturnsOnCall == nil { + fake.detachDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.detachDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) Disks() ([]disk.Disk, error) { + fake.disksMutex.Lock() + ret, specificReturn := fake.disksReturnsOnCall[len(fake.disksArgsForCall)] + fake.disksArgsForCall = append(fake.disksArgsForCall, struct { + }{}) + stub := fake.DisksStub + fakeReturns := fake.disksReturns + fake.recordInvocation("Disks", []interface{}{}) + fake.disksMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVM) DisksCallCount() int { + fake.disksMutex.RLock() + defer fake.disksMutex.RUnlock() + return len(fake.disksArgsForCall) +} + +func (fake *FakeVM) DisksCalls(stub func() ([]disk.Disk, error)) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = stub +} + +func (fake *FakeVM) DisksReturns(result1 []disk.Disk, result2 error) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = nil + fake.disksReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeVM) DisksReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.disksMutex.Lock() + defer fake.disksMutex.Unlock() + fake.DisksStub = nil + if fake.disksReturnsOnCall == nil { + fake.disksReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.disksReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeVM) Drain() error { + fake.drainMutex.Lock() + ret, specificReturn := fake.drainReturnsOnCall[len(fake.drainArgsForCall)] + fake.drainArgsForCall = append(fake.drainArgsForCall, struct { + }{}) + stub := fake.DrainStub + fakeReturns := fake.drainReturns + fake.recordInvocation("Drain", []interface{}{}) + fake.drainMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) DrainCallCount() int { + fake.drainMutex.RLock() + defer fake.drainMutex.RUnlock() + return len(fake.drainArgsForCall) +} + +func (fake *FakeVM) DrainCalls(stub func() error) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = stub +} + +func (fake *FakeVM) DrainReturns(result1 error) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = nil + fake.drainReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) DrainReturnsOnCall(i int, result1 error) { + fake.drainMutex.Lock() + defer fake.drainMutex.Unlock() + fake.DrainStub = nil + if fake.drainReturnsOnCall == nil { + fake.drainReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.drainReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) Exists() (bool, error) { + fake.existsMutex.Lock() + ret, specificReturn := fake.existsReturnsOnCall[len(fake.existsArgsForCall)] + fake.existsArgsForCall = append(fake.existsArgsForCall, struct { + }{}) + stub := fake.ExistsStub + fakeReturns := fake.existsReturns + fake.recordInvocation("Exists", []interface{}{}) + fake.existsMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVM) ExistsCallCount() int { + fake.existsMutex.RLock() + defer fake.existsMutex.RUnlock() + return len(fake.existsArgsForCall) +} + +func (fake *FakeVM) ExistsCalls(stub func() (bool, error)) { + fake.existsMutex.Lock() + defer fake.existsMutex.Unlock() + fake.ExistsStub = stub +} + +func (fake *FakeVM) ExistsReturns(result1 bool, result2 error) { + fake.existsMutex.Lock() + defer fake.existsMutex.Unlock() + fake.ExistsStub = nil + fake.existsReturns = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeVM) ExistsReturnsOnCall(i int, result1 bool, result2 error) { + fake.existsMutex.Lock() + defer fake.existsMutex.Unlock() + fake.ExistsStub = nil + if fake.existsReturnsOnCall == nil { + fake.existsReturnsOnCall = make(map[int]struct { + result1 bool + result2 error + }) + } + fake.existsReturnsOnCall[i] = struct { + result1 bool + result2 error + }{result1, result2} +} + +func (fake *FakeVM) GetState() (agentclient.AgentState, error) { + fake.getStateMutex.Lock() + ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] + fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { + }{}) + stub := fake.GetStateStub + fakeReturns := fake.getStateReturns + fake.recordInvocation("GetState", []interface{}{}) + fake.getStateMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVM) GetStateCallCount() int { + fake.getStateMutex.RLock() + defer fake.getStateMutex.RUnlock() + return len(fake.getStateArgsForCall) +} + +func (fake *FakeVM) GetStateCalls(stub func() (agentclient.AgentState, error)) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = stub +} + +func (fake *FakeVM) GetStateReturns(result1 agentclient.AgentState, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + fake.getStateReturns = struct { + result1 agentclient.AgentState + result2 error + }{result1, result2} +} + +func (fake *FakeVM) GetStateReturnsOnCall(i int, result1 agentclient.AgentState, result2 error) { + fake.getStateMutex.Lock() + defer fake.getStateMutex.Unlock() + fake.GetStateStub = nil + if fake.getStateReturnsOnCall == nil { + fake.getStateReturnsOnCall = make(map[int]struct { + result1 agentclient.AgentState + result2 error + }) + } + fake.getStateReturnsOnCall[i] = struct { + result1 agentclient.AgentState + result2 error + }{result1, result2} +} + +func (fake *FakeVM) MigrateDisk() error { + fake.migrateDiskMutex.Lock() + ret, specificReturn := fake.migrateDiskReturnsOnCall[len(fake.migrateDiskArgsForCall)] + fake.migrateDiskArgsForCall = append(fake.migrateDiskArgsForCall, struct { + }{}) + stub := fake.MigrateDiskStub + fakeReturns := fake.migrateDiskReturns + fake.recordInvocation("MigrateDisk", []interface{}{}) + fake.migrateDiskMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) MigrateDiskCallCount() int { + fake.migrateDiskMutex.RLock() + defer fake.migrateDiskMutex.RUnlock() + return len(fake.migrateDiskArgsForCall) +} + +func (fake *FakeVM) MigrateDiskCalls(stub func() error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = stub +} + +func (fake *FakeVM) MigrateDiskReturns(result1 error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = nil + fake.migrateDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) MigrateDiskReturnsOnCall(i int, result1 error) { + fake.migrateDiskMutex.Lock() + defer fake.migrateDiskMutex.Unlock() + fake.MigrateDiskStub = nil + if fake.migrateDiskReturnsOnCall == nil { + fake.migrateDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.migrateDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) RunScript(arg1 string, arg2 map[string]interface{}) error { + fake.runScriptMutex.Lock() + ret, specificReturn := fake.runScriptReturnsOnCall[len(fake.runScriptArgsForCall)] + fake.runScriptArgsForCall = append(fake.runScriptArgsForCall, struct { + arg1 string + arg2 map[string]interface{} + }{arg1, arg2}) + stub := fake.RunScriptStub + fakeReturns := fake.runScriptReturns + fake.recordInvocation("RunScript", []interface{}{arg1, arg2}) + fake.runScriptMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) RunScriptCallCount() int { + fake.runScriptMutex.RLock() + defer fake.runScriptMutex.RUnlock() + return len(fake.runScriptArgsForCall) +} + +func (fake *FakeVM) RunScriptCalls(stub func(string, map[string]interface{}) error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = stub +} + +func (fake *FakeVM) RunScriptArgsForCall(i int) (string, map[string]interface{}) { + fake.runScriptMutex.RLock() + defer fake.runScriptMutex.RUnlock() + argsForCall := fake.runScriptArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVM) RunScriptReturns(result1 error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = nil + fake.runScriptReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) RunScriptReturnsOnCall(i int, result1 error) { + fake.runScriptMutex.Lock() + defer fake.runScriptMutex.Unlock() + fake.RunScriptStub = nil + if fake.runScriptReturnsOnCall == nil { + fake.runScriptReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.runScriptReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) Start() error { + fake.startMutex.Lock() + ret, specificReturn := fake.startReturnsOnCall[len(fake.startArgsForCall)] + fake.startArgsForCall = append(fake.startArgsForCall, struct { + }{}) + stub := fake.StartStub + fakeReturns := fake.startReturns + fake.recordInvocation("Start", []interface{}{}) + fake.startMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) StartCallCount() int { + fake.startMutex.RLock() + defer fake.startMutex.RUnlock() + return len(fake.startArgsForCall) +} + +func (fake *FakeVM) StartCalls(stub func() error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = stub +} + +func (fake *FakeVM) StartReturns(result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + fake.startReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) StartReturnsOnCall(i int, result1 error) { + fake.startMutex.Lock() + defer fake.startMutex.Unlock() + fake.StartStub = nil + if fake.startReturnsOnCall == nil { + fake.startReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.startReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) Stop() error { + fake.stopMutex.Lock() + ret, specificReturn := fake.stopReturnsOnCall[len(fake.stopArgsForCall)] + fake.stopArgsForCall = append(fake.stopArgsForCall, struct { + }{}) + stub := fake.StopStub + fakeReturns := fake.stopReturns + fake.recordInvocation("Stop", []interface{}{}) + fake.stopMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) StopCallCount() int { + fake.stopMutex.RLock() + defer fake.stopMutex.RUnlock() + return len(fake.stopArgsForCall) +} + +func (fake *FakeVM) StopCalls(stub func() error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = stub +} + +func (fake *FakeVM) StopReturns(result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + fake.stopReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) StopReturnsOnCall(i int, result1 error) { + fake.stopMutex.Lock() + defer fake.stopMutex.Unlock() + fake.StopStub = nil + if fake.stopReturnsOnCall == nil { + fake.stopReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.stopReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) UnmountDisk(arg1 disk.Disk) error { + fake.unmountDiskMutex.Lock() + ret, specificReturn := fake.unmountDiskReturnsOnCall[len(fake.unmountDiskArgsForCall)] + fake.unmountDiskArgsForCall = append(fake.unmountDiskArgsForCall, struct { + arg1 disk.Disk + }{arg1}) + stub := fake.UnmountDiskStub + fakeReturns := fake.unmountDiskReturns + fake.recordInvocation("UnmountDisk", []interface{}{arg1}) + fake.unmountDiskMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) UnmountDiskCallCount() int { + fake.unmountDiskMutex.RLock() + defer fake.unmountDiskMutex.RUnlock() + return len(fake.unmountDiskArgsForCall) +} + +func (fake *FakeVM) UnmountDiskCalls(stub func(disk.Disk) error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = stub +} + +func (fake *FakeVM) UnmountDiskArgsForCall(i int) disk.Disk { + fake.unmountDiskMutex.RLock() + defer fake.unmountDiskMutex.RUnlock() + argsForCall := fake.unmountDiskArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeVM) UnmountDiskReturns(result1 error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = nil + fake.unmountDiskReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) UnmountDiskReturnsOnCall(i int, result1 error) { + fake.unmountDiskMutex.Lock() + defer fake.unmountDiskMutex.Unlock() + fake.UnmountDiskStub = nil + if fake.unmountDiskReturnsOnCall == nil { + fake.unmountDiskReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.unmountDiskReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) UpdateDisks(arg1 manifest.DiskPool, arg2 ui.Stage) ([]disk.Disk, error) { + fake.updateDisksMutex.Lock() + ret, specificReturn := fake.updateDisksReturnsOnCall[len(fake.updateDisksArgsForCall)] + fake.updateDisksArgsForCall = append(fake.updateDisksArgsForCall, struct { + arg1 manifest.DiskPool + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.UpdateDisksStub + fakeReturns := fake.updateDisksReturns + fake.recordInvocation("UpdateDisks", []interface{}{arg1, arg2}) + fake.updateDisksMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeVM) UpdateDisksCallCount() int { + fake.updateDisksMutex.RLock() + defer fake.updateDisksMutex.RUnlock() + return len(fake.updateDisksArgsForCall) +} + +func (fake *FakeVM) UpdateDisksCalls(stub func(manifest.DiskPool, ui.Stage) ([]disk.Disk, error)) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = stub +} + +func (fake *FakeVM) UpdateDisksArgsForCall(i int) (manifest.DiskPool, ui.Stage) { + fake.updateDisksMutex.RLock() + defer fake.updateDisksMutex.RUnlock() + argsForCall := fake.updateDisksArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVM) UpdateDisksReturns(result1 []disk.Disk, result2 error) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = nil + fake.updateDisksReturns = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeVM) UpdateDisksReturnsOnCall(i int, result1 []disk.Disk, result2 error) { + fake.updateDisksMutex.Lock() + defer fake.updateDisksMutex.Unlock() + fake.UpdateDisksStub = nil + if fake.updateDisksReturnsOnCall == nil { + fake.updateDisksReturnsOnCall = make(map[int]struct { + result1 []disk.Disk + result2 error + }) + } + fake.updateDisksReturnsOnCall[i] = struct { + result1 []disk.Disk + result2 error + }{result1, result2} +} + +func (fake *FakeVM) WaitToBeRunning(arg1 int, arg2 time.Duration) error { + fake.waitToBeRunningMutex.Lock() + ret, specificReturn := fake.waitToBeRunningReturnsOnCall[len(fake.waitToBeRunningArgsForCall)] + fake.waitToBeRunningArgsForCall = append(fake.waitToBeRunningArgsForCall, struct { + arg1 int + arg2 time.Duration + }{arg1, arg2}) + stub := fake.WaitToBeRunningStub + fakeReturns := fake.waitToBeRunningReturns + fake.recordInvocation("WaitToBeRunning", []interface{}{arg1, arg2}) + fake.waitToBeRunningMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) WaitToBeRunningCallCount() int { + fake.waitToBeRunningMutex.RLock() + defer fake.waitToBeRunningMutex.RUnlock() + return len(fake.waitToBeRunningArgsForCall) +} + +func (fake *FakeVM) WaitToBeRunningCalls(stub func(int, time.Duration) error) { + fake.waitToBeRunningMutex.Lock() + defer fake.waitToBeRunningMutex.Unlock() + fake.WaitToBeRunningStub = stub +} + +func (fake *FakeVM) WaitToBeRunningArgsForCall(i int) (int, time.Duration) { + fake.waitToBeRunningMutex.RLock() + defer fake.waitToBeRunningMutex.RUnlock() + argsForCall := fake.waitToBeRunningArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVM) WaitToBeRunningReturns(result1 error) { + fake.waitToBeRunningMutex.Lock() + defer fake.waitToBeRunningMutex.Unlock() + fake.WaitToBeRunningStub = nil + fake.waitToBeRunningReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) WaitToBeRunningReturnsOnCall(i int, result1 error) { + fake.waitToBeRunningMutex.Lock() + defer fake.waitToBeRunningMutex.Unlock() + fake.WaitToBeRunningStub = nil + if fake.waitToBeRunningReturnsOnCall == nil { + fake.waitToBeRunningReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitToBeRunningReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) WaitUntilReady(arg1 time.Duration, arg2 time.Duration) error { + fake.waitUntilReadyMutex.Lock() + ret, specificReturn := fake.waitUntilReadyReturnsOnCall[len(fake.waitUntilReadyArgsForCall)] + fake.waitUntilReadyArgsForCall = append(fake.waitUntilReadyArgsForCall, struct { + arg1 time.Duration + arg2 time.Duration + }{arg1, arg2}) + stub := fake.WaitUntilReadyStub + fakeReturns := fake.waitUntilReadyReturns + fake.recordInvocation("WaitUntilReady", []interface{}{arg1, arg2}) + fake.waitUntilReadyMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeVM) WaitUntilReadyCallCount() int { + fake.waitUntilReadyMutex.RLock() + defer fake.waitUntilReadyMutex.RUnlock() + return len(fake.waitUntilReadyArgsForCall) +} + +func (fake *FakeVM) WaitUntilReadyCalls(stub func(time.Duration, time.Duration) error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = stub +} + +func (fake *FakeVM) WaitUntilReadyArgsForCall(i int) (time.Duration, time.Duration) { + fake.waitUntilReadyMutex.RLock() + defer fake.waitUntilReadyMutex.RUnlock() + argsForCall := fake.waitUntilReadyArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeVM) WaitUntilReadyReturns(result1 error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = nil + fake.waitUntilReadyReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) WaitUntilReadyReturnsOnCall(i int, result1 error) { + fake.waitUntilReadyMutex.Lock() + defer fake.waitUntilReadyMutex.Unlock() + fake.WaitUntilReadyStub = nil + if fake.waitUntilReadyReturnsOnCall == nil { + fake.waitUntilReadyReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.waitUntilReadyReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeVM) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeVM) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ vm.VM = new(FakeVM) From 740f175f00b11ebb823ef7cae7a3d4706dba7872 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 15:33:27 -0700 Subject: [PATCH 10/13] Replace hand-crafted `installation/manifest/fakes/` with counterfeiter --- cmd/create_env_test.go | 17 ++- installation/manifest/fakes/fake_parser.go | 26 ---- installation/manifest/fakes/fake_validator.go | 47 ------- .../manifest/manifestfakes/fake_parser.go | 123 ++++++++++++++++++ .../manifest/manifestfakes/fake_validator.go | 112 ++++++++++++++++ installation/manifest/parser.go | 4 + installation/manifest/parser_test.go | 16 +-- installation/manifest/validator.go | 2 + 8 files changed, 258 insertions(+), 89 deletions(-) delete mode 100644 installation/manifest/fakes/fake_parser.go delete mode 100644 installation/manifest/fakes/fake_validator.go create mode 100644 installation/manifest/manifestfakes/fake_parser.go create mode 100644 installation/manifest/manifestfakes/fake_validator.go diff --git a/cmd/create_env_test.go b/cmd/create_env_test.go index 3291f855e0..5df4cd1df0 100644 --- a/cmd/create_env_test.go +++ b/cmd/create_env_test.go @@ -40,7 +40,7 @@ import ( biinstall "github.com/cloudfoundry/bosh-cli/v7/installation" "github.com/cloudfoundry/bosh-cli/v7/installation/installationfakes" biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - fakebiinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest/fakes" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest/manifestfakes" bitarball "github.com/cloudfoundry/bosh-cli/v7/installation/tarball" boshrel "github.com/cloudfoundry/bosh-cli/v7/release" boshjob "github.com/cloudfoundry/bosh-cli/v7/release/job" @@ -95,7 +95,7 @@ var _ = Describe("CreateEnvCmd", func() { fakeStemcellManagerFactory *fakebistemcell.FakeManagerFactory fakeReleaseSetParser *fakebirelsetmanifest.FakeParser - fakeInstallationParser *fakebiinstallmanifest.FakeParser + fakeInstallationParser *manifestfakes.FakeParser fakeDeploymentParser *fakebideplmanifest.FakeParser fakeDeploymentTemplateFactory *fakebidepltpl.FakeDeploymentTemplateFactory mockLegacyDeploymentStateMigrator *configfakes.FakeLegacyDeploymentStateMigrator @@ -173,7 +173,7 @@ var _ = Describe("CreateEnvCmd", func() { fakeStemcellManagerFactory = fakebistemcell.NewFakeManagerFactory() fakeReleaseSetParser = fakebirelsetmanifest.NewFakeParser() - fakeInstallationParser = fakebiinstallmanifest.NewFakeParser() + fakeInstallationParser = &manifestfakes.FakeParser{} fakeDeploymentParser = &fakebideplmanifest.FakeParser{} fakeDeploymentTemplateFactory = &fakebidepltpl.FakeDeploymentTemplateFactory{} @@ -395,7 +395,7 @@ var _ = Describe("CreateEnvCmd", func() { template := bidepltpl.NewDeploymentTemplate([]byte("--- {\"test\":true}")) fakeDeploymentTemplateFactory.NewDeploymentTemplateFromPathReturns(template, nil) fakeDeploymentParser.ParseReturns(boshDeploymentManifest, nil) - fakeInstallationParser.ParseManifest = installationManifest + fakeInstallationParser.ParseReturns(installationManifest, nil) installationPath := filepath.Join("fake-install-dir", "fake-installation-id") target := biinstall.NewTarget(installationPath, "") @@ -463,7 +463,8 @@ var _ = Describe("CreateEnvCmd", func() { err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) - Expect(fakeInstallationParser.ParsePath).To(Equal(deploymentManifestPath)) + pathArg, _, _, _ := fakeInstallationParser.ParseArgsForCall(0) + Expect(pathArg).To(Equal(deploymentManifestPath)) Expect(mockLegacyDeploymentStateMigrator.MigrateIfExistsCallCount()).To(Equal(0)) }) @@ -475,7 +476,8 @@ var _ = Describe("CreateEnvCmd", func() { err = command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) - Expect(fakeInstallationParser.ParsePath).To(Equal(deploymentManifestPath)) + pathArg, _, _, _ := fakeInstallationParser.ParseArgsForCall(0) + Expect(pathArg).To(Equal(deploymentManifestPath)) Expect(mockLegacyDeploymentStateMigrator.MigrateIfExistsCallCount()).To(Equal(1)) Expect(stdOut).To(gbytes.Say("Deployment manifest: '" + regexp.QuoteMeta(filepath.Join("/", "path", "to", "manifest.yml")) + "'")) @@ -501,7 +503,8 @@ var _ = Describe("CreateEnvCmd", func() { It("parses the installation manifest", func() { err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) - Expect(fakeInstallationParser.ParsePath).To(Equal(deploymentManifestPath)) + pathArg, _, _, _ := fakeInstallationParser.ParseArgsForCall(0) + Expect(pathArg).To(Equal(deploymentManifestPath)) }) It("parses the deployment manifest", func() { diff --git a/installation/manifest/fakes/fake_parser.go b/installation/manifest/fakes/fake_parser.go deleted file mode 100644 index 31393d5f31..0000000000 --- a/installation/manifest/fakes/fake_parser.go +++ /dev/null @@ -1,26 +0,0 @@ -package fakes - -import ( - "github.com/cppforlife/go-patch/patch" - - boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" - biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" -) - -type FakeParser struct { - ParsePath string - ReleaseSetManifest birelsetmanifest.Manifest - ParseManifest biinstallmanifest.Manifest - ParseErr error -} - -func NewFakeParser() *FakeParser { - return &FakeParser{} -} - -func (p *FakeParser) Parse(path string, vars boshtpl.Variables, op patch.Op, releaseSetManifest birelsetmanifest.Manifest) (biinstallmanifest.Manifest, error) { - p.ParsePath = path - p.ReleaseSetManifest = releaseSetManifest - return p.ParseManifest, p.ParseErr -} diff --git a/installation/manifest/fakes/fake_validator.go b/installation/manifest/fakes/fake_validator.go deleted file mode 100644 index a5024225a9..0000000000 --- a/installation/manifest/fakes/fake_validator.go +++ /dev/null @@ -1,47 +0,0 @@ -package fakes - -import ( - bosherr "github.com/cloudfoundry/bosh-utils/errors" - - biinstallmanifest "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" -) - -type FakeValidator struct { - ValidateInputs []ValidateInput - validateOutputs []ValidateOutput -} - -func NewFakeValidator() *FakeValidator { - return &FakeValidator{ - ValidateInputs: []ValidateInput{}, - validateOutputs: []ValidateOutput{}, - } -} - -type ValidateInput struct { - InstallationManifest biinstallmanifest.Manifest - ReleaseSetManifest birelsetmanifest.Manifest -} - -type ValidateOutput struct { - Err error -} - -func (v *FakeValidator) Validate(installationManifest biinstallmanifest.Manifest, releaseSetManifest birelsetmanifest.Manifest) error { - v.ValidateInputs = append(v.ValidateInputs, ValidateInput{ - InstallationManifest: installationManifest, - ReleaseSetManifest: releaseSetManifest, - }) - - if len(v.validateOutputs) == 0 { - return bosherr.Errorf("Unexpected FakeValidator.Validate(manifest) called with installation manifest: %#v, release set manifest: %#v", installationManifest, releaseSetManifest) - } - validateOutput := v.validateOutputs[0] - v.validateOutputs = v.validateOutputs[1:] - return validateOutput.Err -} - -func (v *FakeValidator) SetValidateBehavior(outputs []ValidateOutput) { - v.validateOutputs = outputs -} diff --git a/installation/manifest/manifestfakes/fake_parser.go b/installation/manifest/manifestfakes/fake_parser.go new file mode 100644 index 0000000000..fdf8096f15 --- /dev/null +++ b/installation/manifest/manifestfakes/fake_parser.go @@ -0,0 +1,123 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package manifestfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/director/template" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" + manifesta "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" + "github.com/cppforlife/go-patch/patch" +) + +type FakeParser struct { + ParseStub func(string, template.Variables, patch.Op, manifesta.Manifest) (manifest.Manifest, error) + parseMutex sync.RWMutex + parseArgsForCall []struct { + arg1 string + arg2 template.Variables + arg3 patch.Op + arg4 manifesta.Manifest + } + parseReturns struct { + result1 manifest.Manifest + result2 error + } + parseReturnsOnCall map[int]struct { + result1 manifest.Manifest + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeParser) Parse(arg1 string, arg2 template.Variables, arg3 patch.Op, arg4 manifesta.Manifest) (manifest.Manifest, error) { + fake.parseMutex.Lock() + ret, specificReturn := fake.parseReturnsOnCall[len(fake.parseArgsForCall)] + fake.parseArgsForCall = append(fake.parseArgsForCall, struct { + arg1 string + arg2 template.Variables + arg3 patch.Op + arg4 manifesta.Manifest + }{arg1, arg2, arg3, arg4}) + stub := fake.ParseStub + fakeReturns := fake.parseReturns + fake.recordInvocation("Parse", []interface{}{arg1, arg2, arg3, arg4}) + fake.parseMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3, arg4) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeParser) ParseCallCount() int { + fake.parseMutex.RLock() + defer fake.parseMutex.RUnlock() + return len(fake.parseArgsForCall) +} + +func (fake *FakeParser) ParseCalls(stub func(string, template.Variables, patch.Op, manifesta.Manifest) (manifest.Manifest, error)) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = stub +} + +func (fake *FakeParser) ParseArgsForCall(i int) (string, template.Variables, patch.Op, manifesta.Manifest) { + fake.parseMutex.RLock() + defer fake.parseMutex.RUnlock() + argsForCall := fake.parseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 +} + +func (fake *FakeParser) ParseReturns(result1 manifest.Manifest, result2 error) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = nil + fake.parseReturns = struct { + result1 manifest.Manifest + result2 error + }{result1, result2} +} + +func (fake *FakeParser) ParseReturnsOnCall(i int, result1 manifest.Manifest, result2 error) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = nil + if fake.parseReturnsOnCall == nil { + fake.parseReturnsOnCall = make(map[int]struct { + result1 manifest.Manifest + result2 error + }) + } + fake.parseReturnsOnCall[i] = struct { + result1 manifest.Manifest + result2 error + }{result1, result2} +} + +func (fake *FakeParser) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeParser) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ manifest.Parser = new(FakeParser) diff --git a/installation/manifest/manifestfakes/fake_validator.go b/installation/manifest/manifestfakes/fake_validator.go new file mode 100644 index 0000000000..e45013bf3b --- /dev/null +++ b/installation/manifest/manifestfakes/fake_validator.go @@ -0,0 +1,112 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package manifestfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" + manifesta "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" +) + +type FakeValidator struct { + ValidateStub func(manifest.Manifest, manifesta.Manifest) error + validateMutex sync.RWMutex + validateArgsForCall []struct { + arg1 manifest.Manifest + arg2 manifesta.Manifest + } + validateReturns struct { + result1 error + } + validateReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeValidator) Validate(arg1 manifest.Manifest, arg2 manifesta.Manifest) error { + fake.validateMutex.Lock() + ret, specificReturn := fake.validateReturnsOnCall[len(fake.validateArgsForCall)] + fake.validateArgsForCall = append(fake.validateArgsForCall, struct { + arg1 manifest.Manifest + arg2 manifesta.Manifest + }{arg1, arg2}) + stub := fake.ValidateStub + fakeReturns := fake.validateReturns + fake.recordInvocation("Validate", []interface{}{arg1, arg2}) + fake.validateMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeValidator) ValidateCallCount() int { + fake.validateMutex.RLock() + defer fake.validateMutex.RUnlock() + return len(fake.validateArgsForCall) +} + +func (fake *FakeValidator) ValidateCalls(stub func(manifest.Manifest, manifesta.Manifest) error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = stub +} + +func (fake *FakeValidator) ValidateArgsForCall(i int) (manifest.Manifest, manifesta.Manifest) { + fake.validateMutex.RLock() + defer fake.validateMutex.RUnlock() + argsForCall := fake.validateArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *FakeValidator) ValidateReturns(result1 error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = nil + fake.validateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeValidator) ValidateReturnsOnCall(i int, result1 error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = nil + if fake.validateReturnsOnCall == nil { + fake.validateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.validateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeValidator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeValidator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ manifest.Validator = new(FakeValidator) diff --git a/installation/manifest/parser.go b/installation/manifest/parser.go index 4b0e08be2c..e117240936 100644 --- a/installation/manifest/parser.go +++ b/installation/manifest/parser.go @@ -17,6 +17,10 @@ import ( birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Parser + type Parser interface { Parse(string, boshtpl.Variables, patch.Op, birelsetmanifest.Manifest) (Manifest, error) } diff --git a/installation/manifest/parser_test.go b/installation/manifest/parser_test.go index bff40d6285..bdd280e3ea 100644 --- a/installation/manifest/parser_test.go +++ b/installation/manifest/parser_test.go @@ -13,7 +13,7 @@ import ( boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" "github.com/cloudfoundry/bosh-cli/v7/installation/manifest" - "github.com/cloudfoundry/bosh-cli/v7/installation/manifest/fakes" + "github.com/cloudfoundry/bosh-cli/v7/installation/manifest/manifestfakes" birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" ) @@ -30,14 +30,12 @@ var _ = Describe("Parser", func() { fakeUUIDGenerator *fakeuuid.FakeGenerator parser manifest.Parser logger boshlog.Logger - fakeValidator *fakes.FakeValidator + fakeValidator *manifestfakes.FakeValidator fixtures manifestFixtures ) BeforeEach(func() { - fakeValidator = fakes.NewFakeValidator() - fakeValidator.SetValidateBehavior([]fakes.ValidateOutput{ - {Err: nil}, - }) + fakeValidator = &manifestfakes.FakeValidator{} + fakeValidator.ValidateReturns(nil) fakeFs = fakesys.NewFakeFileSystem() logger = boshlog.NewLogger(boshlog.LevelNone) fakeUUIDGenerator = fakeuuid.NewFakeGenerator() @@ -115,6 +113,8 @@ cloud_provider: }, Mbus: "http://fake-mbus-user:fake-mbus-password@0.0.0.0:6868", })) + + Expect(fakeValidator.ValidateCallCount()).To(Equal(1)) }) }) @@ -450,9 +450,7 @@ cloud_provider: err := fakeFs.WriteFileString(comboManifestPath, fixtures.validManifest) Expect(err).ToNot(HaveOccurred()) - fakeValidator.SetValidateBehavior([]fakes.ValidateOutput{ - {Err: errors.New("nope")}, - }) + fakeValidator.ValidateReturns(errors.New("nope")) _, err = parser.Parse(comboManifestPath, boshtpl.StaticVariables{}, patch.Ops{}, releaseSetManifest) Expect(err).To(HaveOccurred()) diff --git a/installation/manifest/validator.go b/installation/manifest/validator.go index 12934d4c46..2e36d05646 100644 --- a/installation/manifest/validator.go +++ b/installation/manifest/validator.go @@ -10,6 +10,8 @@ import ( birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" ) +//counterfeiter:generate . Validator + type Validator interface { Validate(Manifest, birelsetmanifest.Manifest) error } From 2390f46c5bfce59ad6d82cf5b2765b9b1657d8dd Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 15:47:35 -0700 Subject: [PATCH 11/13] Replace hand-crafted `release/set/manifest/fakes/` with counterfeiter --- cmd/create_env_test.go | 8 +- release/set/manifest/fakes/fake_parser.go | 23 ---- release/set/manifest/fakes/fake_validator.go | 44 ------- .../set/manifest/manifestfakes/fake_parser.go | 120 ++++++++++++++++++ .../manifest/manifestfakes/fake_validator.go | 109 ++++++++++++++++ release/set/manifest/parser.go | 4 + release/set/manifest/parser_test.go | 20 +-- release/set/manifest/validator.go | 2 + 8 files changed, 249 insertions(+), 81 deletions(-) delete mode 100644 release/set/manifest/fakes/fake_parser.go delete mode 100644 release/set/manifest/fakes/fake_validator.go create mode 100644 release/set/manifest/manifestfakes/fake_parser.go create mode 100644 release/set/manifest/manifestfakes/fake_validator.go diff --git a/cmd/create_env_test.go b/cmd/create_env_test.go index 5df4cd1df0..f785a3a7c4 100644 --- a/cmd/create_env_test.go +++ b/cmd/create_env_test.go @@ -48,7 +48,7 @@ import ( fakebirel "github.com/cloudfoundry/bosh-cli/v7/release/releasefakes" . "github.com/cloudfoundry/bosh-cli/v7/release/resource" birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" - fakebirelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/fakes" + setmanifestfakes "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/manifestfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" "github.com/cloudfoundry/bosh-cli/v7/stemcell/mockfakes" fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" @@ -94,7 +94,7 @@ var _ = Describe("CreateEnvCmd", func() { mockStemcellManager *mockfakes.FakeManager fakeStemcellManagerFactory *fakebistemcell.FakeManagerFactory - fakeReleaseSetParser *fakebirelsetmanifest.FakeParser + fakeReleaseSetParser *setmanifestfakes.FakeParser fakeInstallationParser *manifestfakes.FakeParser fakeDeploymentParser *fakebideplmanifest.FakeParser fakeDeploymentTemplateFactory *fakebidepltpl.FakeDeploymentTemplateFactory @@ -172,7 +172,7 @@ var _ = Describe("CreateEnvCmd", func() { mockStemcellManager = &mockfakes.FakeManager{} fakeStemcellManagerFactory = fakebistemcell.NewFakeManagerFactory() - fakeReleaseSetParser = fakebirelsetmanifest.NewFakeParser() + fakeReleaseSetParser = &setmanifestfakes.FakeParser{} fakeInstallationParser = &manifestfakes.FakeParser{} fakeDeploymentParser = &fakebideplmanifest.FakeParser{} fakeDeploymentTemplateFactory = &fakebidepltpl.FakeDeploymentTemplateFactory{} @@ -391,7 +391,7 @@ var _ = Describe("CreateEnvCmd", func() { mockStemcellManager.DeleteUnusedReturns(nil) - fakeReleaseSetParser.ParseManifest = releaseSetManifest + fakeReleaseSetParser.ParseReturns(releaseSetManifest, nil) template := bidepltpl.NewDeploymentTemplate([]byte("--- {\"test\":true}")) fakeDeploymentTemplateFactory.NewDeploymentTemplateFromPathReturns(template, nil) fakeDeploymentParser.ParseReturns(boshDeploymentManifest, nil) diff --git a/release/set/manifest/fakes/fake_parser.go b/release/set/manifest/fakes/fake_parser.go deleted file mode 100644 index 8bf0ea5fc1..0000000000 --- a/release/set/manifest/fakes/fake_parser.go +++ /dev/null @@ -1,23 +0,0 @@ -package fakes - -import ( - "github.com/cppforlife/go-patch/patch" - - boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" - birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" -) - -type FakeParser struct { - ParsePath string - ParseManifest birelsetmanifest.Manifest - ParseErr error -} - -func NewFakeParser() *FakeParser { - return &FakeParser{} -} - -func (p *FakeParser) Parse(path string, vars boshtpl.Variables, op patch.Op) (birelsetmanifest.Manifest, error) { - p.ParsePath = path - return p.ParseManifest, p.ParseErr -} diff --git a/release/set/manifest/fakes/fake_validator.go b/release/set/manifest/fakes/fake_validator.go deleted file mode 100644 index a554c9a435..0000000000 --- a/release/set/manifest/fakes/fake_validator.go +++ /dev/null @@ -1,44 +0,0 @@ -package fakes - -import ( - bosherr "github.com/cloudfoundry/bosh-utils/errors" - - birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" -) - -type FakeValidator struct { - ValidateInputs []ValidateInput - validateOutputs []ValidateOutput -} - -func NewFakeValidator() *FakeValidator { - return &FakeValidator{ - ValidateInputs: []ValidateInput{}, - validateOutputs: []ValidateOutput{}, - } -} - -type ValidateInput struct { - Manifest birelsetmanifest.Manifest -} - -type ValidateOutput struct { - Err error -} - -func (v *FakeValidator) Validate(manifest birelsetmanifest.Manifest) error { - v.ValidateInputs = append(v.ValidateInputs, ValidateInput{ - Manifest: manifest, - }) - - if len(v.validateOutputs) == 0 { - return bosherr.Errorf("Unexpected FakeValidator.Validate(manifest) called with manifest: %#v", manifest) - } - validateOutput := v.validateOutputs[0] - v.validateOutputs = v.validateOutputs[1:] - return validateOutput.Err -} - -func (v *FakeValidator) SetValidateBehavior(outputs []ValidateOutput) { - v.validateOutputs = outputs -} diff --git a/release/set/manifest/manifestfakes/fake_parser.go b/release/set/manifest/manifestfakes/fake_parser.go new file mode 100644 index 0000000000..99089dc402 --- /dev/null +++ b/release/set/manifest/manifestfakes/fake_parser.go @@ -0,0 +1,120 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package manifestfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/director/template" + "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" + "github.com/cppforlife/go-patch/patch" +) + +type FakeParser struct { + ParseStub func(string, template.Variables, patch.Op) (manifest.Manifest, error) + parseMutex sync.RWMutex + parseArgsForCall []struct { + arg1 string + arg2 template.Variables + arg3 patch.Op + } + parseReturns struct { + result1 manifest.Manifest + result2 error + } + parseReturnsOnCall map[int]struct { + result1 manifest.Manifest + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeParser) Parse(arg1 string, arg2 template.Variables, arg3 patch.Op) (manifest.Manifest, error) { + fake.parseMutex.Lock() + ret, specificReturn := fake.parseReturnsOnCall[len(fake.parseArgsForCall)] + fake.parseArgsForCall = append(fake.parseArgsForCall, struct { + arg1 string + arg2 template.Variables + arg3 patch.Op + }{arg1, arg2, arg3}) + stub := fake.ParseStub + fakeReturns := fake.parseReturns + fake.recordInvocation("Parse", []interface{}{arg1, arg2, arg3}) + fake.parseMutex.Unlock() + if stub != nil { + return stub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeParser) ParseCallCount() int { + fake.parseMutex.RLock() + defer fake.parseMutex.RUnlock() + return len(fake.parseArgsForCall) +} + +func (fake *FakeParser) ParseCalls(stub func(string, template.Variables, patch.Op) (manifest.Manifest, error)) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = stub +} + +func (fake *FakeParser) ParseArgsForCall(i int) (string, template.Variables, patch.Op) { + fake.parseMutex.RLock() + defer fake.parseMutex.RUnlock() + argsForCall := fake.parseArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *FakeParser) ParseReturns(result1 manifest.Manifest, result2 error) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = nil + fake.parseReturns = struct { + result1 manifest.Manifest + result2 error + }{result1, result2} +} + +func (fake *FakeParser) ParseReturnsOnCall(i int, result1 manifest.Manifest, result2 error) { + fake.parseMutex.Lock() + defer fake.parseMutex.Unlock() + fake.ParseStub = nil + if fake.parseReturnsOnCall == nil { + fake.parseReturnsOnCall = make(map[int]struct { + result1 manifest.Manifest + result2 error + }) + } + fake.parseReturnsOnCall[i] = struct { + result1 manifest.Manifest + result2 error + }{result1, result2} +} + +func (fake *FakeParser) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeParser) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ manifest.Parser = new(FakeParser) diff --git a/release/set/manifest/manifestfakes/fake_validator.go b/release/set/manifest/manifestfakes/fake_validator.go new file mode 100644 index 0000000000..3519da1753 --- /dev/null +++ b/release/set/manifest/manifestfakes/fake_validator.go @@ -0,0 +1,109 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package manifestfakes + +import ( + "sync" + + "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" +) + +type FakeValidator struct { + ValidateStub func(manifest.Manifest) error + validateMutex sync.RWMutex + validateArgsForCall []struct { + arg1 manifest.Manifest + } + validateReturns struct { + result1 error + } + validateReturnsOnCall map[int]struct { + result1 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeValidator) Validate(arg1 manifest.Manifest) error { + fake.validateMutex.Lock() + ret, specificReturn := fake.validateReturnsOnCall[len(fake.validateArgsForCall)] + fake.validateArgsForCall = append(fake.validateArgsForCall, struct { + arg1 manifest.Manifest + }{arg1}) + stub := fake.ValidateStub + fakeReturns := fake.validateReturns + fake.recordInvocation("Validate", []interface{}{arg1}) + fake.validateMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeValidator) ValidateCallCount() int { + fake.validateMutex.RLock() + defer fake.validateMutex.RUnlock() + return len(fake.validateArgsForCall) +} + +func (fake *FakeValidator) ValidateCalls(stub func(manifest.Manifest) error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = stub +} + +func (fake *FakeValidator) ValidateArgsForCall(i int) manifest.Manifest { + fake.validateMutex.RLock() + defer fake.validateMutex.RUnlock() + argsForCall := fake.validateArgsForCall[i] + return argsForCall.arg1 +} + +func (fake *FakeValidator) ValidateReturns(result1 error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = nil + fake.validateReturns = struct { + result1 error + }{result1} +} + +func (fake *FakeValidator) ValidateReturnsOnCall(i int, result1 error) { + fake.validateMutex.Lock() + defer fake.validateMutex.Unlock() + fake.ValidateStub = nil + if fake.validateReturnsOnCall == nil { + fake.validateReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.validateReturnsOnCall[i] = struct { + result1 error + }{result1} +} + +func (fake *FakeValidator) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeValidator) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ manifest.Validator = new(FakeValidator) diff --git a/release/set/manifest/parser.go b/release/set/manifest/parser.go index f120359124..69ea7957de 100644 --- a/release/set/manifest/parser.go +++ b/release/set/manifest/parser.go @@ -12,6 +12,10 @@ import ( birelmanifest "github.com/cloudfoundry/bosh-cli/v7/release/manifest" ) +//go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate + +//counterfeiter:generate . Parser + type Parser interface { Parse(string, boshtpl.Variables, patch.Op) (Manifest, error) } diff --git a/release/set/manifest/parser_test.go b/release/set/manifest/parser_test.go index feee15ae08..22ff8e59c1 100644 --- a/release/set/manifest/parser_test.go +++ b/release/set/manifest/parser_test.go @@ -12,25 +12,25 @@ import ( boshtpl "github.com/cloudfoundry/bosh-cli/v7/director/template" boshman "github.com/cloudfoundry/bosh-cli/v7/release/manifest" "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" - "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/fakes" + "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/manifestfakes" ) var _ = Describe("Parser", func() { var ( - fs *fakesys.FakeFileSystem - validator *fakes.FakeValidator - parser manifest.Parser + fs *fakesys.FakeFileSystem + fakeValidator *manifestfakes.FakeValidator + parser manifest.Parser ) comboManifestPath := "/path/to/manifest/fake-deployment-manifest" BeforeEach(func() { - validator = fakes.NewFakeValidator() - validator.SetValidateBehavior([]fakes.ValidateOutput{{Err: nil}}) + fakeValidator = &manifestfakes.FakeValidator{} + fakeValidator.ValidateReturns(nil) fs = fakesys.NewFakeFileSystem() logger := boshlog.NewLogger(boshlog.LevelNone) - parser = manifest.NewParser(fs, logger, validator) + parser = manifest.NewParser(fs, logger, fakeValidator) err := fs.WriteFileString(comboManifestPath, ` --- @@ -197,6 +197,8 @@ releases: }, }, })) + + Expect(fakeValidator.ValidateCallCount()).To(Equal(1)) }) It("interpolates variables and later resolves their values", func() { @@ -245,9 +247,7 @@ releases: }) It("handles errors validating the release set manifest", func() { - validator.SetValidateBehavior([]fakes.ValidateOutput{ - {Err: errors.New("couldn't validate that")}, - }) + fakeValidator.ValidateReturns(errors.New("couldn't validate that")) _, err := parser.Parse(comboManifestPath, boshtpl.StaticVariables{}, patch.Ops{}) Expect(err).To(HaveOccurred()) diff --git a/release/set/manifest/validator.go b/release/set/manifest/validator.go index 40445aa8cb..6927e01866 100644 --- a/release/set/manifest/validator.go +++ b/release/set/manifest/validator.go @@ -8,6 +8,8 @@ import ( boshlog "github.com/cloudfoundry/bosh-utils/logger" ) +//counterfeiter:generate . Validator + type Validator interface { Validate(Manifest) error } From 490ee9f3bb837e2b0233d3093a39ba2eddaf8099 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 15:55:30 -0700 Subject: [PATCH 12/13] Relocate `stemcell/mockfakes/` to default location --- cmd/create_env_test.go | 19 +- deployment/manager_test.go | 7 +- stemcell/manager.go | 4 +- stemcell/mockfakes/fake_manager.go | 325 ----------------------- stemcell/stemcellfakes/fake_manager.go | 345 +++++++++++++++++++++---- 5 files changed, 302 insertions(+), 398 deletions(-) delete mode 100644 stemcell/mockfakes/fake_manager.go diff --git a/cmd/create_env_test.go b/cmd/create_env_test.go index f785a3a7c4..835d63afc5 100644 --- a/cmd/create_env_test.go +++ b/cmd/create_env_test.go @@ -50,8 +50,7 @@ import ( birelsetmanifest "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest" setmanifestfakes "github.com/cloudfoundry/bosh-cli/v7/release/set/manifest/manifestfakes" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - "github.com/cloudfoundry/bosh-cli/v7/stemcell/mockfakes" - fakebistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" + "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" boshui "github.com/cloudfoundry/bosh-cli/v7/ui" fakeui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -90,9 +89,9 @@ var _ = Describe("CreateEnvCmd", func() { mockVMManagerFactory *vmfakes.FakeManagerFactory fakeVMManager *vmfakes.FakeManager - fakeStemcellExtractor *fakebistemcell.FakeExtractor - mockStemcellManager *mockfakes.FakeManager - fakeStemcellManagerFactory *fakebistemcell.FakeManagerFactory + fakeStemcellExtractor *stemcellfakes.FakeExtractor + mockStemcellManager *stemcellfakes.FakeManager + fakeStemcellManagerFactory *stemcellfakes.FakeManagerFactory fakeReleaseSetParser *setmanifestfakes.FakeParser fakeInstallationParser *manifestfakes.FakeParser @@ -168,9 +167,9 @@ var _ = Describe("CreateEnvCmd", func() { fakeVMManager = &vmfakes.FakeManager{} mockVMManagerFactory.NewManagerReturns(fakeVMManager) - fakeStemcellExtractor = fakebistemcell.NewFakeExtractor() - mockStemcellManager = &mockfakes.FakeManager{} - fakeStemcellManagerFactory = fakebistemcell.NewFakeManagerFactory() + fakeStemcellExtractor = stemcellfakes.NewFakeExtractor() + mockStemcellManager = &stemcellfakes.FakeManager{} + fakeStemcellManagerFactory = stemcellfakes.NewFakeManagerFactory() fakeReleaseSetParser = &setmanifestfakes.FakeParser{} fakeInstallationParser = &manifestfakes.FakeParser{} @@ -376,7 +375,7 @@ var _ = Describe("CreateEnvCmd", func() { stemcellTarballPath = filepath.Join("/", "stemcell", "tarball", "path") - cloudStemcell = fakebistemcell.NewFakeCloudStemcell( + cloudStemcell = stemcellfakes.NewFakeCloudStemcell( "fake-stemcell-cid", "fake-stemcell-name", "fake-stemcell-version", stemcellApiVersion) mockCloud = &cloudfakes.FakeCloud{} @@ -577,7 +576,7 @@ var _ = Describe("CreateEnvCmd", func() { It("extracts the stemcell", func() { err := command.Run(fakeStage, defaultCreateEnvOpts) Expect(err).NotTo(HaveOccurred()) - Expect(fakeStemcellExtractor.ExtractInputs).To(Equal([]fakebistemcell.ExtractInput{ + Expect(fakeStemcellExtractor.ExtractInputs).To(Equal([]stemcellfakes.ExtractInput{ {TarballPath: stemcellTarballPath}, })) }) diff --git a/deployment/manager_test.go b/deployment/manager_test.go index 55ed658644..44fc35c3d0 100644 --- a/deployment/manager_test.go +++ b/deployment/manager_test.go @@ -1,6 +1,7 @@ package deployment_test import ( + "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" boshlog "github.com/cloudfoundry/bosh-utils/logger" boshsys "github.com/cloudfoundry/bosh-utils/system" fakesys "github.com/cloudfoundry/bosh-utils/system/fakes" @@ -23,8 +24,6 @@ import ( bisshtunnel "github.com/cloudfoundry/bosh-cli/v7/deployment/sshtunnel" bivm "github.com/cloudfoundry/bosh-cli/v7/deployment/vm" bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - "github.com/cloudfoundry/bosh-cli/v7/stemcell/mockfakes" - "github.com/cloudfoundry/bosh-cli/v7/stemcell/stemcellfakes" fakebiui "github.com/cloudfoundry/bosh-cli/v7/ui/fakes" ) @@ -33,7 +32,7 @@ var _ = Describe("Manager", func() { var ( mockInstanceManager *instancefakes.FakeManager mockDiskManager *diskfakes.FakeManager - mockStemcellManager *mockfakes.FakeManager + mockStemcellManager *stemcellfakes.FakeManager mockDeploymentFactory *deploymentfakes.FakeFactory mockDeployment *deploymentfakes.FakeDeployment @@ -47,7 +46,7 @@ var _ = Describe("Manager", func() { BeforeEach(func() { mockInstanceManager = &instancefakes.FakeManager{} mockDiskManager = &diskfakes.FakeManager{} - mockStemcellManager = &mockfakes.FakeManager{} + mockStemcellManager = &stemcellfakes.FakeManager{} mockDeploymentFactory = &deploymentfakes.FakeFactory{} mockDeployment = &deploymentfakes.FakeDeployment{} diff --git a/stemcell/manager.go b/stemcell/manager.go index 2b55e9c503..918a631469 100644 --- a/stemcell/manager.go +++ b/stemcell/manager.go @@ -14,9 +14,7 @@ import ( //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate -// stemcellfakes already contains a hand-written FakeManager used elsewhere, so this -// counterfeiter-generated one for full mock coverage lives in a separate package. -//counterfeiter:generate -o mockfakes/fake_manager.go . Manager +//counterfeiter:generate . Manager type Manager interface { FindCurrent() ([]CloudStemcell, error) diff --git a/stemcell/mockfakes/fake_manager.go b/stemcell/mockfakes/fake_manager.go deleted file mode 100644 index 6b6a602005..0000000000 --- a/stemcell/mockfakes/fake_manager.go +++ /dev/null @@ -1,325 +0,0 @@ -// Code generated by counterfeiter. DO NOT EDIT. -package mockfakes - -import ( - "sync" - - "github.com/cloudfoundry/bosh-cli/v7/stemcell" - "github.com/cloudfoundry/bosh-cli/v7/ui" -) - -type FakeManager struct { - DeleteUnusedStub func(ui.Stage) error - deleteUnusedMutex sync.RWMutex - deleteUnusedArgsForCall []struct { - arg1 ui.Stage - } - deleteUnusedReturns struct { - result1 error - } - deleteUnusedReturnsOnCall map[int]struct { - result1 error - } - FindCurrentStub func() ([]stemcell.CloudStemcell, error) - findCurrentMutex sync.RWMutex - findCurrentArgsForCall []struct { - } - findCurrentReturns struct { - result1 []stemcell.CloudStemcell - result2 error - } - findCurrentReturnsOnCall map[int]struct { - result1 []stemcell.CloudStemcell - result2 error - } - FindUnusedStub func() ([]stemcell.CloudStemcell, error) - findUnusedMutex sync.RWMutex - findUnusedArgsForCall []struct { - } - findUnusedReturns struct { - result1 []stemcell.CloudStemcell - result2 error - } - findUnusedReturnsOnCall map[int]struct { - result1 []stemcell.CloudStemcell - result2 error - } - UploadStub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error) - uploadMutex sync.RWMutex - uploadArgsForCall []struct { - arg1 stemcell.ExtractedStemcell - arg2 ui.Stage - } - uploadReturns struct { - result1 stemcell.CloudStemcell - result2 error - } - uploadReturnsOnCall map[int]struct { - result1 stemcell.CloudStemcell - result2 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeManager) DeleteUnused(arg1 ui.Stage) error { - fake.deleteUnusedMutex.Lock() - ret, specificReturn := fake.deleteUnusedReturnsOnCall[len(fake.deleteUnusedArgsForCall)] - fake.deleteUnusedArgsForCall = append(fake.deleteUnusedArgsForCall, struct { - arg1 ui.Stage - }{arg1}) - stub := fake.DeleteUnusedStub - fakeReturns := fake.deleteUnusedReturns - fake.recordInvocation("DeleteUnused", []interface{}{arg1}) - fake.deleteUnusedMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeManager) DeleteUnusedCallCount() int { - fake.deleteUnusedMutex.RLock() - defer fake.deleteUnusedMutex.RUnlock() - return len(fake.deleteUnusedArgsForCall) -} - -func (fake *FakeManager) DeleteUnusedCalls(stub func(ui.Stage) error) { - fake.deleteUnusedMutex.Lock() - defer fake.deleteUnusedMutex.Unlock() - fake.DeleteUnusedStub = stub -} - -func (fake *FakeManager) DeleteUnusedArgsForCall(i int) ui.Stage { - fake.deleteUnusedMutex.RLock() - defer fake.deleteUnusedMutex.RUnlock() - argsForCall := fake.deleteUnusedArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeManager) DeleteUnusedReturns(result1 error) { - fake.deleteUnusedMutex.Lock() - defer fake.deleteUnusedMutex.Unlock() - fake.DeleteUnusedStub = nil - fake.deleteUnusedReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeManager) DeleteUnusedReturnsOnCall(i int, result1 error) { - fake.deleteUnusedMutex.Lock() - defer fake.deleteUnusedMutex.Unlock() - fake.DeleteUnusedStub = nil - if fake.deleteUnusedReturnsOnCall == nil { - fake.deleteUnusedReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.deleteUnusedReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeManager) FindCurrent() ([]stemcell.CloudStemcell, error) { - fake.findCurrentMutex.Lock() - ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] - fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { - }{}) - stub := fake.FindCurrentStub - fakeReturns := fake.findCurrentReturns - fake.recordInvocation("FindCurrent", []interface{}{}) - fake.findCurrentMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeManager) FindCurrentCallCount() int { - fake.findCurrentMutex.RLock() - defer fake.findCurrentMutex.RUnlock() - return len(fake.findCurrentArgsForCall) -} - -func (fake *FakeManager) FindCurrentCalls(stub func() ([]stemcell.CloudStemcell, error)) { - fake.findCurrentMutex.Lock() - defer fake.findCurrentMutex.Unlock() - fake.FindCurrentStub = stub -} - -func (fake *FakeManager) FindCurrentReturns(result1 []stemcell.CloudStemcell, result2 error) { - fake.findCurrentMutex.Lock() - defer fake.findCurrentMutex.Unlock() - fake.FindCurrentStub = nil - fake.findCurrentReturns = struct { - result1 []stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { - fake.findCurrentMutex.Lock() - defer fake.findCurrentMutex.Unlock() - fake.FindCurrentStub = nil - if fake.findCurrentReturnsOnCall == nil { - fake.findCurrentReturnsOnCall = make(map[int]struct { - result1 []stemcell.CloudStemcell - result2 error - }) - } - fake.findCurrentReturnsOnCall[i] = struct { - result1 []stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) FindUnused() ([]stemcell.CloudStemcell, error) { - fake.findUnusedMutex.Lock() - ret, specificReturn := fake.findUnusedReturnsOnCall[len(fake.findUnusedArgsForCall)] - fake.findUnusedArgsForCall = append(fake.findUnusedArgsForCall, struct { - }{}) - stub := fake.FindUnusedStub - fakeReturns := fake.findUnusedReturns - fake.recordInvocation("FindUnused", []interface{}{}) - fake.findUnusedMutex.Unlock() - if stub != nil { - return stub() - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeManager) FindUnusedCallCount() int { - fake.findUnusedMutex.RLock() - defer fake.findUnusedMutex.RUnlock() - return len(fake.findUnusedArgsForCall) -} - -func (fake *FakeManager) FindUnusedCalls(stub func() ([]stemcell.CloudStemcell, error)) { - fake.findUnusedMutex.Lock() - defer fake.findUnusedMutex.Unlock() - fake.FindUnusedStub = stub -} - -func (fake *FakeManager) FindUnusedReturns(result1 []stemcell.CloudStemcell, result2 error) { - fake.findUnusedMutex.Lock() - defer fake.findUnusedMutex.Unlock() - fake.FindUnusedStub = nil - fake.findUnusedReturns = struct { - result1 []stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) FindUnusedReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { - fake.findUnusedMutex.Lock() - defer fake.findUnusedMutex.Unlock() - fake.FindUnusedStub = nil - if fake.findUnusedReturnsOnCall == nil { - fake.findUnusedReturnsOnCall = make(map[int]struct { - result1 []stemcell.CloudStemcell - result2 error - }) - } - fake.findUnusedReturnsOnCall[i] = struct { - result1 []stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) Upload(arg1 stemcell.ExtractedStemcell, arg2 ui.Stage) (stemcell.CloudStemcell, error) { - fake.uploadMutex.Lock() - ret, specificReturn := fake.uploadReturnsOnCall[len(fake.uploadArgsForCall)] - fake.uploadArgsForCall = append(fake.uploadArgsForCall, struct { - arg1 stemcell.ExtractedStemcell - arg2 ui.Stage - }{arg1, arg2}) - stub := fake.UploadStub - fakeReturns := fake.uploadReturns - fake.recordInvocation("Upload", []interface{}{arg1, arg2}) - fake.uploadMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeManager) UploadCallCount() int { - fake.uploadMutex.RLock() - defer fake.uploadMutex.RUnlock() - return len(fake.uploadArgsForCall) -} - -func (fake *FakeManager) UploadCalls(stub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error)) { - fake.uploadMutex.Lock() - defer fake.uploadMutex.Unlock() - fake.UploadStub = stub -} - -func (fake *FakeManager) UploadArgsForCall(i int) (stemcell.ExtractedStemcell, ui.Stage) { - fake.uploadMutex.RLock() - defer fake.uploadMutex.RUnlock() - argsForCall := fake.uploadArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeManager) UploadReturns(result1 stemcell.CloudStemcell, result2 error) { - fake.uploadMutex.Lock() - defer fake.uploadMutex.Unlock() - fake.UploadStub = nil - fake.uploadReturns = struct { - result1 stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) UploadReturnsOnCall(i int, result1 stemcell.CloudStemcell, result2 error) { - fake.uploadMutex.Lock() - defer fake.uploadMutex.Unlock() - fake.UploadStub = nil - if fake.uploadReturnsOnCall == nil { - fake.uploadReturnsOnCall = make(map[int]struct { - result1 stemcell.CloudStemcell - result2 error - }) - } - fake.uploadReturnsOnCall[i] = struct { - result1 stemcell.CloudStemcell - result2 error - }{result1, result2} -} - -func (fake *FakeManager) Invocations() map[string][][]interface{} { - fake.invocationsMutex.RLock() - defer fake.invocationsMutex.RUnlock() - copiedInvocations := map[string][][]interface{}{} - for key, value := range fake.invocations { - copiedInvocations[key] = value - } - return copiedInvocations -} - -func (fake *FakeManager) recordInvocation(key string, args []interface{}) { - fake.invocationsMutex.Lock() - defer fake.invocationsMutex.Unlock() - if fake.invocations == nil { - fake.invocations = map[string][][]interface{}{} - } - if fake.invocations[key] == nil { - fake.invocations[key] = [][]interface{}{} - } - fake.invocations[key] = append(fake.invocations[key], args) -} - -var _ stemcell.Manager = new(FakeManager) diff --git a/stemcell/stemcellfakes/fake_manager.go b/stemcell/stemcellfakes/fake_manager.go index efe4f41821..bb5856443c 100644 --- a/stemcell/stemcellfakes/fake_manager.go +++ b/stemcell/stemcellfakes/fake_manager.go @@ -1,92 +1,325 @@ +// Code generated by counterfeiter. DO NOT EDIT. package stemcellfakes import ( - "fmt" + "sync" - bosherr "github.com/cloudfoundry/bosh-utils/errors" - - bistemcell "github.com/cloudfoundry/bosh-cli/v7/stemcell" - biui "github.com/cloudfoundry/bosh-cli/v7/ui" + "github.com/cloudfoundry/bosh-cli/v7/stemcell" + "github.com/cloudfoundry/bosh-cli/v7/ui" ) type FakeManager struct { - UploadInputs []UploadInput - uploadBehavior map[UploadInput]uploadOutput + DeleteUnusedStub func(ui.Stage) error + deleteUnusedMutex sync.RWMutex + deleteUnusedArgsForCall []struct { + arg1 ui.Stage + } + deleteUnusedReturns struct { + result1 error + } + deleteUnusedReturnsOnCall map[int]struct { + result1 error + } + FindCurrentStub func() ([]stemcell.CloudStemcell, error) + findCurrentMutex sync.RWMutex + findCurrentArgsForCall []struct { + } + findCurrentReturns struct { + result1 []stemcell.CloudStemcell + result2 error + } + findCurrentReturnsOnCall map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + } + FindUnusedStub func() ([]stemcell.CloudStemcell, error) + findUnusedMutex sync.RWMutex + findUnusedArgsForCall []struct { + } + findUnusedReturns struct { + result1 []stemcell.CloudStemcell + result2 error + } + findUnusedReturnsOnCall map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + } + UploadStub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error) + uploadMutex sync.RWMutex + uploadArgsForCall []struct { + arg1 stemcell.ExtractedStemcell + arg2 ui.Stage + } + uploadReturns struct { + result1 stemcell.CloudStemcell + result2 error + } + uploadReturnsOnCall map[int]struct { + result1 stemcell.CloudStemcell + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeManager) DeleteUnused(arg1 ui.Stage) error { + fake.deleteUnusedMutex.Lock() + ret, specificReturn := fake.deleteUnusedReturnsOnCall[len(fake.deleteUnusedArgsForCall)] + fake.deleteUnusedArgsForCall = append(fake.deleteUnusedArgsForCall, struct { + arg1 ui.Stage + }{arg1}) + stub := fake.DeleteUnusedStub + fakeReturns := fake.deleteUnusedReturns + fake.recordInvocation("DeleteUnused", []interface{}{arg1}) + fake.deleteUnusedMutex.Unlock() + if stub != nil { + return stub(arg1) + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} - findUnusedOutput findUnusedOutput +func (fake *FakeManager) DeleteUnusedCallCount() int { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + return len(fake.deleteUnusedArgsForCall) +} - DeleteUnusedCalledTimes int - DeleteUnusedErr error +func (fake *FakeManager) DeleteUnusedCalls(stub func(ui.Stage) error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = stub } -type UploadInput struct { - Stemcell bistemcell.ExtractedStemcell - Stage biui.Stage +func (fake *FakeManager) DeleteUnusedArgsForCall(i int) ui.Stage { + fake.deleteUnusedMutex.RLock() + defer fake.deleteUnusedMutex.RUnlock() + argsForCall := fake.deleteUnusedArgsForCall[i] + return argsForCall.arg1 } -type uploadOutput struct { - stemcell bistemcell.CloudStemcell - err error +func (fake *FakeManager) DeleteUnusedReturns(result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + fake.deleteUnusedReturns = struct { + result1 error + }{result1} } -type findUnusedOutput struct { - stemcells []bistemcell.CloudStemcell - err error +func (fake *FakeManager) DeleteUnusedReturnsOnCall(i int, result1 error) { + fake.deleteUnusedMutex.Lock() + defer fake.deleteUnusedMutex.Unlock() + fake.DeleteUnusedStub = nil + if fake.deleteUnusedReturnsOnCall == nil { + fake.deleteUnusedReturnsOnCall = make(map[int]struct { + result1 error + }) + } + fake.deleteUnusedReturnsOnCall[i] = struct { + result1 error + }{result1} } -func NewFakeManager() *FakeManager { - return &FakeManager{ - UploadInputs: []UploadInput{}, - uploadBehavior: map[UploadInput]uploadOutput{}, +func (fake *FakeManager) FindCurrent() ([]stemcell.CloudStemcell, error) { + fake.findCurrentMutex.Lock() + ret, specificReturn := fake.findCurrentReturnsOnCall[len(fake.findCurrentArgsForCall)] + fake.findCurrentArgsForCall = append(fake.findCurrentArgsForCall, struct { + }{}) + stub := fake.FindCurrentStub + fakeReturns := fake.findCurrentReturns + fake.recordInvocation("FindCurrent", []interface{}{}) + fake.findCurrentMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindCurrentCallCount() int { + fake.findCurrentMutex.RLock() + defer fake.findCurrentMutex.RUnlock() + return len(fake.findCurrentArgsForCall) +} + +func (fake *FakeManager) FindCurrentCalls(stub func() ([]stemcell.CloudStemcell, error)) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = stub } -func (m *FakeManager) FindCurrent() ([]bistemcell.CloudStemcell, error) { - return []bistemcell.CloudStemcell{}, bosherr.Error("FakeManager.FindCurrent() not implemented (yet)") +func (fake *FakeManager) FindCurrentReturns(result1 []stemcell.CloudStemcell, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + fake.findCurrentReturns = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} } -func (m *FakeManager) Upload(stemcell bistemcell.ExtractedStemcell, stage biui.Stage) (bistemcell.CloudStemcell, error) { - input := UploadInput{ - Stemcell: stemcell, - Stage: stage, +func (fake *FakeManager) FindCurrentReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { + fake.findCurrentMutex.Lock() + defer fake.findCurrentMutex.Unlock() + fake.FindCurrentStub = nil + if fake.findCurrentReturnsOnCall == nil { + fake.findCurrentReturnsOnCall = make(map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + }) } - m.UploadInputs = append(m.UploadInputs, input) - output, found := m.uploadBehavior[input] - if !found { - return nil, fmt.Errorf("Unsupported Upload Input: %#v", stemcell) //nolint:staticcheck + fake.findCurrentReturnsOnCall[i] = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnused() ([]stemcell.CloudStemcell, error) { + fake.findUnusedMutex.Lock() + ret, specificReturn := fake.findUnusedReturnsOnCall[len(fake.findUnusedArgsForCall)] + fake.findUnusedArgsForCall = append(fake.findUnusedArgsForCall, struct { + }{}) + stub := fake.FindUnusedStub + fakeReturns := fake.findUnusedReturns + fake.recordInvocation("FindUnused", []interface{}{}) + fake.findUnusedMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) FindUnusedCallCount() int { + fake.findUnusedMutex.RLock() + defer fake.findUnusedMutex.RUnlock() + return len(fake.findUnusedArgsForCall) +} + +func (fake *FakeManager) FindUnusedCalls(stub func() ([]stemcell.CloudStemcell, error)) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = stub +} + +func (fake *FakeManager) FindUnusedReturns(result1 []stemcell.CloudStemcell, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + fake.findUnusedReturns = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) FindUnusedReturnsOnCall(i int, result1 []stemcell.CloudStemcell, result2 error) { + fake.findUnusedMutex.Lock() + defer fake.findUnusedMutex.Unlock() + fake.FindUnusedStub = nil + if fake.findUnusedReturnsOnCall == nil { + fake.findUnusedReturnsOnCall = make(map[int]struct { + result1 []stemcell.CloudStemcell + result2 error + }) } + fake.findUnusedReturnsOnCall[i] = struct { + result1 []stemcell.CloudStemcell + result2 error + }{result1, result2} +} + +func (fake *FakeManager) Upload(arg1 stemcell.ExtractedStemcell, arg2 ui.Stage) (stemcell.CloudStemcell, error) { + fake.uploadMutex.Lock() + ret, specificReturn := fake.uploadReturnsOnCall[len(fake.uploadArgsForCall)] + fake.uploadArgsForCall = append(fake.uploadArgsForCall, struct { + arg1 stemcell.ExtractedStemcell + arg2 ui.Stage + }{arg1, arg2}) + stub := fake.UploadStub + fakeReturns := fake.uploadReturns + fake.recordInvocation("Upload", []interface{}{arg1, arg2}) + fake.uploadMutex.Unlock() + if stub != nil { + return stub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *FakeManager) UploadCallCount() int { + fake.uploadMutex.RLock() + defer fake.uploadMutex.RUnlock() + return len(fake.uploadArgsForCall) +} + +func (fake *FakeManager) UploadCalls(stub func(stemcell.ExtractedStemcell, ui.Stage) (stemcell.CloudStemcell, error)) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = stub +} - return output.stemcell, output.err +func (fake *FakeManager) UploadArgsForCall(i int) (stemcell.ExtractedStemcell, ui.Stage) { + fake.uploadMutex.RLock() + defer fake.uploadMutex.RUnlock() + argsForCall := fake.uploadArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 } -func (m *FakeManager) FindUnused() ([]bistemcell.CloudStemcell, error) { - return m.findUnusedOutput.stemcells, m.findUnusedOutput.err +func (fake *FakeManager) UploadReturns(result1 stemcell.CloudStemcell, result2 error) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = nil + fake.uploadReturns = struct { + result1 stemcell.CloudStemcell + result2 error + }{result1, result2} } -func (m *FakeManager) DeleteUnused(eventLoggerStage biui.Stage) error { - m.DeleteUnusedCalledTimes++ - return m.DeleteUnusedErr +func (fake *FakeManager) UploadReturnsOnCall(i int, result1 stemcell.CloudStemcell, result2 error) { + fake.uploadMutex.Lock() + defer fake.uploadMutex.Unlock() + fake.UploadStub = nil + if fake.uploadReturnsOnCall == nil { + fake.uploadReturnsOnCall = make(map[int]struct { + result1 stemcell.CloudStemcell + result2 error + }) + } + fake.uploadReturnsOnCall[i] = struct { + result1 stemcell.CloudStemcell + result2 error + }{result1, result2} } -func (m *FakeManager) SetUploadBehavior( - extractedStemcell bistemcell.ExtractedStemcell, - stage biui.Stage, - cloudStemcell bistemcell.CloudStemcell, - err error, -) { - input := UploadInput{ - Stemcell: extractedStemcell, - Stage: stage, +func (fake *FakeManager) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value } - m.uploadBehavior[input] = uploadOutput{stemcell: cloudStemcell, err: err} + return copiedInvocations } -func (m *FakeManager) SetFindUnusedBehavior( - stemcells []bistemcell.CloudStemcell, - err error, -) { - m.findUnusedOutput = findUnusedOutput{ - stemcells: stemcells, - err: err, +func (fake *FakeManager) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} } + fake.invocations[key] = append(fake.invocations[key], args) } + +var _ stemcell.Manager = new(FakeManager) From 50ef357d7e7413b8afa2aeb74e95055d5eab23f8 Mon Sep 17 00:00:00 2001 From: aram price Date: Mon, 24 Aug 2026 17:51:18 -0700 Subject: [PATCH 13/13] Normalize counterfeiter invocation Remove `// You only need **one** of these per package!` comment --- cmd/config/interfaces.go | 1 - cmd/log_in.go | 1 - deployment/vm/vm.go | 1 - director/interfaces.go | 1 - installation/blobextract/extractor.go | 3 +-- pcap/pcap.go | 1 - release/interfaces.go | 1 - release/job/interfaces.go | 1 - release/license/interfaces.go | 1 - release/pkg/interfaces.go | 1 - release/resource/interfaces.go | 1 - releasedir/index/interfaces.go | 1 - releasedir/interfaces.go | 1 - ssh/host.go | 1 - ssh/interfaces.go | 1 - templatescompiler/erbrenderer/erb_renderer.go | 1 - uaa/interfaces.go | 1 - 17 files changed, 1 insertion(+), 18 deletions(-) diff --git a/cmd/config/interfaces.go b/cmd/config/interfaces.go index 5678d9a104..d1566b7348 100644 --- a/cmd/config/interfaces.go +++ b/cmd/config/interfaces.go @@ -2,7 +2,6 @@ package config import "github.com/cloudfoundry/bosh-cli/v7/uaa" -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Config diff --git a/cmd/log_in.go b/cmd/log_in.go index e1ed6d2766..232d118969 100644 --- a/cmd/log_in.go +++ b/cmd/log_in.go @@ -6,7 +6,6 @@ import ( boshdir "github.com/cloudfoundry/bosh-cli/v7/director" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . LoginStrategy diff --git a/deployment/vm/vm.go b/deployment/vm/vm.go index e2860fc678..bdd3f0ba2e 100644 --- a/deployment/vm/vm.go +++ b/deployment/vm/vm.go @@ -25,7 +25,6 @@ type Clock interface { Now() time.Time } -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . VM diff --git a/director/interfaces.go b/director/interfaces.go index be7560ffbb..09d37a58fb 100644 --- a/director/interfaces.go +++ b/director/interfaces.go @@ -11,7 +11,6 @@ import ( bio "github.com/cloudfoundry/bosh-cli/v7/io" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Director diff --git a/installation/blobextract/extractor.go b/installation/blobextract/extractor.go index dfd49ff79a..60ba05f497 100644 --- a/installation/blobextract/extractor.go +++ b/installation/blobextract/extractor.go @@ -11,10 +11,9 @@ import ( boshsys "github.com/cloudfoundry/bosh-utils/system" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate -//counterfeiter:generate extractor.go Extractor +//counterfeiter:generate . Extractor type Extractor interface { Extract(blobID, blobSHA1, targetDir string) error Cleanup(blobID string, extractedBlobPath string) error diff --git a/pcap/pcap.go b/pcap/pcap.go index 9b4b58a2fc..81b477b6c2 100644 --- a/pcap/pcap.go +++ b/pcap/pcap.go @@ -35,7 +35,6 @@ var ( openHandleError = fmt.Errorf("unable to open pcap handle") //nolint:staticcheck ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . PcapRunner diff --git a/release/interfaces.go b/release/interfaces.go index a1d131a5b3..1469c0158b 100644 --- a/release/interfaces.go +++ b/release/interfaces.go @@ -8,7 +8,6 @@ import ( boshres "github.com/cloudfoundry/bosh-cli/v7/release/resource" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Extractor diff --git a/release/job/interfaces.go b/release/job/interfaces.go index 1b75d63a9f..ac59511dab 100644 --- a/release/job/interfaces.go +++ b/release/job/interfaces.go @@ -4,7 +4,6 @@ import ( boshman "github.com/cloudfoundry/bosh-cli/v7/release/manifest" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . ArchiveReader diff --git a/release/license/interfaces.go b/release/license/interfaces.go index 2aad11228f..2e605056ff 100644 --- a/release/license/interfaces.go +++ b/release/license/interfaces.go @@ -1,6 +1,5 @@ package license -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . DirReader diff --git a/release/pkg/interfaces.go b/release/pkg/interfaces.go index bdb70ec795..5ae94b52c8 100644 --- a/release/pkg/interfaces.go +++ b/release/pkg/interfaces.go @@ -4,7 +4,6 @@ import ( boshman "github.com/cloudfoundry/bosh-cli/v7/release/manifest" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Compilable diff --git a/release/resource/interfaces.go b/release/resource/interfaces.go index 84241a7d84..73cd17e545 100644 --- a/release/resource/interfaces.go +++ b/release/resource/interfaces.go @@ -6,7 +6,6 @@ import ( "github.com/cloudfoundry/bosh-cli/v7/crypto" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Archive diff --git a/releasedir/index/interfaces.go b/releasedir/index/interfaces.go index 164b0f4743..6620023a06 100644 --- a/releasedir/index/interfaces.go +++ b/releasedir/index/interfaces.go @@ -1,6 +1,5 @@ package index -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Index diff --git a/releasedir/interfaces.go b/releasedir/interfaces.go index 993f1ed7fd..35af4e3f8b 100644 --- a/releasedir/interfaces.go +++ b/releasedir/interfaces.go @@ -11,7 +11,6 @@ import ( boshpkg "github.com/cloudfoundry/bosh-cli/v7/release/pkg" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . ReleaseDir diff --git a/ssh/host.go b/ssh/host.go index 9f7ebd607f..6b195b4822 100644 --- a/ssh/host.go +++ b/ssh/host.go @@ -8,7 +8,6 @@ import ( boshdir "github.com/cloudfoundry/bosh-cli/v7/director" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . HostBuilder diff --git a/ssh/interfaces.go b/ssh/interfaces.go index 3dff7c08a9..97510a1afa 100644 --- a/ssh/interfaces.go +++ b/ssh/interfaces.go @@ -6,7 +6,6 @@ import ( boshdir "github.com/cloudfoundry/bosh-cli/v7/director" ) -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . Runner diff --git a/templatescompiler/erbrenderer/erb_renderer.go b/templatescompiler/erbrenderer/erb_renderer.go index b3e4ca0a11..7c2985ba42 100644 --- a/templatescompiler/erbrenderer/erb_renderer.go +++ b/templatescompiler/erbrenderer/erb_renderer.go @@ -17,7 +17,6 @@ type ERBRenderer interface { Render(srcPath, dstPath string, context TemplateEvaluationContext) error } -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate github.com/cloudfoundry/bosh-utils/system.CmdRunner //counterfeiter:generate github.com/cloudfoundry/bosh-utils/system.FileSystem diff --git a/uaa/interfaces.go b/uaa/interfaces.go index 7e1240f520..965996f5ed 100644 --- a/uaa/interfaces.go +++ b/uaa/interfaces.go @@ -1,6 +1,5 @@ package uaa -// You only need **one** of these per package! //go:generate go run github.com/maxbrunsfeld/counterfeiter/v6 -generate //counterfeiter:generate . UAA