func shouldEcho(input string, expected string) { ln := registerHandler(r, "encoding", func(x *test_util.HttpConn) { x.CheckLine("GET " + expected + " HTTP/1.1") resp := test_util.NewResponse(http.StatusOK) x.WriteResponse(resp) x.Close() }) defer ln.Close() x := dialProxy(proxyServer) req := test_util.NewRequest("GET", "encoding", input, nil) x.WriteRequest(req) resp, _ := x.ReadResponse() Expect(resp.StatusCode).To(Equal(http.StatusOK)) }
conf.RouteServiceEnabled = false conf.SkipSSLValidation = true routeServiceHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { Fail("Should not get here into Route Service") }) }) It("return 502 Bad Gateway", func() { ln := registerHandlerWithRouteService(r, "my_host.com", "https://"+routeServiceListener.Addr().String(), func(conn *test_util.HttpConn) { Fail("Should not get here into the app") }) defer ln.Close() conn := dialProxy(proxyServer) req := test_util.NewRequest("GET", "my_host.com", "/", nil) conn.WriteRequest(req) res, body := conn.ReadResponse() Expect(res.StatusCode).To(Equal(http.StatusBadGateway)) Expect(body).To(ContainSubstring("Support for route services is disabled.")) }) }) Context("with Route Services enabled", func() { BeforeEach(func() { conf.RouteServiceEnabled = true conf.SkipSSLValidation = true })
handler negroni.Handler headersToLog *[]string logger lager.Logger resp http.ResponseWriter req *http.Request nextCalled bool ) nextHandler := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { nextCalled = true }) BeforeEach(func() { headersToLog = &[]string{} logger = lagertest.NewTestLogger("zipkin") req = test_util.NewRequest("GET", "example.com", "/", nil) resp = httptest.NewRecorder() nextCalled = false }) AfterEach(func() { Expect(nextCalled).To(BeTrue(), "Expected the next handler to be called.") }) Context("with Zipkin enabled", func() { BeforeEach(func() { handler = handlers.NewZipkin(true, headersToLog, logger) }) It("sets zipkin headers", func() { handler.ServeHTTP(resp, req, nextHandler)
var ( proxyRoundTripper http.RoundTripper endpointIterator *routefakes.FakeEndpointIterator transport *roundtripperfakes.FakeRoundTripper logger lager.Logger req *http.Request resp *proxyfakes.FakeProxyResponseWriter dialError = &net.OpError{ Err: errors.New("error"), Op: "dial", } ) BeforeEach(func() { endpointIterator = &routefakes.FakeEndpointIterator{} req = test_util.NewRequest("GET", "myapp.com", "/", nil) req.URL.Scheme = "http" resp = &proxyfakes.FakeProxyResponseWriter{} logger = lagertest.NewTestLogger("test") transport = &roundtripperfakes.FakeRoundTripper{} }) Context("backend", func() { BeforeEach(func() { endpoint := &route.Endpoint{ Tags: map[string]string{}, } endpointIterator.NextReturns(endpoint)
SecureCookies: conf.SecureCookies, TLSConfig: tlsConfig, RouteServiceEnabled: conf.RouteServiceEnabled, RouteServiceTimeout: conf.RouteServiceTimeout, Crypto: crypto, CryptoPrev: cryptoPrev, HealthCheckUserAgent: "HTTP-Monitor/1.1", }) r.Register(route.Uri("some-app"), &route.Endpoint{}) }) Context("when backend fails to respond", func() { It("logs the error and associated endpoint", func() { body := []byte("some body") req := test_util.NewRequest("GET", "some-app", "/", bytes.NewReader(body)) resp := httptest.NewRecorder() proxyObj.ServeHTTP(resp, req) Eventually(logger).Should(Say("error")) Eventually(logger).Should(Say("route-endpoint")) }) }) Context("Log response time", func() { It("logs response time for HTTP connections", func() { body := []byte("some body") req := test_util.NewRequest("GET", "some-app", "/", bytes.NewReader(body)) resp := httptest.NewRecorder()
Value: "xxx", MaxAge: 1, Expires: time.Now(), } }) Context("context paths", func() { Context("when two requests have the same context paths", func() { It("responds with the same instance id", func() { ln := registerHandlerWithInstanceId(r, "app.com/path1", "", responseWithJSessionID, "instance-id-1") defer ln.Close() ln2 := registerHandlerWithInstanceId(r, "app.com/path2/context/path", "", responseWithJSessionID, "instance-id-2") defer ln2.Close() conn := dialProxy(proxyServer) req := test_util.NewRequest("GET", "app.com", "/path1/some/sub/path/index.html", nil) conn.WriteRequest(req) Eventually(done).Should(Receive()) resp, _ := conn.ReadResponse() cookie := getCookie(proxy.VcapCookieId, resp.Cookies()) Expect(cookie).ToNot(BeNil()) Expect(cookie.Path).To(Equal("/path1")) Expect(cookie.Value).To(Equal("instance-id-1")) req2 := test_util.NewRequest("GET", "app.com", "/path1/other/sub/path/index.html", nil) conn.WriteRequest(req2) Eventually(done).Should(Receive())
localIP, err = localip.LocalIP() Expect(err).ToNot(HaveOccurred()) statusPort = test_util.NextAvailPort() proxyPort = test_util.NextAvailPort() cfgFile = filepath.Join(tmpdir, "config.yml") config = createConfig(cfgFile, statusPort, proxyPort, defaultPruneInterval, defaultPruneThreshold, 1, false, natsPort) }) JustBeforeEach(func() { gorouterSession = startGorouterSession(cfgFile) }) It("responds to healthcheck", func() { req := test_util.NewRequest("GET", "", "/", nil) req.Header.Set("User-Agent", "HTTP-Monitor/1.1") conn, err := net.Dial("tcp", fmt.Sprintf("localhost:%d", proxyPort)) Expect(err).ToNot(HaveOccurred()) http_conn := test_util.NewHttpConn(conn) http_conn.WriteRequest(req) resp, body := http_conn.ReadResponse() Expect(resp.Status).To(Equal("200 OK")) Expect(body).To(Equal("ok\n")) }) It("waits for all requests to finish", func() { mbusClient, err := newMessageBus(config) Expect(err).ToNot(HaveOccurred()) requestMade := make(chan bool)
}) app.Listen() go app.RegisterRepeatedly(1 * time.Second) Eventually(func() bool { return appRegistered(registry, app) }).Should(BeTrue()) conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", config.Ip, config.Port)) Expect(err).NotTo(HaveOccurred()) defer conn.Close() httpConn := test_util.NewHttpConn(conn) req := test_util.NewRequest("GET", "foo.vcap.me", "/", nil) req.Header.Add(router_http.VcapRequestIdHeader, "A-BOGUS-REQUEST-ID") httpConn.WriteRequest(req) var answer string Eventually(done).Should(Receive(&answer)) Expect(answer).ToNot(Equal("A-BOGUS-REQUEST-ID")) Expect(answer).To(MatchRegexp(uuid_regex)) Expect(logger).To(gbytes.Say("vcap-request-id-header-set")) resp, _ := httpConn.ReadResponse() Expect(resp.StatusCode).To(Equal(http.StatusOK)) }) It("handles a /routes request", func() {
conn.WriteResponse(test_util.NewResponse(http.StatusOK)) }) defer lnWithoutSlash.Close() lnWithSlash := registerHandler(r, "test/another-path/your_path/", func(conn *test_util.HttpConn) { conn.CheckLine("GET /another-path/your_path HTTP/1.1") conn.WriteResponse(test_util.NewResponse(http.StatusOK)) }) defer lnWithSlash.Close() conn := dialProxy(proxyServer) y := dialProxy(proxyServer) req := test_util.NewRequest("GET", "test", "/my%20path/your_path/", nil) conn.WriteRequest(req) resp, _ := conn.ReadResponse() Expect(resp.StatusCode).To(Equal(http.StatusOK)) req = test_util.NewRequest("GET", "test", "/another-path/your_path", nil) y.WriteRequest(req) resp, _ = y.ReadResponse() Expect(resp.StatusCode).To(Equal(http.StatusOK)) }) It("Content-type is not set by proxy", func() { ln := registerHandler(r, "content-test", func(x *test_util.HttpConn) { _, err := http.ReadRequest(x.Reader)