plan = atc.Plan{
					Location: nil,
					DependentGet: &atc.DependentGetPlan{
						Name: "some input",
					},
				}
			})

			It("constructs the step correctly", func() {
				build, err := execEngine.CreateBuild(buildModel, plan)
				Ω(err).ShouldNot(HaveOccurred())
				build.Resume(logger)

				Ω(fakeFactory.DependentGetCallCount()).Should(Equal(1))
				sourceName, workerID, delegate, _, _, _ := fakeFactory.DependentGetArgsForCall(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())
			})
		})
	})

})
				plan = atc.Plan{
					Location: nil,
					DependentGet: &atc.DependentGetPlan{
						Name: "some input",
					},
				}
			})

			It("constructs the step correctly", func() {
				build, err := execEngine.CreateBuild(logger, buildModel, plan)
				Expect(err).NotTo(HaveOccurred())
				build.Resume(logger)

				Expect(fakeFactory.DependentGetCallCount()).To(Equal(1))
				logger, metadata, sourceName, workerID, delegate, _, _, _ := fakeFactory.DependentGetArgsForCall(0)
				Expect(logger).ToNot(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(delegate).To(Equal(fakeGetDelegate))
				_, _, location := fakeDelegate.InputDelegateArgsForCall(0)
				Expect(location).NotTo(BeNil())
			})
		})
	})
Exemple #3
0
						BuildID: 42,
						Type:    worker.ContainerTypePut,
						Name:    "some-put-2",
					}))
					Ω(tags).Should(BeEmpty())
					Ω(delegate).Should(Equal(fakeOutputDelegate))
					Ω(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{"some": "params-2"}))
				})

				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",
					}))

					Ω(tags).Should(BeEmpty())
					Ω(delegate).Should(Equal(fakeInputDelegate))
					_, plan, location := fakeDelegate.InputDelegateArgsForCall(1)
					Ω(plan).Should(Equal((*outputPlan.Plan.Aggregate)[0].Conditional.Plan.OnSuccess.Next.DependentGet.GetPlan()))
					Ω(location).ShouldNot(BeNil())

					Ω(sourceName).Should(Equal(exec.SourceName("some-put")))
					Ω(resourceConfig.Name).Should(Equal("some-output-resource"))
					Ω(resourceConfig.Type).Should(Equal("some-type"))
Exemple #4
0
					Expect(delegate).To(Equal(fakeOutputDelegate))
					Expect(resourceConfig.Name).To(Equal("some-output-resource-2"))
					Expect(resourceConfig.Type).To(Equal("put"))
					Expect(resourceConfig.Source).To(Equal(atc.Source{"some": "source-2"}))
					Expect(params).To(Equal(atc.Params{"some": "params-2"}))
				})

				It("constructs the dependent get correctly", func() {
					var err error
					build, err = execEngine.CreateBuild(logger, buildModel, outputPlan)
					Expect(err).NotTo(HaveOccurred())

					build.Resume(logger)
					Expect(fakeFactory.DependentGetCallCount()).To(Equal(2))

					logger, metadata, sourceName, workerID, workerMetadata, delegate, resourceConfig, tags, params, _ := fakeFactory.DependentGetArgsForCall(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))