Esempio n. 1
0
	Describe("releasing", func() {
		It("releases all sources", func() {
			err := step.Release()
			Ω(err).ShouldNot(HaveOccurred())

			Ω(outStepA.ReleaseCallCount()).Should(Equal(1))
			Ω(outStepB.ReleaseCallCount()).Should(Equal(1))
		})

		Context("when the sources fail to release", func() {
			disasterA := errors.New("nope A")
			disasterB := errors.New("nope B")

			BeforeEach(func() {
				outStepA.ReleaseReturns(disasterA)
				outStepB.ReleaseReturns(disasterB)
			})

			It("returns an error describing the failures", func() {
				err := step.Release()
				Ω(err).Should(HaveOccurred())

				Ω(err.Error()).Should(ContainSubstring("nope A"))
				Ω(err.Error()).Should(ContainSubstring("nope B"))
			})
		})
	})

	Describe("getting a result", func() {
		Context("when the result type is bad", func() {
Esempio n. 2
0
			Ω(repo).Should(Equal(repo))
		})

		Describe("releasing", func() {
			It("releases the output source", func() {
				err := step.Release()
				Ω(err).ShouldNot(HaveOccurred())

				Ω(outStep.ReleaseCallCount()).Should(Equal(1))
			})

			Context("when releasing the output source fails", func() {
				disaster := errors.New("nope")

				BeforeEach(func() {
					outStep.ReleaseReturns(disaster)
				})

				It("returns the error", func() {
					Ω(step.Release()).Should(Equal(disaster))
				})
			})
		})
	}

	Context("with no conditions", func() {
		BeforeEach(func() {
			conditional.Conditions = atc.Conditions{}
		})

		Context("when the input source is successful", func() {
Esempio n. 3
0
								err := step.Release()
								Ω(err).ShouldNot(HaveOccurred())

								Ω(outStep.ReleaseCallCount()).Should(Equal(2))
								Ω(successStep.ReleaseCallCount()).Should(Equal(1))
								Ω(nextStep.ReleaseCallCount()).Should(Equal(1))
							})

							Context("when releasing the sources fails", func() {
								disasterA := errors.New("nope A")
								disasterB := errors.New("nope B")
								disasterC := errors.New("nope C")

								BeforeEach(func() {
									outStep.ReleaseReturns(disasterA)
									successStep.ReleaseReturns(disasterB)
									nextStep.ReleaseReturns(disasterC)
								})

								It("returns an aggregate error", func() {
									Eventually(process.Wait()).Should(Receive(BeNil()))

									err := step.Release()
									Ω(err).Should(HaveOccurred())

									Ω(err.Error()).Should(ContainSubstring("first step: nope A"))
									Ω(err.Error()).Should(ContainSubstring("success step: nope B"))
									Ω(err.Error()).Should(ContainSubstring("next step: nope C"))
								})
							})