var _ = Describe("Provider", func() {
var (
provider Provider
cache Cache
fs *fakesys.FakeFileSystem
httpClient *fakebihttpclient.FakeHTTPClient
sha1Calculator *fakebicrypto.FakeSha1Calculator
source *fakeSource
fakeStage *fakebiui.FakeStage
)
BeforeEach(func() {
fs = fakesys.NewFakeFileSystem()
logger := boshlog.NewLogger(boshlog.LevelNone)
cache = NewCache("/fake-base-path", fs, logger)
sha1Calculator = fakebicrypto.NewFakeSha1Calculator()
httpClient = fakebihttpclient.NewFakeHTTPClient()
provider = NewProvider(cache, fs, httpClient, sha1Calculator, 3, 0, logger)
fakeStage = fakebiui.NewFakeStage()
})
Describe("Get", func() {
Context("when URL starts with file://", func() {
BeforeEach(func() {
source = newFakeSource("file://fake-file", "fake-sha1", "fake-description")
fs.WriteFileString("expanded-file-path", "")
fs.ExpandPathExpanded = "expanded-file-path"
})
It("returns expanded path to file", func() {
path, err := provider.Get(source, fakeStage)
expectCPIInstall = mockCpiInstaller.EXPECT().Install(installationManifest, gomock.Any()).Do(func(_ biinstallmanifest.Manifest, stage biui.Stage) {
Expect(fakeStage.SubStages).To(ContainElement(stage))
}).Return(fakeInstallation, nil).AnyTimes()
mockCpiInstaller.EXPECT().Cleanup(fakeInstallation).AnyTimes()
expectNewCloud = mockCloudFactory.EXPECT().NewCloud(fakeInstallation, directorID).Return(mockCloud, nil).AnyTimes()
}
var newDeploymentDeleter = func() bicmd.DeploymentDeleter {
releaseSetValidator := birelsetmanifest.NewValidator(logger)
releaseSetParser := birelsetmanifest.NewParser(fs, logger, releaseSetValidator)
installationValidator := biinstallmanifest.NewValidator(logger)
installationParser := biinstallmanifest.NewParser(fs, fakeUUIDGenerator, logger, installationValidator)
fakeHTTPClient := fakebihttpclient.NewFakeHTTPClient()
tarballCache := bitarball.NewCache("fake-base-path", fs, logger)
fakeSHA1Calculator := fakebicrypto.NewFakeSha1Calculator()
tarballProvider := bitarball.NewProvider(tarballCache, fs, fakeHTTPClient, fakeSHA1Calculator, 1, 0, logger)
deploymentStateService := biconfig.NewFileSystemDeploymentStateService(fs, fakeUUIDGenerator, logger, biconfig.DeploymentStatePath(deploymentManifestPath))
cpiInstaller := bicpirel.CpiInstaller{
ReleaseManager: releaseManager,
InstallerFactory: mockInstallerFactory,
Validator: bicpirel.NewValidator(),
}
releaseFetcher := birel.NewFetcher(tarballProvider, mockReleaseExtractor, releaseManager)
releaseSetAndInstallationManifestParser := bicmd.ReleaseSetAndInstallationManifestParser{
ReleaseSetParser: releaseSetParser,
InstallationParser: installationParser,
}
fakeInstallationUUIDGenerator := &fakeuuid.FakeGenerator{}
fakeInstallationUUIDGenerator.GeneratedUUID = "fake-installation-id"
func rootDesc() {
var (
fakeRelease *fakebirel.FakeRelease
stemcell bistemcell.ExtractedStemcell
deploymentRepo *fakebiconfig.FakeDeploymentRepo
releaseRepo *fakebiconfig.FakeReleaseRepo
stemcellRepo *fakebiconfig.FakeStemcellRepo
fakeSHA1Calculator *fakebicrypto.FakeSha1Calculator
deploymentRecord Record
releases []release.Release
)
BeforeEach(func() {
fakeRelease = &fakebirel.FakeRelease{
ReleaseName: "fake-release-name",
ReleaseVersion: "fake-release-version",
}
releases = []release.Release{fakeRelease}
fakeFS := fakesys.NewFakeFileSystem()
stemcell = bistemcell.NewExtractedStemcell(
bistemcell.Manifest{
Name: "fake-stemcell-name",
Version: "fake-stemcell-version",
},
"fake-extracted-path",
fakeFS,
)
deploymentRepo = fakebiconfig.NewFakeDeploymentRepo()
releaseRepo = &fakebiconfig.FakeReleaseRepo{}
stemcellRepo = fakebiconfig.NewFakeStemcellRepo()
fakeSHA1Calculator = fakebicrypto.NewFakeSha1Calculator()
deploymentRecord = NewRecord(deploymentRepo, releaseRepo, stemcellRepo, fakeSHA1Calculator)
})
Describe("IsDeployed", func() {
BeforeEach(func() {
stemcellRecord := biconfig.StemcellRecord{
ID: "fake-stemcell-id",
Name: "fake-stemcell-name",
Version: "fake-stemcell-version",
CID: "fake-stemcell-cid",
}
stemcellRepo.SetFindCurrentBehavior(stemcellRecord, true, nil)
deploymentRepo.SetFindCurrentBehavior("fake-manifest-sha1", true, nil)
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-manifest-path": fakebicrypto.CalculateInput{
Sha1: "fake-manifest-sha1",
Err: nil,
},
})
})
Context("when the stemcell and manifest do not change", func() {
Context("when no release is currently deployed", func() {
BeforeEach(func() {
releaseRepo.ListReturns([]biconfig.ReleaseRecord{}, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when the same release is currently deployed", func() {
BeforeEach(func() {
releaseRecords := []biconfig.ReleaseRecord{{
ID: "fake-release-id",
Name: fakeRelease.Name(),
Version: fakeRelease.Version(),
}}
releaseRepo.ListReturns(releaseRecords, nil)
})
It("returns true", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeTrue())
})
})
Context("when a different version of the same release is currently deployed", func() {
BeforeEach(func() {
Expect("other-version").ToNot(Equal(fakeRelease.Version()))
releaseRecords := []biconfig.ReleaseRecord{{
ID: "fake-release-id-2",
Name: fakeRelease.Name(),
Version: "other-version",
}}
releaseRepo.ListReturns(releaseRecords, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when a same version of a different release is currently deployed", func() {
BeforeEach(func() {
Expect("other-release").ToNot(Equal(fakeRelease.Name()))
releaseRecords := []biconfig.ReleaseRecord{{
ID: "fake-release-id-2",
Name: "other-release",
Version: fakeRelease.Version(),
}}
releaseRepo.ListReturns(releaseRecords, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when deploying multiple releases", func() {
var otherFakeRelease *fakebirel.FakeRelease
BeforeEach(func() {
otherFakeRelease = &fakebirel.FakeRelease{
ReleaseName: "other-fake-release-name",
ReleaseVersion: "other-fake-release-version",
}
releaseRecords := []biconfig.ReleaseRecord{
{
ID: "fake-release-id-1",
Name: fakeRelease.Name(),
Version: fakeRelease.Version(),
},
{
ID: "other-fake-release-id-1",
Name: otherFakeRelease.Name(),
Version: otherFakeRelease.Version(),
},
}
releaseRepo.ListReturns(releaseRecords, nil)
})
Context("when the same releases are currently deployed", func() {
Context("(in the same order)", func() {
BeforeEach(func() {
releases = []release.Release{
fakeRelease,
otherFakeRelease,
}
})
It("returns true", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeTrue())
})
})
Context("(in a different order)", func() {
BeforeEach(func() {
releases = []release.Release{
otherFakeRelease,
fakeRelease,
}
})
It("returns true", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeTrue())
})
})
Context("when a superset of releases is currently deployed", func() {
BeforeEach(func() {
releases = []release.Release{
fakeRelease,
}
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
})
})
})
Context("when getting current deployment manifest sha1 fails", func() {
BeforeEach(func() {
deploymentRepo.SetFindCurrentBehavior("fake-manifest-path", true, errors.New("fake-find-error"))
})
It("returns an error", func() {
_, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-find-error"))
})
})
Context("when no deployment is set", func() {
BeforeEach(func() {
deploymentRepo.SetFindCurrentBehavior("", false, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when calculating the deployment manifest sha1 fails", func() {
BeforeEach(func() {
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-manifest-path": fakebicrypto.CalculateInput{
Sha1: "",
Err: errors.New("fake-calculate-error"),
},
})
})
It("returns an error", func() {
_, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-calculate-error"))
})
})
Context("when a different deployment manifest is currently deployed", func() {
BeforeEach(func() {
deploymentRepo.SetFindCurrentBehavior("fake-manifest-sha1-2", true, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when finding the currently deployed stemcell fails", func() {
BeforeEach(func() {
stemcellRepo.SetFindCurrentBehavior(biconfig.StemcellRecord{}, false, errors.New("fake-find-error"))
})
It("returns an error", func() {
_, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-find-error"))
})
})
Context("when no stemcell is currently deployed", func() {
BeforeEach(func() {
stemcellRepo.SetFindCurrentBehavior(biconfig.StemcellRecord{}, false, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when a different stemcell is currently deployed", func() {
BeforeEach(func() {
stemcellRecord := biconfig.StemcellRecord{
ID: "fake-stemcell-id-2",
Name: "fake-stemcell-name-2",
Version: "fake-stemcell-version-2",
CID: "fake-stemcell-cid-2",
}
stemcellRepo.SetFindCurrentBehavior(stemcellRecord, true, nil)
})
It("returns false", func() {
isDeployed, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).ToNot(HaveOccurred())
Expect(isDeployed).To(BeFalse())
})
})
Context("when finding the currently deployed release fails", func() {
BeforeEach(func() {
releaseRepo.ListReturns([]biconfig.ReleaseRecord{}, errors.New("fake-find-error"))
})
It("returns an error", func() {
_, err := deploymentRecord.IsDeployed("fake-manifest-path", releases, stemcell)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-find-error"))
})
})
})
Describe("Update", func() {
BeforeEach(func() {
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-manifest-path": fakebicrypto.CalculateInput{
Sha1: "fake-manifest-sha1",
Err: nil,
},
})
})
It("calculates and updates sha1 of currently deployed manifest", func() {
err := deploymentRecord.Update("fake-manifest-path", releases)
Expect(err).ToNot(HaveOccurred())
Expect(deploymentRepo.UpdateCurrentManifestSHA1).To(Equal("fake-manifest-sha1"))
})
It("passes the releases to the release repo", func() {
err := deploymentRecord.Update("fake-manifest-path", releases)
Expect(err).ToNot(HaveOccurred())
Expect(releaseRepo.UpdateCallCount()).To(Equal(1))
Expect(releaseRepo.UpdateArgsForCall(0)).To(Equal(releases))
})
Context("when calculating the deployment manifest sha1 fails", func() {
BeforeEach(func() {
fakeSHA1Calculator.SetCalculateBehavior(map[string]fakebicrypto.CalculateInput{
"fake-manifest-path": fakebicrypto.CalculateInput{
Sha1: "",
Err: errors.New("fake-calculate-error"),
},
})
})
It("returns an error", func() {
err := deploymentRecord.Update("fake-manifest-path", releases)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-calculate-error"))
})
It("does not update the release records", func() {
deploymentRecord.Update("fake-manifest-path", releases)
Expect(releaseRepo.UpdateCallCount()).To(Equal(0))
})
})
Context("when updating currently deployed manifest sha1 fails", func() {
BeforeEach(func() {
deploymentRepo.UpdateCurrentErr = errors.New("fake-update-error")
})
It("returns an error", func() {
err := deploymentRecord.Update("fake-manifest-path", releases)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-update-error"))
})
It("does not update the release records", func() {
deploymentRecord.Update("fake-manifest-path", releases)
Expect(releaseRepo.UpdateCallCount()).To(Equal(0))
})
})
Context("when updating release records fails", func() {
BeforeEach(func() {
releaseRepo.UpdateReturns(errors.New("fake-update-error"))
})
It("returns an error", func() {
err := deploymentRecord.Update("fake-manifest-path", releases)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-update-error"))
})
})
})
Describe("Clear", func() {
It("clears manifest hash", func() {
deploymentRepo.UpdateCurrentManifestSHA1 = "initial-sha1"
err := deploymentRecord.Clear()
Expect(err).ToNot(HaveOccurred())
Expect(deploymentRepo.UpdateCurrentManifestSHA1).To(Equal(""))
})
It("clears releases list", func() {
err := deploymentRecord.Clear()
Expect(err).ToNot(HaveOccurred())
Expect(releaseRepo.UpdateCallCount()).To(Equal(1))
Expect(releaseRepo.UpdateArgsForCall(0)).To(Equal([]release.Release{}))
})
Context("when clearing manifest hash fails", func() {
BeforeEach(func() {
deploymentRepo.UpdateCurrentErr = errors.New("fake-update-error")
})
It("returns an error", func() {
err := deploymentRecord.Clear()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-update-error"))
})
})
Context("when clearing release records fails", func() {
BeforeEach(func() {
releaseRepo.UpdateReturns(errors.New("fake-update-error"))
})
It("returns an error", func() {
err := deploymentRecord.Clear()
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("fake-update-error"))
})
})
})
}
