예제 #1
0
				plan = atc.Plan{
					Location: nil,
					Put: &atc.PutPlan{
						Name: "some output",
					},
				}
			})

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

				Ω(fakeFactory.PutCallCount()).Should(Equal(1))
				workerID, delegate, _, _, _ := fakeFactory.PutArgsForCall(0)
				Ω(workerID).Should(Equal(worker.Identifier{
					BuildID: 84,
					Type:    worker.ContainerTypePut,
					Name:    "some output",
				}))

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

		Context("task with nil location", func() {
			var (
				taskStepFactory *execfakes.FakeStepFactory
예제 #2
0
				plan = atc.Plan{
					Location: nil,
					Put: &atc.PutPlan{
						Name: "some output",
					},
				}
			})

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

				Expect(fakeFactory.PutCallCount()).To(Equal(1))
				logger, metadata, workerID, delegate, _, _, _ := fakeFactory.PutArgsForCall(0)
				Expect(logger).ToNot(BeNil())
				Expect(metadata).To(Equal(expectedMetadata))
				Expect(workerID).To(Equal(worker.Identifier{
					BuildID: 84,
					Type:    db.ContainerTypePut,
					Name:    "some output",
				}))

				Expect(delegate).To(Equal(fakePutDelegate))
				_, _, location := fakeDelegate.OutputDelegateArgsForCall(0)
				Expect(location).NotTo(BeNil())
			})
		})

		Context("task with nil location", func() {
예제 #3
0
												},
											},
										},
									},
								},
							},
						},
					},
				}
			})

			Context("constructing outputs", func() {
				It("constructs the put correctly", func() {
					Ω(fakeFactory.PutCallCount()).Should(Equal(2))

					workerID, delegate, resourceConfig, tags, params := fakeFactory.PutArgsForCall(0)
					Ω(workerID).Should(Equal(worker.Identifier{
						BuildID: 42,
						Type:    worker.ContainerTypePut,
						Name:    "some-put",
					}))
					Ω(tags).Should(BeEmpty())
					Ω(delegate).Should(Equal(fakeOutputDelegate))
					Ω(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{"some": "params"}))

					workerID, delegate, resourceConfig, tags, params = fakeFactory.PutArgsForCall(1)
					Ω(workerID).Should(Equal(worker.Identifier{
						BuildID: 42,
예제 #4
0
								},
							},
						},
					}
			})

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

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

					logger, metadata, workerID, delegate, resourceConfig, tags, params := fakeFactory.PutArgsForCall(0)
					Expect(logger).NotTo(BeNil())
					Expect(metadata).To(Equal(expectedMetadata))
					Expect(workerID).To(Equal(worker.Identifier{
						BuildID:      42,
						Type:         db.ContainerTypePut,
						Name:         "some-put",
						PipelineName: "some-pipeline",
					}))

					Expect(tags).To(BeEmpty())
					Expect(delegate).To(Equal(fakeOutputDelegate))
					Expect(resourceConfig.Name).To(Equal("some-output-resource"))
					Expect(resourceConfig.Type).To(Equal("some-type"))
					Expect(resourceConfig.Source).To(Equal(atc.Source{"some": "source"}))
					Expect(params).To(Equal(atc.Params{"some": "params"}))