示例#1
0
			Eventually(eventsNotifier.OnEventCallCount).Should(Equal(1))
			handle, event := eventsNotifier.OnEventArgsForCall(0)
			Expect(handle).To(Equal("some-container"))
			Expect(event).To(Equal("Out of memory"))

			eventsCh <- `{"type":"oom"}`
			Eventually(eventsNotifier.OnEventCallCount).Should(Equal(2))
			handle, event = eventsNotifier.OnEventArgsForCall(1)
			Expect(handle).To(Equal("some-container"))
			Expect(event).To(Equal("Out of memory"))
		})

		It("does not report non-OOM events", func() {
			defer close(eventsCh)

			go runner.WatchEvents(logger, "some-container", eventsNotifier)

			eventsCh <- `{"type":"stats"}`
			Consistently(eventsNotifier.OnEventCallCount).Should(Equal(0))
		})

		It("waits on the process to avoid zombies", func() {
			close(eventsCh)

			Expect(runner.WatchEvents(logger, "some-container", eventsNotifier)).To(Succeed())
			Eventually(commandRunner.WaitedCommands).Should(HaveLen(1))
			Expect(commandRunner.WaitedCommands()[0].Path).To(Equal("funC-events"))
		})
	})
})
示例#2
0
	})

	Describe("Kill", func() {
		It("should record Kill commands", func() {
			runner.Kill(cmd)
			Expect(runner.KilledCommands()).To(Equal([]*exec.Cmd{cmd}))
		})

		// This may seem like an odd test, but it exposed a bug.
		It("should not confuse Kill and Wait", func() {
			runner.Kill(cmd)
			runner.Wait(cmd2)
			Expect(runner.KilledCommands()).To(Equal([]*exec.Cmd{cmd}))
		})
	})

	Describe("Wait", func() {
		It("should record Wait commands", func() {
			runner.Wait(cmd)
			Expect(runner.WaitedCommands()).To(Equal([]*exec.Cmd{cmd}))
		})

		It("should not confuse Wait and Kill", func() {
			runner.Wait(cmd)
			runner.Kill(cmd2)
			Expect(runner.WaitedCommands()).To(Equal([]*exec.Cmd{cmd}))
		})
	})

})