errs := make(chan error, 1)
						errs <- io.EOF
						close(errs)

						fakeProcess.SetTTYStub = func(garden.TTYSpec) error {
							return <-errs
						}
					})

					It("reattaches on use of closed connection", func() {
						ttySpec := garden.TTYSpec{
							WindowSize: &garden.WindowSize{Columns: 345678, Rows: 45689},
						}

						Expect(process.SetTTY(ttySpec)).To(Succeed())
						Expect(fakeProcess.SetTTYArgsForCall(0)).To(Equal(ttySpec))

						Expect(innerConnection.AttachCallCount()).To(Equal(2))
						handle, processID, calledProcessIO := innerConnection.AttachArgsForCall(1)
						Expect(handle).To(Equal("la-contineur"))
						Expect(processID).To(Equal("process-id"))
						Expect(calledProcessIO).To(Equal(processIO))
					})
				})
			})
		})
	})

	Describe("Run", func() {
		var (
			fakeProcess *gfakes.FakeProcess
					process, err := container.Run(processSpec, garden.ProcessIO{})
					Ω(err).ShouldNot(HaveOccurred())

					ttySpec := garden.TTYSpec{
						WindowSize: &garden.WindowSize{
							Columns: 80,
							Rows:    24,
						},
					}

					err = process.SetTTY(ttySpec)
					Ω(err).ShouldNot(HaveOccurred())

					Eventually(fakeProcess.SetTTYCallCount).Should(Equal(1))

					Ω(fakeProcess.SetTTYArgsForCall(0)).Should(Equal(ttySpec))
				})
			})

			Context("when waiting on the process fails server-side", func() {
				BeforeEach(func() {
					fakeContainer.RunStub = func(spec garden.ProcessSpec, io garden.ProcessIO) (garden.Process, error) {
						process := new(fakes.FakeProcess)

						process.IDReturns(42)
						process.WaitReturns(0, errors.New("oh no!"))

						return process, nil
					}
				})
Example #3
0
						JustBeforeEach(func() {
							err := conn.WriteJSON(atc.HijackInput{
								TTYSpec: &atc.HijackTTYSpec{
									WindowSize: atc.HijackWindowSize{
										Columns: 123,
										Rows:    456,
									},
								},
							})
							Expect(err).NotTo(HaveOccurred())
						})

						It("forwards it to the process", func() {
							Eventually(fakeProcess.SetTTYCallCount).Should(Equal(1))

							Expect(fakeProcess.SetTTYArgsForCall(0)).To(Equal(garden.TTYSpec{
								WindowSize: &garden.WindowSize{
									Columns: 123,
									Rows:    456,
								},
							}))
						})

						Context("and setting the TTY on the process fails", func() {
							BeforeEach(func() {
								fakeProcess.SetTTYReturns(errors.New("oh no!"))
							})

							It("forwards the error to the response", func() {
								var hijackOutput atc.HijackOutput
								err := conn.ReadJSON(&hijackOutput)