func createBlobManager() (blobManager BlobManager, fs *fakesys.FakeFileSystem) { fs = fakesys.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") blobManager = NewBlobManager(fs, dirProvider) return }
func TestConfigure(t *testing.T) { jobsBc, _, _, monitor, applier := buildJobApplier() job := buildJob() fs := fakesys.NewFakeFileSystem() fs.WriteToFile("/path/to/job/monit", "some conf") fs.GlobPaths = []string{"/path/to/job/subjob.monit"} jobsBc.GetDirPath = "/path/to/job" jobsBc.GetDirFs = fs err := applier.Configure(job, 0) assert.NoError(t, err) assert.Equal(t, "/path/to/job/*.monit", fs.GlobPattern) assert.Equal(t, 2, len(monitor.AddJobArgs)) firstArgs := fakemon.AddJobArgs{ Name: job.Name, Index: 0, ConfigPath: "/path/to/job/monit", } secondArgs := fakemon.AddJobArgs{ Name: job.Name + "_subjob", Index: 0, ConfigPath: "/path/to/job/subjob.monit", } assert.Equal(t, firstArgs, monitor.AddJobArgs[0]) assert.Equal(t, secondArgs, monitor.AddJobArgs[1]) }
func TestApplyCopiesFromDecompressedTmpPathToInstallPath(t *testing.T) { jobsBc, blobstore, compressor, _, applier := buildJobApplier() job := buildJob() job.Source.PathInArchive = "fake-path-in-archive" fs := fakesys.NewFakeFileSystem() fs.TempDirDir = "fake-tmp-dir" fs.MkdirAll("fake-tmp-dir", os.FileMode(0)) jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) blobstore.GetFileName = "/dev/null" compressor.DecompressFileToDirCallBack = func() { fs.MkdirAll("fake-tmp-dir/fake-path-in-archive", os.FileMode(0)) fs.WriteToFile("fake-tmp-dir/fake-path-in-archive/file", "file-contents") } err := applier.Apply(job) assert.NoError(t, err) fileInArchiveStat := fs.GetFileTestStat("fake-install-dir/file") assert.NotNil(t, fileInArchiveStat) assert.Equal(t, "file-contents", fileInArchiveStat.Content) }
func buildCompiler() ( deps compilerDeps, compiler Compiler, ) { deps.compressor = fakecmd.NewFakeCompressor() deps.blobstore = &fakeblobstore.FakeBlobstore{} deps.fs = fakesys.NewFakeFileSystem() deps.runner = fakesys.NewFakeCmdRunner() deps.packageApplier = fakepa.NewFakePackageApplier() fakeBundleCollection := fakebc.NewFakeBundleCollection() bundleDefinition := boshmodels.Package{ Name: "pkg_name", Version: "pkg_version", } deps.bundle = fakeBundleCollection.FakeGet(bundleDefinition) deps.bundle.InstallPath = "/fake-dir/data/packages/pkg_name/pkg_version" deps.bundle.EnablePath = "/fake-dir/packages/pkg_name" deps.packagesBc = fakeBundleCollection compiler = NewConcreteCompiler( deps.compressor, deps.blobstore, deps.fs, deps.runner, boshdirs.NewDirectoriesProvider("/fake-dir"), deps.packageApplier, deps.packagesBc, ) return }
func getNewProvider() (provider provider) { dirProvider := boshsys.NewDirectoriesProvider("/var/vcap") fs := fakefs.NewFakeFileSystem() provider = NewProvider(boshlog.NewLogger(boshlog.LEVEL_NONE), fs, dirProvider) return }
func init() { Describe("dummyInfrastructure", func() { It("get settings", func() { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") platform := fakeplatform.NewFakePlatform() fakeDevicePathResolver := fakedpresolv.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs()) settingsPath := filepath.Join(dirProvider.BoshDir(), "dummy-cpi-agent-env.json") expectedSettings := boshsettings.Settings{ AgentID: "123-456-789", Blobstore: boshsettings.Blobstore{ Type: boshsettings.BlobstoreTypeDummy, }, Mbus: "nats://127.0.0.1:4222", } existingSettingsBytes, _ := json.Marshal(expectedSettings) fs.WriteFile(settingsPath, existingSettingsBytes) dummy := NewDummyInfrastructure(fs, dirProvider, platform, fakeDevicePathResolver) settings, err := dummy.GetSettings() Expect(err).ToNot(HaveOccurred()) assert.Equal(GinkgoT(), settings, boshsettings.Settings{ AgentID: "123-456-789", Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy}, Mbus: "nats://127.0.0.1:4222", }) }) It("get settings errs when settings file does not exist", func() { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") platform := fakeplatform.NewFakePlatform() fakeDevicePathResolver := fakedpresolv.NewFakeDevicePathResolver(1*time.Millisecond, platform.GetFs()) dummy := NewDummyInfrastructure(fs, dirProvider, platform, fakeDevicePathResolver) _, err := dummy.GetSettings() Expect(err).To(HaveOccurred()) Expect(err.Error()).To(ContainSubstring("Read settings file")) }) }) }
func TestNewDrainScript(t *testing.T) { runner := fakesys.NewFakeCmdRunner() fs := fakesys.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") scriptProvider := NewConcreteDrainScriptProvider(runner, fs, dirProvider) drainScript := scriptProvider.NewDrainScript("foo") assert.Equal(t, drainScript.Path(), "/var/vcap/jobs/foo/bin/drain") }
func TestGetSettingsErrsWhenSettingsFileDoesNotExist(t *testing.T) { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") dummy := newDummyInfrastructure(fs, dirProvider) _, err := dummy.GetSettings() assert.Error(t, err) assert.Contains(t, err.Error(), "Read settings file") }
func buildService(NTPData string) (service Service) { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") if NTPData != "" { fs.WriteToFile("/var/vcap/bosh/log/ntpdate.out", NTPData) } service = NewConcreteService(fs, dirProvider) return }
func TestApplyErrsWhenJobDecompressErrs(t *testing.T) { jobsBc, _, compressor, applier := buildJobApplier() pkg := buildJob() compressor.DecompressFileToDirError = errors.New("fake-decompress-error") fs := fakesys.NewFakeFileSystem() jobsBc.InstallFs = fs err := applier.Apply(pkg) assert.Error(t, err) assert.Contains(t, err.Error(), "fake-decompress-error") }
func init() { Describe("Testing with Ginkgo", func() { It("get settings", func() { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") platform := fakeplatform.NewFakePlatform() settingsPath := filepath.Join(dirProvider.BaseDir(), "bosh", "settings.json") expectedSettings := boshsettings.Settings{AgentId: "123-456-789", Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy}, Mbus: "nats://127.0.0.1:4222"} existingSettingsBytes, _ := json.Marshal(expectedSettings) fs.WriteToFile(settingsPath, string(existingSettingsBytes)) dummy := NewDummyInfrastructure(fs, dirProvider, platform) settings, err := dummy.GetSettings() assert.NoError(GinkgoT(), err) assert.Equal(GinkgoT(), settings, boshsettings.Settings{ AgentId: "123-456-789", Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy}, Mbus: "nats://127.0.0.1:4222", }) }) It("get settings errs when settings file does not exist", func() { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") platform := fakeplatform.NewFakePlatform() dummy := NewDummyInfrastructure(fs, dirProvider, platform) _, err := dummy.GetSettings() assert.Error(GinkgoT(), err) assert.Contains(GinkgoT(), err.Error(), "Read settings file") }) }) }
func TestApplyInstallsAndEnablesJob(t *testing.T) { jobsBc, _, _, applier := buildJobApplier() pkg := buildJob() fs := fakesys.NewFakeFileSystem() jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) err := applier.Apply(pkg) assert.NoError(t, err) assert.True(t, jobsBc.IsInstalled(pkg)) assert.True(t, jobsBc.IsEnabled(pkg)) }
func TestApplyErrsWhenTempDirErrs(t *testing.T) { jobsBc, blobstore, _, _, applier := buildJobApplier() job := buildJob() fs := fakesys.NewFakeFileSystem() fs.TempDirError = errors.New("fake-filesystem-tempdir-error") jobsBc.InstallFs = fs blobstore.GetFileName = "/dev/null" err := applier.Apply(job) assert.Error(t, err) assert.Contains(t, err.Error(), "fake-filesystem-tempdir-error") }
func TestApplyInstallsAndEnablesJob(t *testing.T) { jobsBc, _, _, _, applier := buildJobApplier() job, bundle := buildJob(jobsBc) fs := fakesys.NewFakeFileSystem() bundle.InstallFs = fs bundle.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) err := applier.Apply(job) assert.NoError(t, err) assert.True(t, bundle.Installed) assert.True(t, bundle.Enabled) }
func NewFakePlatform() (platform *FakePlatform) { platform = new(FakePlatform) platform.Fs = fakesys.NewFakeFileSystem() platform.Runner = fakesys.NewFakeCmdRunner() platform.FakeCompressor = fakecmd.NewFakeCompressor() platform.FakeCopier = fakecmd.NewFakeCopier() platform.FakeVitalsService = fakevitals.NewFakeService() platform.DevicePathResolver = fakedpresolv.NewFakeDevicePathResolver() platform.AddUserToGroupsGroups = make(map[string][]string) platform.SetupSshPublicKeys = make(map[string]string) platform.UserPasswords = make(map[string]string) platform.ScsiDiskMap = make(map[string]string) return }
func buildCompiler() ( compressor *fakecmd.FakeCompressor, blobstore *fakeblobstore.FakeBlobstore, fs *fakesys.FakeFileSystem, runner *fakesys.FakeCmdRunner, compiler Compiler, ) { compressor = fakecmd.NewFakeCompressor() blobstore = &fakeblobstore.FakeBlobstore{} fs = fakesys.NewFakeFileSystem() runner = fakesys.NewFakeCmdRunner() compiler = newConcreteCompiler(compressor, blobstore, fs, runner, boshdirs.NewDirectoriesProvider("/fake-dir")) return }
func startServer() (serverURL string, handler HttpsHandler, fs *fakesys.FakeFileSystem) { serverURL = "https://*****:*****@127.0.0.1:6900" mbusUrl, _ := url.Parse(serverURL) logger := boshlog.NewLogger(boshlog.LEVEL_NONE) fs = fakesys.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") handler = NewHttpsHandler(mbusUrl, logger, fs, dirProvider) go handler.Start(func(req boshhandler.Request) (resp boshhandler.Response) { receivedRequest = req return boshhandler.NewValueResponse("expected value") }) return }
func TestApplyErrsWhenJobEnableFails(t *testing.T) { jobsBc, _, _, applier := buildJobApplier() pkg := buildJob() fs := fakesys.NewFakeFileSystem() jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) jobsBc.EnableError = errors.New("fake-enable-error") err := applier.Apply(pkg) assert.Error(t, err) assert.Contains(t, err.Error(), "fake-enable-error") }
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")) }) }) }
func TestApplyErrsWhenCopyAllErrs(t *testing.T) { jobsBc, blobstore, _, _, applier := buildJobApplier() job := buildJob() fs := fakesys.NewFakeFileSystem() fs.TempDirDir = "fake-tmp-dir" fs.CopyDirEntriesError = errors.New("fake-copy-dir-entries-error") jobsBc.InstallFs = fs blobstore.GetFileName = "/dev/null" err := applier.Apply(job) assert.Error(t, err) assert.Contains(t, err.Error(), "fake-copy-dir-entries-error") }
func buildDrain() ( cmdRunner *fakesys.FakeCmdRunner, fs *fakesys.FakeFileSystem, notifier *fakenotif.FakeNotifier, specService *fakeas.FakeV1Service, action drainAction, ) { cmdRunner = fakesys.NewFakeCmdRunner() fs = fakesys.NewFakeFileSystem() notifier = fakenotif.NewFakeNotifier() specService = fakeas.NewFakeV1Service() dirProvider := boshdirs.NewDirectoriesProvider("/fake-dir") drainScriptProvider := boshdrain.NewDrainScriptProvider(cmdRunner, fs, dirProvider) action = newDrain(notifier, specService, drainScriptProvider) return }
func NewFakePlatform() (platform *FakePlatform) { platform = new(FakePlatform) platform.Fs = fakesys.NewFakeFileSystem() platform.Runner = &fakesys.FakeCmdRunner{} platform.FakeStatsCollector = &fakestats.FakeStatsCollector{} platform.FakeCompressor = fakecmd.NewFakeCompressor() platform.FakeCopier = fakecmd.NewFakeCopier() platform.FakeVitalsService = fakevitals.NewFakeService() platform.FakeDiskManager = fakedisk.NewFakeDiskManager() platform.DevicePathResolver = boshdevicepathresolver.NewFakeDevicePathResolver(1*time.Millisecond, platform.Fs) platform.AddUserToGroupsGroups = make(map[string][]string) platform.SetupSshPublicKeys = make(map[string]string) platform.UserPasswords = make(map[string]string) platform.ScsiDiskMap = make(map[string]string) return }
func TestApplyErrsWhenTempDirErrs(t *testing.T) { jobsBc, blobstore, _, applier := buildJobApplier() pkg := buildJob() file, err := os.Open("/dev/null") assert.NoError(t, err) defer file.Close() fs := fakesys.NewFakeFileSystem() fs.TempDirError = errors.New("fake-filesystem-tempdir-error") jobsBc.InstallFs = fs blobstore.GetFile = file err = applier.Apply(pkg) assert.Error(t, err) assert.Contains(t, err.Error(), "fake-filesystem-tempdir-error") }
func buildDrainScript(commandResult fakesys.FakeCmdResult) ( drainScript ConcreteDrainScript, params staticDrainParams, runner *fakesys.FakeCmdRunner, fs *fakesys.FakeFileSystem, ) { fs = fakesys.NewFakeFileSystem() runner = fakesys.NewFakeCmdRunner() drainScript = NewConcreteDrainScript(fs, runner, "/fake/script") params = staticDrainParams{ jobChange: "job_shutdown", hashChange: "hash_unchanged", updatedPackages: []string{"foo", "bar"}, } runner.AddCmdResult("/fake/script"+" job_shutdown hash_unchanged foo bar", commandResult) return }
func TestApplyDownloadsAndCleansUpJob(t *testing.T) { jobsBc, blobstore, _, _, applier := buildJobApplier() job := buildJob() job.Source.BlobstoreId = "fake-blobstore-id" job.Source.Sha1 = "blob-sha1" fs := fakesys.NewFakeFileSystem() jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) blobstore.GetFileName = "/dev/null" err := applier.Apply(job) assert.NoError(t, err) assert.Equal(t, "fake-blobstore-id", blobstore.GetBlobIds[0]) assert.Equal(t, "blob-sha1", blobstore.GetFingerprints[0]) assert.Equal(t, blobstore.GetFileName, blobstore.CleanUpFileName) }
func TestApplyDecompressesJobToTmpPathAndCleansItUp(t *testing.T) { jobsBc, blobstore, compressor, _, applier := buildJobApplier() job := buildJob() fs := fakesys.NewFakeFileSystem() fs.TempDirDir = "fake-tmp-dir" fs.MkdirAll("fake-tmp-dir", os.FileMode(0)) jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) blobstore.GetFileName = "/dev/null" err := applier.Apply(job) assert.NoError(t, err) assert.Equal(t, blobstore.GetFileName, compressor.DecompressFileToDirTarballPaths[0]) assert.Equal(t, "fake-tmp-dir", compressor.DecompressFileToDirDirs[0]) assert.Nil(t, fs.GetFileTestStat(fs.TempDirDir)) }
func TestApplyDownloadsAndCleansUpJob(t *testing.T) { jobsBc, blobstore, _, applier := buildJobApplier() pkg := buildJob() pkg.Source.BlobstoreId = "fake-blobstore-id" file, err := os.Open("/dev/null") assert.NoError(t, err) defer file.Close() fs := fakesys.NewFakeFileSystem() jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) blobstore.GetFile = file err = applier.Apply(pkg) assert.NoError(t, err) assert.Equal(t, "fake-blobstore-id", blobstore.GetBlobId) assert.Equal(t, file, blobstore.CleanUpFile) }
func TestGetSettings(t *testing.T) { fs := fakefs.NewFakeFileSystem() dirProvider := boshdir.NewDirectoriesProvider("/var/vcap") settingsPath := filepath.Join(dirProvider.BaseDir(), "bosh", "settings.json") expectedSettings := boshsettings.Settings{AgentId: "123-456-789", Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy}, Mbus: "nats://127.0.0.1:4222"} existingSettingsBytes, _ := json.Marshal(expectedSettings) fs.WriteToFile(settingsPath, string(existingSettingsBytes)) dummy := newDummyInfrastructure(fs, dirProvider) settings, err := dummy.GetSettings() assert.NoError(t, err) assert.Equal(t, settings, boshsettings.Settings{ AgentId: "123-456-789", Blobstore: boshsettings.Blobstore{Type: boshsettings.BlobstoreTypeDummy}, Mbus: "nats://127.0.0.1:4222", }) }
func TestApplySetsExecutableBitForFilesInBin(t *testing.T) { jobsBc, blobstore, compressor, _, applier := buildJobApplier() job := buildJob() job.Source.PathInArchive = "fake-path-in-archive" blobstore.GetFileName = "/dev/null" fs := fakesys.NewFakeFileSystem() fs.TempDirDir = "fake-tmp-dir" jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" compressor.DecompressFileToDirCallBack = func() { fs.WriteToFile("fake-tmp-dir/fake-path-in-archive/bin/test1", "") fs.WriteToFile("fake-tmp-dir/fake-path-in-archive/bin/test2", "") fs.WriteToFile("fake-tmp-dir/fake-path-in-archive/config/test", "") } fs.GlobPaths = []string{"fake-install-dir/bin/test1", "fake-install-dir/bin/test2"} err := applier.Apply(job) assert.NoError(t, err) assert.Equal(t, "fake-install-dir/bin/*", fs.GlobPattern) testBin1Stats := fs.GetFileTestStat("fake-install-dir/bin/test1") assert.NotNil(t, testBin1Stats) assert.Equal(t, 0755, int(testBin1Stats.FileMode)) testBin2Stats := fs.GetFileTestStat("fake-install-dir/bin/test2") assert.NotNil(t, testBin2Stats) assert.Equal(t, 0755, int(testBin2Stats.FileMode)) testConfigStats := fs.GetFileTestStat("fake-install-dir/config/test") assert.NotNil(t, testConfigStats) assert.NotEqual(t, 0755, int(testConfigStats.FileMode)) }
func TestApplyDecompressesJobToTmpPath(t *testing.T) { jobsBc, blobstore, compressor, applier := buildJobApplier() pkg := buildJob() file, err := os.Open("/dev/null") assert.NoError(t, err) defer file.Close() fs := fakesys.NewFakeFileSystem() fs.TempDirDir = "fake-tmp-dir" fs.MkdirAll("fake-tmp-dir", os.FileMode(0)) jobsBc.InstallFs = fs jobsBc.InstallPath = "fake-install-dir" fs.MkdirAll("fake-install-dir", os.FileMode(0)) blobstore.GetFile = file err = applier.Apply(pkg) assert.NoError(t, err) assert.Equal(t, file, compressor.DecompressFileToDirTarball) assert.Equal(t, "fake-tmp-dir", compressor.DecompressFileToDirDir) }