예제 #1
0
				spec := ResourceTypeContainerSpec{
					Type: "some-resource-a",
				}

				fakeContainer := new(gfakes.FakeContainer)
				fakeContainer.HandleReturns("created-handle")

				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)
예제 #2
0
					fakeContainer := new(gfakes.FakeContainer)
					fakeContainer.HandleReturns("created-handle")

					worker.CreateReturns(fakeContainer, nil)
					worker.LookupReturns(fakeContainer, nil)

					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)
예제 #3
0
파일: main_test.go 프로젝트: savaki/tsa
							err := json.NewEncoder(sshStdin).Encode(workerPayload)
							Ω(err).ShouldNot(HaveOccurred())
						})

						It("forwards garden API calls through the tunnel", func() {
							registration := <-registered
							addr := registration.worker.Addr

							client := gclient.New(gconn.New("tcp", addr))

							fakeBackend.CreateReturns(new(gfakes.FakeContainer), nil)

							_, err := client.Create(garden.ContainerSpec{})
							Ω(err).ShouldNot(HaveOccurred())

							Ω(fakeBackend.CreateCallCount()).Should(Equal(1))
						})

						It("continuously registers it with the ATC as long as it works", func() {
							a := time.Now()
							registration := <-registered
							Ω(registration.ttl).Should(Equal(2 * heartbeatInterval))

							// shortcut for equality w/out checking addr
							expectedWorkerPayload := workerPayload
							expectedWorkerPayload.Addr = registration.worker.Addr
							expectedWorkerPayload.ActiveContainers = 3
							Ω(registration.worker).Should(Equal(expectedWorkerPayload))

							host, _, err := net.SplitHostPort(registration.worker.Addr)
							Ω(err).ShouldNot(HaveOccurred())