})
		})
	})

	Describe("Unwatch", func() {
		Context("when oom has already occurred", func() {
			JustBeforeEach(func() {
				oomNotifier.Watch(oNoom)
			})

			It("should not kill the oom command", func() {
				Eventually(oomChan).Should(BeClosed())

				oomNotifier.Unwatch()

				Expect(runner.KilledCommands()).To(HaveLen(0))
			})
		})

		Context("when oom has not already occurred", func() {
			BeforeEach(func() {
				runner.WhenWaitingFor(
					fake_command_runner.CommandSpec{},
					func(cmd *exec.Cmd) error {
						return errors.New("Command got killed")
					})
			})

			It("kills the oom process", func() {
				Expect(oomNotifier.Watch(oNoom)).To(Succeed())
Example #2
0
	var (
		runner    *fake_command_runner.FakeCommandRunner
		cmd, cmd2 *exec.Cmd
	)

	BeforeEach(func() {
		runner = fake_command_runner.New()
		cmd = &exec.Cmd{}
		cmd2 = &exec.Cmd{}
	})

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