Golang FakeArtifactSource.StreamToCallCount方法代码示例

				Expect(sources).To(HaveKey("some-mounted-source"))
			})

			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)

									{Name: "some-input", Path: "some-input-configured-path"},
									{Name: "some-other-input"},
								},
							}, 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))

				Ω(tags).Should(ConsistOf("some", "tags"))
			})

			It("puts the resource with the correct source and params, and the full repository as the artifact source", func() {
				Ω(fakeResource.PutCallCount()).Should(Equal(1))

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

				dest := new(fakes.FakeArtifactDestination)

				err := putArtifactSource.StreamTo(dest)
				Ω(err).ShouldNot(HaveOccurred())

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

				sourceDest := fakeSource.StreamToArgsForCall(0)

				someStream := new(bytes.Buffer)

				err = sourceDest.StreamIn("foo", someStream)
				Ω(err).ShouldNot(HaveOccurred())

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

			It("puts the resource with the io config forwarded", func() {

				BeforeEach(func() {
					fakeDestination = new(fakes.FakeArtifactDestination)
				})

				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))

				BeforeEach(func() {
					fakeDestination = new(fakes.FakeArtifactDestination)
				})

				JustBeforeEach(func() {
					streamErr = repo.StreamTo(fakeDestination)
				})

				It("succeeds", func() {
					Ω(streamErr).ShouldNot(HaveOccurred())
				})

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

					Ω(firstSource.StreamToCallCount()).Should(Equal(1))
					Ω(secondSource.StreamToCallCount()).Should(Equal(1))

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

					Ω(firstDestination.StreamIn("foo", someStream)).Should(Succeed())

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

					Ω(secondDestination.StreamIn("foo", someStream)).Should(Succeed())

					Ω(fakeDestination.StreamInCallCount()).Should(Equal(2))