Properties: map[string]string{
"prop-a": "val-a",
"prop-b": "val-b",
},
Env: []string{"env1=env1Value", "env2=env2Value"},
}))
})
Context("when a grace time is given", func() {
It("destroys the container after it has been idle for the grace time", func() {
graceTime := time.Second
fakeContainer = new(fakes.FakeContainer)
fakeContainer.HandleReturns("doomed-handle")
serverBackend.GraceTimeReturns(graceTime)
serverBackend.CreateReturns(fakeContainer, nil)
serverBackend.LookupReturns(fakeContainer, nil)
before := time.Now()
_, err := apiClient.Create(garden.ContainerSpec{})
Ω(err).ShouldNot(HaveOccurred())
Eventually(serverBackend.DestroyCallCount, 2*time.Second).Should(Equal(1))
Ω(serverBackend.DestroyArgsForCall(0)).Should(Equal("doomed-handle"))
Ω(time.Since(before)).Should(BeNumerically("~", graceTime, 100*time.Millisecond))
})
})
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"time"
"github.com/cloudfoundry-incubator/garden"
"github.com/cloudfoundry-incubator/garden/fakes"
"github.com/cloudfoundry-incubator/garden/server/bomberman"
)
var _ = Describe("Bomberman", func() {
It("straps a bomb to the given container with the container's grace time as the countdown", func() {
detonated := make(chan garden.Container)
backend := new(fakes.FakeBackend)
backend.GraceTimeReturns(100 * time.Millisecond)
bomberman := bomberman.New(backend, func(container garden.Container) {
detonated <- container
})
container := new(fakes.FakeContainer)
container.HandleReturns("doomed")
bomberman.Strap(container)
select {
case <-detonated:
case <-time.After(backend.GraceTime(container) + 50*time.Millisecond):
Fail("did not detonate!")
}
Ω(fakeBackend.StartCallCount()).Should(Equal(1))
})
It("destroys containers that have been idle for their grace time", func() {
var err error
tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
Ω(err).ShouldNot(HaveOccurred())
socketPath := path.Join(tmpdir, "api.sock")
fakeBackend := new(fakes.FakeBackend)
doomedContainer := new(fakes.FakeContainer)
fakeBackend.ContainersReturns([]garden.Container{doomedContainer}, nil)
fakeBackend.GraceTimeReturns(100 * time.Millisecond)
apiServer := server.New("unix", socketPath, 0, fakeBackend, logger)
before := time.Now()
err = apiServer.Start()
Ω(err).ShouldNot(HaveOccurred())
Ω(fakeBackend.DestroyCallCount()).Should(Equal(0))
Eventually(fakeBackend.DestroyCallCount).Should(Equal(1))
Ω(time.Since(before)).Should(BeNumerically(">", 100*time.Millisecond))
})
Context("when starting the backend fails", func() {
