e8af67c180
The API server sends its own CORS headers in its response, and if the proxied pod response also includes its own headers, it confuses clients.
352 lines
9.8 KiB
Go
352 lines
9.8 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes Authors All rights reserved.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package rest
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"testing"
|
|
|
|
"golang.org/x/net/websocket"
|
|
|
|
"github.com/GoogleCloudPlatform/kubernetes/pkg/util/proxy"
|
|
)
|
|
|
|
type SimpleBackendHandler struct {
|
|
requestURL url.URL
|
|
requestHeader http.Header
|
|
requestBody []byte
|
|
requestMethod string
|
|
responseBody string
|
|
responseHeader map[string]string
|
|
t *testing.T
|
|
}
|
|
|
|
func (s *SimpleBackendHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
|
|
s.requestURL = *req.URL
|
|
s.requestHeader = req.Header
|
|
s.requestMethod = req.Method
|
|
var err error
|
|
s.requestBody, err = ioutil.ReadAll(req.Body)
|
|
if err != nil {
|
|
s.t.Errorf("Unexpected error: %v", err)
|
|
return
|
|
}
|
|
|
|
if s.responseHeader != nil {
|
|
for k, v := range s.responseHeader {
|
|
w.Header().Add(k, v)
|
|
}
|
|
}
|
|
w.Write([]byte(s.responseBody))
|
|
}
|
|
|
|
func validateParameters(t *testing.T, name string, actual url.Values, expected map[string]string) {
|
|
for k, v := range expected {
|
|
actualValue, ok := actual[k]
|
|
if !ok {
|
|
t.Errorf("%s: Expected parameter %s not received", name, k)
|
|
continue
|
|
}
|
|
if actualValue[0] != v {
|
|
t.Errorf("%s: Parameter %s values don't match. Actual: %#v, Expected: %s",
|
|
name, k, actualValue, v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func validateHeaders(t *testing.T, name string, actual http.Header, expected map[string]string, notExpected []string) {
|
|
for k, v := range expected {
|
|
actualValue, ok := actual[k]
|
|
if !ok {
|
|
t.Errorf("%s: Expected header %s not received", name, k)
|
|
continue
|
|
}
|
|
if actualValue[0] != v {
|
|
t.Errorf("%s: Header %s values don't match. Actual: %s, Expected: %s",
|
|
name, k, actualValue, v)
|
|
}
|
|
}
|
|
if notExpected == nil {
|
|
return
|
|
}
|
|
for _, h := range notExpected {
|
|
if _, present := actual[h]; present {
|
|
t.Errorf("%s: unexpected header: %s", name, h)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestServeHTTP(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
method string
|
|
requestPath string
|
|
expectedPath string
|
|
requestBody string
|
|
requestParams map[string]string
|
|
requestHeader map[string]string
|
|
responseHeader map[string]string
|
|
expectedRespHeader map[string]string
|
|
notExpectedRespHeader []string
|
|
}{
|
|
{
|
|
name: "root path, simple get",
|
|
method: "GET",
|
|
requestPath: "/",
|
|
expectedPath: "/",
|
|
},
|
|
{
|
|
name: "simple path, get",
|
|
method: "GET",
|
|
requestPath: "/path/to/test",
|
|
expectedPath: "/path/to/test",
|
|
},
|
|
{
|
|
name: "request params",
|
|
method: "POST",
|
|
requestPath: "/some/path/",
|
|
expectedPath: "/some/path/",
|
|
requestParams: map[string]string{"param1": "value/1", "param2": "value%2"},
|
|
requestBody: "test request body",
|
|
},
|
|
{
|
|
name: "request headers",
|
|
method: "PUT",
|
|
requestPath: "/some/path",
|
|
expectedPath: "/some/path",
|
|
requestHeader: map[string]string{"Header1": "value1", "Header2": "value2"},
|
|
},
|
|
{
|
|
name: "empty path - slash should be added",
|
|
method: "GET",
|
|
requestPath: "",
|
|
expectedPath: "/",
|
|
},
|
|
{
|
|
name: "remove CORS headers",
|
|
method: "GET",
|
|
requestPath: "/some/path",
|
|
expectedPath: "/some/path",
|
|
responseHeader: map[string]string{
|
|
"Header1": "value1",
|
|
"Access-Control-Allow-Origin": "some.server",
|
|
"Access-Control-Allow-Methods": "GET"},
|
|
expectedRespHeader: map[string]string{
|
|
"Header1": "value1",
|
|
},
|
|
notExpectedRespHeader: []string{
|
|
"Access-Control-Allow-Origin",
|
|
"Access-Control-Allow-Methods",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
func() {
|
|
backendResponse := "<html><head></head><body><a href=\"/test/path\">Hello</a></body></html>"
|
|
backendResponseHeader := test.responseHeader
|
|
// Test a simple header if not specified in the test
|
|
if backendResponseHeader == nil && test.expectedRespHeader == nil {
|
|
backendResponseHeader = map[string]string{"Content-Type": "text/html"}
|
|
test.expectedRespHeader = map[string]string{"Content-Type": "text/html"}
|
|
}
|
|
backendHandler := &SimpleBackendHandler{
|
|
responseBody: backendResponse,
|
|
responseHeader: backendResponseHeader,
|
|
}
|
|
backendServer := httptest.NewServer(backendHandler)
|
|
defer backendServer.Close()
|
|
|
|
backendURL, _ := url.Parse(backendServer.URL)
|
|
backendURL.Path = test.requestPath
|
|
proxyHandler := &UpgradeAwareProxyHandler{
|
|
Location: backendURL,
|
|
}
|
|
proxyServer := httptest.NewServer(proxyHandler)
|
|
defer proxyServer.Close()
|
|
proxyURL, _ := url.Parse(proxyServer.URL)
|
|
proxyURL.Path = test.requestPath
|
|
paramValues := url.Values{}
|
|
for k, v := range test.requestParams {
|
|
paramValues[k] = []string{v}
|
|
}
|
|
proxyURL.RawQuery = paramValues.Encode()
|
|
var requestBody io.Reader
|
|
if test.requestBody != "" {
|
|
requestBody = bytes.NewBufferString(test.requestBody)
|
|
}
|
|
req, err := http.NewRequest(test.method, proxyURL.String(), requestBody)
|
|
if test.requestHeader != nil {
|
|
header := http.Header{}
|
|
for k, v := range test.requestHeader {
|
|
header.Add(k, v)
|
|
}
|
|
req.Header = header
|
|
}
|
|
if err != nil {
|
|
t.Errorf("Error creating client request: %v", err)
|
|
}
|
|
client := &http.Client{}
|
|
res, err := client.Do(req)
|
|
if err != nil {
|
|
t.Errorf("Error from proxy request: %v", err)
|
|
}
|
|
|
|
// Validate backend request
|
|
// Method
|
|
if backendHandler.requestMethod != test.method {
|
|
t.Errorf("Unexpected request method: %s. Expected: %s",
|
|
backendHandler.requestMethod, test.method)
|
|
}
|
|
|
|
// Body
|
|
if string(backendHandler.requestBody) != test.requestBody {
|
|
t.Errorf("Unexpected request body: %s. Expected: %s",
|
|
string(backendHandler.requestBody), test.requestBody)
|
|
}
|
|
|
|
// Path
|
|
if backendHandler.requestURL.Path != test.expectedPath {
|
|
t.Errorf("Unexpected request path: %s", backendHandler.requestURL.Path)
|
|
}
|
|
// Parameters
|
|
validateParameters(t, test.name, backendHandler.requestURL.Query(), test.requestParams)
|
|
|
|
// Headers
|
|
validateHeaders(t, test.name+" backend request", backendHandler.requestHeader,
|
|
test.requestHeader, nil)
|
|
|
|
// Validate proxy response
|
|
|
|
// Response Headers
|
|
validateHeaders(t, test.name+" backend headers", res.Header, test.expectedRespHeader, test.notExpectedRespHeader)
|
|
|
|
// Validate Body
|
|
responseBody, err := ioutil.ReadAll(res.Body)
|
|
if err != nil {
|
|
t.Errorf("Unexpected error reading response body: %v", err)
|
|
}
|
|
if rb := string(responseBody); rb != backendResponse {
|
|
t.Errorf("Did not get expected response body: %s. Expected: %s", rb, backendResponse)
|
|
}
|
|
|
|
// Error
|
|
err = proxyHandler.RequestError()
|
|
if err != nil {
|
|
t.Errorf("Unexpected proxy handler error: %v", err)
|
|
}
|
|
}()
|
|
}
|
|
}
|
|
|
|
func TestProxyUpgrade(t *testing.T) {
|
|
backendServer := httptest.NewServer(websocket.Handler(func(ws *websocket.Conn) {
|
|
defer ws.Close()
|
|
body := make([]byte, 5)
|
|
ws.Read(body)
|
|
ws.Write([]byte("hello " + string(body)))
|
|
}))
|
|
defer backendServer.Close()
|
|
|
|
serverURL, _ := url.Parse(backendServer.URL)
|
|
proxyHandler := &UpgradeAwareProxyHandler{
|
|
Location: serverURL,
|
|
}
|
|
proxy := httptest.NewServer(proxyHandler)
|
|
defer proxy.Close()
|
|
|
|
ws, err := websocket.Dial("ws://"+proxy.Listener.Addr().String()+"/some/path", "", "http://127.0.0.1/")
|
|
if err != nil {
|
|
t.Fatalf("websocket dial err: %s", err)
|
|
}
|
|
defer ws.Close()
|
|
|
|
if _, err := ws.Write([]byte("world")); err != nil {
|
|
t.Fatalf("write err: %s", err)
|
|
}
|
|
|
|
response := make([]byte, 20)
|
|
n, err := ws.Read(response)
|
|
if err != nil {
|
|
t.Fatalf("read err: %s", err)
|
|
}
|
|
if e, a := "hello world", string(response[0:n]); e != a {
|
|
t.Fatalf("expected '%#v', got '%#v'", e, a)
|
|
}
|
|
}
|
|
|
|
func TestDefaultProxyTransport(t *testing.T) {
|
|
tests := []struct {
|
|
name,
|
|
url,
|
|
location,
|
|
expectedScheme,
|
|
expectedHost,
|
|
expectedPathPrepend string
|
|
}{
|
|
|
|
{
|
|
name: "simple path",
|
|
url: "http://test.server:8080/a/test/location",
|
|
location: "http://localhost/location",
|
|
expectedScheme: "http",
|
|
expectedHost: "test.server:8080",
|
|
expectedPathPrepend: "/a/test",
|
|
},
|
|
{
|
|
name: "empty path",
|
|
url: "http://test.server:8080/a/test/",
|
|
location: "http://localhost",
|
|
expectedScheme: "http",
|
|
expectedHost: "test.server:8080",
|
|
expectedPathPrepend: "/a/test",
|
|
},
|
|
{
|
|
name: "location ending in slash",
|
|
url: "http://test.server:8080/a/test/",
|
|
location: "http://localhost/",
|
|
expectedScheme: "http",
|
|
expectedHost: "test.server:8080",
|
|
expectedPathPrepend: "/a/test",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
locURL, _ := url.Parse(test.location)
|
|
URL, _ := url.Parse(test.url)
|
|
h := UpgradeAwareProxyHandler{
|
|
Location: locURL,
|
|
}
|
|
result := h.defaultProxyTransport(URL)
|
|
transport := result.(*corsRemovingTransport).RoundTripper.(*proxy.Transport)
|
|
if transport.Scheme != test.expectedScheme {
|
|
t.Errorf("%s: unexpected scheme. Actual: %s, Expected: %s", test.name, transport.Scheme, test.expectedScheme)
|
|
}
|
|
if transport.Host != test.expectedHost {
|
|
t.Errorf("%s: unexpected host. Actual: %s, Expected: %s", test.name, transport.Host, test.expectedHost)
|
|
}
|
|
if transport.PathPrepend != test.expectedPathPrepend {
|
|
t.Errorf("%s: unexpected path prepend. Actual: %s, Expected: %s", test.name, transport.PathPrepend, test.expectedPathPrepend)
|
|
}
|
|
}
|
|
}
|