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{