func TestVia(t *testing.T) { t.Parallel() canonicalKey := http.CanonicalHeaderKey("via") var testText = "notnedomi 2.2" v, err := New(config.NewHandler("headers", json.RawMessage(`{ "response": { "add_headers": { "vIa": "notnedomi 2.2" } } }`)), nil, handlerCode(200)) if err != nil { t.Errorf("Got error when initializing via - %s", err) } var expect []string recorder := httptest.NewRecorder() req, err := http.NewRequest("get", "/to/test", nil) if err != nil { t.Fatal(err) } v.RequestHandle(nil, recorder, req) expect = []string{testText} testHeaders(t, canonicalKey, expect, recorder.Header()) recorder.Header().Set(canonicalKey, "holla") expect = []string{"holla", testText} v.RequestHandle(nil, recorder, req) testHeaders(t, canonicalKey, expect, recorder.Header()) }
func TestVia(t *testing.T) { t.Parallel() canonicalKey := http.CanonicalHeaderKey("via") var testText = "notnedomi 2.2" v, err := New(config.NewHandler("via", json.RawMessage(`{"text": "notnedomi 2.2"}`)), nil, testStringHandler(t, testText)) if err != nil { t.Errorf("Got error when initializing via - %s", err) } var expect, got []string recorder := httptest.NewRecorder() v.RequestHandle(nil, recorder, nil) expect = []string{testText} got = recorder.Header()[canonicalKey] if !reflect.DeepEqual(got, expect) { t.Errorf("expected via header to be equal to %s but got %s", expect, got) } recorder.Header().Set(canonicalKey, "holla") expect = []string{"holla", testText} v.RequestHandle(nil, recorder, nil) got = recorder.Header()[canonicalKey] if !reflect.DeepEqual(got, expect) { t.Errorf("expected via header to be equal to %s but got %s", expect, got) } }
func setup(t *testing.T) types.RequestHandler { var v, err = New(config.NewHandler("flv", json.RawMessage(``)), nil, fsMapHandler()) if err != nil { t.Fatalf("error on creating new flv handler - %s", err) } return v }
func TestErrorOnNonExistingHandler(t *testing.T) { t.Parallel() _, err := New(config.NewHandler("bogus_handler", nil), nil, nil) if err == nil { t.Error("No error returned with bogus handler.") } }
func TestWithBrokenConfig(t *testing.T) { t.Parallel() v, err := New(config.NewHandler("headers", json.RawMessage(`{ "response: { "add_headers": { "vIa": "notnedomi 2.2" } } }`)), nil, handlerCode(200)) if err == nil { t.Errorf("Expected error on initializing with broken config but got %+v", v) } }
func TestNilNext(t *testing.T) { t.Parallel() v, err := New(config.NewHandler("headers", json.RawMessage(`{ "response": { "add_headers": { "vIa": "notnedomi 2.2" } } }`)), nil, nil) if err == nil { t.Errorf("Expected error on initializing with nil next handler but got %+v", v) } }
func TestRemoveFromRequest(t *testing.T) { t.Parallel() var expectedHeaders = map[string][]string{ "Via": nil, "Added": {"old value", "added value"}, "Setting": {"this", "header"}, } v, err := New(config.NewHandler("headers", json.RawMessage(`{ "request": { "remove_headers": ["vIa"], "add_headers": { "added": "added value" }, "set_headers": { "setting": ["this", "header"] } } }`)), nil, types.RequestHandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) { for key, expected := range expectedHeaders { got := r.Header[http.CanonicalHeaderKey(key)] if !reflect.DeepEqual(got, expected) { t.Errorf("for header '%s' expected '%+v', got '%+v'", key, got, expected) } } })) if err != nil { t.Errorf("Got error when initializing via - %s", err) } recorder := httptest.NewRecorder() req, err := http.NewRequest("get", "/to/test", nil) if err != nil { t.Fatal(err) } req.Header.Add(http.CanonicalHeaderKey("via"), "this should be removed") req.Header.Add(http.CanonicalHeaderKey("added"), "old value") req.Header.Add(http.CanonicalHeaderKey("setting"), "this should be resetted") v.RequestHandle(nil, recorder, req) }
func TestRemoveFromResponse(t *testing.T) { t.Parallel() canonicalKey := http.CanonicalHeaderKey("via") v, err := New(config.NewHandler("headers", json.RawMessage(`{ "response": { "remove_headers": ["vIa"] } }`)), nil, addHeaderHandler(t, "via", "pesho")) if err != nil { t.Errorf("Got error when initializing via - %s", err) } recorder := httptest.NewRecorder() req, err := http.NewRequest("get", "/to/test", nil) if err != nil { t.Fatal(err) } v.RequestHandle(nil, recorder, req) var got = recorder.Header()[canonicalKey] if len(got) != 0 { t.Errorf("expected via header to be removed but got %s", got) } }
func TestCodes(t *testing.T) { t.Parallel() var codes = []int{http.StatusPartialContent, http.StatusOK, http.StatusNotFound, http.StatusTeapot} for _, code := range codes { canonicalKey := http.CanonicalHeaderKey("via") var testText = "notnedomi 2.2" v, err := New(config.NewHandler("headers", json.RawMessage(`{ "response": { "add_headers": { "vIa": "notnedomi 2.2" } }, "request": { "add_headers": { "via": "notnedomi 2.2" } } }`)), nil, handlerCode(code)) if err != nil { t.Errorf("Got error when initializing via - %s", err) } var expect []string rec := httptest.NewRecorder() req, err := http.NewRequest("get", "/to/test", nil) if err != nil { t.Fatal(err) } v.RequestHandle(nil, rec, req) expect = []string{testText} testHeaders(t, canonicalKey, expect, rec.Header()) if code != rec.Code { t.Errorf("expected code %d got %d", code, rec.Code) } } }
func TestSimpleRetryWithNilUpstream(t *testing.T) { t.Parallel() ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/err" { w.WriteHeader(404) fmt.Fprint(w, "error!") return } w.WriteHeader(200) fmt.Fprint(w, "hello world") })) defer ts.Close() upstreamURL, err := url.Parse(ts.URL) if err != nil { t.Fatal(err) } up, err := upstream.NewSimple(upstreamURL) if err != nil { t.Fatal(err) } retryTs := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == "/err" { w.WriteHeader(200) fmt.Fprint(w, "not error!") return } w.WriteHeader(404) fmt.Fprint(w, "not hello world") })) defer retryTs.Close() retryUpstreamURL, err := url.Parse(retryTs.URL) if err != nil { t.Fatal(err) } retryUpstream, err := upstream.NewSimple(retryUpstreamURL) if err != nil { t.Fatal(err) } proxy, err := New( config.NewHandler("proxy", json.RawMessage(`{ "try_other_upstream_on_code" : {"404": "nonexistant_upstream"}}`)), &types.Location{ Name: "test", Logger: mock.NewLogger(), Upstream: up, }, nil) if err != nil { t.Fatal(err) } req1, err := http.NewRequest("GET", "http://www.somewhere.com/err", nil) if err != nil { t.Fatal(err) } resp1 := httptest.NewRecorder() ctx := contexts.NewAppContext(context.Background(), &mockApp{ upstreams: map[string]types.Upstream{ "retry_upstream": retryUpstream, }, }) proxy.ServeHTTP(ctx, resp1, req1) if resp1.Code != 404 || resp1.Body.String() != "error!" { t.Errorf("Unexpected response %#v", resp1) } req2, err := http.NewRequest("GET", "http://www.somewhere.com/index", nil) if err != nil { t.Fatal(err) } resp2 := httptest.NewRecorder() proxy.ServeHTTP(nil, resp2, req2) if resp2.Code != 200 || resp2.Body.String() != "hello world" { t.Errorf("Unexpected response %#v", resp2) } }