func describeDummyPlatform() { var ( platform Platform collector boshstats.Collector fs boshsys.FileSystem cmdRunner boshsys.CmdRunner dirProvider boshdirs.Provider devicePathResolver boshdpresolv.DevicePathResolver logger boshlog.Logger ) BeforeEach(func() { collector = &fakestats.FakeCollector{} fs = fakesys.NewFakeFileSystem() cmdRunner = fakesys.NewFakeCmdRunner() dirProvider = boshdirs.NewProvider("/fake-dir") devicePathResolver = fakedpresolv.NewFakeDevicePathResolver() logger = boshlog.NewLogger(boshlog.LevelNone) }) JustBeforeEach(func() { platform = NewDummyPlatform( collector, fs, cmdRunner, dirProvider, devicePathResolver, logger, ) }) Describe("GetDefaultNetwork", func() { It("returns the contents of dummy-defaults-network-settings.json since that's what the dummy cpi writes", func() { settingsFilePath := "/fake-dir/bosh/dummy-default-network-settings.json" fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`) network, err := platform.GetDefaultNetwork() Expect(err).NotTo(HaveOccurred()) Expect(network.IP).To(Equal("1.2.3.4")) }) }) Describe("GetCertManager", func() { It("returs a dummy cert manager", func() { certManager := platform.GetCertManager() Expect(certManager.UpdateCertificates("")).Should(BeNil()) }) }) }
blobId = "105d33ae-655c-493d-bf9f-1df5cf3ca847" basePath = os.TempDir() blobPath = filepath.Join(basePath, blobId) toWrite = bytes.NewReader([]byte("new data")) }) readFile := func(fileIO boshsys.File) []byte { fileStat, _ := fileIO.Stat() fileBytes := make([]byte, fileStat.Size()) fileIO.Read(fileBytes) return fileBytes } It("fetches", func() { blobManager := NewBlobManager(fs, basePath) fs.WriteFileString(blobPath, "some data") readOnlyFile, err, _ := blobManager.Fetch(blobId) defer fs.RemoveAll(readOnlyFile.Name()) Expect(err).ToNot(HaveOccurred()) fileBytes := readFile(readOnlyFile) Expect(string(fileBytes)).To(Equal("some data")) }) It("writes", func() { blobManager := NewBlobManager(fs, basePath) fs.WriteFileString(blobPath, "some data") defer fs.RemoveAll(blobPath)
Expect(cmdRunner.RunCommands[0]).To(Equal( []string{ "tar", "--same-owner", "-xzvf", tarballPath, "-C", dstDir, }, )) }) }) Describe("CleanUp", func() { It("removes tarball path", func() { fs := fakesys.NewFakeFileSystem() compressor := NewTarballCompressor(cmdRunner, fs) err := fs.WriteFileString("/fake-tarball.tar", "") Expect(err).ToNot(HaveOccurred()) err = compressor.CleanUp("/fake-tarball.tar") Expect(err).ToNot(HaveOccurred()) Expect(fs.FileExists("/fake-tarball.tar")).To(BeFalse()) }) It("returns error if removing tarball path fails", func() { fs := fakesys.NewFakeFileSystem() compressor := NewTarballCompressor(cmdRunner, fs) fs.RemoveAllStub = func(_ string) error { return errors.New("fake-remove-all-err") }
func init() { Describe("App", func() { var ( baseDir string agentConfPath string agentConfJSON string app App ) BeforeEach(func() { var err error baseDir, err = ioutil.TempDir("", "go-agent-test") Expect(err).ToNot(HaveOccurred()) err = os.Mkdir(filepath.Join(baseDir, "bosh"), os.ModePerm) Expect(err).ToNot(HaveOccurred()) }) BeforeEach(func() { agentConfPath = filepath.Join(baseDir, "bosh", "agent.json") agentConfJSON = `{ "Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } } }` settingsPath := filepath.Join(baseDir, "bosh", "settings.json") settingsJSON := `{ "agent_id": "my-agent-id", "blobstore": { "options": { "bucket_name": "george", "encryption_key": "optional encryption key", "access_key_id": "optional access key id", "secret_access_key": "optional secret access key" }, "provider": "dummy" }, "disks": { "ephemeral": "/dev/sdb", "persistent": { "vol-xxxxxx": "/dev/sdf" }, "system": "/dev/sda1" }, "env": { "bosh": { "password": "******" } }, "networks": { "netA": { "default": ["dns", "gateway"], "ip": "ww.ww.ww.ww", "dns": [ "xx.xx.xx.xx", "yy.yy.yy.yy" ] }, "netB": { "dns": [ "zz.zz.zz.zz" ] } }, "Mbus": "https://*****:*****@0.0.0.0:6868", "ntp": [ "0.north-america.pool.ntp.org", "1.north-america.pool.ntp.org" ], "vm": { "name": "vm-abc-def" } }` err := ioutil.WriteFile(settingsPath, []byte(settingsJSON), 0640) Expect(err).ToNot(HaveOccurred()) }) JustBeforeEach(func() { err := ioutil.WriteFile(agentConfPath, []byte(agentConfJSON), 0640) Expect(err).ToNot(HaveOccurred()) logger := boshlog.NewLogger(boshlog.LevelNone) fakefs := boshsys.NewOsFileSystem(logger) app = New(logger, fakefs) }) AfterEach(func() { os.RemoveAll(baseDir) }) It("Sets up device path resolver on platform specific to infrastructure", func() { err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(err).ToNot(HaveOccurred()) Expect(app.GetPlatform().GetDevicePathResolver()).To(Equal(devicepathresolver.NewIdentityDevicePathResolver())) }) Context("when DevicePathResolutionType is 'virtio'", func() { BeforeEach(func() { agentConfJSON = `{ "Platform": { "Linux": { "DevicePathResolutionType": "virtio" } }, "Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } } }` }) It("uses a VirtioDevicePathResolver", func() { err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(err).ToNot(HaveOccurred()) logLevel, err := boshlog.Levelify("DEBUG") Expect(err).NotTo(HaveOccurred()) Expect(app.GetPlatform().GetDevicePathResolver()).To( BeAssignableToTypeOf(devicepathresolver.NewVirtioDevicePathResolver(nil, nil, boshlog.NewLogger(logLevel)))) }) }) Context("when DevicePathResolutionType is 'scsi'", func() { BeforeEach(func() { agentConfJSON = `{ "Platform": { "Linux": { "DevicePathResolutionType": "scsi" } }, "Infrastructure": { "Settings": { "Sources": [{ "Type": "CDROM", "FileName": "/fake-file-name" }] } } }` }) It("uses a VirtioDevicePathResolver", func() { err := app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(err).ToNot(HaveOccurred()) Expect(app.GetPlatform().GetDevicePathResolver()).To( BeAssignableToTypeOf(devicepathresolver.NewScsiDevicePathResolver(nil, nil, nil))) }) }) Context("logging stemcell version and git sha", func() { var ( logger boshlog.Logger outBuf *bytes.Buffer fakeFs boshsys.FileSystem stemcellVersionFilePath string stemcellSha1FilePath string ) JustBeforeEach(func() { outBuf = bytes.NewBufferString("") errBuf := bytes.NewBufferString("") logger = boshlog.NewWriterLogger(boshlog.LevelDebug, outBuf, errBuf) fakeFs = fakesys.NewFakeFileSystem() dirProvider := boshdirs.NewProvider(baseDir) stemcellVersionFilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_version") stemcellSha1FilePath = filepath.Join(dirProvider.EtcDir(), "stemcell_git_sha1") app = New(logger, fakeFs) }) Context("when stemcell version and sha files are present", func() { It("should print out the stemcell version and sha in the logs", func() { fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah") fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah") app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: sha1-blah)")) }) }) Context("when stemcell version file is NOT present", func() { It("should print out the sha in the logs", func() { fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah") app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)")) }) }) Context("when sha version file is NOT present", func() { It("should print out the stemcell version in the logs", func() { fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah") app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)")) }) }) Context("when stemcell version file is empty", func() { It("should print out the sha in the logs", func() { fakeFs.WriteFileString(stemcellVersionFilePath, "") fakeFs.WriteFileString(stemcellSha1FilePath, "sha1-blah") app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: sha1-blah)")) }) }) Context("when sha version file is empty", func() { It("should print out the stemcell version in the logs", func() { fakeFs.WriteFileString(stemcellVersionFilePath, "version-blah") fakeFs.WriteFileString(stemcellSha1FilePath, "") app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version 'version-blah' (git: ?)")) }) }) Context("when stemcell version and sha files are NOT present", func() { It("should print unknown version and sha in the logs", func() { app.Setup([]string{"bosh-agent", "-P", "dummy", "-C", agentConfPath, "-b", baseDir}) Expect(string(outBuf.Bytes())).To(ContainSubstring("Running on stemcell version '?' (git: ?)")) }) }) }) }) }
Describe("AddJob", func() { It("creates a service with vcap description", func() { conf, err := AddJob("say-hello") Expect(err).ToNot(HaveOccurred()) for _, proc := range conf.Processes { stdout, _, _, err := runner.RunCommand("powershell", "/C", "get-service", proc.Name) Expect(err).ToNot(HaveOccurred()) Expect(stdout).To(ContainSubstring(proc.Name)) Expect(stdout).To(ContainSubstring("Stopped")) } }) Context("when monit file is empty", func() { BeforeEach(func() { Expect(fs.WriteFileString(processConfigPath, "")).To(Succeed()) }) It("does not return an error", func() { _, err := AddJob("say-hello") Expect(err).ToNot(HaveOccurred()) }) }) }) Describe("Start", func() { var conf WindowsProcessConfig BeforeEach(func() { var err error conf, err = AddJob("say-hello") Expect(err).ToNot(HaveOccurred())
BeforeEach(func() { fs = boshsys.NewOsFileSystem(logger) cmdRunner = boshsys.NewExecCmdRunner(logger) compressor = boshcmd.NewTarballCompressor(cmdRunner, fs) renderedJobListCompressor = NewRenderedJobListCompressor(fs, compressor, fakeSHA1Calculator, logger) }) It("copies rendered jobs into a new temp dir, compresses the temp dir, and wraps it in a RenderedJobListArchive", func() { // create rendered job with 2 rendered scripts renderedJobDir0, err := fs.TempDir("RenderedJobListCompressorTest") Expect(err).ToNot(HaveOccurred()) renderedJob0 := NewRenderedJob(bireljob.Job{Name: "fake-job-name-0"}, renderedJobDir0, fs, logger) defer func() { err := renderedJob0.Delete(); Expect(err).ToNot(HaveOccurred()) }() err = fs.WriteFileString(filepath.Join(renderedJobDir0, "script-0"), "fake-rendered-job-0-script-0-content") Expect(err).ToNot(HaveOccurred()) err = fs.WriteFileString(filepath.Join(renderedJobDir0, "script-1"), "fake-rendered-job-0-script-1-content") Expect(err).ToNot(HaveOccurred()) renderedJobList.Add(renderedJob0) // create another rendered job with 1 rendered script renderedJobDir1, err := fs.TempDir("RenderedJobListCompressorTest") Expect(err).ToNot(HaveOccurred()) renderedJob1 := NewRenderedJob(bireljob.Job{Name: "fake-job-name-1"}, renderedJobDir1, fs, logger) defer func() { err := renderedJob1.Delete(); Expect(err).ToNot(HaveOccurred()) }() err = fs.WriteFileString(filepath.Join(renderedJobDir1, "script-0"), "fake-rendered-job-1-script-0-content") Expect(err).ToNot(HaveOccurred()) renderedJobList.Add(renderedJob1) // compress
blobId = "105d33ae-655c-493d-bf9f-1df5cf3ca847" basePath = os.TempDir() blobPath = filepath.Join(basePath, blobId) toWrite = bytes.NewReader([]byte("new data")) }) readFile := func(fileIO boshsys.File) []byte { fileStat, _ := fileIO.Stat() fileBytes := make([]byte, fileStat.Size()) fileIO.Read(fileBytes) return fileBytes } It("fetches", func() { blobManager := NewBlobManager(fs, basePath) fs.WriteFileString(blobPath, "some data") readOnlyFile, err, _ := blobManager.Fetch(blobId) defer fs.RemoveAll(readOnlyFile.Name()) Expect(err).ToNot(HaveOccurred()) fileBytes := readFile(readOnlyFile) Expect(string(fileBytes)).To(Equal("some data")) }) It("writes", func() { blobManager := NewBlobManager(fs, basePath) fs.WriteFileString(blobPath, "some data") defer fs.RemoveAll(blobPath)
func GenerateDeploymentManifest(deploymentManifestFilePath string, fs boshsys.FileSystem, manifestContents string) error { return fs.WriteFileString(deploymentManifestFilePath, manifestContents) }
fs boshsys.FileSystem ) BeforeEach(func() { fs = fakesys.NewFakeFileSystem() factory = NewDigestProvider(fs) }) Describe("CreateFromFile", func() { const ( filePath = "/file.txt" fileContents = "something different" ) BeforeEach(func() { fs.WriteFileString(filePath, fileContents) }) Context("sha1", func() { It("opens a file and returns a digest", func() { expectedDigest, err := factory.CreateFromFile(filePath, DigestAlgorithmSHA1) Expect(err).ToNot(HaveOccurred()) Expect(expectedDigest.Digest()).To(Equal("da7102c07515effc353226eac2be923c916c5c94")) }) }) Context("sha256", func() { It("opens a file and returns a digest", func() { expectedDigest, err := factory.CreateFromFile(filePath, DigestAlgorithmSHA256) Expect(err).ToNot(HaveOccurred()) Expect(expectedDigest.Digest()).To(Equal("73af606b33433fa3a699134b39d5f6bce1ab4a6d9ca3263d3300f31fc5776b12"))
func describeDummyPlatform() { var ( platform Platform collector boshstats.Collector fs boshsys.FileSystem cmdRunner boshsys.CmdRunner dirProvider boshdirs.Provider devicePathResolver boshdpresolv.DevicePathResolver logger boshlog.Logger ) BeforeEach(func() { collector = &fakestats.FakeCollector{} fs = fakesys.NewFakeFileSystem() cmdRunner = fakesys.NewFakeCmdRunner() dirProvider = boshdirs.NewProvider("/fake-dir") devicePathResolver = fakedpresolv.NewFakeDevicePathResolver() logger = boshlog.NewLogger(boshlog.LevelNone) }) JustBeforeEach(func() { platform = NewDummyPlatform( collector, fs, cmdRunner, dirProvider, devicePathResolver, logger, ) }) Describe("GetDefaultNetwork", func() { It("returns the contents of dummy-defaults-network-settings.json since that's what the dummy cpi writes", func() { settingsFilePath := "/fake-dir/bosh/dummy-default-network-settings.json" fs.WriteFileString(settingsFilePath, `{"IP": "1.2.3.4"}`) network, err := platform.GetDefaultNetwork() Expect(err).NotTo(HaveOccurred()) Expect(network.IP).To(Equal("1.2.3.4")) }) }) Describe("GetCertManager", func() { It("returs a dummy cert manager", func() { certManager := platform.GetCertManager() Expect(certManager.UpdateCertificates("")).Should(BeNil()) }) }) Describe("UnmountPersistentDisk", func() { Context("when there are two mounted persistent disks in the mounts json", func() { BeforeEach(func() { var mounts []mount mounts = append(mounts, mount{MountDir: "dir1", DiskCid: "cid1"}) mounts = append(mounts, mount{MountDir: "dir2", DiskCid: "cid2"}) mountsJSON, _ := json.Marshal(mounts) mountsPath := path.Join(dirProvider.BoshDir(), "mounts.json") fs.WriteFile(mountsPath, mountsJSON) }) It("removes one of the disks from the mounts json", func() { unmounted, err := platform.UnmountPersistentDisk(settings.DiskSettings{ID: "cid1"}) Expect(err).NotTo(HaveOccurred()) Expect(unmounted).To(Equal(true)) Expect(platform.IsMountPoint("dir1")).To(Equal(false)) Expect(platform.IsMountPoint("dir2")).To(Equal(true)) }) }) }) }