Example #1
0
					Expect(delegate).To(Equal(fakeExecutionDelegate))

					Expect(fakeFactory.GetCallCount()).To(Equal(2))
					logger, metadata, sourceName, workerID, getDelegate, _, _, _, _ := fakeFactory.GetArgsForCall(1)
					Expect(logger).NotTo(BeNil())
					Expect(metadata).To(Equal(expectedMetadata))
					Expect(sourceName).To(Equal(exec.SourceName("some-input")))
					Expect(workerID).To(Equal(worker.Identifier{
						BuildID: 84,
						Type:    db.ContainerTypeGet,
						Name:    "some-input",
					}))

					Expect(getDelegate).To(Equal(fakeInputDelegate))
					_, _, location := fakeDelegate.InputDelegateArgsForCall(1)
					Expect(location).NotTo(BeNil())

					_, _, location = fakeDelegate.ExecutionDelegateArgsForCall(0)
					Expect(location).NotTo(BeNil())

					logger, sourceName, workerID, delegate, _, _, _ = fakeFactory.TaskArgsForCall(1)
					Expect(logger).NotTo(BeNil())
					Expect(sourceName).To(Equal(exec.SourceName("some-success-task-2")))
					Expect(workerID).To(Equal(worker.Identifier{
						BuildID: 84,
						Type:    db.ContainerTypeTask,
						Name:    "some-success-task-2",
					}))

					Expect(delegate).To(Equal(fakeExecutionDelegate))
Example #2
0
				build.Resume(logger)
			})

			It("constructs the step correctly", func() {
				Ω(fakeFactory.GetCallCount()).Should(Equal(1))
				sourceName, workerID, delegate, _, _, _, _ := fakeFactory.GetArgsForCall(0)
				Ω(sourceName).Should(Equal(exec.SourceName("some-input")))
				Ω(workerID).Should(Equal(worker.Identifier{
					BuildID:      84,
					Type:         worker.ContainerTypeGet,
					Name:         "some-input",
					StepLocation: 1,
				}))

				Ω(delegate).Should(Equal(fakeInputDelegate))
				_, _, location, hook := fakeDelegate.InputDelegateArgsForCall(0)
				Ω(location).Should(Equal(event.OriginLocation{
					ParentID:      0,
					ID:            1,
					ParallelGroup: 0,
				}))
				Ω(hook).Should(Equal(""))
			})
		})

		Context("when the inner step fails", func() {
			BeforeEach(func() {
				inputStep.ResultStub = successResult(false)
			})

			It("runs the next step", func() {
Example #3
0
				})

				It("constructs the dependent get correctly", func() {
					Ω(fakeFactory.DependentGetCallCount()).Should(Equal(2))

					sourceName, workerID, delegate, resourceConfig, tags, params := fakeFactory.DependentGetArgsForCall(0)
					Ω(workerID).Should(Equal(worker.Identifier{
						BuildID:      42,
						Type:         worker.ContainerTypeGet,
						Name:         "some-put",
						StepLocation: 7,
					}))

					Ω(tags).Should(BeEmpty())
					Ω(delegate).Should(Equal(fakeInputDelegate))
					_, plan, location, hook := fakeDelegate.InputDelegateArgsForCall(1)
					Ω(plan).Should(Equal((*outputPlan.Plan.Aggregate)[0].Conditional.Plan.PutGet.Head.Put.GetPlan()))
					Ω(location).Should(Equal(event.OriginLocation{
						ParentID:      6,
						ID:            7,
						ParallelGroup: 0,
					}))
					Ω(hook).Should(Equal(""))

					Ω(sourceName).Should(Equal(exec.SourceName("some-put")))
					Ω(resourceConfig.Name).Should(Equal("some-output-resource"))
					Ω(resourceConfig.Type).Should(Equal("some-type"))
					Ω(resourceConfig.Source).Should(Equal(atc.Source{"some": "source"}))
					Ω(params).Should(Equal(atc.Params{"another": "params"}))

					sourceName, workerID, delegate, resourceConfig, tags, params = fakeFactory.DependentGetArgsForCall(1)
Example #4
0
					Expect(logger).NotTo(BeNil())
					Expect(metadata).To(Equal(expectedMetadata))
					Expect(workerMetadata).To(Equal(worker.Metadata{
						ResourceName: "",
						Type:         db.ContainerTypeGet,
						StepName:     "some-get",
						PipelineName: "some-pipeline",
					}))
					Expect(workerID).To(Equal(worker.Identifier{
						BuildID: 42,
						PlanID:  dependentGetPlan.ID,
					}))

					Expect(tags).To(BeEmpty())
					Expect(delegate).To(Equal(fakeInputDelegate))
					_, plan, planID := fakeDelegate.InputDelegateArgsForCall(0)
					Expect(plan).To(Equal((*outputPlan.Aggregate)[0].OnSuccess.Next.DependentGet.GetPlan()))
					Expect(planID).NotTo(BeNil())

					Expect(sourceName).To(Equal(exec.SourceName("some-get")))
					Expect(resourceConfig.Name).To(Equal("some-input-resource"))
					Expect(resourceConfig.Type).To(Equal("get"))
					Expect(resourceConfig.Source).To(Equal(atc.Source{"some": "source"}))
					Expect(params).To(Equal(atc.Params{"another": "params"}))

					logger, metadata, sourceName, workerID, workerMetadata, delegate, resourceConfig, tags, params, _ = fakeFactory.DependentGetArgsForCall(1)
					Expect(logger).NotTo(BeNil())
					Expect(metadata).To(Equal(expectedMetadata))
					Expect(workerMetadata).To(Equal(worker.Metadata{
						ResourceName: "",
						Type:         db.ContainerTypeGet,