func commonTestOrderedCalls(t *testing.T) (reporter *ErrorReporter, ctrl *gomock.Controller, subjectOne, subjectTwo *Subject) {
reporter, ctrl = createFixtures(t)
subjectOne = new(Subject)
subjectTwo = new(Subject)
gomock.InOrder(
ctrl.RecordCall(subjectOne, "FooMethod", "1").AnyTimes(),
ctrl.RecordCall(subjectTwo, "FooMethod", "2"),
ctrl.RecordCall(subjectTwo, "BarMethod", "3"),
)
return
}
func TestCallAfterLoopPanic(t *testing.T) {
_, ctrl := createFixtures(t)
subject := new(Subject)
firstCall := ctrl.RecordCall(subject, "Foo", "1")
secondCall := ctrl.RecordCall(subject, "Foo", "2")
thirdCall := ctrl.RecordCall(subject, "Foo", "3")
gomock.InOrder(firstCall, secondCall, thirdCall)
defer func() {
err := recover()
if err == nil {
t.Error("Call.After creation of dependency loop did not panic.")
}
}()
// This should panic due to dependency loop.
firstCall.After(thirdCall)
}
cpiInstaller,
mockCpiUninstaller,
releaseFetcher,
releaseSetAndInstallationManifestParser,
tempRootConfigurator,
targetProvider,
)
}
var expectDeleteAndCleanup = func(defaultUninstallerUsed bool) {
mockDeploymentManagerFactory.EXPECT().NewManager(mockCloud, mockAgentClient, mockBlobstore).Return(mockDeploymentManager)
mockDeploymentManager.EXPECT().FindCurrent().Return(mockDeployment, true, nil)
gomock.InOrder(
mockDeployment.EXPECT().Delete(gomock.Any()).Do(func(stage biui.Stage) {
Expect(fakeStage.SubStages).To(ContainElement(stage))
}),
mockDeploymentManager.EXPECT().Cleanup(fakeStage),
)
if defaultUninstallerUsed {
mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil)
}
}
var expectCleanup = func() {
mockDeploymentManagerFactory.EXPECT().NewManager(mockCloud, mockAgentClient, mockBlobstore).Return(mockDeploymentManager).AnyTimes()
mockDeploymentManager.EXPECT().FindCurrent().Return(nil, false, nil).AnyTimes()
mockDeploymentManager.EXPECT().Cleanup(fakeStage)
mockCpiUninstaller.EXPECT().Uninstall(gomock.Any()).Return(nil)
}
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))
})
})
})
}
var expectDeployFlow = func() {
agentID := "fake-uuid-0"
vmCID := "fake-vm-cid-1"
diskCID := "fake-disk-cid-1"
diskSize := 1024
//TODO: use a real StateBuilder and test mockBlobstore.Add & mockAgentClient.CompilePackage
gomock.InOrder(
mockCloud.EXPECT().CreateStemcell(stemcellImagePath, stemcellCloudProperties).Return(stemcellCID, nil),
mockCloud.EXPECT().CreateVM(agentID, stemcellCID, vmCloudProperties, networkInterfaces, vmEnv).Return(vmCID, nil),
mockCloud.EXPECT().SetVMMetadata(vmCID, gomock.Any()).Return(nil),
mockAgentClient.EXPECT().Ping().Return("any-state", nil),
mockCloud.EXPECT().CreateDisk(diskSize, diskCloudProperties, vmCID).Return(diskCID, nil),
mockCloud.EXPECT().AttachDisk(vmCID, diskCID),
mockAgentClient.EXPECT().MountDisk(diskCID),
mockAgentClient.EXPECT().Stop(),
mockAgentClient.EXPECT().Apply(applySpec),
mockAgentClient.EXPECT().Start(),
mockAgentClient.EXPECT().GetState().Return(agentRunningState, nil),
)
}
var expectDeployWithDiskMigration = func() {
agentID := "fake-uuid-1"
oldVMCID := "fake-vm-cid-1"
newVMCID := "fake-vm-cid-2"
oldDiskCID := "fake-disk-cid-1"
newDiskCID := "fake-disk-cid-2"
compiledPackageRecord1 := bistatepkg.CompiledPackageRecord{
BlobID: "fake-compiled-package-blobstore-id-1",
BlobSHA1: "fake-compiled-package-sha1-1",
}
expectCompilePkg1 = mockPackageCompiler.EXPECT().Compile(releasePackage1).Return(compiledPackageRecord1, false, nil).AnyTimes()
compiledPackageRecord2 := bistatepkg.CompiledPackageRecord{
BlobID: "fake-compiled-package-blobstore-id-2",
BlobSHA1: "fake-compiled-package-sha1-2",
}
expectCompilePkg2 = mockPackageCompiler.EXPECT().Compile(releasePackage2).Return(compiledPackageRecord2, false, nil).AnyTimes()
})
It("compiles all the job dependencies (packages) such that no package is compiled before its dependencies", func() {
gomock.InOrder(
expectCompilePkg1.Times(1),
expectCompilePkg2.Times(1),
)
_, err := dependencyCompiler.Compile(releaseJobs, fakeStage)
Expect(err).ToNot(HaveOccurred())
})
It("returns references to the compiled packages", func() {
compiledPackageRefs, err := dependencyCompiler.Compile(releaseJobs, fakeStage)
Expect(err).ToNot(HaveOccurred())
Expect(compiledPackageRefs).To(Equal([]CompiledPackageRef{
{
Name: "fake-release-package-name-1",
Version: "fake-release-package-fingerprint-1",
BlobstoreID: "fake-compiled-package-blobstore-id-1",
mockBlobstore *mock_blobstore.MockBlobstore
fakeStage *fakebiui.FakeStage
deploymentFactory Factory
deployment Deployment
)
var expectNormalFlow = func() {
gomock.InOrder(
mockCloud.EXPECT().HasVM("fake-vm-cid").Return(true, nil),
mockAgentClient.EXPECT().Ping().Return("any-state", nil), // ping to make sure agent is responsive
mockAgentClient.EXPECT().Stop(), // stop all jobs
mockAgentClient.EXPECT().ListDisk().Return([]string{"fake-disk-cid"}, nil), // get mounted disks to be unmounted
mockAgentClient.EXPECT().UnmountDisk("fake-disk-cid"),
mockCloud.EXPECT().DeleteVM("fake-vm-cid"),
mockCloud.EXPECT().DeleteDisk("fake-disk-cid"),
mockCloud.EXPECT().DeleteStemcell("fake-stemcell-cid"),
)
}
var allowApplySpecToBeCreated = func() {
jobName := "fake-job-name"
jobIndex := 0
applySpec := bias.ApplySpec{
Deployment: "test-release",
Index: jobIndex,
Packages: map[string]bias.Blob{},
Networks: map[string]biproperty.Map{
