support deflate encoding reader

add unit test for rewrite response

response body using encode

refactor test case to struct

move expected to global

add long body test

staging/src/k8s.io/apimachinery/pkg/util/proxy/transport.go

@@ -18,6 +18,7 @@ package proxy
 
 import (
 	"bytes"
+	"compress/flate"
 	"compress/gzip"
 	"fmt"
 	"io"
@@ -231,7 +232,18 @@ func (t *Transport) rewriteResponse(req *http.Request, resp *http.Response) (*ht
 		gzw := gzip.NewWriter(writer)
 		defer gzw.Close()
 		writer = gzw
-	// TODO: support flate, other encodings.
+	case "deflate":
+		var err error
+		reader = flate.NewReader(reader)
+		flw, err := flate.NewWriter(writer, flate.BestCompression)
+		if err != nil {
+			return nil, fmt.Errorf("errorf making flate writer: %v", err)
+		}
+		defer func() {
+			flw.Close()
+			flw.Flush()
+		}()
+		writer = flw
 	case "":
 		// This is fine
 	default:

staging/src/k8s.io/apimachinery/pkg/util/proxy/transport_test.go

@@ -17,6 +17,9 @@ limitations under the License.
 package proxy
 
 import (
+	"bytes"
+	"compress/flate"
+	"compress/gzip"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -274,3 +277,83 @@ func TestProxyTransport(t *testing.T) {
 		testItem(name, &item)
 	}
 }
+
+func TestRewriteResponse(t *testing.T) {
+	gzipbuf := bytes.NewBuffer(nil)
+	flatebuf := bytes.NewBuffer(nil)
+
+	testTransport := &Transport{
+		Scheme:      "http",
+		Host:        "foo.com",
+		PathPrepend: "/proxy/node/node1:10250",
+	}
+	expected := []string{
+		"short body test",
+		strings.Repeat("long body test", 4097),
+	}
+	test := []struct {
+		encodeType string
+		writer     func(string) *http.Response
+		reader     func(*http.Response) string
+	}{
+		{
+			encodeType: "gzip",
+			writer: func(ept string) *http.Response {
+				gzw := gzip.NewWriter(gzipbuf)
+				defer gzw.Close()
+
+				gzw.Write([]byte(ept))
+				gzw.Flush()
+				return &http.Response{
+					Body: ioutil.NopCloser(gzipbuf),
+				}
+			},
+			reader: func(rep *http.Response) string {
+				reader, _ := gzip.NewReader(rep.Body)
+				s, _ := ioutil.ReadAll(reader)
+				return string(s)
+			},
+		},
+		{
+			encodeType: "deflate",
+			writer: func(ept string) *http.Response {
+				flw, _ := flate.NewWriter(flatebuf, flate.BestCompression)
+				defer flw.Close()
+
+				flw.Write([]byte(ept))
+				flw.Flush()
+				return &http.Response{
+					Body: ioutil.NopCloser(flatebuf),
+				}
+			},
+			reader: func(rep *http.Response) string {
+				reader := flate.NewReader(rep.Body)
+				s, _ := ioutil.ReadAll(reader)
+				return string(s)
+			},
+		},
+	}
+
+	errFn := func(encode string, err error) {
+		t.Errorf("%s failed to read and write: %v", encode, err)
+	}
+	for _, v := range test {
+		request, _ := http.NewRequest("GET", "http://mynode.com/", nil)
+		request.Header.Set("Content-Encoding", v.encodeType)
+		request.Header.Add("Accept-Encoding", v.encodeType)
+
+		for _, exp := range expected {
+			resp := v.writer(exp)
+			gotResponse, err := testTransport.rewriteResponse(request, resp)
+
+			if err != nil {
+				errFn(v.encodeType, err)
+			}
+
+			result := v.reader(gotResponse)
+			if result != exp {
+				errFn(v.encodeType, fmt.Errorf("expected %s, get %s", exp, result))
+			}
+		}
+	}
+}