Esempio n. 1
0
											Config: &atc.TaskConfig{},
										},
									},
								},
							},
						},
					}

					build, err := execEngine.CreateBuild(logger, buildModel, plan)
					Expect(err).NotTo(HaveOccurred())
					build.Resume(logger)
				})

				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")))
Esempio n. 2
0
			Ω(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"))
			Ω(resourceConfig.Source).Should(Equal(atc.Source{"some": "source"}))
			Ω(params).Should(Equal(atc.Params{"some": "params"}))
			Ω(version).Should(Equal(atc.Version{"some": "version"}))
		})

		It("constructs tasks correctly", func() {
			Ω(fakeFactory.TaskCallCount()).Should(Equal(1))

			sourceName, workerID, delegate, privileged, tags, configSource := fakeFactory.TaskArgsForCall(0)
			Ω(sourceName).Should(Equal(exec.SourceName("some-task")))
			Ω(workerID).Should(Equal(worker.Identifier{
				BuildID: 42,
				Type:    worker.ContainerTypeTask,
				Name:    "some-task",
			}))
			Ω(delegate).Should(Equal(fakeExecutionDelegate))
			Ω(privileged).Should(Equal(exec.Privileged(false)))
			Ω(tags).Should(BeEmpty())
			Ω(configSource).ShouldNot(BeNil())
		})

		Context("constructing outputs", func() {
			It("constructs the put correctly", func() {
				Ω(fakeFactory.PutCallCount()).Should(Equal(1))
Esempio n. 3
0
				plan = atc.Plan{
					Location: nil,
					Task: &atc.TaskPlan{
						Name:       "some task",
						ConfigPath: "some-path-to-config",
					},
				}
			})

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

				Ω(fakeFactory.TaskCallCount()).Should(Equal(1))
				sourceName, workerID, delegate, _, _, _ := fakeFactory.TaskArgsForCall(0)
				Ω(sourceName).Should(Equal(exec.SourceName("some task")))
				Ω(workerID).Should(Equal(worker.Identifier{
					BuildID: 84,
					Type:    worker.ContainerTypeTask,
					Name:    "some task",
				}))

				Ω(delegate).Should(Equal(fakeExecutionDelegate))
				_, _, location := fakeDelegate.ExecutionDelegateArgsForCall(0)
				Ω(location).ShouldNot(BeNil())
			})
		})

		Context("dependent get with nil location", func() {
			var (
Esempio n. 4
0
				Expect(tags).To(BeEmpty())
				Expect(delegate).To(Equal(fakeInputDelegate))

				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{"some": "params"}))
			})

			It("constructs nested retries correctly", func() {
				Expect(*retryPlanTwo.Retry).To(HaveLen(2))
			})

			It("constructs nested steps correctly", func() {
				logger, sourceName, workerID, workerMetadata, delegate, privileged, tags, configSource, _ := fakeFactory.TaskArgsForCall(0)
				Expect(logger).NotTo(BeNil())
				Expect(sourceName).To(Equal(exec.SourceName("some-task")))
				Expect(workerMetadata).To(Equal(worker.Metadata{
					ResourceName: "",
					Type:         db.ContainerTypeTask,
					StepName:     "some-task",
					PipelineName: "some-pipeline",
					Attempts:     []int{2, 1},
				}))
				Expect(workerID).To(Equal(worker.Identifier{
					BuildID: 42,
					PlanID:  taskPlan.ID,
				}))

				Expect(delegate).To(Equal(fakeExecutionDelegate))