Function TestBreakFilterChain

proxy/proxy_test.go:970–1026

(t *testing.T)

func (*shunter) Name() string                                            { return "shunter" }

func TestBreakFilterChain(t *testing.T) {
	s := startTestServer([]byte("Hello World!"), 0, func(r *http.Request) {
		t.Error("This should never be called")
	})
	defer s.Close()

	fr := make(filters.Registry)
	fr.Register(builtin.NewAppendRequestHeader())
	resp1 := &http.Response{
		Header:     make(http.Header),
		Body:       io.NopCloser(new(bytes.Buffer)),
		StatusCode: http.StatusUnauthorized,
		Status:     "Impossible body",
	}
	fr.Register(&shunter{resp1})
	fr.Register(builtin.NewAppendResponseHeader())

	doc := fmt.Sprintf(`breakerDemo:
		Path("/shunter") ->
		appendRequestHeader("X-Expected", "request header") ->
		appendResponseHeader("X-Expected", "response header") ->
		shunter() ->
		appendRequestHeader("X-Unexpected", "foo") ->
		appendResponseHeader("X-Unexpected", "bar") ->
		"%s"`, s.URL)
	tp, err := newTestProxyWithFilters(fr, doc, FlagsNone)
	if err != nil {
		t.Error(err)
		return
	}

	defer tp.close()

	r, _ := http.NewRequest("GET", "https://www.example.org/shunter", nil)
	w := httptest.NewRecorder()
	tp.proxy.ServeHTTP(w, r)

	if _, has := r.Header["X-Expected"]; !has {
		t.Error("Request is missing the expected header (added during filter chain winding)")
	}

	if _, has := w.Header()["X-Expected"]; !has {
		t.Error("Response is missing the expected header (added during filter chain unwinding)")
	}

	if _, has := r.Header["X-Unexpected"]; has {
		t.Error("Request has an unexpected header from a filter after the shunter in the chain")
	}

	if _, has := w.Header()["X-Unexpected"]; has {
		t.Error("Response has an unexpected header from a filter after the shunter in the chain")
	}

	if w.Code != http.StatusUnauthorized && w.Body.String() != "Impossible body" {
		t.Errorf("Wrong status code/body. Expected 401 - Impossible body but got %d - %s", w.Code, w.Body.String())
	}
}