It("constructs the steps correctly", func() {
Expect(fakeFactory.TaskCallCount()).To(Equal(3))
logger, sourceName, workerID, delegate, _, _, _ := fakeFactory.TaskArgsForCall(0)
Expect(logger).NotTo(BeNil())
Expect(sourceName).To(Equal(exec.SourceName("some-success-task-1")))
Expect(workerID).To(Equal(worker.Identifier{
BuildID: 84,
Type: db.ContainerTypeTask,
Name: "some-success-task-1",
}))
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())
Ω(plan).Should(Equal((*outputPlan.Plan.Aggregate)[1].Conditional.Plan.OnSuccess.Next.DependentGet.GetPlan()))
Ω(location).ShouldNot(BeNil())
Ω(sourceName).Should(Equal(exec.SourceName("some-put-2")))
Ω(resourceConfig.Name).Should(Equal("some-output-resource-2"))
Ω(resourceConfig.Type).Should(Equal("some-type-2"))
Ω(resourceConfig.Source).Should(Equal(atc.Source{"some": "source-2"}))
Ω(params).Should(Equal(atc.Params{"another": "params-2"}))
})
})
})
It("constructs inputs correctly", func() {
Ω(fakeFactory.GetCallCount()).Should(Equal(1))
sourceName, workerID, delegate, resourceConfig, params, tags, version := fakeFactory.GetArgsForCall(0)
Ω(sourceName).Should(Equal(exec.SourceName("some-input")))
Ω(workerID).Should(Equal(worker.Identifier{
BuildID: 42,
Type: worker.ContainerTypeGet,
Name: "some-input",
}))
Ω(tags).Should(ConsistOf("some", "get", "tags"))
Ω(delegate).Should(Equal(fakeInputDelegate))
_, plan, location := fakeDelegate.InputDelegateArgsForCall(0)
Ω(plan).Should(Equal(*inputPlan))
Ω(location).ShouldNot(BeNil())
Ω(resourceConfig.Name).Should(Equal("some-input-resource"))
Ω(resourceConfig.Type).Should(Equal("some-type"))
plan = atc.Plan{
Location: nil,
Get: &atc.GetPlan{
Name: "some input",
},
}
})
It("constructs the step correctly", func() {
build, err := execEngine.CreateBuild(buildModel, plan)
Ω(err).ShouldNot(HaveOccurred())
build.Resume(logger)
Ω(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",
}))
Ω(delegate).Should(Equal(fakeGetDelegate))
_, _, location := fakeDelegate.InputDelegateArgsForCall(0)
Ω(location).ShouldNot(BeNil())
})
})
Context("put with nil location", func() {
var (
getPlan,
})
build, err = execEngine.CreateBuild(logger, buildModel, retryPlan)
Expect(err).NotTo(HaveOccurred())
build.Resume(logger)
Expect(fakeFactory.GetCallCount()).To(Equal(2))
Expect(fakeFactory.TaskCallCount()).To(Equal(2))
})
It("constructs the retry correctly", func() {
Expect(*retryPlan.Retry).To(HaveLen(3))
})
It("constructss the first get correctly", func() {
logger, metadata, sourceName, workerID, workerMetadata, delegate, resourceConfig, tags, params, _, _ := fakeFactory.GetArgsForCall(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",
Attempts: []int{1},
}))
Expect(workerID).To(Equal(worker.Identifier{
BuildID: 42,
PlanID: getPlan.ID,
}))
Expect(tags).To(BeEmpty())