Revert "Configure the kubelet to use HTTPS"

pkg/apiserver/validator_test.go

@@ -21,27 +21,35 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
-	"net"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
 	"testing"
 
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/probe"
 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 )
 
-type fakeRoundTripper struct {
+type fakeHttpGet struct {
 	err  error
 	resp *http.Response
 	url  string
 }
 
-func (f *fakeRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
-	f.url = req.URL.String()
+func (f *fakeHttpGet) Get(url string) (*http.Response, error) {
+	f.url = url
 	return f.resp, f.err
 }
 
+func makeFake(data string, statusCode int, err error) *fakeHttpGet {
+	return &fakeHttpGet{
+		err: err,
+		resp: &http.Response{
+			Body:       ioutil.NopCloser(bytes.NewBufferString(data)),
+			StatusCode: statusCode,
+		},
+	}
+}
+
 func TestValidate(t *testing.T) {
 	tests := []struct {
 		err            error
@@ -58,18 +66,11 @@ func TestValidate(t *testing.T) {
 	s := Server{Addr: "foo.com", Port: 8080, Path: "/healthz"}
 
 	for _, test := range tests {
-		fakeRT := &fakeRoundTripper{
-			err: test.err,
-			resp: &http.Response{
-				Body:       ioutil.NopCloser(bytes.NewBufferString(test.data)),
-				StatusCode: test.code,
-			},
-		}
-		fake := &http.Client{Transport: fakeRT}
+		fake := makeFake(test.data, test.code, test.err)
 		status, data, err := s.check(fake)
 		expect := fmt.Sprintf("http://%s:%d/healthz", s.Addr, s.Port)
-		if fakeRT.url != expect {
-			t.Errorf("expected %s, got %s", expect, fakeRT.url)
+		if fake.url != expect {
+			t.Errorf("expected %s, got %s", expect, fake.url)
 		}
 		if test.expectErr && err == nil {
 			t.Errorf("unexpected non-error")
@@ -86,30 +87,8 @@ func TestValidate(t *testing.T) {
 	}
 }
 
-func makeTestValidator(servers map[string]string, rt http.RoundTripper) (http.Handler, error) {
-	result := map[string]Server{}
-	for name, value := range servers {
-		host, port, err := net.SplitHostPort(value)
-		if err != nil {
-			return nil, fmt.Errorf("invalid server spec: %s (%v)", value, err)
-		}
-		val, err := strconv.Atoi(port)
-		if err != nil {
-			return nil, fmt.Errorf("invalid server spec: %s (%v)", port, err)
-		}
-		result[name] = Server{Addr: host, Port: val, Path: "/healthz"}
-	}
-
-	return &validator{servers: func() map[string]Server { return result }, rt: rt}, nil
-}
-
 func TestValidator(t *testing.T) {
-	fake := &fakeRoundTripper{
-		resp: &http.Response{
-			Body:       ioutil.NopCloser(bytes.NewBufferString("foo")),
-			StatusCode: 200,
-		},
-	}
+	fake := makeFake("foo", 200, nil)
 	validator, err := makeTestValidator(map[string]string{
 		"foo": "foo.com:80",
 		"bar": "bar.com:8080",
@@ -122,6 +101,7 @@ func TestValidator(t *testing.T) {
 	defer testServer.Close()
 
 	resp, err := http.Get(testServer.URL + "/validatez")
+
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
@@ -133,15 +113,13 @@ func TestValidator(t *testing.T) {
 	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
-	var status []ServerStatus
-	if err := json.Unmarshal(data, &status); err != nil {
+	status := []ServerStatus{}
+	err = json.Unmarshal(data, &status)
+	if err != nil {
 		t.Errorf("unexpected error: %v", err)
 	}
 	components := util.StringSet{}
 	for _, s := range status {
-		if s.Err != "nil" {
-			t.Errorf("Component %v is unhealthy: %v", s.Component, s.Err)
-		}
 		components.Insert(s.Component)
 	}
 	if len(status) != 2 || !components.Has("foo") || !components.Has("bar") {