buffer := bytes.NewBufferString("chunk-1chunk-2")
err := connection.StreamIn("foo-handle", garden.StreamInSpec{User: "******", Path: "/bar", TarStream: buffer})
Ω(err).Should(HaveOccurred())
Ω(server.ReceivedRequests()).Should(HaveLen(1))
})
})
Context("when streaming in fails hard", func() {
BeforeEach(func() {
server.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("PUT", "/containers/foo-handle/files", "user=bob&destination=%2Fbar"),
ghttp.RespondWith(http.StatusInternalServerError, "no."),
func(w http.ResponseWriter, r *http.Request) {
server.CloseClientConnections()
},
),
)
})
It("returns an error on close", func() {
buffer := bytes.NewBufferString("chunk-1chunk-2")
err := connection.StreamIn("foo-handle", garden.StreamInSpec{User: "******", Path: "/bar", TarStream: buffer})
Ω(err).Should(HaveOccurred())
Ω(server.ReceivedRequests()).Should(HaveLen(1))
})
})
})
Ω(sess.ExitCode()).Should(Equal(0))
Ω(sess).ShouldNot(gbytes.Say("the pipeline is currently paused. to unpause, either:"))
Ω(atcServer.ReceivedRequests()).Should(HaveLen(2))
})
})
})
Context("when the server rejects the request", func() {
BeforeEach(func() {
path, err := atc.Routes.CreatePathForRoute(atc.SaveConfig, rata.Params{"pipeline_name": "awesome-pipeline"})
Ω(err).ShouldNot(HaveOccurred())
atcServer.RouteToHandler("PUT", path, func(w http.ResponseWriter, r *http.Request) {
atcServer.CloseClientConnections()
})
})
It("prints the error to stderr and exits 1", func() {
flyCmd := exec.Command(flyPath, "-t", atcServer.URL()+"/", "configure", "-c", configFile.Name(), "awesome-pipeline")
stdin, err := flyCmd.StdinPipe()
Ω(err).ShouldNot(HaveOccurred())
sess, err := gexec.Start(flyCmd, GinkgoWriter, GinkgoWriter)
Ω(err).ShouldNot(HaveOccurred())
Eventually(sess).Should(gbytes.Say(`apply configuration\? \(y/n\): `))
fmt.Fprintln(stdin, "y")
})
It("makes the request and returns an error", func() {
Expect(stopErr).To(HaveOccurred())
Expect(stopErr.Error()).To(ContainSubstring("http error: status code 500"))
Expect(fakeServer.ReceivedRequests()).To(HaveLen(1))
})
})
Context("when the connection fails", func() {
BeforeEach(func() {
fakeServer.AppendHandlers(
ghttp.CombineHandlers(
ghttp.VerifyRequest("POST", "/v1/lrps/some-process-guid/instances/some-instance-guid/stop"),
func(w http.ResponseWriter, r *http.Request) {
fakeServer.CloseClientConnections()
},
),
)
})
It("makes the request and returns an error", func() {
Expect(stopErr).To(HaveOccurred())
Expect(stopErr.Error()).To(ContainSubstring("EOF"))
Expect(fakeServer.ReceivedRequests()).To(HaveLen(1))
})
})
Context("when the connection times out", func() {
BeforeEach(func() {
fakeServer.AppendHandlers(
})
var _ = BeforeEach(func() {
logger := lagertest.NewTestLogger("test")
auctionRep = &repfakes.FakeClient{}
fakeLRPStopper = &fake_lrp_stopper.FakeLRPStopper{}
fakeExecutorClient = &executorfakes.FakeClient{}
fakeEvacuatable = &fake_evacuation_context.FakeEvacuatable{}
handler, err := rata.NewRouter(rep.Routes, handlers.New(auctionRep, fakeLRPStopper, fakeExecutorClient, fakeEvacuatable, logger))
Expect(err).NotTo(HaveOccurred())
server = httptest.NewServer(handler)
client = rep.NewClient(&http.Client{}, server.URL)
serverThatErrors = ghttp.NewServer()
erroringHandler := http.HandlerFunc(func(http.ResponseWriter, *http.Request) {
serverThatErrors.CloseClientConnections()
})
//5 erroringHandlers should be more than enough: none of the individual tests should make more than 5 requests to this server
serverThatErrors.AppendHandlers(erroringHandler, erroringHandler, erroringHandler, erroringHandler, erroringHandler)
clientForServerThatErrors = rep.NewClient(&http.Client{}, serverThatErrors.URL())
})
var _ = AfterEach(func() {
server.Close()
serverThatErrors.Close()
})
