Esempio n. 1
0
			Context("when job exists", func() {
				Context("when the next build exists", func() {
					BeforeEach(func() {
						job := atc.Job{
							Name:      expectedJobName,
							NextBuild: &expectedBuild,
						}
						client.JobReturns(job, true, nil)
					})

					It("returns the next build for that job", func() {
						build, err := GetBuild(client, expectedJobName, "", expectedPipelineName)
						Expect(err).NotTo(HaveOccurred())
						Expect(build).To(Equal(expectedBuild))
						Expect(client.JobCallCount()).To(Equal(1))
						pipelineName, jobName := client.JobArgsForCall(0)
						Expect(pipelineName).To(Equal(expectedPipelineName))
						Expect(jobName).To(Equal(expectedJobName))
					})
				})

				Context("when the only the finished build exists", func() {
					BeforeEach(func() {
						job := atc.Job{
							Name:          expectedJobName,
							FinishedBuild: &expectedBuild,
						}
						client.JobReturns(job, true, nil)
					})

					It("returns the finished build for that job", func() {
Esempio n. 2
0
			fakeClient.PipelineReturns(atc.Pipeline{
				Groups: atc.GroupConfigs{
					{
						Name: "group-with-job",
						Jobs: []string{"some-job"},
					},
					{
						Name: "group-without-job",
						Jobs: []string{"some-other-job"},
					},
				},
			}, true, nil)
		})

		It("calls to get the job from the client", func() {
			actualPipelineName, actualJobName := fakeClient.JobArgsForCall(0)
			Expect(actualPipelineName).To(Equal("some-pipeline"))
			Expect(actualJobName).To(Equal("some-job"))
		})

		Context("when the client returns an error", func() {
			var expectedErr error
			BeforeEach(func() {
				expectedErr = errors.New("nope")
				fakeClient.JobReturns(atc.Job{}, false, expectedErr)
			})

			It("returns an error", func() {
				Expect(fetchErr).To(Equal(expectedErr))
			})
		})