})

				It("runs the process and streams the output", func(done Done) {
					stdout := gbytes.NewBuffer()
					stderr := gbytes.NewBuffer()

					processIO := garden.ProcessIO{
						Stdin:  bytes.NewBufferString("stdin data"),
						Stdout: stdout,
						Stderr: stderr,
					}

					process, err := container.Run(processSpec, processIO)
					Ω(err).ShouldNot(HaveOccurred())

					ranSpec, processIO := fakeContainer.RunArgsForCall(0)
					Ω(ranSpec).Should(Equal(processSpec))

					Eventually(stdout).Should(gbytes.Say("stdout data"))
					Eventually(stdout).Should(gbytes.Say("mirrored stdin data"))
					Eventually(stderr).Should(gbytes.Say("stderr data"))

					status, err := process.Wait()
					Ω(err).ShouldNot(HaveOccurred())
					Ω(status).Should(Equal(123))

					_, err = processIO.Stdin.Read([]byte{})
					Ω(err).Should(Equal(io.EOF))

					close(done)
				})
Beispiel #2
0
				By("Creates the container")
				Expect(gardenClient.CreateCallCount()).To(Equal(1))
				containerSpec := gardenClient.CreateArgsForCall(0)
				Expect(containerSpec).To(Equal(garden.ContainerSpec{
					Handle:     "executor-healthcheck-abc-123",
					RootFSPath: rootfsPath,
					Properties: garden.Properties{
						gardenstore.ContainerOwnerProperty:                          containerOwnerName,
						gardenstore.TagPropertyPrefix + gardenhealth.HealthcheckTag: gardenhealth.HealthcheckTagValue,
					},
				}))

				By("Runs the process")
				Expect(fakeContainer.RunCallCount()).To(Equal(1))

				procSpec, procIO := fakeContainer.RunArgsForCall(0)
				Expect(procSpec).To(Equal(healthcheckSpec))
				Expect(procIO).To(Equal(garden.ProcessIO{}))

				By("Waits for the process to finish")
				Expect(fakeProcess.WaitCallCount()).To(Equal(1))

				By("Destroys the container")
				guid = gardenClient.DestroyArgsForCall(1)
				Expect(guid).To(Equal("executor-healthcheck-abc-123"))

				By("Returns success")
				Expect(err).Should(BeNil())
			})
		})