Refactor tests to match new versioned code structure

hack/.linted_packages

@@ -156,6 +156,7 @@ pkg/client/listers/storage/internalversion
 pkg/client/listers/storage/v1beta1
 pkg/client/metrics
 pkg/client/metrics/prometheus
+pkg/client/restclient/watch
 pkg/client/testing/core
 pkg/client/typed/discovery
 pkg/client/unversioned
@@ -281,6 +282,7 @@ pkg/volume/util/nestedpendingoperations
 pkg/volume/util/operationexecutor
 pkg/volume/util/types
 pkg/volume/util/volumehelper
+pkg/watch
 pkg/watch/json
 pkg/watch/versioned
 plugin/cmd/kube-scheduler

pkg/api/v1/conversion_test.go

@@ -24,7 +24,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
-	versioned "k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/api/v1"
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/diff"
@@ -36,7 +36,7 @@ func TestPodLogOptions(t *testing.T) {
 	tailLines := int64(2)
 	limitBytes := int64(3)
 
-	versionedLogOptions := &metav1.PodLogOptions{
+	versionedLogOptions := &v1.PodLogOptions{
 		Container:    "mycontainer",
 		Follow:       true,
 		Previous:     true,
@@ -71,7 +71,7 @@ func TestPodLogOptions(t *testing.T) {
 
 	// unversioned -> query params
 	{
-		actualParameters, err := codec.EncodeParameters(unversionedLogOptions, metav1.SchemeGroupVersion)
+		actualParameters, err := codec.EncodeParameters(unversionedLogOptions, v1.SchemeGroupVersion)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -82,7 +82,7 @@ func TestPodLogOptions(t *testing.T) {
 
 	// versioned -> query params
 	{
-		actualParameters, err := codec.EncodeParameters(versionedLogOptions, metav1.SchemeGroupVersion)
+		actualParameters, err := codec.EncodeParameters(versionedLogOptions, v1.SchemeGroupVersion)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -93,8 +93,8 @@ func TestPodLogOptions(t *testing.T) {
 
 	// query params -> versioned
 	{
-		convertedLogOptions := &metav1.PodLogOptions{}
+		convertedLogOptions := &v1.PodLogOptions{}
-		err := codec.DecodeParameters(expectedParameters, metav1.SchemeGroupVersion, convertedLogOptions)
+		err := codec.DecodeParameters(expectedParameters, v1.SchemeGroupVersion, convertedLogOptions)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -106,7 +106,7 @@ func TestPodLogOptions(t *testing.T) {
 	// query params -> unversioned
 	{
 		convertedLogOptions := &api.PodLogOptions{}
-		err := codec.DecodeParameters(expectedParameters, metav1.SchemeGroupVersion, convertedLogOptions)
+		err := codec.DecodeParameters(expectedParameters, v1.SchemeGroupVersion, convertedLogOptions)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -126,7 +126,7 @@ func TestPodSpecConversion(t *testing.T) {
 	i := &api.PodSpec{
 		ServiceAccountName: name,
 	}
-	v := metav1.PodSpec{}
+	v := v1.PodSpec{}
 	if err := api.Scheme.Convert(i, &v, nil); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
@@ -140,7 +140,7 @@ func TestPodSpecConversion(t *testing.T) {
 	// Test v1 -> internal. Either DeprecatedServiceAccount, ServiceAccountName,
 	// or both should translate to ServiceAccountName. ServiceAccountName wins
 	// if both are set.
-	testCases := []*metav1.PodSpec{
+	testCases := []*v1.PodSpec{
 		// New
 		{ServiceAccountName: name},
 		// Alias
@@ -167,14 +167,14 @@ func TestResourceListConversion(t *testing.T) {
 	bigMilliQuantity.Add(resource.MustParse("12345m"))
 
 	tests := []struct {
-		input    metav1.ResourceList
+		input    v1.ResourceList
 		expected api.ResourceList
 	}{
 		{ // No changes necessary.
-			input: metav1.ResourceList{
+			input: v1.ResourceList{
-				metav1.ResourceMemory:  resource.MustParse("30M"),
+				v1.ResourceMemory:  resource.MustParse("30M"),
-				metav1.ResourceCPU:     resource.MustParse("100m"),
+				v1.ResourceCPU:     resource.MustParse("100m"),
-				metav1.ResourceStorage: resource.MustParse("1G"),
+				v1.ResourceStorage: resource.MustParse("1G"),
 			},
 			expected: api.ResourceList{
 				api.ResourceMemory:  resource.MustParse("30M"),
@@ -183,9 +183,9 @@ func TestResourceListConversion(t *testing.T) {
 			},
 		},
 		{ // Nano-scale values should be rounded up to milli-scale.
-			input: metav1.ResourceList{
+			input: v1.ResourceList{
-				metav1.ResourceCPU:    resource.MustParse("3.000023m"),
+				v1.ResourceCPU:    resource.MustParse("3.000023m"),
-				metav1.ResourceMemory: resource.MustParse("500.000050m"),
+				v1.ResourceMemory: resource.MustParse("500.000050m"),
 			},
 			expected: api.ResourceList{
 				api.ResourceCPU:    resource.MustParse("4m"),
@@ -193,9 +193,9 @@ func TestResourceListConversion(t *testing.T) {
 			},
 		},
 		{ // Large values should still be accurate.
-			input: metav1.ResourceList{
+			input: v1.ResourceList{
-				metav1.ResourceCPU:     *bigMilliQuantity.Copy(),
+				v1.ResourceCPU:     *bigMilliQuantity.Copy(),
-				metav1.ResourceStorage: *bigMilliQuantity.Copy(),
+				v1.ResourceStorage: *bigMilliQuantity.Copy(),
 			},
 			expected: api.ResourceList{
 				api.ResourceCPU:     *bigMilliQuantity.Copy(),

pkg/api/v1/defaults_test.go

@@ -23,13 +23,13 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/resource"
-	versioned "k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util/intstr"
 )
 
 func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
-	codec := api.Codecs.LegacyCodec(metav1.SchemeGroupVersion)
+	codec := api.Codecs.LegacyCodec(v1.SchemeGroupVersion)
 	data, err := runtime.Encode(codec, obj)
 	if err != nil {
 		t.Errorf("%v\n %#v", err, obj)
@@ -51,15 +51,15 @@ func roundTrip(t *testing.T, obj runtime.Object) runtime.Object {
 
 func TestSetDefaultReplicationController(t *testing.T) {
 	tests := []struct {
-		rc             *metav1.ReplicationController
+		rc             *v1.ReplicationController
 		expectLabels   bool
 		expectSelector bool
 	}{
 		{
-			rc: &metav1.ReplicationController{
+			rc: &v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -71,15 +71,15 @@ func TestSetDefaultReplicationController(t *testing.T) {
 			expectSelector: true,
 		},
 		{
-			rc: &metav1.ReplicationController{
+			rc: &v1.ReplicationController{
-				ObjectMeta: metav1.ObjectMeta{
+				ObjectMeta: v1.ObjectMeta{
 					Labels: map[string]string{
 						"bar": "foo",
 					},
 				},
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -91,18 +91,18 @@ func TestSetDefaultReplicationController(t *testing.T) {
 			expectSelector: true,
 		},
 		{
-			rc: &metav1.ReplicationController{
+			rc: &v1.ReplicationController{
-				ObjectMeta: metav1.ObjectMeta{
+				ObjectMeta: v1.ObjectMeta{
 					Labels: map[string]string{
 						"bar": "foo",
 					},
 				},
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
 					Selector: map[string]string{
 						"some": "other",
 					},
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -114,13 +114,13 @@ func TestSetDefaultReplicationController(t *testing.T) {
 			expectSelector: false,
 		},
 		{
-			rc: &metav1.ReplicationController{
+			rc: &v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
 					Selector: map[string]string{
 						"some": "other",
 					},
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -136,7 +136,7 @@ func TestSetDefaultReplicationController(t *testing.T) {
 	for _, test := range tests {
 		rc := test.rc
 		obj2 := roundTrip(t, runtime.Object(rc))
-		rc2, ok := obj2.(*metav1.ReplicationController)
+		rc2, ok := obj2.(*v1.ReplicationController)
 		if !ok {
 			t.Errorf("unexpected object: %v", rc2)
 			t.FailNow()
@@ -166,14 +166,14 @@ func newInt(val int32) *int32 {
 
 func TestSetDefaultReplicationControllerReplicas(t *testing.T) {
 	tests := []struct {
-		rc             metav1.ReplicationController
+		rc             v1.ReplicationController
 		expectReplicas int32
 	}{
 		{
-			rc: metav1.ReplicationController{
+			rc: v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -184,11 +184,11 @@ func TestSetDefaultReplicationControllerReplicas(t *testing.T) {
 			expectReplicas: 1,
 		},
 		{
-			rc: metav1.ReplicationController{
+			rc: v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
 					Replicas: newInt(0),
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -199,11 +199,11 @@ func TestSetDefaultReplicationControllerReplicas(t *testing.T) {
 			expectReplicas: 0,
 		},
 		{
-			rc: metav1.ReplicationController{
+			rc: v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
 					Replicas: newInt(3),
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Labels: map[string]string{
 								"foo": "bar",
 							},
@@ -218,7 +218,7 @@ func TestSetDefaultReplicationControllerReplicas(t *testing.T) {
 	for _, test := range tests {
 		rc := &test.rc
 		obj2 := roundTrip(t, runtime.Object(rc))
-		rc2, ok := obj2.(*metav1.ReplicationController)
+		rc2, ok := obj2.(*v1.ReplicationController)
 		if !ok {
 			t.Errorf("unexpected object: %v", rc2)
 			t.FailNow()
@@ -247,14 +247,14 @@ func TestSetDefaultReplicationControllerImagePullPolicy(t *testing.T) {
 	})
 
 	tests := []struct {
-		rc               metav1.ReplicationController
+		rc               v1.ReplicationController
-		expectPullPolicy metav1.PullPolicy
+		expectPullPolicy v1.PullPolicy
 	}{
 		{
-			rc: metav1.ReplicationController{
+			rc: v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Annotations: map[string]string{
 								"pod.beta.kubernetes.io/init-containers": string(containersWithoutPullPolicy),
 							},
@@ -262,13 +262,13 @@ func TestSetDefaultReplicationControllerImagePullPolicy(t *testing.T) {
 					},
 				},
 			},
-			expectPullPolicy: metav1.PullAlways,
+			expectPullPolicy: v1.PullAlways,
 		},
 		{
-			rc: metav1.ReplicationController{
+			rc: v1.ReplicationController{
-				Spec: metav1.ReplicationControllerSpec{
+				Spec: v1.ReplicationControllerSpec{
-					Template: &metav1.PodTemplateSpec{
+					Template: &v1.PodTemplateSpec{
-						ObjectMeta: metav1.ObjectMeta{
+						ObjectMeta: v1.ObjectMeta{
 							Annotations: map[string]string{
 								"pod.beta.kubernetes.io/init-containers": string(containersWithPullPolicy),
 							},
@@ -276,14 +276,14 @@ func TestSetDefaultReplicationControllerImagePullPolicy(t *testing.T) {
 					},
 				},
 			},
-			expectPullPolicy: metav1.PullIfNotPresent,
+			expectPullPolicy: v1.PullIfNotPresent,
 		},
 	}
 
 	for _, test := range tests {
 		rc := &test.rc
 		obj2 := roundTrip(t, runtime.Object(rc))
-		rc2, ok := obj2.(*metav1.ReplicationController)
+		rc2, ok := obj2.(*v1.ReplicationController)
 		if !ok {
 			t.Errorf("unexpected object: %v", rc2)
 			t.FailNow()
@@ -298,33 +298,33 @@ func TestSetDefaultReplicationControllerImagePullPolicy(t *testing.T) {
 }
 
 func TestSetDefaultService(t *testing.T) {
-	svc := &metav1.Service{}
+	svc := &v1.Service{}
 	obj2 := roundTrip(t, runtime.Object(svc))
-	svc2 := obj2.(*metav1.Service)
+	svc2 := obj2.(*v1.Service)
-	if svc2.Spec.SessionAffinity != metav1.ServiceAffinityNone {
+	if svc2.Spec.SessionAffinity != v1.ServiceAffinityNone {
-		t.Errorf("Expected default session affinity type:%s, got: %s", metav1.ServiceAffinityNone, svc2.Spec.SessionAffinity)
+		t.Errorf("Expected default session affinity type:%s, got: %s", v1.ServiceAffinityNone, svc2.Spec.SessionAffinity)
 	}
-	if svc2.Spec.Type != metav1.ServiceTypeClusterIP {
+	if svc2.Spec.Type != v1.ServiceTypeClusterIP {
-		t.Errorf("Expected default type:%s, got: %s", metav1.ServiceTypeClusterIP, svc2.Spec.Type)
+		t.Errorf("Expected default type:%s, got: %s", v1.ServiceTypeClusterIP, svc2.Spec.Type)
 	}
 }
 
 func TestSetDefaultSecretVolumeSource(t *testing.T) {
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Volumes = []metav1.Volume{
+	s.Volumes = []v1.Volume{
 		{
-			VolumeSource: metav1.VolumeSource{
+			VolumeSource: v1.VolumeSource{
-				Secret: &metav1.SecretVolumeSource{},
+				Secret: &v1.SecretVolumeSource{},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	output := roundTrip(t, runtime.Object(pod))
-	pod2 := output.(*metav1.Pod)
+	pod2 := output.(*v1.Pod)
 	defaultMode := pod2.Spec.Volumes[0].VolumeSource.Secret.DefaultMode
-	expectedMode := metav1.SecretVolumeSourceDefaultMode
+	expectedMode := v1.SecretVolumeSourceDefaultMode
 
 	if defaultMode == nil || *defaultMode != expectedMode {
 		t.Errorf("Expected secret DefaultMode %v, got %v", expectedMode, defaultMode)
@@ -332,21 +332,21 @@ func TestSetDefaultSecretVolumeSource(t *testing.T) {
 }
 
 func TestSetDefaultConfigMapVolumeSource(t *testing.T) {
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Volumes = []metav1.Volume{
+	s.Volumes = []v1.Volume{
 		{
-			VolumeSource: metav1.VolumeSource{
+			VolumeSource: v1.VolumeSource{
-				ConfigMap: &metav1.ConfigMapVolumeSource{},
+				ConfigMap: &v1.ConfigMapVolumeSource{},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	output := roundTrip(t, runtime.Object(pod))
-	pod2 := output.(*metav1.Pod)
+	pod2 := output.(*v1.Pod)
 	defaultMode := pod2.Spec.Volumes[0].VolumeSource.ConfigMap.DefaultMode
-	expectedMode := metav1.ConfigMapVolumeSourceDefaultMode
+	expectedMode := v1.ConfigMapVolumeSourceDefaultMode
 
 	if defaultMode == nil || *defaultMode != expectedMode {
 		t.Errorf("Expected ConfigMap DefaultMode %v, got %v", expectedMode, defaultMode)
@@ -354,21 +354,21 @@ func TestSetDefaultConfigMapVolumeSource(t *testing.T) {
 }
 
 func TestSetDefaultDownwardAPIVolumeSource(t *testing.T) {
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Volumes = []metav1.Volume{
+	s.Volumes = []v1.Volume{
 		{
-			VolumeSource: metav1.VolumeSource{
+			VolumeSource: v1.VolumeSource{
-				DownwardAPI: &metav1.DownwardAPIVolumeSource{},
+				DownwardAPI: &v1.DownwardAPIVolumeSource{},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	output := roundTrip(t, runtime.Object(pod))
-	pod2 := output.(*metav1.Pod)
+	pod2 := output.(*v1.Pod)
 	defaultMode := pod2.Spec.Volumes[0].VolumeSource.DownwardAPI.DefaultMode
-	expectedMode := metav1.DownwardAPIVolumeSourceDefaultMode
+	expectedMode := v1.DownwardAPIVolumeSourceDefaultMode
 
 	if defaultMode == nil || *defaultMode != expectedMode {
 		t.Errorf("Expected DownwardAPI DefaultMode %v, got %v", expectedMode, defaultMode)
@@ -376,50 +376,50 @@ func TestSetDefaultDownwardAPIVolumeSource(t *testing.T) {
 }
 
 func TestSetDefaultSecret(t *testing.T) {
-	s := &metav1.Secret{}
+	s := &v1.Secret{}
 	obj2 := roundTrip(t, runtime.Object(s))
-	s2 := obj2.(*metav1.Secret)
+	s2 := obj2.(*v1.Secret)
 
-	if s2.Type != metav1.SecretTypeOpaque {
+	if s2.Type != v1.SecretTypeOpaque {
-		t.Errorf("Expected secret type %v, got %v", metav1.SecretTypeOpaque, s2.Type)
+		t.Errorf("Expected secret type %v, got %v", v1.SecretTypeOpaque, s2.Type)
 	}
 }
 
 func TestSetDefaultPersistentVolume(t *testing.T) {
-	pv := &metav1.PersistentVolume{}
+	pv := &v1.PersistentVolume{}
 	obj2 := roundTrip(t, runtime.Object(pv))
-	pv2 := obj2.(*metav1.PersistentVolume)
+	pv2 := obj2.(*v1.PersistentVolume)
 
-	if pv2.Status.Phase != metav1.VolumePending {
+	if pv2.Status.Phase != v1.VolumePending {
-		t.Errorf("Expected volume phase %v, got %v", metav1.VolumePending, pv2.Status.Phase)
+		t.Errorf("Expected volume phase %v, got %v", v1.VolumePending, pv2.Status.Phase)
 	}
-	if pv2.Spec.PersistentVolumeReclaimPolicy != metav1.PersistentVolumeReclaimRetain {
+	if pv2.Spec.PersistentVolumeReclaimPolicy != v1.PersistentVolumeReclaimRetain {
-		t.Errorf("Expected pv reclaim policy %v, got %v", metav1.PersistentVolumeReclaimRetain, pv2.Spec.PersistentVolumeReclaimPolicy)
+		t.Errorf("Expected pv reclaim policy %v, got %v", v1.PersistentVolumeReclaimRetain, pv2.Spec.PersistentVolumeReclaimPolicy)
 	}
 }
 
 func TestSetDefaultPersistentVolumeClaim(t *testing.T) {
-	pvc := &metav1.PersistentVolumeClaim{}
+	pvc := &v1.PersistentVolumeClaim{}
 	obj2 := roundTrip(t, runtime.Object(pvc))
-	pvc2 := obj2.(*metav1.PersistentVolumeClaim)
+	pvc2 := obj2.(*v1.PersistentVolumeClaim)
 
-	if pvc2.Status.Phase != metav1.ClaimPending {
+	if pvc2.Status.Phase != v1.ClaimPending {
-		t.Errorf("Expected claim phase %v, got %v", metav1.ClaimPending, pvc2.Status.Phase)
+		t.Errorf("Expected claim phase %v, got %v", v1.ClaimPending, pvc2.Status.Phase)
 	}
 }
 
 func TestSetDefaulEndpointsProtocol(t *testing.T) {
-	in := &metav1.Endpoints{Subsets: []metav1.EndpointSubset{
+	in := &v1.Endpoints{Subsets: []v1.EndpointSubset{
-		{Ports: []metav1.EndpointPort{{}, {Protocol: "UDP"}, {}}},
+		{Ports: []v1.EndpointPort{{}, {Protocol: "UDP"}, {}}},
 	}}
 	obj := roundTrip(t, runtime.Object(in))
-	out := obj.(*metav1.Endpoints)
+	out := obj.(*v1.Endpoints)
 
 	for i := range out.Subsets {
 		for j := range out.Subsets[i].Ports {
 			if in.Subsets[i].Ports[j].Protocol == "" {
-				if out.Subsets[i].Ports[j].Protocol != metav1.ProtocolTCP {
+				if out.Subsets[i].Ports[j].Protocol != v1.ProtocolTCP {
-					t.Errorf("Expected protocol %s, got %s", metav1.ProtocolTCP, out.Subsets[i].Ports[j].Protocol)
+					t.Errorf("Expected protocol %s, got %s", v1.ProtocolTCP, out.Subsets[i].Ports[j].Protocol)
 				}
 			} else {
 				if out.Subsets[i].Ports[j].Protocol != in.Subsets[i].Ports[j].Protocol {
@@ -431,16 +431,16 @@ func TestSetDefaulEndpointsProtocol(t *testing.T) {
 }
 
 func TestSetDefaulServiceTargetPort(t *testing.T) {
-	in := &metav1.Service{Spec: metav1.ServiceSpec{Ports: []metav1.ServicePort{{Port: 1234}}}}
+	in := &v1.Service{Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Port: 1234}}}}
 	obj := roundTrip(t, runtime.Object(in))
-	out := obj.(*metav1.Service)
+	out := obj.(*v1.Service)
 	if out.Spec.Ports[0].TargetPort != intstr.FromInt(1234) {
 		t.Errorf("Expected TargetPort to be defaulted, got %v", out.Spec.Ports[0].TargetPort)
 	}
 
-	in = &metav1.Service{Spec: metav1.ServiceSpec{Ports: []metav1.ServicePort{{Port: 1234, TargetPort: intstr.FromInt(5678)}}}}
+	in = &v1.Service{Spec: v1.ServiceSpec{Ports: []v1.ServicePort{{Port: 1234, TargetPort: intstr.FromInt(5678)}}}}
 	obj = roundTrip(t, runtime.Object(in))
-	out = obj.(*metav1.Service)
+	out = obj.(*v1.Service)
 	if out.Spec.Ports[0].TargetPort != intstr.FromInt(5678) {
 		t.Errorf("Expected TargetPort to be unchanged, got %v", out.Spec.Ports[0].TargetPort)
 	}
@@ -448,42 +448,42 @@ func TestSetDefaulServiceTargetPort(t *testing.T) {
 
 func TestSetDefaultServicePort(t *testing.T) {
 	// Unchanged if set.
-	in := &metav1.Service{Spec: metav1.ServiceSpec{
+	in := &v1.Service{Spec: v1.ServiceSpec{
-		Ports: []metav1.ServicePort{
+		Ports: []v1.ServicePort{
 			{Protocol: "UDP", Port: 9376, TargetPort: intstr.FromString("p")},
 			{Protocol: "UDP", Port: 8675, TargetPort: intstr.FromInt(309)},
 		},
 	}}
-	out := roundTrip(t, runtime.Object(in)).(*metav1.Service)
+	out := roundTrip(t, runtime.Object(in)).(*v1.Service)
-	if out.Spec.Ports[0].Protocol != metav1.ProtocolUDP {
+	if out.Spec.Ports[0].Protocol != v1.ProtocolUDP {
-		t.Errorf("Expected protocol %s, got %s", metav1.ProtocolUDP, out.Spec.Ports[0].Protocol)
+		t.Errorf("Expected protocol %s, got %s", v1.ProtocolUDP, out.Spec.Ports[0].Protocol)
 	}
 	if out.Spec.Ports[0].TargetPort != intstr.FromString("p") {
 		t.Errorf("Expected port %v, got %v", in.Spec.Ports[0].Port, out.Spec.Ports[0].TargetPort)
 	}
-	if out.Spec.Ports[1].Protocol != metav1.ProtocolUDP {
+	if out.Spec.Ports[1].Protocol != v1.ProtocolUDP {
-		t.Errorf("Expected protocol %s, got %s", metav1.ProtocolUDP, out.Spec.Ports[1].Protocol)
+		t.Errorf("Expected protocol %s, got %s", v1.ProtocolUDP, out.Spec.Ports[1].Protocol)
 	}
 	if out.Spec.Ports[1].TargetPort != intstr.FromInt(309) {
 		t.Errorf("Expected port %v, got %v", in.Spec.Ports[1].Port, out.Spec.Ports[1].TargetPort)
 	}
 
 	// Defaulted.
-	in = &metav1.Service{Spec: metav1.ServiceSpec{
+	in = &v1.Service{Spec: v1.ServiceSpec{
-		Ports: []metav1.ServicePort{
+		Ports: []v1.ServicePort{
 			{Protocol: "", Port: 9376, TargetPort: intstr.FromString("")},
 			{Protocol: "", Port: 8675, TargetPort: intstr.FromInt(0)},
 		},
 	}}
-	out = roundTrip(t, runtime.Object(in)).(*metav1.Service)
+	out = roundTrip(t, runtime.Object(in)).(*v1.Service)
-	if out.Spec.Ports[0].Protocol != metav1.ProtocolTCP {
+	if out.Spec.Ports[0].Protocol != v1.ProtocolTCP {
-		t.Errorf("Expected protocol %s, got %s", metav1.ProtocolTCP, out.Spec.Ports[0].Protocol)
+		t.Errorf("Expected protocol %s, got %s", v1.ProtocolTCP, out.Spec.Ports[0].Protocol)
 	}
 	if out.Spec.Ports[0].TargetPort != intstr.FromInt(int(in.Spec.Ports[0].Port)) {
 		t.Errorf("Expected port %v, got %v", in.Spec.Ports[0].Port, out.Spec.Ports[0].TargetPort)
 	}
-	if out.Spec.Ports[1].Protocol != metav1.ProtocolTCP {
+	if out.Spec.Ports[1].Protocol != v1.ProtocolTCP {
-		t.Errorf("Expected protocol %s, got %s", metav1.ProtocolTCP, out.Spec.Ports[1].Protocol)
+		t.Errorf("Expected protocol %s, got %s", v1.ProtocolTCP, out.Spec.Ports[1].Protocol)
 	}
 	if out.Spec.Ports[1].TargetPort != intstr.FromInt(int(in.Spec.Ports[1].Port)) {
 		t.Errorf("Expected port %v, got %v", in.Spec.Ports[1].Port, out.Spec.Ports[1].TargetPort)
@@ -491,33 +491,33 @@ func TestSetDefaultServicePort(t *testing.T) {
 }
 
 func TestSetDefaultNamespace(t *testing.T) {
-	s := &metav1.Namespace{}
+	s := &v1.Namespace{}
 	obj2 := roundTrip(t, runtime.Object(s))
-	s2 := obj2.(*metav1.Namespace)
+	s2 := obj2.(*v1.Namespace)
 
-	if s2.Status.Phase != metav1.NamespaceActive {
+	if s2.Status.Phase != v1.NamespaceActive {
-		t.Errorf("Expected phase %v, got %v", metav1.NamespaceActive, s2.Status.Phase)
+		t.Errorf("Expected phase %v, got %v", v1.NamespaceActive, s2.Status.Phase)
 	}
 }
 
 func TestSetDefaultPodSpecHostNetwork(t *testing.T) {
 	portNum := int32(8080)
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
 	s.HostNetwork = true
-	s.Containers = []metav1.Container{
+	s.Containers = []v1.Container{
 		{
-			Ports: []metav1.ContainerPort{
+			Ports: []v1.ContainerPort{
 				{
 					ContainerPort: portNum,
 				},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	obj2 := roundTrip(t, runtime.Object(pod))
-	pod2 := obj2.(*metav1.Pod)
+	pod2 := obj2.(*v1.Pod)
 	s2 := pod2.Spec
 
 	hostPortNum := s2.Containers[0].Ports[0].HostPort
@@ -528,10 +528,10 @@ func TestSetDefaultPodSpecHostNetwork(t *testing.T) {
 
 func TestSetDefaultNodeExternalID(t *testing.T) {
 	name := "node0"
-	n := &metav1.Node{}
+	n := &v1.Node{}
 	n.Name = name
 	obj2 := roundTrip(t, runtime.Object(n))
-	n2 := obj2.(*metav1.Node)
+	n2 := obj2.(*v1.Node)
 	if n2.Spec.ExternalID != name {
 		t.Errorf("Expected default External ID: %s, got: %s", name, n2.Spec.ExternalID)
 	}
@@ -541,18 +541,18 @@ func TestSetDefaultNodeExternalID(t *testing.T) {
 }
 
 func TestSetDefaultNodeStatusAllocatable(t *testing.T) {
-	capacity := metav1.ResourceList{
+	capacity := v1.ResourceList{
-		metav1.ResourceCPU:    resource.MustParse("1000m"),
+		v1.ResourceCPU:    resource.MustParse("1000m"),
-		metav1.ResourceMemory: resource.MustParse("10G"),
+		v1.ResourceMemory: resource.MustParse("10G"),
 	}
-	allocatable := metav1.ResourceList{
+	allocatable := v1.ResourceList{
-		metav1.ResourceCPU:    resource.MustParse("500m"),
+		v1.ResourceCPU:    resource.MustParse("500m"),
-		metav1.ResourceMemory: resource.MustParse("5G"),
+		v1.ResourceMemory: resource.MustParse("5G"),
 	}
 	tests := []struct {
-		capacity            metav1.ResourceList
+		capacity            v1.ResourceList
-		allocatable         metav1.ResourceList
+		allocatable         v1.ResourceList
-		expectedAllocatable metav1.ResourceList
+		expectedAllocatable v1.ResourceList
 	}{{ // Everything set, no defaulting.
 		capacity:            capacity,
 		allocatable:         allocatable,
@@ -571,18 +571,18 @@ func TestSetDefaultNodeStatusAllocatable(t *testing.T) {
 		expectedAllocatable: nil,
 	}}
 
-	copyResourceList := func(rl metav1.ResourceList) metav1.ResourceList {
+	copyResourceList := func(rl v1.ResourceList) v1.ResourceList {
 		if rl == nil {
 			return nil
 		}
-		copy := make(metav1.ResourceList, len(rl))
+		copy := make(v1.ResourceList, len(rl))
 		for k, v := range rl {
 			copy[k] = *v.Copy()
 		}
 		return copy
 	}
 
-	resourceListsEqual := func(a metav1.ResourceList, b metav1.ResourceList) bool {
+	resourceListsEqual := func(a v1.ResourceList, b v1.ResourceList) bool {
 		if len(a) != len(b) {
 			return false
 		}
@@ -599,13 +599,13 @@ func TestSetDefaultNodeStatusAllocatable(t *testing.T) {
 	}
 
 	for i, testcase := range tests {
-		node := metav1.Node{
+		node := v1.Node{
-			Status: metav1.NodeStatus{
+			Status: v1.NodeStatus{
 				Capacity:    copyResourceList(testcase.capacity),
 				Allocatable: copyResourceList(testcase.allocatable),
 			},
 		}
-		node2 := roundTrip(t, runtime.Object(&node)).(*metav1.Node)
+		node2 := roundTrip(t, runtime.Object(&node)).(*v1.Node)
 		actual := node2.Status.Allocatable
 		expected := testcase.expectedAllocatable
 		if !resourceListsEqual(expected, actual) {
@@ -615,24 +615,24 @@ func TestSetDefaultNodeStatusAllocatable(t *testing.T) {
 }
 
 func TestSetDefaultObjectFieldSelectorAPIVersion(t *testing.T) {
-	s := metav1.PodSpec{
+	s := v1.PodSpec{
-		Containers: []metav1.Container{
+		Containers: []v1.Container{
 			{
-				Env: []metav1.EnvVar{
+				Env: []v1.EnvVar{
 					{
-						ValueFrom: &metav1.EnvVarSource{
+						ValueFrom: &v1.EnvVarSource{
-							FieldRef: &metav1.ObjectFieldSelector{},
+							FieldRef: &v1.ObjectFieldSelector{},
 						},
 					},
 				},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	obj2 := roundTrip(t, runtime.Object(pod))
-	pod2 := obj2.(*metav1.Pod)
+	pod2 := obj2.(*v1.Pod)
 	s2 := pod2.Spec
 
 	apiVersion := s2.Containers[0].Env[0].ValueFrom.FieldRef.APIVersion
@@ -643,88 +643,88 @@ func TestSetDefaultObjectFieldSelectorAPIVersion(t *testing.T) {
 
 func TestSetMinimumScalePod(t *testing.T) {
 	// verify we default if limits are specified (and that request=0 is preserved)
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Containers = []metav1.Container{
+	s.Containers = []v1.Container{
 		{
-			Resources: metav1.ResourceRequirements{
+			Resources: v1.ResourceRequirements{
-				Requests: metav1.ResourceList{
+				Requests: v1.ResourceList{
-					metav1.ResourceMemory: resource.MustParse("1n"),
+					v1.ResourceMemory: resource.MustParse("1n"),
 				},
-				Limits: metav1.ResourceList{
+				Limits: v1.ResourceList{
-					metav1.ResourceCPU: resource.MustParse("2n"),
+					v1.ResourceCPU: resource.MustParse("2n"),
 				},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
-	metav1.SetObjectDefaults_Pod(pod)
+	v1.SetObjectDefaults_Pod(pod)
 
-	if expect := resource.MustParse("1m"); expect.Cmp(pod.Spec.Containers[0].Resources.Requests[metav1.ResourceMemory]) != 0 {
+	if expect := resource.MustParse("1m"); expect.Cmp(pod.Spec.Containers[0].Resources.Requests[v1.ResourceMemory]) != 0 {
 		t.Errorf("did not round resources: %#v", pod.Spec.Containers[0].Resources)
 	}
 }
 
 func TestSetDefaultRequestsPod(t *testing.T) {
 	// verify we default if limits are specified (and that request=0 is preserved)
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Containers = []metav1.Container{
+	s.Containers = []v1.Container{
 		{
-			Resources: metav1.ResourceRequirements{
+			Resources: v1.ResourceRequirements{
-				Requests: metav1.ResourceList{
+				Requests: v1.ResourceList{
-					metav1.ResourceMemory: resource.MustParse("0"),
+					v1.ResourceMemory: resource.MustParse("0"),
 				},
-				Limits: metav1.ResourceList{
+				Limits: v1.ResourceList{
-					metav1.ResourceCPU:    resource.MustParse("100m"),
+					v1.ResourceCPU:    resource.MustParse("100m"),
-					metav1.ResourceMemory: resource.MustParse("1Gi"),
+					v1.ResourceMemory: resource.MustParse("1Gi"),
 				},
 			},
 		},
 	}
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
 		Spec: s,
 	}
 	output := roundTrip(t, runtime.Object(pod))
-	pod2 := output.(*metav1.Pod)
+	pod2 := output.(*v1.Pod)
 	defaultRequest := pod2.Spec.Containers[0].Resources.Requests
-	if requestValue := defaultRequest[metav1.ResourceCPU]; requestValue.String() != "100m" {
+	if requestValue := defaultRequest[v1.ResourceCPU]; requestValue.String() != "100m" {
 		t.Errorf("Expected request cpu: %s, got: %s", "100m", requestValue.String())
 	}
-	if requestValue := defaultRequest[metav1.ResourceMemory]; requestValue.String() != "0" {
+	if requestValue := defaultRequest[v1.ResourceMemory]; requestValue.String() != "0" {
 		t.Errorf("Expected request memory: %s, got: %s", "0", requestValue.String())
 	}
 
 	// verify we do nothing if no limits are specified
-	s = metav1.PodSpec{}
+	s = v1.PodSpec{}
-	s.Containers = []metav1.Container{{}}
+	s.Containers = []v1.Container{{}}
-	pod = &metav1.Pod{
+	pod = &v1.Pod{
 		Spec: s,
 	}
 	output = roundTrip(t, runtime.Object(pod))
-	pod2 = output.(*metav1.Pod)
+	pod2 = output.(*v1.Pod)
 	defaultRequest = pod2.Spec.Containers[0].Resources.Requests
-	if requestValue := defaultRequest[metav1.ResourceCPU]; requestValue.String() != "0" {
+	if requestValue := defaultRequest[v1.ResourceCPU]; requestValue.String() != "0" {
 		t.Errorf("Expected 0 request value, got: %s", requestValue.String())
 	}
 }
 
 func TestDefaultRequestIsNotSetForReplicationController(t *testing.T) {
-	s := metav1.PodSpec{}
+	s := v1.PodSpec{}
-	s.Containers = []metav1.Container{
+	s.Containers = []v1.Container{
 		{
-			Resources: metav1.ResourceRequirements{
+			Resources: v1.ResourceRequirements{
-				Limits: metav1.ResourceList{
+				Limits: v1.ResourceList{
-					metav1.ResourceCPU: resource.MustParse("100m"),
+					v1.ResourceCPU: resource.MustParse("100m"),
 				},
 			},
 		},
 	}
-	rc := &metav1.ReplicationController{
+	rc := &v1.ReplicationController{
-		Spec: metav1.ReplicationControllerSpec{
+		Spec: v1.ReplicationControllerSpec{
 			Replicas: newInt(3),
-			Template: &metav1.PodTemplateSpec{
+			Template: &v1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{
+				ObjectMeta: v1.ObjectMeta{
 					Labels: map[string]string{
 						"foo": "bar",
 					},
@@ -734,59 +734,59 @@ func TestDefaultRequestIsNotSetForReplicationController(t *testing.T) {
 		},
 	}
 	output := roundTrip(t, runtime.Object(rc))
-	rc2 := output.(*metav1.ReplicationController)
+	rc2 := output.(*v1.ReplicationController)
 	defaultRequest := rc2.Spec.Template.Spec.Containers[0].Resources.Requests
-	requestValue := defaultRequest[metav1.ResourceCPU]
+	requestValue := defaultRequest[v1.ResourceCPU]
 	if requestValue.String() != "0" {
 		t.Errorf("Expected 0 request value, got: %s", requestValue.String())
 	}
 }
 
 func TestSetDefaultLimitRangeItem(t *testing.T) {
-	limitRange := &metav1.LimitRange{
+	limitRange := &v1.LimitRange{
-		ObjectMeta: metav1.ObjectMeta{
+		ObjectMeta: v1.ObjectMeta{
 			Name: "test-defaults",
 		},
-		Spec: metav1.LimitRangeSpec{
+		Spec: v1.LimitRangeSpec{
-			Limits: []metav1.LimitRangeItem{{
+			Limits: []v1.LimitRangeItem{{
-				Type: metav1.LimitTypeContainer,
+				Type: v1.LimitTypeContainer,
-				Max: metav1.ResourceList{
+				Max: v1.ResourceList{
-					metav1.ResourceCPU: resource.MustParse("100m"),
+					v1.ResourceCPU: resource.MustParse("100m"),
 				},
-				Min: metav1.ResourceList{
+				Min: v1.ResourceList{
-					metav1.ResourceMemory: resource.MustParse("100Mi"),
+					v1.ResourceMemory: resource.MustParse("100Mi"),
 				},
-				Default:        metav1.ResourceList{},
+				Default:        v1.ResourceList{},
-				DefaultRequest: metav1.ResourceList{},
+				DefaultRequest: v1.ResourceList{},
 			}},
 		},
 	}
 
 	output := roundTrip(t, runtime.Object(limitRange))
-	limitRange2 := output.(*metav1.LimitRange)
+	limitRange2 := output.(*v1.LimitRange)
 	defaultLimit := limitRange2.Spec.Limits[0].Default
 	defaultRequest := limitRange2.Spec.Limits[0].DefaultRequest
 
 	// verify that default cpu was set to the max
-	defaultValue := defaultLimit[metav1.ResourceCPU]
+	defaultValue := defaultLimit[v1.ResourceCPU]
 	if defaultValue.String() != "100m" {
 		t.Errorf("Expected default cpu: %s, got: %s", "100m", defaultValue.String())
 	}
 	// verify that default request was set to the limit
-	requestValue := defaultRequest[metav1.ResourceCPU]
+	requestValue := defaultRequest[v1.ResourceCPU]
 	if requestValue.String() != "100m" {
 		t.Errorf("Expected request cpu: %s, got: %s", "100m", requestValue.String())
 	}
 	// verify that if a min is provided, it will be the default if no limit is specified
-	requestMinValue := defaultRequest[metav1.ResourceMemory]
+	requestMinValue := defaultRequest[v1.ResourceMemory]
 	if requestMinValue.String() != "100Mi" {
 		t.Errorf("Expected request memory: %s, got: %s", "100Mi", requestMinValue.String())
 	}
 }
 
 func TestSetDefaultProbe(t *testing.T) {
-	originalProbe := metav1.Probe{}
+	originalProbe := v1.Probe{}
-	expectedProbe := metav1.Probe{
+	expectedProbe := v1.Probe{
 		InitialDelaySeconds: 0,
 		TimeoutSeconds:      1,
 		PeriodSeconds:       10,
@@ -794,13 +794,13 @@ func TestSetDefaultProbe(t *testing.T) {
 		FailureThreshold:    3,
 	}
 
-	pod := &metav1.Pod{
+	pod := &v1.Pod{
-		Spec: metav1.PodSpec{
+		Spec: v1.PodSpec{
-			Containers: []metav1.Container{{LivenessProbe: &originalProbe}},
+			Containers: []v1.Container{{LivenessProbe: &originalProbe}},
 		},
 	}
 
-	output := roundTrip(t, runtime.Object(pod)).(*metav1.Pod)
+	output := roundTrip(t, runtime.Object(pod)).(*v1.Pod)
 	actualProbe := *output.Spec.Containers[0].LivenessProbe
 	if actualProbe != expectedProbe {
 		t.Errorf("Expected probe: %+v\ngot: %+v\n", expectedProbe, actualProbe)

pkg/apis/meta/v1/register.go

@@ -17,6 +17,7 @@ limitations under the License.
 package v1
 
 import (
+	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/schema"
 )
 
@@ -26,7 +27,25 @@ const GroupName = "meta.k8s.io"
 // SchemeGroupVersion is group version used to register these objects
 var SchemeGroupVersion = schema.GroupVersion{Group: "", Version: ""}
 
+// WatchEventKind is name reserved for serializing watch events.
+const WatchEventKind = "WatchEvent"
+
 // Kind takes an unqualified kind and returns a Group qualified GroupKind
 func Kind(kind string) schema.GroupKind {
 	return SchemeGroupVersion.WithKind(kind).GroupKind()
 }
+
+// AddToGroupVersion registers common meta types into schemas.
+func AddToGroupVersion(scheme *runtime.Scheme, groupVersion schema.GroupVersion) {
+	scheme.AddKnownTypeWithName(groupVersion.WithKind(WatchEventKind), &Event{})
+	scheme.AddKnownTypeWithName(
+		schema.GroupVersion{Group: groupVersion.Group, Version: runtime.APIVersionInternal}.WithKind(WatchEventKind),
+		&InternalEvent{},
+	)
+	scheme.AddConversionFuncs(
+		Convert_versioned_Event_to_watch_Event,
+		Convert_versioned_InternalEvent_to_versioned_Event,
+		Convert_watch_Event_to_versioned_Event,
+		Convert_versioned_Event_to_versioned_InternalEvent,
+	)
+}

pkg/apis/meta/v1/watch.go

@@ -26,7 +26,7 @@ import (
 // Event represents a single event to a watched resource.
 //
 // +protobuf=true
-// +k8s:openapi-gen=true
+// +k8s:openapi-gen=false
 type Event struct {
 	Type string `json:"type" protobuf:"bytes,1,opt,name=type"`
 
@@ -74,6 +74,7 @@ func Convert_versioned_Event_to_versioned_InternalEvent(in *Event, out *Internal
 }
 
 // InternalEvent makes watch.Event versioned
+// +protobuf=false
 type InternalEvent watch.Event
 
 func (e *InternalEvent) GetObjectKind() schema.ObjectKind { return schema.EmptyObjectKind }

pkg/client/restclient/BUILD

@@ -65,6 +65,7 @@ go_test(
         "//pkg/api/v1:go_default_library",
         "//pkg/apimachinery/registered:go_default_library",
         "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/client/restclient/watch:go_default_library",
         "//pkg/client/unversioned/clientcmd/api:go_default_library",
         "//pkg/labels:go_default_library",
         "//pkg/runtime:go_default_library",

pkg/client/restclient/request.go

@@ -37,6 +37,7 @@ import (
 	pathvalidation "k8s.io/kubernetes/pkg/api/validation/path"
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/client/metrics"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/fields"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
@@ -46,7 +47,6 @@ import (
 	"k8s.io/kubernetes/pkg/util/net"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/watch"
-	"k8s.io/kubernetes/pkg/watch/versioned"
 )
 
 var (
@@ -683,7 +683,7 @@ func (r *Request) Watch() (watch.Interface, error) {
 	}
 	framer := r.serializers.Framer.NewFrameReader(resp.Body)
 	decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
-	return watch.NewStreamWatcher(versioned.NewDecoder(decoder, r.serializers.Decoder)), nil
+	return watch.NewStreamWatcher(restclientwatch.NewDecoder(decoder, r.serializers.Decoder)), nil
 }
 
 // updateURLMetrics is a convenience function for pushing metrics.

pkg/client/restclient/request_test.go

@@ -39,6 +39,7 @@ import (
 	"k8s.io/kubernetes/pkg/api/v1"
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/labels"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/schema"
@@ -50,7 +51,6 @@ import (
 	"k8s.io/kubernetes/pkg/util/intstr"
 	utiltesting "k8s.io/kubernetes/pkg/util/testing"
 	"k8s.io/kubernetes/pkg/watch"
-	"k8s.io/kubernetes/pkg/watch/versioned"
 )
 
 func TestNewRequestSetsAccept(t *testing.T) {
@@ -1571,7 +1571,7 @@ func TestWatch(t *testing.T) {
 		w.WriteHeader(http.StatusOK)
 		flusher.Flush()
 
-		encoder := versioned.NewEncoder(streaming.NewEncoder(w, testapi.Default.Codec()), testapi.Default.Codec())
+		encoder := restclientwatch.NewEncoder(streaming.NewEncoder(w, testapi.Default.Codec()), testapi.Default.Codec())
 		for _, item := range table {
 			if err := encoder.Encode(&watch.Event{Type: item.t, Object: item.obj}); err != nil {
 				panic(err)

pkg/client/restclient/watch/BUILD

@@ -34,6 +34,7 @@ go_test(
         "//pkg/api:go_default_library",
         "//pkg/api/testapi:go_default_library",
         "//pkg/apis/meta/v1:go_default_library",
+        "//pkg/client/restclient/watch:go_default_library",
         "//pkg/runtime:go_default_library",
         "//pkg/runtime/serializer/streaming:go_default_library",
         "//pkg/util/wait:go_default_library",

pkg/client/restclient/watch/decoder.go

@@ -19,6 +19,7 @@ package versioned
 import (
 	"fmt"
 
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/serializer/streaming"
 	"k8s.io/kubernetes/pkg/watch"
@@ -44,13 +45,13 @@ func NewDecoder(decoder streaming.Decoder, embeddedDecoder runtime.Decoder) *Dec
 // Decode blocks until it can return the next object in the reader. Returns an error
 // if the reader is closed or an object can't be decoded.
 func (d *Decoder) Decode() (watch.EventType, runtime.Object, error) {
-	var got Event
+	var got metav1.Event
 	res, _, err := d.decoder.Decode(nil, &got)
 	if err != nil {
 		return "", nil, err
 	}
 	if res != &got {
-		return "", nil, fmt.Errorf("unable to decode to versioned.Event")
+		return "", nil, fmt.Errorf("unable to decode to metav1.Event")
 	}
 	switch got.Type {
 	case string(watch.Added), string(watch.Modified), string(watch.Deleted), string(watch.Error):

pkg/client/restclient/watch/decoder_test.go

@@ -24,11 +24,12 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/testapi"
+	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/serializer/streaming"
 	"k8s.io/kubernetes/pkg/util/wait"
 	"k8s.io/kubernetes/pkg/watch"
-	"k8s.io/kubernetes/pkg/watch/versioned"
 )
 
 func TestDecoder(t *testing.T) {
@@ -37,7 +38,7 @@ func TestDecoder(t *testing.T) {
 	for _, eventType := range table {
 		out, in := io.Pipe()
 		codec := testapi.Default.Codec()
-		decoder := versioned.NewDecoder(streaming.NewDecoder(out, codec), codec)
+		decoder := restclientwatch.NewDecoder(streaming.NewDecoder(out, codec), codec)
 
 		expect := &api.Pod{ObjectMeta: api.ObjectMeta{Name: "foo"}}
 		encoder := json.NewEncoder(in)
@@ -46,7 +47,7 @@ func TestDecoder(t *testing.T) {
 			if err != nil {
 				t.Fatalf("Unexpected error %v", err)
 			}
-			event := versioned.Event{
+			event := metav1.Event{
 				Type:   string(eventType),
 				Object: runtime.RawExtension{Raw: json.RawMessage(data)},
 			}
@@ -90,7 +91,7 @@ func TestDecoder(t *testing.T) {
 func TestDecoder_SourceClose(t *testing.T) {
 	out, in := io.Pipe()
 	codec := testapi.Default.Codec()
-	decoder := versioned.NewDecoder(streaming.NewDecoder(out, codec), codec)
+	decoder := restclientwatch.NewDecoder(streaming.NewDecoder(out, codec), codec)
 
 	done := make(chan struct{})
 

pkg/client/restclient/watch/encoder_test.go

@@ -23,10 +23,10 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/api/testapi"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/serializer/streaming"
 	"k8s.io/kubernetes/pkg/watch"
-	"k8s.io/kubernetes/pkg/watch/versioned"
 )
 
 func TestEncodeDecodeRoundTrip(t *testing.T) {
@@ -55,14 +55,14 @@ func TestEncodeDecodeRoundTrip(t *testing.T) {
 		buf := &bytes.Buffer{}
 
 		codec := testCase.Codec
-		encoder := versioned.NewEncoder(streaming.NewEncoder(buf, codec), codec)
+		encoder := restclientwatch.NewEncoder(streaming.NewEncoder(buf, codec), codec)
 		if err := encoder.Encode(&watch.Event{Type: testCase.Type, Object: testCase.Object}); err != nil {
 			t.Errorf("%d: unexpected error: %v", i, err)
 			continue
 		}
 
 		rc := ioutil.NopCloser(buf)
-		decoder := versioned.NewDecoder(streaming.NewDecoder(rc, codec), codec)
+		decoder := restclientwatch.NewDecoder(streaming.NewDecoder(rc, codec), codec)
 		event, obj, err := decoder.Decode()
 		if err != nil {
 			t.Errorf("%d: unexpected error: %v", i, err)

pkg/client/typed/dynamic/BUILD

@@ -46,6 +46,7 @@ go_test(
         "//pkg/apis/meta/v1:go_default_library",
         "//pkg/apis/meta/v1/unstructured:go_default_library",
         "//pkg/client/restclient:go_default_library",
+        "//pkg/client/restclient/watch:go_default_library",
         "//pkg/runtime:go_default_library",
         "//pkg/runtime/schema:go_default_library",
         "//pkg/runtime/serializer/streaming:go_default_library",

pkg/client/typed/dynamic/client_test.go

@@ -30,6 +30,7 @@ import (
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/apis/meta/v1/unstructured"
 	"k8s.io/kubernetes/pkg/client/restclient"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/schema"
 	"k8s.io/kubernetes/pkg/runtime/serializer/streaming"
@@ -458,7 +459,7 @@ func TestWatch(t *testing.T) {
 				t.Errorf("Watch(%q) got path %s. wanted %s", tc.name, r.URL.Path, tc.path)
 			}
 
-			enc := metav1.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
+			enc := restclientwatch.NewEncoder(streaming.NewEncoder(w, dynamicCodec{}), dynamicCodec{})
 			for _, e := range tc.events {
 				enc.Encode(&e)
 			}

pkg/kubectl/cmd/BUILD

@@ -187,6 +187,7 @@ go_test(
         "//pkg/apis/policy:go_default_library",
         "//pkg/client/restclient:go_default_library",
         "//pkg/client/restclient/fake:go_default_library",
+        "//pkg/client/restclient/watch:go_default_library",
         "//pkg/client/typed/dynamic:go_default_library",
         "//pkg/kubectl:go_default_library",
         "//pkg/kubectl/cmd/testing:go_default_library",

pkg/kubectl/cmd/get_test.go

@@ -34,6 +34,7 @@ import (
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/client/restclient"
 	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	cmdtesting "k8s.io/kubernetes/pkg/kubectl/cmd/testing"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/schema"
@@ -890,7 +891,7 @@ func TestWatchOnlyList(t *testing.T) {
 
 func watchBody(codec runtime.Codec, events []watch.Event) io.ReadCloser {
 	buf := bytes.NewBuffer([]byte{})
-	enc := metav1.NewEncoder(streaming.NewEncoder(buf, codec), codec)
+	enc := restclientwatch.NewEncoder(streaming.NewEncoder(buf, codec), codec)
 	for i := range events {
 		enc.Encode(&events[i])
 	}

pkg/kubectl/resource/BUILD

@@ -67,6 +67,7 @@ go_test(
         "//pkg/apimachinery/registered:go_default_library",
         "//pkg/apis/meta/v1:go_default_library",
         "//pkg/client/restclient/fake:go_default_library",
+        "//pkg/client/restclient/watch:go_default_library",
         "//pkg/labels:go_default_library",
         "//pkg/runtime:go_default_library",
         "//pkg/runtime/serializer/streaming:go_default_library",

pkg/kubectl/resource/builder_test.go

@@ -40,6 +40,7 @@ import (
 	"k8s.io/kubernetes/pkg/apimachinery/registered"
 	metav1 "k8s.io/kubernetes/pkg/apis/meta/v1"
 	"k8s.io/kubernetes/pkg/client/restclient/fake"
+	restclientwatch "k8s.io/kubernetes/pkg/client/restclient/watch"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/runtime/serializer/streaming"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
@@ -54,7 +55,7 @@ func stringBody(body string) io.ReadCloser {
 func watchBody(events ...watch.Event) string {
 	buf := &bytes.Buffer{}
 	codec := testapi.Default.Codec()
-	enc := metav1.NewEncoder(streaming.NewEncoder(buf, codec), codec)
+	enc := restclientwatch.NewEncoder(streaming.NewEncoder(buf, codec), codec)
 	for _, e := range events {
 		enc.Encode(&e)
 	}

pkg/watch/BUILD

@@ -30,7 +30,7 @@ go_library(
 )
 
 go_test(
-    name = "go_default_test",
+    name = "go_default_xtest",
     srcs = [
         "filter_test.go",
         "mux_test.go",
@@ -38,13 +38,13 @@ go_test(
         "until_test.go",
         "watch_test.go",
     ],
-    library = ":go_default_library",
     tags = ["automanaged"],
     deps = [
         "//pkg/api:go_default_library",
         "//pkg/runtime:go_default_library",
         "//pkg/runtime/schema:go_default_library",
         "//pkg/util/wait:go_default_library",
+        "//pkg/watch:go_default_library",
     ],
 )
 

pkg/watch/filter_test.go

@@ -14,11 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package watch
+package watch_test
 
 import (
 	"reflect"
 	"testing"
+
+	. "k8s.io/kubernetes/pkg/watch"
 )
 
 func TestFilter(t *testing.T) {

pkg/watch/mux_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package watch
+package watch_test
 
 import (
 	"reflect"
@@ -24,6 +24,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/runtime/schema"
 	"k8s.io/kubernetes/pkg/util/wait"
+	. "k8s.io/kubernetes/pkg/watch"
 )
 
 type myType struct {

pkg/watch/streamwatcher_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package watch
+package watch_test
 
 import (
 	"io"
@@ -22,6 +22,7 @@ import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/runtime"
+	. "k8s.io/kubernetes/pkg/watch"
 )
 
 type fakeDecoder struct {

pkg/watch/until_test.go

@@ -14,7 +14,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package watch
+package watch_test
 
 import (
 	"errors"
@@ -24,6 +24,7 @@ import (
 
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/util/wait"
+	. "k8s.io/kubernetes/pkg/watch"
 )
 
 func TestUntil(t *testing.T) {

pkg/watch/watch_test.go

@@ -14,12 +14,13 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-package watch
+package watch_test
 
 import (
 	"testing"
 
 	"k8s.io/kubernetes/pkg/runtime/schema"
+	. "k8s.io/kubernetes/pkg/watch"
 )
 
 type testType string