refactor: introduce a fast path when headers don't need to injected

kong/utils.go

@@ -62,16 +62,27 @@ type headerRoundTripper struct {
 
 // RoundTrip satisfies the RoundTripper interface.
 func (t headerRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	req = requestWithHeaders(req, t.headers)
+	return t.rt.RoundTrip(req)
+}
+
+func requestWithHeaders(req *http.Request, headers http.Header) *http.Request {
+	if req == nil {
+		return nil
+	}
+	// fast-path
+	if len(headers) == 0 {
+		return req
+	}
 	newRequest := new(http.Request)
 	*newRequest = *req
-	newRequest.Header = make(http.Header, len(req.Header))
-	for k, s := range req.Header {
-		newRequest.Header[k] = append([]string(nil), s...)
-	}
-	for k, v := range t.headers {
-		newRequest.Header[k] = v
+	newRequest.Header = req.Header.Clone()
+	for k, values := range headers {
+		for _, v := range values {
+			newRequest.Header.Add(k, v)
+		}
 	}
-	return t.rt.RoundTrip(newRequest)
+	return newRequest
 }
 
 // RoundTripperWithHTTPHeaders returns a client which injects headers

kong/utils_test.go

@@ -1,6 +1,8 @@
 package kong
 
 import (
+	"net/http"
+	"reflect"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -52,3 +54,75 @@ func TestStringSlice(t *testing.T) {
 	assert.Equal("foo", *arrp[0])
 	assert.Equal("bar", *arrp[1])
 }
+
+func Test_requestWithHeaders(t *testing.T) {
+	type args struct {
+		req     *http.Request
+		headers http.Header
+	}
+	tests := []struct {
+		name string
+		args args
+		want *http.Request
+	}{
+		{
+			name: "returns request as is if no headers are set",
+			args: args{
+				req: &http.Request{
+					Method: "GET",
+					Header: http.Header{
+						"foo": []string{"bar", "baz"},
+					},
+				},
+				headers: http.Header{},
+			},
+			want: &http.Request{
+				Method: "GET",
+				Header: http.Header{
+					"foo": []string{"bar", "baz"},
+				},
+			},
+		},
+		{
+			name: "returns request with headers added",
+			args: args{
+				req: &http.Request{
+					Method: "GET",
+					Header: http.Header{
+						"foo": []string{"bar", "baz"},
+					},
+				},
+				headers: http.Header{
+					"password": []string{"my-secret-key"},
+					"key-with": []string{"multiple", "values"},
+				},
+			},
+			want: &http.Request{
+				Method: "GET",
+				Header: http.Header{
+					"foo":      []string{"bar", "baz"},
+					"Password": []string{"my-secret-key"},
+					"Key-With": []string{"multiple", "values"},
+				},
+			},
+		},
+		{
+			name: "returns nil when input request is nil",
+			args: args{
+				req: nil,
+				headers: http.Header{
+					"password": []string{"my-secret-key"},
+					"key-with": []string{"multiple", "values"},
+				},
+			},
+			want: nil,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := requestWithHeaders(tt.args.req, tt.args.headers); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("requestWithHeaders() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}