Esempio n. 1
0
					Ω(err).ShouldNot(Equal(io.EOF))
				})
			})

			Context("when the process is killed", func() {
				var fakeProcess *fakes.FakeProcess

				BeforeEach(func() {
					fakeProcess = new(fakes.FakeProcess)
					fakeProcess.IDReturns(42)
					fakeProcess.WaitStub = func() (int, error) {
						select {}
						return 0, nil
					}

					fakeContainer.RunReturns(fakeProcess, nil)
				})

				It("is eventually killed in the backend", func() {
					process, err := container.Run(processSpec, garden.ProcessIO{})
					Ω(err).ShouldNot(HaveOccurred())

					err = process.Signal(garden.SignalKill)
					Ω(err).ShouldNot(HaveOccurred())

					Eventually(fakeProcess.SignalCallCount).Should(Equal(1))
					Ω(fakeProcess.SignalArgsForCall(0)).Should(Equal(garden.SignalKill))
				})
			})

			Context("when the process is terminated", func() {
Esempio n. 2
0
		var fakeContainer *gardenFakes.FakeContainer
		var oldContainer *gardenFakes.FakeContainer
		var fakeProcess *gardenFakes.FakeProcess

		BeforeEach(func() {
			fakeContainer = &gardenFakes.FakeContainer{}
			oldContainer = &gardenFakes.FakeContainer{}
			oldContainer.HandleReturns("old-guid")
			fakeProcess = &gardenFakes.FakeProcess{}
		})

		Context("When garden is healthy", func() {
			BeforeEach(func() {
				gardenClient.CreateReturns(fakeContainer, nil)
				gardenClient.ContainersReturns([]garden.Container{oldContainer}, nil)
				fakeContainer.RunReturns(fakeProcess, nil)
				fakeProcess.WaitReturns(0, nil)
			})

			It("drives a container lifecycle", func() {
				err := gardenChecker.Healthcheck(logger)

				By("Fetching any pre-existing healthcheck containers")
				Expect(gardenClient.ContainersCallCount()).To(Equal(1))

				By("Deleting all pre-existing-containers")
				//call count is two because we also expect to destroy the container we create
				Expect(gardenClient.DestroyCallCount()).To(Equal(2))
				guid := gardenClient.DestroyArgsForCall(0)
				Expect(guid).To(Equal("old-guid"))