It("returns the repo record", func() {
record, err := compiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(record).To(Equal(bistatepkg.CompiledPackageRecord{
BlobID: "fake-blob-id",
BlobSHA1: "fake-fingerprint",
}))
})
It("cleans up the packages dir", func() {
_, err := compiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(packagesDir)).To(BeFalse())
})
Context("when dependency installation fails", func() {
JustBeforeEach(func() {
fakeExtractor.ExtractReturns(errors.New("fake-install-error"))
})
It("returns an error", func() {
_, err := compiler.Compile(pkg)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-install-error"))
})
})
Context("when the packaging script does not exist", func() {
func init() {
Describe("settingsService", func() {
var (
fs *fakesys.FakeFileSystem
fakeDefaultNetworkResolver *fakenet.FakeDefaultNetworkResolver
fakeSettingsSource *fakes.FakeSettingsSource
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
fakeDefaultNetworkResolver = &fakenet.FakeDefaultNetworkResolver{}
fakeSettingsSource = &fakes.FakeSettingsSource{}
})
buildService := func() (Service, *fakesys.FakeFileSystem) {
logger := boshlog.NewLogger(boshlog.LevelNone)
service := NewService(fs, "/setting/path.json", fakeSettingsSource, fakeDefaultNetworkResolver, logger)
return service, fs
}
Describe("LoadSettings", func() {
var (
fetchedSettings Settings
fetcherFuncErr error
service Service
)
BeforeEach(func() {
fetchedSettings = Settings{}
fetcherFuncErr = nil
})
JustBeforeEach(func() {
fakeSettingsSource.SettingsValue = fetchedSettings
fakeSettingsSource.SettingsErr = fetcherFuncErr
service, fs = buildService()
})
Context("when settings fetcher succeeds fetching settings", func() {
BeforeEach(func() {
fetchedSettings = Settings{AgentID: "some-new-agent-id"}
})
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fetchedSettings.Networks = Networks{
"fake-net-1": Network{Type: NetworkTypeDynamic},
}
})
It("updates the service with settings from the fetcher", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
Expect(service.GetSettings().AgentID).To(Equal("some-new-agent-id"))
})
It("persists settings to the settings file", func() {
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
json, err := json.Marshal(fetchedSettings)
Expect(err).NotTo(HaveOccurred())
fileContent, err := fs.ReadFile("/setting/path.json")
Expect(err).NotTo(HaveOccurred())
Expect(fileContent).To(Equal(json))
})
It("returns any error from writing to the setting file", func() {
fs.WriteFileError = errors.New("fs-write-file-error")
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-write-file-error"))
})
})
})
Context("when settings fetcher fails fetching settings", func() {
BeforeEach(func() {
fetcherFuncErr = errors.New("fake-fetch-error")
})
Context("when a settings file exists", func() {
Context("when settings contain at most one dynamic network", func() {
BeforeEach(func() {
fs.WriteFile("/setting/path.json", []byte(`{
"agent_id":"some-agent-id",
"networks": {"fake-net-1": {"type": "dynamic"}}
}`))
fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns settings from the settings file with resolved network", func() {
err := service.LoadSettings()
Expect(err).ToNot(HaveOccurred())
Expect(service.GetSettings()).To(Equal(Settings{
AgentID: "some-agent-id",
Networks: Networks{
"fake-net-1": Network{
Type: NetworkTypeDynamic,
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
Resolved: true,
},
},
}))
})
})
})
Context("when non-unmarshallable settings file exists", func() {
It("returns any error from the fetcher", func() {
fs.WriteFile("/setting/path.json", []byte(`$%^&*(`))
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
Context("when no settings file exists", func() {
It("returns any error from the fetcher", func() {
err := service.LoadSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-fetch-error"))
Expect(service.GetSettings()).To(Equal(Settings{}))
})
})
})
})
Describe("InvalidateSettings", func() {
It("removes the settings file", func() {
fakeSettingsSource.SettingsValue = Settings{}
fakeSettingsSource.SettingsErr = nil
service, fs := buildService()
fs.WriteFile("/setting/path.json", []byte(`{}`))
err := service.InvalidateSettings()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("/setting/path.json")).To(BeFalse())
})
It("returns err if removing settings file errored", func() {
fakeSettingsSource.SettingsValue = Settings{}
fakeSettingsSource.SettingsErr = nil
service, fs := buildService()
fs.RemoveAllError = errors.New("fs-remove-all-error")
err := service.InvalidateSettings()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fs-remove-all-error"))
})
})
Describe("GetSettings", func() {
var (
loadedSettings Settings
service Service
)
BeforeEach(func() {
loadedSettings = Settings{AgentID: "some-agent-id"}
})
JustBeforeEach(func() {
fakeSettingsSource.SettingsValue = loadedSettings
fakeSettingsSource.SettingsErr = nil
service, _ = buildService()
err := service.LoadSettings()
Expect(err).NotTo(HaveOccurred())
})
Context("when there is are no dynamic networks", func() {
It("returns settings without modifying any networks", func() {
Expect(service.GetSettings()).To(Equal(loadedSettings))
})
It("does not try to determine default network", func() {
_ = service.GetSettings()
Expect(fakeDefaultNetworkResolver.GetDefaultNetworkCalled).To(BeFalse())
})
})
Context("when there is network that needs to be resolved (ip, netmask, or mac are not set)", func() {
BeforeEach(func() {
loadedSettings = Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Mac: "fake-net1-mac",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
Gateway: "fake-net2-gateway",
DNS: []string{"fake-net2-dns"},
},
},
}
})
Context("when default network can be retrieved", func() {
BeforeEach(func() {
fakeDefaultNetworkResolver.GetDefaultNetworkNetwork = Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
}
})
It("returns settings with resolved dynamic network ip, netmask, gateway and keeping everything else the same", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(Settings{
Networks: map[string]Network{
"fake-net1": Network{
IP: "fake-net1-ip",
Netmask: "fake-net1-netmask",
Mac: "fake-net1-mac",
Gateway: "fake-net1-gateway",
},
"fake-net2": Network{
IP: "fake-resolved-ip",
Netmask: "fake-resolved-netmask",
Gateway: "fake-resolved-gateway",
DNS: []string{"fake-net2-dns"},
Resolved: true,
},
},
}))
})
})
Context("when default network fails to be retrieved", func() {
BeforeEach(func() {
fakeDefaultNetworkResolver.GetDefaultNetworkErr = errors.New("fake-get-default-network-err")
})
It("returns error", func() {
settings := service.GetSettings()
Expect(settings).To(Equal(loadedSettings))
})
})
})
})
})
}
Context("when the job does not exist", func() {
It("returns nil and false", func() {
_, ok := release.FindJobByName("fake-non-existent-job")
Expect(ok).To(BeFalse())
})
})
})
Describe("Delete", func() {
BeforeEach(func() {
fakeFS.WriteFileString("fake-extracted-path", "")
})
It("deletes the extracted release path", func() {
Expect(fakeFS.FileExists("fake-extracted-path")).To(BeTrue())
err := release.Delete()
Expect(err).ToNot(HaveOccurred())
Expect(fakeFS.FileExists("fake-extracted-path")).To(BeFalse())
})
})
Describe("Exists", func() {
BeforeEach(func() {
fakeFS.WriteFileString("fake-extracted-path", "")
})
It("returns false after deletion", func() {
Expect(release.Exists()).To(BeTrue())
err := release.Delete()
Expect(err).ToNot(HaveOccurred())
fs.WriteFileString("source-path", "")
err := cache.Save("source-path", &fakeSource{
sha1: "fake-sha1",
url: "http://foo.bar.com",
description: "some tarball",
})
Expect(err).ToNot(HaveOccurred())
path, found := cache.Get(&fakeSource{
sha1: "fake-sha1",
url: "http://foo.bar.com",
description: "some tarball",
})
Expect(found).To(BeTrue())
Expect(fs.FileExists(path)).To(BeTrue())
})
It("is a cache miss when a tarball from a different url has been downloaded, even if SHA1 matches", func() {
fs.WriteFileString("source-path", "")
err := cache.Save("source-path", &fakeSource{
sha1: "fake-sha1",
url: "http://foo.bar.com",
description: "some tarball",
})
Expect(err).ToNot(HaveOccurred())
_, found := cache.Get(&fakeSource{
sha1: "fake-sha1",
url: "http://baz.bar.com",
blobSHA1 = "fake-sha1"
fileName = "tarball.tgz"
blobstore.GetFileName = fileName
fakeError = errors.New("Initial error")
extractor = NewExtractor(fs, compressor, blobstore, logger)
})
Describe("Cleanup", func() {
BeforeEach(func() {
err := extractor.Extract(blobID, blobSHA1, targetDir)
Expect(err).ToNot(HaveOccurred())
})
It("deletes the extracted temp file", func() {
Expect(fs.FileExists(targetDir)).To(BeTrue())
err := extractor.Cleanup(blobID, targetDir)
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(targetDir)).To(BeFalse())
})
It("deletes the stored blob", func() {
err := extractor.Cleanup(blobID, targetDir)
Expect(err).ToNot(HaveOccurred())
Expect(blobstore.DeleteBlobID).To(Equal(blobID))
})
})
Describe("Extract", func() {
Context("when the specified blobID exists in the blobstore", func() {
It("creates the installed package dir if it does not exist", func() {
Expect(deploymentState.DirectorID).To(Equal("fake-director-id"))
Expect(deploymentState.Stemcells).To(Equal(stemcells))
Expect(deploymentState.CurrentVMCID).To(Equal("fake-vm-cid"))
Expect(deploymentState.CurrentDiskID).To(Equal("fake-disk-id"))
Expect(deploymentState.Disks).To(Equal(disks))
})
Context("when the config does not exist", func() {
It("returns a new DeploymentState with generated defaults", func() {
deploymentState, err := service.Load()
Expect(err).NotTo(HaveOccurred())
Expect(deploymentState).To(Equal(DeploymentState{
DirectorID: "fake-uuid-0",
}))
Expect(fakeFs.FileExists(deploymentStatePath)).To(BeTrue())
})
})
Context("when reading config file fails", func() {
BeforeEach(func() {
fakeFs.WriteFileString(deploymentStatePath, "{}")
fakeFs.ReadFileError = errors.New("fake-read-error")
})
It("returns an error", func() {
_, err := service.Load()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-error"))
})
})
})
Describe("Path", func() {
It("returns the rendered job path", func() {
Expect(renderedJob.Path()).To(Equal(renderedJobPath))
})
})
Describe("Delete", func() {
It("deletes the rendered job path from the file system", func() {
err := fs.MkdirAll(renderedJobPath, os.ModePerm)
Expect(err).ToNot(HaveOccurred())
err = renderedJob.Delete()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(renderedJobPath)).To(BeFalse())
})
Context("when deleting from the file system fails", func() {
JustBeforeEach(func() {
fs.RemoveAllError = bosherr.Error("fake-delete-error")
})
It("returns an error", func() {
err := renderedJob.Delete()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-delete-error"))
})
})
})
Expect(archive.Fingerprint()).To(Equal("fake-sha1"))
})
It("calculates the SHA1 of the archive", func() {
fakeCompressor.CompressFilesInDirTarballPath = "fake-archive-path"
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-archive-path": fakebicrypto.CalculateInput{Sha1: "fake-sha1"},
})
archive, err := renderedJobListCompressor.Compress(renderedJobList)
Expect(err).ToNot(HaveOccurred())
Expect(archive.SHA1()).To(Equal("fake-sha1"))
})
It("deletes the temp dir compressed into the archive", func() {
fakeFS.TempDirDir = "fake-rendered-job-list-path"
err := fakeFS.MkdirAll("fake-rendered-job-list-path", os.ModePerm)
Expect(err).ToNot(HaveOccurred())
_, err = renderedJobListCompressor.Compress(renderedJobList)
Expect(err).ToNot(HaveOccurred())
Expect(fakeFS.FileExists("fake-rendered-job-list-path")).To(BeFalse())
})
})
})
})
Expect(count).To(Equal(0))
})
})
Describe("cert.Manager implementations", func() {
var (
fakeFs *fakesys.FakeFileSystem
fakeCmd *fakesys.FakeCmdRunner
certManager cert.Manager
)
SharedLinuxCertManagerExamples := func(certBasePath, certUpdateProgram string) {
It("writes 1 cert to a file", func() {
err := certManager.UpdateCertificates(cert1)
Expect(err).NotTo(HaveOccurred())
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath))).To(BeTrue())
})
It("writes each cert to its own file", func() {
certs := fmt.Sprintf("%s\n%s\n", cert1, cert1)
err := certManager.UpdateCertificates(certs)
Expect(err).NotTo(HaveOccurred())
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath))).To(BeTrue())
Expect(fakeFs.FileExists(fmt.Sprintf("%s/bosh-trusted-cert-2.crt", certBasePath))).To(BeTrue())
Expect(countFiles(fakeFs, certBasePath)).To(Equal(2))
})
It("deletes all certs when passed an empty string", func() {
fakeFs.WriteFileString(fmt.Sprintf("%s/bosh-trusted-cert-1.crt", certBasePath), "goodbye")
fakeFs.SetGlob(fmt.Sprintf("%s/bosh-trusted-cert-*", certBasePath), []string{
It("errs when copy file errs", func() {
tempFile, err := fs.TempFile("bosh-blobstore-local-TestLocalGetErrsWhenCopyFileErrs")
Expect(err).ToNot(HaveOccurred())
fs.ReturnTempFile = tempFile
defer fs.RemoveAll(tempFile.Name())
fs.CopyFileError = errors.New("fake-copy-file-error")
fileName, err := blobstore.Get("fake-blob-id", "")
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-copy-file-error"))
Expect(fileName).To(BeEmpty())
Expect(fs.FileExists(tempFile.Name())).To(BeFalse())
})
})
Describe("CleanUp", func() {
It("removes the path given by Get", func() {
file, err := fs.TempFile("bosh-blobstore-local-TestLocalCleanUp")
Expect(err).ToNot(HaveOccurred())
fileName := file.Name()
defer fs.RemoveAll(fileName)
err = blobstore.CleanUp(fileName)
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(fileName)).To(BeFalse())
})
fs *fakesys.FakeFileSystem
cdrom *fakecdrom.FakeCdrom
cdutil boshdevutil.DeviceUtil
logger boshlog.Logger
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
cdrom = fakecdrom.NewFakeCdrom(fs, "env", "fake env contents")
logger = boshlog.NewLogger(boshlog.LevelNone)
})
JustBeforeEach(func() {
cdutil = boshcdrom.NewCdUtil("/fake/settings/dir", fs, cdrom, logger)
})
It("gets file contents from CDROM", func() {
contents, err := cdutil.GetFilesContents([]string{"env"})
Expect(err).NotTo(HaveOccurred())
Expect(cdrom.Mounted).To(Equal(false))
Expect(cdrom.MediaAvailable).To(Equal(false))
Expect(fs.FileExists("/fake/settings/dir")).To(Equal(true))
Expect(cdrom.MountMountPath).To(Equal("/fake/settings/dir"))
Expect(len(contents)).To(Equal(1))
Expect(contents[0]).To(Equal([]byte("fake env contents")))
})
})
_, err := provider.Get(source, fakeStage)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("'fake-sha2' does not match expected SHA1 'fake-sha1'"))
})
It("retries downloading up to 3 times", func() {
_, err := provider.Get(source, fakeStage)
Expect(err).To(HaveOccurred())
Expect(httpClient.GetInputs).To(HaveLen(3))
})
It("removes the downloaded file", func() {
_, err := provider.Get(source, fakeStage)
Expect(err).To(HaveOccurred())
Expect(fs.FileExists(tempDownloadFilePath)).To(BeFalse())
})
})
Context("when saving to cache fails", func() {
BeforeEach(func() {
// Creating cache base directory fails
fs.MkdirAllError = errors.New("fake-mkdir-error")
})
It("returns an error", func() {
_, err := provider.Get(source, fakeStage)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-mkdir-error"))
})
fakeUUIDGenerator = fakeuuid.NewFakeGenerator()
legacyDeploymentStateFilePath = "/path/to/legacy/bosh-deployment.yml"
modernDeploymentStateFilePath = "/path/to/legacy/deployment.json"
logger := boshlog.NewLogger(boshlog.LevelNone)
deploymentStateService = NewFileSystemDeploymentStateService(fakeFs, fakeUUIDGenerator, logger, modernDeploymentStateFilePath)
migrator = NewLegacyDeploymentStateMigrator(deploymentStateService, fakeFs, fakeUUIDGenerator, logger)
})
Describe("MigrateIfExists", func() {
Context("when no legacy deploment config file exists", func() {
It("does nothing", func() {
migrated, err := migrator.MigrateIfExists(legacyDeploymentStateFilePath)
Expect(migrated).To(BeFalse())
Expect(err).ToNot(HaveOccurred())
Expect(fakeFs.FileExists(modernDeploymentStateFilePath)).To(BeFalse())
})
})
Context("when legacy deploment config file exists (but is unparseable)", func() {
BeforeEach(func() {
fakeFs.WriteFileString(legacyDeploymentStateFilePath, `xyz`)
})
It("does not delete the legacy deployment state file", func() {
migrated, err := migrator.MigrateIfExists(legacyDeploymentStateFilePath)
Expect(migrated).To(BeFalse())
Expect(err).To(HaveOccurred())
Expect(fakeFs.FileExists(modernDeploymentStateFilePath)).To(BeFalse())
Expect(fakeFs.FileExists(legacyDeploymentStateFilePath)).To(BeTrue())
})
Describe("SHA1", func() {
It("returns the rendered job list archive sha1", func() {
Expect(renderedJobListArchive.SHA1()).To(Equal(renderedJobListArchiveSHA1))
})
})
Describe("Delete", func() {
It("deletes the rendered job list archive from the file system", func() {
err := fs.MkdirAll(renderedJobListArchivePath, os.ModePerm)
Expect(err).ToNot(HaveOccurred())
err = renderedJobListArchive.Delete()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(renderedJobListArchivePath)).To(BeFalse())
})
Context("when deleting from the file system fails", func() {
JustBeforeEach(func() {
fs.RemoveAllError = bosherr.Error("fake-delete-error")
})
It("returns an error", func() {
err := renderedJobListArchive.Delete()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-delete-error"))
})
})
})
It("extracts and parses the stemcell manifest", func() {
stemcell, err := extractor.Extract(stemcellTarballPath)
Expect(err).ToNot(HaveOccurred())
Expect(stemcell).To(Equal(expectedExtractedStemcell))
Expect(reader.ReadInputs).To(Equal([]fakebistemcell.ReadInput{
{
StemcellTarballPath: stemcellTarballPath,
DestPath: stemcellExtractionDir,
},
}))
})
It("does not delete the destination file path", func() {
extractor.Extract(stemcellTarballPath)
Expect(fs.FileExists(stemcellExtractionDir)).To(BeTrue())
})
})
Context("when the read fails", func() {
BeforeEach(func() {
reader.SetReadBehavior(stemcellTarballPath, stemcellExtractionDir, expectedExtractedStemcell, errors.New("fake-read-error"))
})
It("returns an error", func() {
_, err := extractor.Extract(stemcellTarballPath)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-read-error"))
})
It("deletes the destination file path", func() {
Expect(string(contents[0])).To(Equal("fake-contents-1"))
Expect(string(contents[1])).To(Equal("fake-contents-2"))
})
It("unmount disk path", func() {
_, err := diskUtil.GetFilesContents([]string{"fake-file-path-1"})
Expect(err).ToNot(HaveOccurred())
Expect(mounter.UnmountPartitionPathOrMountPoint).To(Equal("fake-tempdir"))
})
It("cleans up temporary directory after reading settings", func() {
_, err := diskUtil.GetFilesContents([]string{"fake-file-path-1"})
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("fake-tempdir")).To(BeFalse())
})
It("returns error if it fails to create temporary mount directory", func() {
fs.TempDirError = errors.New("fake-tempdir-error")
_, err := diskUtil.GetFilesContents([]string{"fake-file-path-1"})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-tempdir-error"))
})
It("returns error if it fails to mount disk path", func() {
mounter.MountErr = errors.New("fake-mount-error")
_, err := diskUtil.GetFilesContents([]string{"fake-file-path-1"})
Expect(err).To(HaveOccurred())
It("deletes the rendered jobs", func() {
err := fs.MkdirAll("fake-path-0", os.ModePerm)
Expect(err).ToNot(HaveOccurred())
err = fs.MkdirAll("fake-path-1", os.ModePerm)
Expect(err).ToNot(HaveOccurred())
renderedJob0 := NewRenderedJob(bireljob.Job{Name: "fake-job-0"}, "fake-path-0", fs, logger)
renderedJob1 := NewRenderedJob(bireljob.Job{Name: "fake-job-1"}, "fake-path-1", fs, logger)
renderedJobList.Add(renderedJob0)
renderedJobList.Add(renderedJob1)
err = renderedJobList.Delete()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists("fake-path-0")).To(BeFalse())
Expect(fs.FileExists("fake-path-1")).To(BeFalse())
})
Context("when deleting from the file system fails", func() {
JustBeforeEach(func() {
fs.RemoveAllError = bosherr.Error("fake-delete-error")
})
It("returns an error", func() {
renderedJob0 := NewRenderedJob(bireljob.Job{Name: "fake-job-0"}, "fake-path-0", fs, logger)
renderedJobList.Add(renderedJob0)
err := renderedJobList.Delete()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-delete-error"))
PackageNames: []string{
"fake-release-package-name",
},
Packages: []*birelpkg.Package{expectedPackage},
Properties: map[string]bireljob.PropertyDefinition{},
},
},
[]*birelpkg.Package{expectedPackage},
"/extracted-release-path",
fakeFS,
false,
)
Expect(release).To(Equal(expectedRelease))
Expect(fakeFS.FileExists("/extracted-release-path")).To(BeTrue())
Expect(fakeFS.FileExists("/extracted-release-path/extracted_packages/fake-release-package-name")).To(BeTrue())
Expect(fakeFS.FileExists("/extracted-release-path/extracted_jobs/cpi")).To(BeTrue())
})
})
Context("and the tarball is not a valid BOSH release", func() {
BeforeEach(func() {
fakeFS.WriteFileString("/extracted-release-path/release.MF", `{}`)
fakeReleaseValidator.ValidateError = bosherr.Error("fake-error")
})
It("returns an error", func() {
_, err := releaseExtractor.Extract(releaseTarballPath)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-error"))
gomock.InOrder(
expectCPIExtractRelease.Times(1),
expectCPIInstall.Times(1),
expectNewCloud.Times(1),
)
err := newDeploymentDeleter().DeleteDeployment(fakeStage)
Expect(err).NotTo(HaveOccurred())
})
It("deletes the extracted CPI release", func() {
expectDeleteAndCleanup(true)
err := newDeploymentDeleter().DeleteDeployment(fakeStage)
Expect(err).NotTo(HaveOccurred())
Expect(fs.FileExists("fake-cpi-extracted-dir")).To(BeFalse())
})
It("deletes the deployment & cleans up orphans", func() {
expectDeleteAndCleanup(true)
err := newDeploymentDeleter().DeleteDeployment(fakeStage)
Expect(err).ToNot(HaveOccurred())
Expect(fakeUI.Errors).To(BeEmpty())
})
It("deletes the local CPI installation", func() {
expectDeleteAndCleanup(false)
mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil)
err := newDeploymentDeleter().DeleteDeployment(fakeStage)
})
Describe("Path", func() {
It("returns the local blob path", func() {
Expect(localBlob.Path()).To(Equal(localBlobPath))
})
})
Describe("Delete", func() {
It("deletes the local blob from the file system", func() {
err := fs.WriteFileString(localBlobPath, "fake-local-blob-content")
Expect(err).ToNot(HaveOccurred())
err = localBlob.Delete()
Expect(err).ToNot(HaveOccurred())
Expect(fs.FileExists(localBlobPath)).To(BeFalse())
})
Context("when deleting from the file system fails", func() {
JustBeforeEach(func() {
fs.RemoveAllError = bosherr.Error("fake-delete-error")
})
It("returns an error", func() {
err := localBlob.Delete()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-delete-error"))
})
})
})