Exemplo n.º 1
0
							BeforeEach(func() {
								createdBuild = new(enginefakes.FakeBuild)
								fakeEngine.CreateBuildReturns(createdBuild, nil)
							})

							It("triggers a build of the job with the found inputs", func() {
								err := scheduler.BuildLatestInputs(logger, job, resources)
								Ω(err).ShouldNot(HaveOccurred())

								Ω(fakePipelineDB.ScheduleBuildCallCount()).Should(Equal(1))
								scheduledBuildID, jobConfig := fakePipelineDB.ScheduleBuildArgsForCall(0)
								Ω(scheduledBuildID).Should(Equal(128))
								Ω(jobConfig).Should(Equal(job))

								Ω(factory.CreateCallCount()).Should(Equal(1))
								createJob, createResources, createInputs := factory.CreateArgsForCall(0)
								Ω(createJob).Should(Equal(job))
								Ω(createResources).Should(Equal(resources))
								Ω(createInputs).Should(Equal(newInputs))

								Ω(fakePipelineDB.UseInputsForBuildCallCount()).Should(Equal(1))
								usedBuildID, usedInputs := fakePipelineDB.UseInputsForBuildArgsForCall(0)
								Ω(usedBuildID).Should(Equal(128))
								Ω(usedInputs).Should(Equal(newInputs))

								Ω(fakeEngine.CreateBuildCallCount()).Should(Equal(1))
								builtBuild, plan := fakeEngine.CreateBuildArgsForCall(0)
								Ω(builtBuild).Should(Equal(db.Build{ID: 128, Name: "42"}))
								Ω(plan).Should(Equal(createdPlan))
							})
Exemplo n.º 2
0
							fakePipelineDB.UpdateBuildToScheduledReturns(false, nil)
						})

						It("logs and returns nil", func() {
							Expect(engineBuild).To(BeNil())
							Expect(logger).To(gbytes.Say("unable-to-update-build-to-scheduled"))
						})
					})

					Context("when the build is successfully marked as scheduled", func() {
						BeforeEach(func() {
							fakePipelineDB.UpdateBuildToScheduledReturns(true, nil)
						})

						It("creates a plan", func() {
							Expect(factory.CreateCallCount()).To(Equal(1))

							passedJob, passedResources, passedResourceTypes, passedInputs := factory.CreateArgsForCall(0)
							Expect(passedJob).To(Equal(job))
							Expect(passedResources).To(Equal(resources))
							Expect(passedResourceTypes).To(Equal(resourceTypes))
							Expect(passedInputs).To(ConsistOf(passedInputs))
						})

						Context("when making a plan for the build fails due to an error", func() {
							BeforeEach(func() {
								factory.CreateReturns(atc.Plan{}, errors.New("to err is human"))
							})

							It("marks the build as finished with an errored status and returns nil", func() {
								Expect(fakeBuildsDB.FinishBuildCallCount()).To(Equal(1))