fix go vet errors

federation/pkg/federation-controller/service/service_helper_test.go

@@ -62,7 +62,7 @@ func TestProcessServiceUpdate(t *testing.T) {
 			&cachedService{
 				lastState: &v1.Service{Status: v1.ServiceStatus{LoadBalancer: buildServiceStatus([][]string{{"ip1", ""}})}},
 				serviceStatusMap: map[string]v1.LoadBalancerStatus{
-					"foo1": {Ingress: []v1.LoadBalancerIngress{{"ip1", ""}}},
+					"foo1": {Ingress: []v1.LoadBalancerIngress{{IP: "ip1", Hostname: ""}}},
 				},
 			},
 			&v1.Service{Status: v1.ServiceStatus{LoadBalancer: buildServiceStatus([][]string{{"ip1", ""}})}},
@@ -77,7 +77,7 @@ func TestProcessServiceUpdate(t *testing.T) {
 					ObjectMeta: v1.ObjectMeta{Name: "bar1"},
 				},
 				serviceStatusMap: map[string]v1.LoadBalancerStatus{
-					"foo2": {Ingress: []v1.LoadBalancerIngress{{"ip1", ""}}},
+					"foo2": {Ingress: []v1.LoadBalancerIngress{{IP: "ip1", Hostname: ""}}},
 				},
 			},
 			&v1.Service{Status: v1.ServiceStatus{LoadBalancer: buildServiceStatus([][]string{{"ip1", ""}})}},
@@ -127,7 +127,7 @@ func TestProcessServiceDeletion(t *testing.T) {
 			&cachedService{
 				lastState: &v1.Service{Status: v1.ServiceStatus{LoadBalancer: buildServiceStatus([][]string{{"ip1", ""}})}},
 				serviceStatusMap: map[string]v1.LoadBalancerStatus{
-					"foo1": {Ingress: []v1.LoadBalancerIngress{{"ip1", ""}}},
+					"foo1": {Ingress: []v1.LoadBalancerIngress{{IP: "ip1", Hostname: ""}}},
 				},
 			},
 			&v1.Service{Status: v1.ServiceStatus{LoadBalancer: buildServiceStatus([][]string{{"ip1", ""}})}},

hack/make-rules/vet.sh

@@ -42,8 +42,8 @@ for arg; do
 done
 
 if [[ ${#targets[@]} -eq 0 ]]; then
-  # Do not run on third_party directories.
-  targets=$(go list -e ./... | egrep -v "/(third_party|vendor|staging)/")
+  # Do not run on third_party directories or generated client code.
+  targets=$(go list -e ./... | egrep -v "/(third_party|vendor|staging|clientset_generated)/")
 fi
 
 go vet "${goflags[@]:+${goflags[@]}}" ${targets[@]}

pkg/api/validation/validation_test.go

@@ -2209,8 +2209,8 @@ func TestValidateHandler(t *testing.T) {
 		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromInt(1), Host: "", Scheme: "HTTP"}},
 		{HTTPGet: &api.HTTPGetAction{Path: "/foo", Port: intstr.FromInt(65535), Host: "host", Scheme: "HTTP"}},
 		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP"}},
-		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{"Host", "foo.example.com"}}}},
-		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{"X-Forwarded-For", "1.2.3.4"}, {"X-Forwarded-For", "5.6.7.8"}}}},
+		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{Name: "Host", Value: "foo.example.com"}}}},
+		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{Name: "X-Forwarded-For", Value: "1.2.3.4"}, {Name: "X-Forwarded-For", Value: "5.6.7.8"}}}},
 	}
 	for _, h := range successCases {
 		if errs := validateHandler(&h, field.NewPath("field")); len(errs) != 0 {
@@ -2224,8 +2224,8 @@ func TestValidateHandler(t *testing.T) {
 		{HTTPGet: &api.HTTPGetAction{Path: "", Port: intstr.FromInt(0), Host: ""}},
 		{HTTPGet: &api.HTTPGetAction{Path: "/foo", Port: intstr.FromInt(65536), Host: "host"}},
 		{HTTPGet: &api.HTTPGetAction{Path: "", Port: intstr.FromString(""), Host: ""}},
-		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{"Host:", "foo.example.com"}}}},
-		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{"X_Forwarded_For", "foo.example.com"}}}},
+		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{Name: "Host:", Value: "foo.example.com"}}}},
+		{HTTPGet: &api.HTTPGetAction{Path: "/", Port: intstr.FromString("port"), Host: "", Scheme: "HTTP", HTTPHeaders: []api.HTTPHeader{{Name: "X_Forwarded_For", Value: "foo.example.com"}}}},
 	}
 	for _, h := range errorCases {
 		if errs := validateHandler(&h, field.NewPath("field")); len(errs) == 0 {

pkg/client/cache/reflector_test.go

@@ -286,14 +286,14 @@ func TestReflectorListAndWatchWithErrors(t *testing.T) {
 		{
 			list: mkList("1"),
 			events: []watch.Event{
-				{watch.Added, mkPod("foo", "2")},
-				{watch.Added, mkPod("bar", "3")},
+				{Type: watch.Added, Object: mkPod("foo", "2")},
+				{Type: watch.Added, Object: mkPod("bar", "3")},
 			},
 		}, {
 			list: mkList("3", mkPod("foo", "2"), mkPod("bar", "3")),
 			events: []watch.Event{
-				{watch.Deleted, mkPod("foo", "4")},
-				{watch.Added, mkPod("qux", "5")},
+				{Type: watch.Deleted, Object: mkPod("foo", "4")},
+				{Type: watch.Added, Object: mkPod("qux", "5")},
 			},
 		}, {
 			listErr: fmt.Errorf("a list error"),
@@ -303,7 +303,7 @@ func TestReflectorListAndWatchWithErrors(t *testing.T) {
 		}, {
 			list: mkList("5", mkPod("bar", "3"), mkPod("qux", "5")),
 			events: []watch.Event{
-				{watch.Added, mkPod("baz", "6")},
+				{Type: watch.Added, Object: mkPod("baz", "6")},
 			},
 		}, {
 			list: mkList("6", mkPod("bar", "3"), mkPod("qux", "5"), mkPod("baz", "6")),

pkg/client/typed/discovery/client_test.go

@@ -154,17 +154,17 @@ func TestGetServerResources(t *testing.T) {
 	stable := unversioned.APIResourceList{
 		GroupVersion: "v1",
 		APIResources: []unversioned.APIResource{
-			{"pods", true, "Pod"},
-			{"services", true, "Service"},
-			{"namespaces", false, "Namespace"},
+			{Name: "pods", Namespaced: true, Kind: "Pod"},
+			{Name: "services", Namespaced: true, Kind: "Service"},
+			{Name: "namespaces", Namespaced: false, Kind: "Namespace"},
 		},
 	}
 	beta := unversioned.APIResourceList{
 		GroupVersion: "extensions/v1",
 		APIResources: []unversioned.APIResource{
-			{"deployments", true, "Deployment"},
-			{"ingresses", true, "Ingress"},
-			{"jobs", true, "Job"},
+			{Name: "deployments", Namespaced: true, Kind: "Deployment"},
+			{Name: "ingresses", Namespaced: true, Kind: "Ingress"},
+			{Name: "jobs", Namespaced: true, Kind: "Job"},
 		},
 	}
 	tests := []struct {

pkg/controller/podautoscaler/horizontal_test.go

@@ -314,7 +314,7 @@ func (tc *testCase) prepareTestClient(t *testing.T) *fake.Clientset {
 			metrics := heapster.MetricResultList{}
 			for _, level := range tc.reportedLevels {
 				metric := heapster.MetricResult{
-					Metrics:         []heapster.MetricPoint{{timestamp, level, nil}},
+					Metrics:         []heapster.MetricPoint{{Timestamp: timestamp, Value: level, FloatValue: nil}},
 					LatestTimestamp: timestamp,
 				}
 				metrics.Items = append(metrics.Items, metric)

pkg/controller/podautoscaler/metrics/metrics_client_test.go

@@ -442,9 +442,9 @@ func TestAggregateSum(t *testing.T) {
 		Items: []heapster.MetricResult{
 			{
 				Metrics: []heapster.MetricPoint{
-					{now, 50, nil},
-					{now.Add(-15 * time.Second), 100, nil},
-					{now.Add(-60 * time.Second), 100000, nil}},
+					{Timestamp: now, Value: 50, FloatValue: nil},
+					{Timestamp: now.Add(-15 * time.Second), Value: 100, FloatValue: nil},
+					{Timestamp: now.Add(-60 * time.Second), Value: 100000, FloatValue: nil}},
 				LatestTimestamp: now,
 			},
 		},
@@ -461,8 +461,8 @@ func TestAggregateSumSingle(t *testing.T) {
 		Items: []heapster.MetricResult{
 			{
 				Metrics: []heapster.MetricPoint{
-					{now, 50, nil},
-					{now.Add(-65 * time.Second), 100000, nil}},
+					{Timestamp: now, Value: 50, FloatValue: nil},
+					{Timestamp: now.Add(-65 * time.Second), Value: 100000, FloatValue: nil}},
 				LatestTimestamp: now,
 			},
 		},

pkg/kubelet/container/runtime_cache_fake.go

@@ -37,6 +37,9 @@ func (r *TestRuntimeCache) GetCachedPods() []*Pod {
 }
 
 func NewTestRuntimeCache(getter podsGetter) *TestRuntimeCache {
-	c, _ := NewRuntimeCache(getter)
-	return &TestRuntimeCache{*c.(*runtimeCache)}
+	return &TestRuntimeCache{
+		runtimeCache: runtimeCache{
+			getter: getter,
+		},
+	}
 }

pkg/kubelet/dockertools/docker_manager.go

@@ -604,9 +604,9 @@ func (dm *DockerManager) runContainer(
 		// Experimental. For now, we hardcode /dev/nvidia0 no matter what the user asks for
 		// (we only support one device per node).
 		devices = []dockercontainer.DeviceMapping{
-			{"/dev/nvidia0", "/dev/nvidia0", "mrw"},
-			{"/dev/nvidiactl", "/dev/nvidiactl", "mrw"},
-			{"/dev/nvidia-uvm", "/dev/nvidia-uvm", "mrw"},
+			{PathOnHost: "/dev/nvidia0", PathInContainer: "/dev/nvidia0", CgroupPermissions: "mrw"},
+			{PathOnHost: "/dev/nvidiactl", PathInContainer: "/dev/nvidiactl", CgroupPermissions: "mrw"},
+			{PathOnHost: "/dev/nvidia-uvm", PathInContainer: "/dev/nvidia-uvm", CgroupPermissions: "mrw"},
 		}
 	}
 	podHasSELinuxLabel := pod.Spec.SecurityContext != nil && pod.Spec.SecurityContext.SELinuxOptions != nil

pkg/kubelet/dockertools/docker_test.go

@@ -277,25 +277,33 @@ func TestPullWithSecrets(t *testing.T) {
 		"default keyring secrets": {
 			"ubuntu",
 			[]api.Secret{},
-			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"index.docker.io/v1/": {"built-in", "password", "email", nil}}),
+			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{
+				"index.docker.io/v1/": {Username: "built-in", Password: "password", Email: "email", Provider: nil},
+			}),
 			[]string{`ubuntu:latest using {"username":"built-in","password":"password","email":"email"}`},
 		},
 		"default keyring secrets unused": {
 			"ubuntu",
 			[]api.Secret{},
-			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"extraneous": {"built-in", "password", "email", nil}}),
+			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{
+				"extraneous": {Username: "built-in", Password: "password", Email: "email", Provider: nil},
+			}),
 			[]string{`ubuntu:latest using {}`},
 		},
 		"builtin keyring secrets, but use passed": {
 			"ubuntu",
 			[]api.Secret{{Type: api.SecretTypeDockercfg, Data: map[string][]byte{api.DockerConfigKey: dockercfgContent}}},
-			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"index.docker.io/v1/": {"built-in", "password", "email", nil}}),
+			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{
+				"index.docker.io/v1/": {Username: "built-in", Password: "password", Email: "email", Provider: nil},
+			}),
 			[]string{`ubuntu:latest using {"username":"passed-user","password":"passed-password","email":"passed-email"}`},
 		},
 		"builtin keyring secrets, but use passed with new docker config": {
 			"ubuntu",
 			[]api.Secret{{Type: api.SecretTypeDockerConfigJson, Data: map[string][]byte{api.DockerConfigJsonKey: dockerConfigJsonContent}}},
-			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{"index.docker.io/v1/": {"built-in", "password", "email", nil}}),
+			credentialprovider.DockerConfig(map[string]credentialprovider.DockerConfigEntry{
+				"index.docker.io/v1/": {Username: "built-in", Password: "password", Email: "email", Provider: nil},
+			}),
 			[]string{`ubuntu:latest using {"username":"passed-user","password":"passed-password","email":"passed-email"}`},
 		},
 	}

pkg/kubelet/images/image_manager_test.go

@@ -108,7 +108,7 @@ func TestParallelPuller(t *testing.T) {
 		fakeRecorder := &record.FakeRecorder{}
 		puller := NewImageManager(fakeRecorder, fakeRuntime, backOff, false)
 
-		fakeRuntime.ImageList = []Image{{"present_image", nil, nil, 1}}
+		fakeRuntime.ImageList = []Image{{ID: "present_image", Size: 1}}
 		fakeRuntime.Err = c.pullerErr
 		fakeRuntime.InspectErr = c.inspectErr
 

pkg/kubelet/kubelet_test.go

@@ -945,32 +945,32 @@ func TestMakeVolumeMounts(t *testing.T) {
 
 	expectedMounts := []kubecontainer.Mount{
 		{
-			"disk",
-			"/etc/hosts",
-			"/mnt/disk",
-			false,
-			false,
+			Name:           "disk",
+			ContainerPath:  "/etc/hosts",
+			HostPath:       "/mnt/disk",
+			ReadOnly:       false,
+			SELinuxRelabel: false,
 		},
 		{
-			"disk",
-			"/mnt/path3",
-			"/mnt/disk",
-			true,
-			false,
+			Name:           "disk",
+			ContainerPath:  "/mnt/path3",
+			HostPath:       "/mnt/disk",
+			ReadOnly:       true,
+			SELinuxRelabel: false,
 		},
 		{
-			"disk4",
-			"/mnt/path4",
-			"/mnt/host",
-			false,
-			false,
+			Name:           "disk4",
+			ContainerPath:  "/mnt/path4",
+			HostPath:       "/mnt/host",
+			ReadOnly:       false,
+			SELinuxRelabel: false,
 		},
 		{
-			"disk5",
-			"/mnt/path5",
-			"/var/lib/kubelet/podID/volumes/empty/disk5",
-			false,
-			false,
+			Name:           "disk5",
+			ContainerPath:  "/mnt/path5",
+			HostPath:       "/var/lib/kubelet/podID/volumes/empty/disk5",
+			ReadOnly:       false,
+			SELinuxRelabel: false,
 		},
 	}
 	if !reflect.DeepEqual(mounts, expectedMounts) {

pkg/kubelet/prober/prober_test.go

@@ -175,16 +175,16 @@ func TestHTTPHeaders(t *testing.T) {
 	}{
 		{[]api.HTTPHeader{}, http.Header{}},
 		{[]api.HTTPHeader{
-			{"X-Muffins-Or-Cupcakes", "Muffins"},
+			{Name: "X-Muffins-Or-Cupcakes", Value: "Muffins"},
 		}, http.Header{"X-Muffins-Or-Cupcakes": {"Muffins"}}},
 		{[]api.HTTPHeader{
-			{"X-Muffins-Or-Cupcakes", "Muffins"},
-			{"X-Muffins-Or-Plumcakes", "Muffins!"},
+			{Name: "X-Muffins-Or-Cupcakes", Value: "Muffins"},
+			{Name: "X-Muffins-Or-Plumcakes", Value: "Muffins!"},
 		}, http.Header{"X-Muffins-Or-Cupcakes": {"Muffins"},
 			"X-Muffins-Or-Plumcakes": {"Muffins!"}}},
 		{[]api.HTTPHeader{
-			{"X-Muffins-Or-Cupcakes", "Muffins"},
-			{"X-Muffins-Or-Cupcakes", "Cupcakes, too"},
+			{Name: "X-Muffins-Or-Cupcakes", Value: "Muffins"},
+			{Name: "X-Muffins-Or-Cupcakes", Value: "Cupcakes, too"},
 		}, http.Header{"X-Muffins-Or-Cupcakes": {"Muffins", "Cupcakes, too"}}},
 	}
 	for _, test := range testCases {

pkg/kubelet/rkt/rkt_test.go

@@ -860,7 +860,7 @@ func baseApp(t *testing.T) *appctypes.App {
 		SupplementaryGIDs: []int{4, 5, 6},
 		WorkingDirectory:  "/foo",
 		Environment: []appctypes.EnvironmentVariable{
-			{"env-foo", "bar"},
+			{Name: "env-foo", Value: "bar"},
 		},
 		MountPoints: []appctypes.MountPoint{
 			{Name: *appctypes.MustACName("mnt-foo"), Path: "/mnt-foo", ReadOnly: false},
@@ -997,7 +997,7 @@ func TestSetApp(t *testing.T) {
 				SupplementaryGIDs: []int{4, 5, 6},
 				WorkingDirectory:  "/foo",
 				Environment: []appctypes.EnvironmentVariable{
-					{"env-foo", "bar"},
+					{Name: "env-foo", Value: "bar"},
 				},
 				MountPoints: []appctypes.MountPoint{
 					{Name: *appctypes.MustACName("mnt-foo"), Path: "/mnt-foo", ReadOnly: false},
@@ -1056,8 +1056,8 @@ func TestSetApp(t *testing.T) {
 				SupplementaryGIDs: []int{1, 2, 3, 4},
 				WorkingDirectory:  tmpDir,
 				Environment: []appctypes.EnvironmentVariable{
-					{"env-foo", "bar"},
-					{"env-bar", "foo"},
+					{Name: "env-foo", Value: "bar"},
+					{Name: "env-bar", Value: "foo"},
 				},
 				MountPoints: []appctypes.MountPoint{
 					{Name: *appctypes.MustACName("mnt-foo"), Path: "/mnt-foo", ReadOnly: false},
@@ -1120,8 +1120,8 @@ func TestSetApp(t *testing.T) {
 				SupplementaryGIDs: []int{1, 2, 3, 4},
 				WorkingDirectory:  tmpDir,
 				Environment: []appctypes.EnvironmentVariable{
-					{"env-foo", "foo"},
-					{"env-bar", "bar"},
+					{Name: "env-foo", Value: "foo"},
+					{Name: "env-bar", Value: "bar"},
 				},
 				MountPoints: []appctypes.MountPoint{
 					{Name: *appctypes.MustACName("mnt-foo"), Path: "/mnt-bar", ReadOnly: true},

pkg/master/master_test.go

@@ -229,9 +229,9 @@ func TestFindExternalAddress(t *testing.T) {
 	expectedIP := "172.0.0.1"
 
 	nodes := []*api.Node{new(api.Node), new(api.Node), new(api.Node)}
-	nodes[0].Status.Addresses = []api.NodeAddress{{"ExternalIP", expectedIP}}
-	nodes[1].Status.Addresses = []api.NodeAddress{{"LegacyHostIP", expectedIP}}
-	nodes[2].Status.Addresses = []api.NodeAddress{{"ExternalIP", expectedIP}, {"LegacyHostIP", "172.0.0.2"}}
+	nodes[0].Status.Addresses = []api.NodeAddress{{Type: "ExternalIP", Address: expectedIP}}
+	nodes[1].Status.Addresses = []api.NodeAddress{{Type: "LegacyHostIP", Address: expectedIP}}
+	nodes[2].Status.Addresses = []api.NodeAddress{{Type: "ExternalIP", Address: expectedIP}, {Type: "LegacyHostIP", Address: "172.0.0.2"}}
 
 	// Pass Case
 	for _, node := range nodes {

pkg/util/flowcontrol/throttle.go

@@ -106,11 +106,9 @@ type fakeNeverRateLimiter struct {
 }
 
 func NewFakeNeverRateLimiter() RateLimiter {
-	wg := sync.WaitGroup{}
-	wg.Add(1)
-	return &fakeNeverRateLimiter{
-		wg: wg,
-	}
+	rl := fakeNeverRateLimiter{}
+	rl.wg.Add(1)
+	return &rl
 }
 
 func (t *fakeNeverRateLimiter) TryAccept() bool {

pkg/util/proxy/dial.go

@@ -69,9 +69,9 @@ func DialURL(url *url.URL, transport http.RoundTripper) (net.Conn, error) {
 					inferredHost = host
 				}
 				// Make a copy to avoid polluting the provided config
-				tlsConfigCopy := *tlsConfig
+				tlsConfigCopy, _ := utilnet.TLSClientConfig(transport)
 				tlsConfigCopy.ServerName = inferredHost
-				tlsConfig = &tlsConfigCopy
+				tlsConfig = tlsConfigCopy
 			}
 			tlsConn = tls.Client(netConn, tlsConfig)
 			if err := tlsConn.Handshake(); err != nil {

pkg/volume/glusterfs/glusterfs_test.go

@@ -217,7 +217,7 @@ func TestPersistentClaimReadOnlyFlag(t *testing.T) {
 		},
 		Subsets: []api.EndpointSubset{{
 			Addresses: []api.EndpointAddress{{IP: "127.0.0.1"}},
-			Ports:     []api.EndpointPort{{"foo", 80, api.ProtocolTCP}},
+			Ports:     []api.EndpointPort{{Name: "foo", Port: 80, Protocol: api.ProtocolTCP}},
 		}},
 	}
 

pkg/volume/iscsi/iscsi_util_test.go

@@ -86,7 +86,7 @@ func fakeFilepathGlob(devicePath string) (globs []string, err error) {
 	return []string{devicePath}, nil
 }
 
-func TestextractTransportname(t *testing.T) {
+func TestExtractTransportname(t *testing.T) {
 	fakeIscsiadmOutput := []string{
 		"# BEGIN RECORD 2.0-873\n" +
 			"iface.iscsi_ifacename = default\n" +

pkg/volume/testing/testing.go

@@ -721,9 +721,16 @@ func VerifyZeroDetachCallCount(fakeVolumePlugin *FakeVolumePlugin) error {
 // manager and fake volume plugin using a fake volume host.
 func GetTestVolumePluginMgr(
 	t *testing.T) (*VolumePluginMgr, *FakeVolumePlugin) {
+	v := NewFakeVolumeHost(
+		"",  /* rootDir */
+		nil, /* kubeClient */
+		nil, /* plugins */
+		"",  /* rootContext */
+	)
 	plugins := ProbeVolumePlugins(VolumeConfig{})
-	volumePluginMgr := NewFakeVolumeHost(
-		"" /* rootDir */, nil /* kubeClient */, plugins, "" /* rootContext */).pluginMgr
+	if err := v.pluginMgr.InitPlugins(plugins, v); err != nil {
+		t.Fatal(err)
+	}
 
-	return &volumePluginMgr, plugins[0].(*FakeVolumePlugin)
+	return &v.pluginMgr, plugins[0].(*FakeVolumePlugin)
 }

pkg/volume/util/device_util_linux_test.go

@@ -112,7 +112,7 @@ func TestFindMultipathDeviceForDevice(t *testing.T) {
 	}
 }
 
-func TestfindDeviceForPath(t *testing.T) {
+func TestFindDeviceForPath(t *testing.T) {
 	io := &mockOsIOHandler{}
 
 	disk, err := findDeviceForPath("/dev/sde", io)

plugin/pkg/scheduler/algorithm/priorities/node_affinity_test.go

@@ -107,7 +107,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: api.ObjectMeta{Name: "machine2", Labels: label2}},
 				{ObjectMeta: api.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
-			expectedList: []schedulerapi.HostPriority{{"machine1", 0}, {"machine2", 0}, {"machine3", 0}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			test:         "all machines are same priority as NodeAffinity is nil",
 		},
 		{
@@ -121,7 +121,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: api.ObjectMeta{Name: "machine2", Labels: label2}},
 				{ObjectMeta: api.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
-			expectedList: []schedulerapi.HostPriority{{"machine1", 0}, {"machine2", 0}, {"machine3", 0}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 0}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			test:         "no machine macthes preferred scheduling requirements in NodeAffinity of pod so all machines' priority is zero",
 		},
 		{
@@ -135,7 +135,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: api.ObjectMeta{Name: "machine2", Labels: label2}},
 				{ObjectMeta: api.ObjectMeta{Name: "machine3", Labels: label3}},
 			},
-			expectedList: []schedulerapi.HostPriority{{"machine1", 10}, {"machine2", 0}, {"machine3", 0}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 10}, {Host: "machine2", Score: 0}, {Host: "machine3", Score: 0}},
 			test:         "only machine1 matches the preferred scheduling requirements of pod",
 		},
 		{
@@ -149,7 +149,7 @@ func TestNodeAffinityPriority(t *testing.T) {
 				{ObjectMeta: api.ObjectMeta{Name: "machine5", Labels: label5}},
 				{ObjectMeta: api.ObjectMeta{Name: "machine2", Labels: label2}},
 			},
-			expectedList: []schedulerapi.HostPriority{{"machine1", 1}, {"machine5", 10}, {"machine2", 3}},
+			expectedList: []schedulerapi.HostPriority{{Host: "machine1", Score: 1}, {Host: "machine5", Score: 10}, {Host: "machine2", Score: 3}},
 			test:         "all machines matches the preferred scheduling requirements of pod but with different priorities ",
 		},
 	}

plugin/pkg/scheduler/extender_test.go

@@ -170,7 +170,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 	}{
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates: []fitPredicate{truePredicateExtender},
@@ -185,7 +185,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates: []fitPredicate{truePredicateExtender},
@@ -200,7 +200,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates: []fitPredicate{truePredicateExtender},
@@ -215,7 +215,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates: []fitPredicate{machine2PredicateExtender},
@@ -230,7 +230,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates:   []fitPredicate{truePredicateExtender},
@@ -244,7 +244,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{EqualPriority, 1}},
+			prioritizers: []algorithm.PriorityConfig{{Function: EqualPriority, Weight: 1}},
 			extenders: []FakeExtender{
 				{
 					predicates:   []fitPredicate{truePredicateExtender},
@@ -263,7 +263,7 @@ func TestGenericSchedulerWithExtenders(t *testing.T) {
 		},
 		{
 			predicates:   map[string]algorithm.FitPredicate{"true": truePredicate},
-			prioritizers: []algorithm.PriorityConfig{{machine2Prioritizer, 20}},
+			prioritizers: []algorithm.PriorityConfig{{Function: machine2Prioritizer, Weight: 20}},
 			extenders: []FakeExtender{
 				{
 					predicates:   []fitPredicate{truePredicateExtender},

test/integration/framework/master_utils.go

@@ -114,14 +114,12 @@ func NewMasterComponents(c *Config) *MasterComponents {
 	if c.StartReplicationManager {
 		go controllerManager.Run(goruntime.NumCPU(), rcStopCh)
 	}
-	var once sync.Once
 	return &MasterComponents{
 		ApiServer:         s,
 		KubeMaster:        m,
 		RestClient:        restClient,
 		ControllerManager: controllerManager,
 		rcStopCh:          rcStopCh,
-		once:              once,
 	}
 }