func buildApplyAction() (*fakeappl.FakeApplier, *fakesys.FakeFileSystem, *fakeplatform.FakePlatform, applyAction) { applier := fakeappl.NewFakeApplier() platform := fakeplatform.NewFakePlatform() fs := platform.Fs action := newApply(applier, fs, platform) return applier, fs, platform, action }
func buildFactory() ( deps concreteFactoryDependencies, factory Factory) { deps.settings = &fakesettings.FakeSettingsService{} deps.platform = fakeplatform.NewFakePlatform() deps.blobstore = &fakeblobstore.FakeBlobstore{} deps.taskService = &faketask.FakeService{} deps.notifier = fakenotif.NewFakeNotifier() deps.applier = fakeappl.NewFakeApplier() deps.compiler = fakecomp.NewFakeCompiler() deps.monitor = fakemon.NewFakeMonitor() deps.specService = fakeas.NewFakeV1Service() deps.dirProvider = boshdirs.NewDirectoriesProvider("/foo") deps.drainScriptProvider = boshdrain.NewDrainScriptProvider(nil, nil, deps.dirProvider) factory = NewFactory( deps.settings, deps.platform, deps.blobstore, deps.taskService, deps.notifier, deps.applier, deps.compiler, deps.monitor, deps.specService, deps.dirProvider, deps.drainScriptProvider, ) return }
func buildFactory() ( deps concreteFactoryDependencies, factory Factory) { deps.settings = &fakesettings.FakeSettingsService{} deps.platform = fakeplatform.NewFakePlatform() deps.blobstore = &fakeblobstore.FakeBlobstore{} deps.taskService = &faketask.FakeService{} deps.notifier = fakenotif.NewFakeNotifier() deps.applier = fakeappl.NewFakeApplier() deps.compiler = fakecomp.NewFakeCompiler() deps.jobSupervisor = fakejobsuper.NewFakeJobSupervisor() deps.specService = fakeas.NewFakeV1Service() deps.drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, deps.platform.GetDirProvider()) factory = NewFactory( deps.settings, deps.platform, deps.blobstore, deps.taskService, deps.notifier, deps.applier, deps.compiler, deps.jobSupervisor, deps.specService, deps.drainScriptProvider, ) return }
func buildFactory() ( settings *fakesettings.FakeSettingsService, platform *fakeplatform.FakePlatform, blobstore *fakeblobstore.FakeBlobstore, taskService *faketask.FakeService, applier *fakeappl.FakeApplier, factory Factory) { settings = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() blobstore = &fakeblobstore.FakeBlobstore{} taskService = &faketask.FakeService{} applier = fakeappl.NewFakeApplier() factory = NewFactory(settings, platform, blobstore, taskService, applier) return }
func init() { Describe("concreteFactory", func() { var ( settings *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform infrastructure *fakeinfrastructure.FakeInfrastructure blobstore *fakeblobstore.FakeBlobstore taskService *faketask.FakeService notifier *fakenotif.FakeNotifier applier *fakeappl.FakeApplier compiler *fakecomp.FakeCompiler jobSupervisor *fakejobsuper.FakeJobSupervisor specService *fakeas.FakeV1Service drainScriptProvider boshdrain.DrainScriptProvider factory Factory logger boshlog.Logger ) BeforeEach(func() { settings = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() infrastructure = fakeinfrastructure.NewFakeInfrastructure() blobstore = &fakeblobstore.FakeBlobstore{} taskService = &faketask.FakeService{} notifier = fakenotif.NewFakeNotifier() applier = fakeappl.NewFakeApplier() compiler = fakecomp.NewFakeCompiler() jobSupervisor = fakejobsuper.NewFakeJobSupervisor() specService = fakeas.NewFakeV1Service() drainScriptProvider = boshdrain.NewConcreteDrainScriptProvider(nil, nil, platform.GetDirProvider()) logger = boshlog.NewLogger(boshlog.LEVEL_NONE) }) JustBeforeEach(func() { factory = NewFactory( settings, platform, infrastructure, blobstore, taskService, notifier, applier, compiler, jobSupervisor, specService, drainScriptProvider, logger, ) }) It("new factory", func() { actions := []string{ "apply", "drain", "fetch_logs", "get_task", "get_state", "list_disk", "migrate_disk", "mount_disk", "ping", "prepare_network_change", "ssh", "start", "stop", "unmount_disk", "compile_package", "release_apply_spec", } for _, actionName := range actions { action, err := factory.Create(actionName) Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) } action, err := factory.Create("gobberish") Expect(err).To(HaveOccurred()) Expect(action).To(BeNil()) }) It("apply", func() { action, err := factory.Create("apply") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewApply(applier, specService)).To(Equal(action)) }) It("drain", func() { action, err := factory.Create("drain") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewDrain(notifier, specService, drainScriptProvider, jobSupervisor)).To(Equal(action)) }) It("fetch_logs", func() { action, err := factory.Create("fetch_logs") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewLogs(platform.GetCompressor(), platform.GetCopier(), blobstore, platform.GetDirProvider())).To(Equal(action)) }) It("get_task", func() { action, err := factory.Create("get_task") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewGetTask(taskService)).To(Equal(action)) }) It("get_state", func() { ntpService := boshntp.NewConcreteService(platform.GetFs(), platform.GetDirProvider()) action, err := factory.Create("get_state") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewGetState(settings, specService, jobSupervisor, platform.GetVitalsService(), ntpService)).To(Equal(action)) }) It("list_disk", func() { action, err := factory.Create("list_disk") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewListDisk(settings, platform, logger)).To(Equal(action)) }) It("migrate_disk", func() { action, err := factory.Create("migrate_disk") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewMigrateDisk(platform, platform.GetDirProvider())).To(Equal(action)) }) It("mount_disk", func() { action, err := factory.Create("mount_disk") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewMountDisk(settings, infrastructure, platform, platform.GetDirProvider())).To(Equal(action)) }) It("prepare_network_change", func() { action, err := factory.Create("prepare_network_change") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewPrepareNetworkChange(platform.GetFs(), settings)).To(Equal(action)) }) It("prepare_configure_networks", func() { action, err := factory.Create("prepare_configure_networks") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewPrepareConfigureNetworks(platform.GetFs(), settings)).To(Equal(action)) }) It("configure_networks", func() { action, err := factory.Create("configure_networks") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewConfigureNetworks()).To(Equal(action)) }) It("ssh", func() { action, err := factory.Create("ssh") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewSsh(settings, platform, platform.GetDirProvider())).To(Equal(action)) }) It("start", func() { action, err := factory.Create("start") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewStart(jobSupervisor)).To(Equal(action)) }) It("unmount_disk", func() { action, err := factory.Create("unmount_disk") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewUnmountDisk(settings, platform)).To(Equal(action)) }) It("compile_package", func() { action, err := factory.Create("compile_package") Expect(err).NotTo(HaveOccurred()) Expect(action).ToNot(BeNil()) Expect(NewCompilePackage(compiler)).To(Equal(action)) }) }) }
func buildApplyAction() (*fakeappl.FakeApplier, *fakeas.FakeV1Service, ApplyAction) { applier := fakeappl.NewFakeApplier() specService := fakeas.NewFakeV1Service() action := NewApply(applier, specService) return applier, specService, action }
. "github.com/onsi/ginkgo" . "github.com/onsi/gomega" . "bosh/agent/action" boshas "bosh/agent/applier/applyspec" fakeappl "bosh/agent/applier/fakes" ) var _ = Describe("PrepareAction", func() { var ( applier *fakeappl.FakeApplier action PrepareAction ) BeforeEach(func() { applier = fakeappl.NewFakeApplier() action = NewPrepare(applier) }) It("is asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"} It("runs applier to prepare vm for future configuration with desired apply spec", func() {
func init() { Describe("ApplyAction", func() { var ( applier *fakeappl.FakeApplier specService *fakeas.FakeV1Service settingsService *fakesettings.FakeSettingsService action ApplyAction ) BeforeEach(func() { applier = fakeappl.NewFakeApplier() specService = fakeas.NewFakeV1Service() settingsService = &fakesettings.FakeSettingsService{} action = NewApply(applier, specService, settingsService) }) It("apply should be asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { settings := boshsettings.Settings{AgentID: "fake-agent-id"} BeforeEach(func() { settingsService.Settings = settings }) Context("when desired spec has configuration hash", func() { currentApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-current-config-hash"} desiredApplySpec := boshas.V1ApplySpec{ConfigurationHash: "fake-desired-config-hash"} populatedDesiredApplySpec := boshas.V1ApplySpec{ ConfigurationHash: "fake-populated-desired-config-hash", } Context("when current spec can be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec }) It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDynamicNetworksResultSpec = populatedDesiredApplySpec }) It("runs applier with populated desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeTrue()) Expect(applier.ApplyCurrentApplySpec).To(Equal(currentApplySpec)) Expect(applier.ApplyDesiredApplySpec).To(Equal(populatedDesiredApplySpec)) }) Context("when applier succeeds applying desired spec", func() { Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting populated desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) }) Context("when saving populated desires spec as current spec fails", func() { It("returns error because agent was not able to remember that is converged to desired spec", func() { specService.SetErr = errors.New("fake-set-error") _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) }) }) Context("when applier fails applying desired spec", func() { BeforeEach(func() { applier.ApplyError = errors.New("fake-apply-error") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-apply-error")) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDynamicNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when current spec cannot be retrieved", func() { BeforeEach(func() { specService.Spec = currentApplySpec specService.GetErr = errors.New("fake-get-error") }) It("returns error and does not apply desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-get-error")) }) It("does not run applier with desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).To(Equal(currentApplySpec)) }) }) }) Context("when desired spec does not have a configuration hash", func() { desiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-job-template", }, } populatedDesiredApplySpec := boshas.V1ApplySpec{ JobSpec: boshas.JobSpec{ Template: "fake-populated-job-template", }, } It("populates dynamic networks in desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(specService.PopulateDynamicNetworksSpec).To(Equal(desiredApplySpec)) Expect(specService.PopulateDynamicNetworksSettings).To(Equal(settings)) }) Context("when resolving dynamic networks succeeds", func() { BeforeEach(func() { specService.PopulateDynamicNetworksResultSpec = populatedDesiredApplySpec }) Context("when saving desires spec as current spec succeeds", func() { It("returns 'applied' after setting desired spec as current spec", func() { value, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(value).To(Equal("applied")) Expect(specService.Spec).To(Equal(populatedDesiredApplySpec)) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).ToNot(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) Context("when saving desires spec as current spec fails", func() { BeforeEach(func() { specService.SetErr = errors.New("fake-set-error") }) It("returns error because agent was not able to remember that is converged to desired spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-error")) }) It("does not try to apply desired spec since it does not have jobs and packages", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) }) }) Context("when resolving dynamic networks fails", func() { BeforeEach(func() { specService.PopulateDynamicNetworksErr = errors.New("fake-populate-dynamic-networks-err") }) It("returns error", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-populate-dynamic-networks-err")) }) It("does not apply desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(applier.Applied).To(BeFalse()) }) It("does not save desired spec as current spec", func() { _, err := action.Run(desiredApplySpec) Expect(err).To(HaveOccurred()) Expect(specService.Spec).ToNot(Equal(desiredApplySpec)) }) }) }) }) }) }