Beispiel #1
0
			It("returns an error", func() {
				Expect(validateErr).To(HaveOccurred())
				Expect(validateErr.Error()).To(ContainSubstring(
					"jobs[2] has no name",
				))
			})
		})

		Describe("plans", func() {
			Context("when multiple actions are specified in the same plan", func() {
				Context("when it's not just Get and Put", func() {
					BeforeEach(func() {
						job.Plan = append(job.Plan, atc.PlanConfig{
							Get:       "some-resource",
							Put:       "some-resource",
							Task:      "some-resource",
							Do:        &atc.PlanSequence{},
							Aggregate: &atc.PlanSequence{},
						})

						config.Jobs = append(config.Jobs, job)
					})

					It("returns an error", func() {
						Expect(validateErr).To(HaveOccurred())
						Expect(validateErr.Error()).To(ContainSubstring(
							"jobs.some-other-job.plan[0] has multiple actions specified (aggregate, do, get, put, task)",
						))

					})
				})
Beispiel #2
0
			job.Plan = atc.PlanSequence{
				{
					Aggregate: &atc.PlanSequence{
						{
							Get:      "some-input",
							Resource: "some-resource",
							Params:   atc.Params{"some": "params"},
							Tags:     []string{"some", "tags"},
						},
					},
				},
				{
					Task:           "build",
					Privileged:     true,
					Tags:           []string{"some", "tags"},
					TaskConfigPath: "some-input/build.yml",
					TaskConfig: &atc.TaskConfig{
						Image: "some-image",
						Params: map[string]string{
							"FOO": "1",
							"BAR": "2",
						},
						Run: atc.TaskRunConfig{
							Path: "some-script",
							Args: []string{"arg1", "arg2"},
						},
					},
				},
				{
					Aggregate: &atc.PlanSequence{
						{
							Conditions: &atc.Conditions{atc.ConditionSuccess},
							RawName:    "some-resource",
							Do: &atc.PlanSequence{
								{
									Put:    "some-resource",
									Params: atc.Params{"foo": "bar"},
									Tags:   []string{"some", "tags"},
								},
							},
						},
						{
							Conditions: &atc.Conditions{atc.ConditionFailure},
							Put:        "some-other-resource",
							Params:     atc.Params{"foo": "bar"},
						},
						{
							Conditions: &atc.Conditions{},
							Put:        "some-other-other-resource",
							Params:     atc.Params{"foo": "bar"},
						},
					},
				},
			}
Beispiel #3
0
			inputs []config.JobInput
		)

		BeforeEach(func() {
			jobConfig = atc.JobConfig{}
		})

		JustBeforeEach(func() {
			inputs = config.JobInputs(jobConfig)
		})

		Context("with a build plan", func() {
			Context("with an empty plan", func() {
				BeforeEach(func() {
					jobConfig.Plan = atc.PlanSequence{}
				})

				It("returns an empty set of inputs", func() {
					Expect(inputs).To(BeEmpty())
				})
			})

			Context("with two serial gets", func() {
				BeforeEach(func() {
					jobConfig.Plan = atc.PlanSequence{
						{
							Get:     "some-get-plan",
							Passed:  []string{"a", "b"},
							Trigger: true,
						},
Beispiel #4
0
				fakePipelineDB.GetLatestInputVersionsReturns(nil, false, disaster)
				err = scheduler.BuildLatestInputs(logger, someVersions, job, resources, resourceTypes)
			})

			It("returns the error", func() {
				Expect(err).To(Equal(disaster))
			})

			It("does not trigger a build", func() {
				Expect(fakeEngine.CreateBuildCallCount()).To(Equal(0))
			})
		})

		Context("when the job has no inputs", func() {
			BeforeEach(func() {
				job.Plan = atc.PlanSequence{}
				err := scheduler.BuildLatestInputs(logger, someVersions, job, resources, resourceTypes)
				Expect(err).NotTo(HaveOccurred())
			})

			It("does not try to fetch inputs from the database", func() {
				Expect(fakeEngine.CreateBuildCallCount()).To(Equal(0))
			})
		})

		Context("when versions are found", func() {
			var newInputs []db.BuildInput
			var err error

			BeforeEach(func() {
				newInputs = []db.BuildInput{