func describeRemotePackageCompiler() {
var mockCtrl *gomock.Controller
BeforeEach(func() {
mockCtrl = gomock.NewController(GinkgoT())
})
AfterEach(func() {
mockCtrl.Finish()
})
var (
packageRepo bistatepkg.CompiledPackageRepo
pkgDependency *birelpkg.Package
pkg *birelpkg.Package
mockBlobstore *mock_blobstore.MockBlobstore
mockAgentClient *mock_agentclient.MockAgentClient
archivePath = "fake-archive-path"
remotePackageCompiler bistatepkg.Compiler
compiledPackages map[bistatepkg.CompiledPackageRecord]*birelpkg.Package
expectBlobstoreAdd *gomock.Call
expectAgentCompile *gomock.Call
)
BeforeEach(func() {
mockBlobstore = mock_blobstore.NewMockBlobstore(mockCtrl)
mockAgentClient = mock_agentclient.NewMockAgentClient(mockCtrl)
index := biindex.NewInMemoryIndex()
packageRepo = bistatepkg.NewCompiledPackageRepo(index)
remotePackageCompiler = NewRemotePackageCompiler(mockBlobstore, mockAgentClient, packageRepo)
pkgDependency = &birelpkg.Package{
Name: "fake-package-name-dep",
Fingerprint: "fake-package-fingerprint-dep",
}
pkg = &birelpkg.Package{
Name: "fake-package-name",
Fingerprint: "fake-package-fingerprint",
SHA1: "fake-source-package-sha1",
ArchivePath: archivePath,
Dependencies: []*birelpkg.Package{pkgDependency},
}
depRecord1 := bistatepkg.CompiledPackageRecord{
BlobID: "fake-compiled-package-blob-id-dep",
BlobSHA1: "fake-compiled-package-sha1-dep",
}
compiledPackages = map[bistatepkg.CompiledPackageRecord]*birelpkg.Package{
depRecord1: pkgDependency,
}
})
JustBeforeEach(func() {
// add compiled packages to the repo
for record, dependency := range compiledPackages {
err := packageRepo.Save(*dependency, record)
Expect(err).ToNot(HaveOccurred())
}
packageSource := biagentclient.BlobRef{
Name: "fake-package-name",
Version: "fake-package-fingerprint",
BlobstoreID: "fake-source-package-blob-id",
SHA1: "fake-source-package-sha1",
}
packageDependencies := []biagentclient.BlobRef{
{
Name: "fake-package-name-dep",
Version: "fake-package-fingerprint-dep",
BlobstoreID: "fake-compiled-package-blob-id-dep",
SHA1: "fake-compiled-package-sha1-dep",
},
}
compiledPackageRef := biagentclient.BlobRef{
Name: "fake-package-name",
Version: "fake-package-version",
BlobstoreID: "fake-compiled-package-blob-id",
SHA1: "fake-compiled-package-sha1",
}
expectBlobstoreAdd = mockBlobstore.EXPECT().Add(archivePath).Return("fake-source-package-blob-id", nil).AnyTimes()
expectAgentCompile = mockAgentClient.EXPECT().CompilePackage(packageSource, packageDependencies).Return(compiledPackageRef, nil).AnyTimes()
})
Describe("Compile", func() {
It("uploads the package archive to the blobstore and then compiles the package with the agent", func() {
gomock.InOrder(
expectBlobstoreAdd.Times(1),
expectAgentCompile.Times(1),
)
compiledPackageRecord, _, err := remotePackageCompiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(compiledPackageRecord).To(Equal(bistatepkg.CompiledPackageRecord{
BlobID: "fake-compiled-package-blob-id",
BlobSHA1: "fake-compiled-package-sha1",
}))
})
It("saves the compiled package ref in the package repo", func() {
compiledPackageRecord, _, err := remotePackageCompiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
record, found, err := packageRepo.Find(*pkg)
Expect(err).ToNot(HaveOccurred())
Expect(found).To(BeTrue())
Expect(record).To(Equal(compiledPackageRecord))
})
Context("when the dependencies are not in the repo", func() {
BeforeEach(func() {
compiledPackages = map[bistatepkg.CompiledPackageRecord]*birelpkg.Package{}
})
It("returns an error", func() {
_, _, err := remotePackageCompiler.Compile(pkg)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Remote compilation failure: Package 'fake-package-name/fake-package-fingerprint' requires package 'fake-package-name-dep/fake-package-fingerprint-dep', but it has not been compiled"))
})
})
Context("when package belongs to a compiled release", func() {
BeforeEach(func() {
pkg.Stemcell = "ubuntu/fake"
})
AfterEach(func() {
pkg.Stemcell = ""
})
It("should skip compilation", func() {
compiledPackageRecord, isAlreadyCompiled, err := remotePackageCompiler.Compile(pkg)
expectAgentCompile.Times(0)
Expect(err).ToNot(HaveOccurred())
Expect(isAlreadyCompiled).To(Equal(true))
Expect(compiledPackageRecord.BlobID).To(Equal("fake-source-package-blob-id"))
Expect(compiledPackageRecord.BlobSHA1).To(Equal(pkg.SHA1))
})
})
})
}
BlobID: "fake-blob-id",
BlobSHA1: "fake-fingerprint",
}
expectSave = mockCompiledPackageRepo.EXPECT().Save(*pkg, record).AnyTimes()
})
Context("when the compiled package repo already has the package", func() {
JustBeforeEach(func() {
compiledPkgRecord := bistatepkg.CompiledPackageRecord{
BlobSHA1: "fake-fingerprint",
}
expectFind.Return(compiledPkgRecord, true, nil).Times(1)
})
It("skips the compilation", func() {
_, _, err := compiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
Expect(len(runner.RunComplexCommands)).To(Equal(0))
})
})
It("installs all the dependencies for the package", func() {
_, _, err := compiler.Compile(pkg)
Expect(err).ToNot(HaveOccurred())
blobstoreID, sha1, jobPath := fakeExtractor.ExtractArgsForCall(0)
Expect(blobstoreID).To(Equal(dep1.BlobID))
Expect(sha1).To(Equal(dep1.BlobSHA1))
Expect(jobPath).To(Equal(filepath.Join(packagesDir, "fake-package-name-dependency-1")))