func createBlobManager() (blobManager BlobManager, fs *fakesys.FakeFileSystem) { fs = fakesys.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") blobManager = NewBlobManager(fs, dirProvider) return }
func init() { Describe("Testing with Ginkgo", func() { It("new drain script", func() { runner := fakesys.NewFakeCmdRunner() fs := fakesys.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") scriptProvider := NewConcreteDrainScriptProvider(runner, fs, dirProvider) drainScript := scriptProvider.NewDrainScript("foo") Expect(drainScript.Path()).To(Equal("/var/vcap/jobs/foo/bin/drain")) }) }) }
fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshsettings "github.com/cloudfoundry/bosh-agent/settings" boshdir "github.com/cloudfoundry/bosh-agent/settings/directories" boshuuid "github.com/cloudfoundry/bosh-agent/uuid" ) var _ = Describe("Provider", func() { var ( platform *fakeplatform.FakePlatform logger boshlog.Logger provider Provider ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") logger = boshlog.NewLogger(boshlog.LevelNone) provider = NewProvider(platform, dirProvider, logger) }) Describe("Get", func() { It("get dummy", func() { blobstore, err := provider.Get(boshsettings.Blobstore{ Type: boshsettings.BlobstoreTypeDummy, }) Expect(err).ToNot(HaveOccurred()) Expect(blobstore).ToNot(BeNil()) }) It("get external when external command in path", func() { options := map[string]interface{}{"key": "value"}
boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories" ) var _ = Describe("FetchLogsAction", func() { var ( compressor *fakecmd.FakeCompressor copier *fakecmd.FakeCopier blobstore *fakeblobstore.FakeBlobstore dirProvider boshdirs.DirectoriesProvider action FetchLogsAction ) BeforeEach(func() { compressor = fakecmd.NewFakeCompressor() blobstore = &fakeblobstore.FakeBlobstore{} dirProvider = boshdirs.NewDirectoriesProvider("/fake/dir") copier = fakecmd.NewFakeCopier() action = NewFetchLogs(compressor, copier, blobstore, dirProvider) }) It("logs should be asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { testLogs := func(logType string, filters []string, expectedFilters []string) { copier.FilteredCopyToTempTempDir = "/fake-temp-dir"
func buildSSHAction(settingsService boshsettings.Service) (*fakeplatform.FakePlatform, SSHAction) { platform := fakeplatform.NewFakePlatform() dirProvider := boshdirs.NewDirectoriesProvider("/foo") action := NewSSH(settingsService, platform, dirProvider) return platform, action }
func init() { Describe("provider", func() { var ( platform *fakeplatform.FakePlatform client *fakemonit.FakeMonitClient logger boshlog.Logger dirProvider boshdir.DirectoriesProvider jobFailuresServerPort int handler *fakembus.FakeHandler provider Provider ) BeforeEach(func() { platform = fakeplatform.NewFakePlatform() client = fakemonit.NewFakeMonitClient() logger = boshlog.NewLogger(boshlog.LevelNone) dirProvider = boshdir.NewDirectoriesProvider("/fake-base-dir") jobFailuresServerPort = 2825 handler = &fakembus.FakeHandler{} provider = NewProvider( platform, client, logger, dirProvider, handler, ) }) It("provides a monit job supervisor", func() { actualSupervisor, err := provider.Get("monit") Expect(err).ToNot(HaveOccurred()) expectedSupervisor := NewMonitJobSupervisor( platform.Fs, platform.Runner, client, logger, dirProvider, jobFailuresServerPort, MonitReloadOptions{ MaxTries: 3, MaxCheckTries: 6, DelayBetweenCheckTries: 5 * time.Second, }, ) Expect(actualSupervisor).To(Equal(expectedSupervisor)) }) It("provides a dummy job supervisor", func() { actualSupervisor, err := provider.Get("dummy") Expect(err).ToNot(HaveOccurred()) expectedSupervisor := NewDummyJobSupervisor() Expect(actualSupervisor).To(Equal(expectedSupervisor)) }) It("provides a dummy nats job supervisor", func() { actualSupervisor, err := provider.Get("dummy-nats") Expect(err).NotTo(HaveOccurred()) expectedSupervisor := NewDummyNatsJobSupervisor(handler) Expect(actualSupervisor).To(Equal(expectedSupervisor)) }) It("returns an error when the supervisor is not found", func() { _, err := provider.Get("does-not-exist") Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("does-not-exist could not be found")) }) }) }
fakeplatform "github.com/cloudfoundry/bosh-agent/platform/fakes" boshdirs "github.com/cloudfoundry/bosh-agent/settings/directories" fakesettings "github.com/cloudfoundry/bosh-agent/settings/fakes" ) var _ = Describe("MountDiskAction", func() { var ( settingsService *fakesettings.FakeSettingsService platform *fakeplatform.FakePlatform action MountDiskAction ) BeforeEach(func() { settingsService = &fakesettings.FakeSettingsService{} platform = fakeplatform.NewFakePlatform() dirProvider := boshdirs.NewDirectoriesProvider("/fake-base-dir") action = NewMountDisk(settingsService, platform, platform, dirProvider) }) It("is asynchronous", func() { Expect(action.IsAsynchronous()).To(BeTrue()) }) It("is not persistent", func() { Expect(action.IsPersistent()).To(BeFalse()) }) Describe("Run", func() { Context("when settings can be loaded", func() { Context("when disk cid can be resolved to a device path from infrastructure settings", func() { BeforeEach(func() {
func (p *FakePlatform) GetDirProvider() (dirProvider boshdir.DirectoriesProvider) { return boshdir.NewDirectoriesProvider("/var/vcap") }
func init() { Describe("concreteApplier", func() { var ( jobApplier *fakeja.FakeJobApplier packageApplier *fakepa.FakePackageApplier logRotateDelegate *FakeLogRotateDelegate jobSupervisor *fakejobsuper.FakeJobSupervisor applier Applier ) BeforeEach(func() { jobApplier = fakeja.NewFakeJobApplier() packageApplier = fakepa.NewFakePackageApplier() logRotateDelegate = &FakeLogRotateDelegate{} jobSupervisor = fakejobsuper.NewFakeJobSupervisor() applier = NewConcreteApplier( jobApplier, packageApplier, logRotateDelegate, jobSupervisor, boshdirs.NewDirectoriesProvider("/fake-base-dir"), ) }) Describe("Prepare", func() { It("prepares each jobs", func() { job := buildJob() err := applier.Prepare( &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) Expect(err).ToNot(HaveOccurred()) Expect(jobApplier.PreparedJobs).To(Equal([]models.Job{job})) }) It("returns error when preparing jobs fails", func() { job := buildJob() jobApplier.PrepareError = errors.New("fake-prepare-job-error") err := applier.Prepare( &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-prepare-job-error")) }) It("prepares each packages", func() { pkg1 := buildPackage() pkg2 := buildPackage() err := applier.Prepare( &fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}}, ) Expect(err).ToNot(HaveOccurred()) Expect(packageApplier.PreparedPackages).To(Equal([]models.Package{pkg1, pkg2})) }) It("returns error when preparing packages fails", func() { pkg := buildPackage() packageApplier.PrepareError = errors.New("fake-prepare-package-error") err := applier.Prepare( &fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-prepare-package-error")) }) }) Describe("Apply", func() { It("removes all jobs from job supervisor", func() { err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{}) Expect(err).ToNot(HaveOccurred()) Expect(jobSupervisor.RemovedAllJobs).To(BeTrue()) }) It("removes all previous jobs from job supervisor before starting to apply jobs", func() { // force remove all error jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error") job := buildJob() applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) // check that jobs were not applied before removing all other jobs Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{})) }) It("returns error if removing all jobs from job supervisor fails", func() { jobSupervisor.RemovedAllJobsErr = errors.New("fake-remove-all-jobs-error") err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{}) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-remove-all-jobs-error")) }) It("apply applies jobs", func() { job := buildJob() err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) Expect(err).ToNot(HaveOccurred()) Expect(jobApplier.AppliedJobs).To(Equal([]models.Job{job})) }) It("apply errs when applying jobs errs", func() { job := buildJob() jobApplier.ApplyError = errors.New("fake-apply-job-error") err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-apply-job-error")) }) It("asked jobApplier to keep only the jobs in the desired and current specs", func() { currentJob := buildJob() desiredJob := buildJob() err := applier.Apply( &fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}}, &fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}}, ) Expect(err).ToNot(HaveOccurred()) Expect(jobApplier.KeepOnlyJobs).To(Equal([]models.Job{currentJob, desiredJob})) }) It("returns error when jobApplier fails to keep only the jobs in the desired and current specs", func() { jobApplier.KeepOnlyErr = errors.New("fake-keep-only-error") currentJob := buildJob() desiredJob := buildJob() err := applier.Apply( &fakeas.FakeApplySpec{JobResults: []models.Job{currentJob}}, &fakeas.FakeApplySpec{JobResults: []models.Job{desiredJob}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-keep-only-error")) }) It("apply applies packages", func() { pkg1 := buildPackage() pkg2 := buildPackage() err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{PackageResults: []models.Package{pkg1, pkg2}}, ) Expect(err).ToNot(HaveOccurred()) Expect(packageApplier.AppliedPackages).To(Equal([]models.Package{pkg1, pkg2})) }) It("apply errs when applying packages errs", func() { pkg := buildPackage() packageApplier.ApplyError = errors.New("fake-apply-package-error") err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{PackageResults: []models.Package{pkg}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-apply-package-error")) }) It("asked packageApplier to keep only the packages in the desired and current specs", func() { currentPkg := buildPackage() desiredPkg := buildPackage() err := applier.Apply( &fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}}, &fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}}, ) Expect(err).ToNot(HaveOccurred()) Expect(packageApplier.KeptOnlyPackages).To(Equal([]models.Package{currentPkg, desiredPkg})) }) It("returns error when packageApplier fails to keep only the packages in the desired and current specs", func() { packageApplier.KeepOnlyErr = errors.New("fake-keep-only-error") currentPkg := buildPackage() desiredPkg := buildPackage() err := applier.Apply( &fakeas.FakeApplySpec{PackageResults: []models.Package{currentPkg}}, &fakeas.FakeApplySpec{PackageResults: []models.Package{desiredPkg}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-keep-only-error")) }) It("apply configures jobs", func() { job1 := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"} job2 := models.Job{Name: "fake-job-name-2", Version: "fake-version-name-2"} jobs := []models.Job{job1, job2} err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs}) Expect(err).ToNot(HaveOccurred()) Expect(jobApplier.ConfiguredJobs).To(Equal([]models.Job{job2, job1})) Expect(jobApplier.ConfiguredJobIndices).To(Equal([]int{0, 1})) Expect(jobSupervisor.Reloaded).To(BeTrue()) }) It("apply errs if monitor fails reload", func() { jobs := []models.Job{} jobSupervisor.ReloadErr = errors.New("error reloading monit") err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: jobs}) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("error reloading monit")) }) It("apply errs if a job fails configuring", func() { jobApplier.ConfigureError = errors.New("error configuring job") job := models.Job{Name: "fake-job-name-1", Version: "fake-version-name-1"} err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{JobResults: []models.Job{job}}, ) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("error configuring job")) }) It("apply sets up logrotation", func() { err := applier.Apply( &fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{MaxLogFileSizeResult: "fake-size"}, ) Expect(err).ToNot(HaveOccurred()) assert.Equal(GinkgoT(), logRotateDelegate.SetupLogrotateArgs, SetupLogrotateArgs{ GroupName: boshsettings.VCAPUsername, BasePath: "/fake-base-dir", Size: "fake-size", }) }) It("apply errs if setup logrotate fails", func() { logRotateDelegate.SetupLogrotateErr = errors.New("fake-set-up-logrotate-error") err := applier.Apply(&fakeas.FakeApplySpec{}, &fakeas.FakeApplySpec{}) Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("fake-set-up-logrotate-error")) }) }) }) }