Exemple #1
0
				expectNormalFlow()

				err := deployment.Delete(fakeStage)
				Expect(err).ToNot(HaveOccurred())

				_, found, err := vmRepo.FindCurrent()
				Expect(found).To(BeFalse(), "should be no current VM")

				_, found, err = diskRepo.FindCurrent()
				Expect(found).To(BeFalse(), "should be no current disk")

				diskRecords, err := diskRepo.All()
				Expect(err).ToNot(HaveOccurred())
				Expect(diskRecords).To(BeEmpty(), "expected no disk records")

				_, found, err = stemcellRepo.FindCurrent()
				Expect(found).To(BeFalse(), "should be no current stemcell")

				stemcellRecords, err := stemcellRepo.All()
				Expect(err).ToNot(HaveOccurred())
				Expect(stemcellRecords).To(BeEmpty(), "expected no stemcell records")
			})

			//TODO: It'd be nice to test recovering after agent was responsive, before timeout (hard to do with gomock)
			Context("when agent is unresponsive", func() {
				BeforeEach(func() {
					// reduce timout & delay to reduce test duration
					pingTimeout := 1 * time.Second
					pingDelay := 100 * time.Millisecond
					deploymentFactory = NewFactory(pingTimeout, pingDelay)
				})
Exemple #2
0
				currentStemcellRecord, err = stemcellRepo.Save("fake-stemcell-name", "fake-stemcell-version", "fake-stemcell-cid")
				Expect(err).ToNot(HaveOccurred())
				err = stemcellRepo.UpdateCurrent(currentStemcellRecord.ID)
				Expect(err).ToNot(HaveOccurred())
			})

			It("does not delete anything", func() {
				err := deploymentManager.Cleanup(fakeStage)
				Expect(err).ToNot(HaveOccurred())

				diskRecord, found, err := diskRepo.FindCurrent()
				Expect(err).ToNot(HaveOccurred())
				Expect(found).To(BeTrue())
				Expect(diskRecord).To(Equal(currentDiskRecord))

				stemcellRecord, found, err := stemcellRepo.FindCurrent()
				Expect(err).ToNot(HaveOccurred())
				Expect(found).To(BeTrue())
				Expect(stemcellRecord).To(Equal(currentStemcellRecord))
			})

			It("does not log any stages", func() {
				err := deploymentManager.Cleanup(fakeStage)
				Expect(err).ToNot(HaveOccurred())

				Expect(fakeStage.PerformCalls).To(BeEmpty())
			})
		})

		Context("orphan disk records exist", func() {
			BeforeEach(func() {
		cloudStemcell = NewCloudStemcell(stemcellRecord, stemcellRepo, fakeCloud)
	})

	Describe("PromoteAsCurrent", func() {
		Context("when stemcell is in the repo", func() {
			BeforeEach(func() {
				fakeUUIDGenerator.GeneratedUUID = "fake-stemcell-id"
				_, err := stemcellRepo.Save("fake-stemcell-name", "fake-stemcell-version", "fake-stemcell-cid")
				Expect(err).ToNot(HaveOccurred())
			})

			It("sets stemcell as current in the repo", func() {
				err := cloudStemcell.PromoteAsCurrent()
				Expect(err).ToNot(HaveOccurred())

				currentStemcell, found, err := stemcellRepo.FindCurrent()
				Expect(err).ToNot(HaveOccurred())
				Expect(found).To(BeTrue())
				Expect(currentStemcell).To(Equal(biconfig.StemcellRecord{
					ID:      "fake-stemcell-id",
					CID:     "fake-stemcell-cid",
					Name:    "fake-stemcell-name",
					Version: "fake-stemcell-version",
				}))
			})
		})

		Context("when stemcell is not in the repo", func() {
			It("returns an error", func() {
				err := cloudStemcell.PromoteAsCurrent()
				Expect(err).To(HaveOccurred())