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))
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() {
})
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)
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,