Golang FakeBackend.DestroyCallCount方法代碼示例

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