Beispiel #1
0
								},
							}, nil)
						})

						Context("when all inputs are present in the in source repository", func() {
							BeforeEach(func() {
								repo.RegisterSource("some-input", inputSource)
								repo.RegisterSource("some-other-input", otherInputSource)
							})

							It("streams each of them to their configured destinations", func() {
								streamIn := new(bytes.Buffer)

								Ω(inputSource.StreamToCallCount()).Should(Equal(1))

								destination := inputSource.StreamToArgsForCall(0)

								initial := fakeContainer.StreamInCallCount()

								err := destination.StreamIn("foo", streamIn)
								Ω(err).ShouldNot(HaveOccurred())

								Ω(fakeContainer.StreamInCallCount()).Should(Equal(initial + 1))

								spec := fakeContainer.StreamInArgsForCall(initial)
								Ω(spec.Path).Should(Equal("/tmp/build/a-random-guid/some-input-configured-path/foo"))
								Ω(spec.User).Should(Equal("")) // use default
								Ω(spec.TarStream).Should(Equal(streamIn))

								Ω(otherInputSource.StreamToCallCount()).Should(Equal(1))
Beispiel #2
0
			It("puts the resource with the correct source and params, and the full repository as the artifact source", func() {
				Expect(fakeResource.PutCallCount()).To(Equal(1))

				_, putSource, putParams, putArtifactSource := fakeResource.PutArgsForCall(0)
				Expect(putSource).To(Equal(resourceConfig.Source))
				Expect(putParams).To(Equal(params))

				dest := new(fakes.FakeArtifactDestination)

				err := putArtifactSource.StreamTo(dest)
				Expect(err).NotTo(HaveOccurred())

				Expect(fakeSource.StreamToCallCount()).To(Equal(1))

				sourceDest := fakeSource.StreamToArgsForCall(0)
				someStream := new(bytes.Buffer)

				err = sourceDest.StreamIn("foo", someStream)
				Expect(err).NotTo(HaveOccurred())

				Expect(dest.StreamInCallCount()).To(Equal(1))
				destPath, stream := dest.StreamInArgsForCall(0)
				Expect(destPath).To(Equal("some-source/foo"))
				Expect(stream).To(Equal(someStream))

				Expect(fakeOtherSource.StreamToCallCount()).To(Equal(1))

				otherSourceDest := fakeOtherSource.StreamToArgsForCall(0)
				someOtherStream := new(bytes.Buffer)
Beispiel #3
0
				JustBeforeEach(func() {
					streamErr = repo.StreamTo(fakeDestination)
				})

				It("succeeds", func() {
					Expect(streamErr).NotTo(HaveOccurred())
				})

				It("streams both sources to the destination under subdirectories", func() {
					someStream := new(bytes.Buffer)

					Expect(firstSource.StreamToCallCount()).To(Equal(1))
					Expect(secondSource.StreamToCallCount()).To(Equal(1))

					firstDestination := firstSource.StreamToArgsForCall(0)
					secondDestination := secondSource.StreamToArgsForCall(0)

					Expect(firstDestination.StreamIn("foo", someStream)).To(Succeed())

					Expect(fakeDestination.StreamInCallCount()).To(Equal(1))
					destDir, stream := fakeDestination.StreamInArgsForCall(0)
					Expect(destDir).To(Equal("first-source/foo"))
					Expect(stream).To(Equal(someStream))

					Expect(secondDestination.StreamIn("foo", someStream)).To(Succeed())

					Expect(fakeDestination.StreamInCallCount()).To(Equal(2))
					destDir, stream = fakeDestination.StreamInArgsForCall(1)
					Expect(destDir).To(Equal("second-source/foo"))
					Expect(stream).To(Equal(someStream))