container, err := workers[0].CreateContainer(logger, id, spec)
Expect(err).NotTo(HaveOccurred())
Expect(fakeDB.CreateContainerCallCount()).To(Equal(1))
createdInfo, _ := fakeDB.CreateContainerArgsForCall(0)
Expect(createdInfo.WorkerName).To(Equal("some-worker-name"))
Expect(container.Handle()).To(Equal("created-handle"))
Expect(worker.CreateCallCount()).To(Equal(1))
err = container.Destroy()
Expect(err).NotTo(HaveOccurred())
Expect(worker.DestroyCallCount()).To(Equal(1))
Expect(worker.DestroyArgsForCall(0)).To(Equal("created-handle"))
})
})
Describe("a looked-up container", func() {
It("calls through to garden", func() {
fakeContainer := new(gfakes.FakeContainer)
fakeContainer.HandleReturns("some-handle")
worker.ContainersReturns([]garden.Container{fakeContainer}, nil)
worker.LookupReturns(fakeContainer, nil)
fakeDB.FindContainerByIdentifierReturns(db.Container{Handle: "some-handle"}, true, nil)
container, found, err := workers[0].FindContainerForIdentifier(logger, Identifier{
workerA.CreateReturns(fakeContainer, nil)
container, err := workers[0].CreateContainer(id, spec)
Ω(err).ShouldNot(HaveOccurred())
Ω(container.Handle()).Should(Equal("created-handle"))
Ω(workerA.CreateCallCount()).Should(Equal(1))
Ω(workerA.CreateArgsForCall(0).Properties).Should(Equal(garden.Properties{
"concourse:name": "some-name",
}))
err = container.Destroy()
Ω(err).ShouldNot(HaveOccurred())
Ω(workerA.DestroyCallCount()).Should(Equal(1))
Ω(workerA.DestroyArgsForCall(0)).Should(Equal("created-handle"))
})
})
Describe("a looked-up container", func() {
It("calls through to garden", func() {
fakeContainer := new(gfakes.FakeContainer)
fakeContainer.HandleReturns("some-handle")
workerA.ContainersReturns([]garden.Container{fakeContainer}, nil)
container, err := workers[0].LookupContainer(Identifier{Name: "some-name"})
Ω(err).ShouldNot(HaveOccurred())
Ω(container.Handle()).Should(Equal("some-handle"))
serverBackend.DestroyStub = func(string) error {
close(destroying)
time.Sleep(time.Second)
return nil
}
})
It("only destroys once", func() {
go apiClient.Destroy("some-handle")
<-destroying
err := apiClient.Destroy("some-handle")
Ω(err).Should(HaveOccurred())
Ω(serverBackend.DestroyCallCount()).Should(Equal(1))
})
})
Context("when the container cannot be found", func() {
var theError = garden.ContainerNotFoundError{"some-handle"}
BeforeEach(func() {
serverBackend.DestroyReturns(theError)
})
It("returns an ContainerNotFoundError", func() {
err := apiClient.Destroy("some-handle")
Ω(err).Should(MatchError(garden.ContainerNotFoundError{"some-handle"}))
})
})
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() {
disaster := errors.New("oh no!")
It("fails to start", func() {
var err error
tmpdir, err = ioutil.TempDir(os.TempDir(), "api-server-test")
Ω(err).ShouldNot(HaveOccurred())
socketPath := path.Join(tmpdir, "api.sock")