func TestSetDefaultServicePort(t *testing.T) { // Unchanged if set. in := ¤t.Service{Ports: []current.ServicePort{{Protocol: "UDP", Port: 9376, ContainerPort: util.NewIntOrStringFromInt(118)}}} out := roundTrip(t, runtime.Object(in)).(*current.Service) if out.Ports[0].Protocol != current.ProtocolUDP { t.Errorf("Expected protocol %s, got %s", current.ProtocolUDP, out.Ports[0].Protocol) } if out.Ports[0].ContainerPort != in.Ports[0].ContainerPort { t.Errorf("Expected port %d, got %d", in.Ports[0].ContainerPort, out.Ports[0].ContainerPort) } // Defaulted. in = ¤t.Service{Ports: []current.ServicePort{{Protocol: "", Port: 9376, ContainerPort: util.NewIntOrStringFromInt(0)}}} out = roundTrip(t, runtime.Object(in)).(*current.Service) if out.Ports[0].Protocol != current.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", current.ProtocolTCP, out.Ports[0].Protocol) } if out.Ports[0].ContainerPort != util.NewIntOrStringFromInt(in.Ports[0].Port) { t.Errorf("Expected port %d, got %v", in.Ports[0].Port, out.Ports[0].ContainerPort) } // Defaulted. in = ¤t.Service{Ports: []current.ServicePort{{Protocol: "", Port: 9376, ContainerPort: util.NewIntOrStringFromString("")}}} out = roundTrip(t, runtime.Object(in)).(*current.Service) if out.Ports[0].Protocol != current.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", current.ProtocolTCP, out.Ports[0].Protocol) } if out.Ports[0].ContainerPort != util.NewIntOrStringFromInt(in.Ports[0].Port) { t.Errorf("Expected port %d, got %v", in.Ports[0].Port, out.Ports[0].ContainerPort) } }
func TestSetDefaulServiceTargetPort(t *testing.T) { in := &versioned.Service{Spec: versioned.ServiceSpec{Ports: []versioned.ServicePort{{Port: 1234}}}} obj := roundTrip(t, runtime.Object(in)) out := obj.(*versioned.Service) if out.Spec.Ports[0].TargetPort != util.NewIntOrStringFromInt(1234) { t.Errorf("Expected TargetPort to be defaulted, got %s", out.Spec.Ports[0].TargetPort) } in = &versioned.Service{Spec: versioned.ServiceSpec{Ports: []versioned.ServicePort{{Port: 1234, TargetPort: util.NewIntOrStringFromInt(5678)}}}} obj = roundTrip(t, runtime.Object(in)) out = obj.(*versioned.Service) if out.Spec.Ports[0].TargetPort != util.NewIntOrStringFromInt(5678) { t.Errorf("Expected TargetPort to be unchanged, got %s", out.Spec.Ports[0].TargetPort) } }
func TestSetDefaulServiceTargetPort(t *testing.T) { in := ¤t.Service{Spec: current.ServiceSpec{Port: 1234}} obj := roundTrip(t, runtime.Object(in)) out := obj.(*current.Service) if out.Spec.TargetPort.Kind != util.IntstrInt || out.Spec.TargetPort.IntVal != 1234 { t.Errorf("Expected TargetPort to be defaulted, got %s", out.Spec.TargetPort) } in = ¤t.Service{Spec: current.ServiceSpec{Port: 1234, TargetPort: util.NewIntOrStringFromInt(5678)}} obj = roundTrip(t, runtime.Object(in)) out = obj.(*current.Service) if out.Spec.TargetPort.Kind != util.IntstrInt || out.Spec.TargetPort.IntVal != 5678 { t.Errorf("Expected TargetPort to be unchanged, got %s", out.Spec.TargetPort) } }
func TestSetDefaultPodSpecHostNetwork(t *testing.T) { portNum := 8080 s := versioned.PodSpec{} s.HostNetwork = true s.Containers = []versioned.Container{ { Ports: []versioned.ContainerPort{ { ContainerPort: portNum, }, }, }, } pod := &versioned.Pod{ Spec: s, } obj2 := roundTrip(t, runtime.Object(pod)) pod2 := obj2.(*versioned.Pod) s2 := pod2.Spec hostPortNum := s2.Containers[0].Ports[0].HostPort if hostPortNum != portNum { t.Errorf("Expected container port to be defaulted, was made %d instead of %d", hostPortNum, portNum) } }
func TestSetDefaultObjectFieldSelectorAPIVersion(t *testing.T) { s := versioned.PodSpec{ Containers: []versioned.Container{ { Env: []versioned.EnvVar{ { ValueFrom: &versioned.EnvVarSource{ FieldRef: &versioned.ObjectFieldSelector{}, }, }, }, }, }, } pod := &versioned.Pod{ Spec: s, } obj2 := roundTrip(t, runtime.Object(pod)) pod2 := obj2.(*versioned.Pod) s2 := pod2.Spec apiVersion := s2.Containers[0].Env[0].ValueFrom.FieldRef.APIVersion if apiVersion != "v1" { t.Errorf("Expected default APIVersion v1, got: %v", apiVersion) } }
// Test that we use "legacy" fields if "modern" fields are not provided. func TestSetDefaulEndpointsLegacy(t *testing.T) { in := ¤t.Endpoints{ Protocol: "UDP", Endpoints: []string{"1.2.3.4:93", "5.6.7.8:76"}, TargetRefs: []current.EndpointObjectReference{{Endpoint: "1.2.3.4:93", ObjectReference: current.ObjectReference{ID: "foo"}}}, } obj := roundTrip(t, runtime.Object(in)) out := obj.(*current.Endpoints) if len(out.Subsets) != 2 { t.Errorf("Expected 2 EndpointSubsets, got %d (%#v)", len(out.Subsets), out.Subsets) } expected := []current.EndpointSubset{ { Addresses: []current.EndpointAddress{{IP: "1.2.3.4", TargetRef: ¤t.ObjectReference{ID: "foo"}}}, Ports: []current.EndpointPort{{Protocol: current.ProtocolUDP, Port: 93}}, }, { Addresses: []current.EndpointAddress{{IP: "5.6.7.8"}}, Ports: []current.EndpointPort{{Protocol: current.ProtocolUDP, Port: 76}}, }, } if !reflect.DeepEqual(out.Subsets, expected) { t.Errorf("Expected %#v, got %#v", expected, out.Subsets) } }
func TestSetDefaultObjectFieldSelectorAPIVersion(t *testing.T) { s := versioned.ContainerManifest{ Containers: []versioned.Container{ { Env: []versioned.EnvVar{ { ValueFrom: &versioned.EnvVarSource{ FieldRef: &versioned.ObjectFieldSelector{}, }, }, }, }, }, } obj2 := roundTrip(t, runtime.Object(&versioned.ContainerManifestList{ Items: []versioned.ContainerManifest{s}, })) sList2 := obj2.(*versioned.ContainerManifestList) s2 := sList2.Items[0] apiVersion := s2.Containers[0].Env[0].ValueFrom.FieldRef.APIVersion if apiVersion != "v1beta1" { t.Errorf("Expected default APIVersion v1beta1, got: %v", apiVersion) } }
func TestSetDefaultService(t *testing.T) { svc := ¤t.Service{} obj2 := roundTrip(t, runtime.Object(svc)) svc2 := obj2.(*current.Service) if svc2.Spec.SessionAffinity != current.AffinityTypeNone { t.Errorf("Expected default sesseion affinity type:%s, got: %s", current.AffinityTypeNone, svc2.Spec.SessionAffinity) } }
func TestSetDefaultPersistentVolumeClaim(t *testing.T) { pvc := &versioned.PersistentVolumeClaim{} obj2 := roundTrip(t, runtime.Object(pvc)) pvc2 := obj2.(*versioned.PersistentVolumeClaim) if pvc2.Status.Phase != versioned.ClaimPending { t.Errorf("Expected claim phase %v, got %v", versioned.ClaimPending, pvc2.Status.Phase) } }
func TestSetDefaultSecret(t *testing.T) { s := ¤t.Secret{} obj2 := roundTrip(t, runtime.Object(s)) s2 := obj2.(*current.Secret) if s2.Type != current.SecretTypeOpaque { t.Errorf("Expected secret type %v, got %v", current.SecretTypeOpaque, s2.Type) } }
func TestSetDefaulEndpointsProtocol(t *testing.T) { in := ¤t.Endpoints{} obj := roundTrip(t, runtime.Object(in)) out := obj.(*current.Endpoints) if out.Protocol != current.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", current.ProtocolTCP, out.Protocol) } }
func TestSetDefaultServiceWithLoadbalancer(t *testing.T) { svc := &versioned.Service{} svc.Spec.CreateExternalLoadBalancer = true obj2 := roundTrip(t, runtime.Object(svc)) svc2 := obj2.(*versioned.Service) if svc2.Spec.Type != versioned.ServiceTypeLoadBalancer { t.Errorf("Expected default type:%s, got: %s", versioned.ServiceTypeLoadBalancer, svc2.Spec.Type) } }
func TestSetDefaultNamespace(t *testing.T) { s := ¤t.Namespace{} obj2 := roundTrip(t, runtime.Object(s)) s2 := obj2.(*current.Namespace) if s2.Status.Phase != current.NamespaceActive { t.Errorf("Expected phase %v, got %v", current.NamespaceActive, s2.Status.Phase) } }
func TestSetDefaultPersistentVolume(t *testing.T) { pv := &versioned.PersistentVolume{} obj2 := roundTrip(t, runtime.Object(pv)) pv2 := obj2.(*versioned.PersistentVolume) if pv2.Status.Phase != versioned.VolumePending { t.Errorf("Expected volume phase %v, got %v", versioned.VolumePending, pv2.Status.Phase) } }
func TestSetDefaultNodeExternalID(t *testing.T) { name := "node0" n := ¤t.Node{} n.Name = name obj2 := roundTrip(t, runtime.Object(n)) n2 := obj2.(*current.Node) if n2.Spec.ExternalID != name { t.Errorf("Expected default External ID: %s, got: %s", name, n2.Spec.ExternalID) } }
func TestSetDefaultServicePort(t *testing.T) { // Unchanged if set. in := &versioned.Service{Spec: versioned.ServiceSpec{ Ports: []versioned.ServicePort{ {Protocol: "UDP", Port: 9376, TargetPort: util.NewIntOrStringFromString("p")}, {Protocol: "UDP", Port: 8675, TargetPort: util.NewIntOrStringFromInt(309)}, }, }} out := roundTrip(t, runtime.Object(in)).(*versioned.Service) if out.Spec.Ports[0].Protocol != versioned.ProtocolUDP { t.Errorf("Expected protocol %s, got %s", versioned.ProtocolUDP, out.Spec.Ports[0].Protocol) } if out.Spec.Ports[0].TargetPort != util.NewIntOrStringFromString("p") { t.Errorf("Expected port %d, got %s", in.Spec.Ports[0].Port, out.Spec.Ports[0].TargetPort) } if out.Spec.Ports[1].Protocol != versioned.ProtocolUDP { t.Errorf("Expected protocol %s, got %s", versioned.ProtocolUDP, out.Spec.Ports[1].Protocol) } if out.Spec.Ports[1].TargetPort != util.NewIntOrStringFromInt(309) { t.Errorf("Expected port %d, got %s", in.Spec.Ports[1].Port, out.Spec.Ports[1].TargetPort) } // Defaulted. in = &versioned.Service{Spec: versioned.ServiceSpec{ Ports: []versioned.ServicePort{ {Protocol: "", Port: 9376, TargetPort: util.NewIntOrStringFromString("")}, {Protocol: "", Port: 8675, TargetPort: util.NewIntOrStringFromInt(0)}, }, }} out = roundTrip(t, runtime.Object(in)).(*versioned.Service) if out.Spec.Ports[0].Protocol != versioned.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", versioned.ProtocolTCP, out.Spec.Ports[0].Protocol) } if out.Spec.Ports[0].TargetPort != util.NewIntOrStringFromInt(in.Spec.Ports[0].Port) { t.Errorf("Expected port %d, got %d", in.Spec.Ports[0].Port, out.Spec.Ports[0].TargetPort) } if out.Spec.Ports[1].Protocol != versioned.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", versioned.ProtocolTCP, out.Spec.Ports[1].Protocol) } if out.Spec.Ports[1].TargetPort != util.NewIntOrStringFromInt(in.Spec.Ports[1].Port) { t.Errorf("Expected port %d, got %d", in.Spec.Ports[1].Port, out.Spec.Ports[1].TargetPort) } }
func TestSetDefaultMinionExternalID(t *testing.T) { name := "node0" m := ¤t.Minion{} m.ID = name obj2 := roundTrip(t, runtime.Object(m)) m2 := obj2.(*current.Minion) if m2.ExternalID != name { t.Errorf("Expected default External ID: %s, got: %s", name, m2.ExternalID) } }
func TestSetDefaultService(t *testing.T) { svc := &versioned.Service{} obj2 := roundTrip(t, runtime.Object(svc)) svc2 := obj2.(*versioned.Service) if svc2.Spec.SessionAffinity != versioned.ServiceAffinityNone { t.Errorf("Expected default session affinity type:%s, got: %s", versioned.ServiceAffinityNone, svc2.Spec.SessionAffinity) } if svc2.Spec.Type != versioned.ServiceTypeClusterIP { t.Errorf("Expected default type:%s, got: %s", versioned.ServiceTypeClusterIP, svc2.Spec.Type) } }
func TestSetDefaultNodeExternalID(t *testing.T) { name := "node0" n := &versioned.Node{} n.Name = name obj2 := roundTrip(t, runtime.Object(n)) n2 := obj2.(*versioned.Node) if n2.Spec.ExternalID != name { t.Errorf("Expected default External ID: %s, got: %s", name, n2.Spec.ExternalID) } if n2.Spec.ProviderID != "" { t.Errorf("Expected empty default Cloud Provider ID, got: %s", n2.Spec.ProviderID) } }
func TestEncode_Ptr(t *testing.T) { pod := &api.Pod{ Labels: map[string]string{"name": "foo"}, } obj := runtime.Object(pod) data, err := runtime.DefaultCodec.Encode(obj) obj2, err2 := runtime.DefaultCodec.Decode(data) if err != nil || err2 != nil { t.Fatalf("Failure: '%v' '%v'", err, err2) } if _, ok := obj2.(*api.Pod); !ok { t.Fatalf("Got wrong type") } if !reflect.DeepEqual(obj2, pod) { t.Errorf("Expected:\n %#v,\n Got:\n %#v", &pod, obj2) } }
func TestSetDefaulPodSpec(t *testing.T) { bp := ¤t.BoundPod{} bp.Spec.Volumes = []current.Volume{{}} obj2 := roundTrip(t, runtime.Object(bp)) bp2 := obj2.(*current.BoundPod) if bp2.Spec.DNSPolicy != current.DNSClusterFirst { t.Errorf("Expected default dns policy :%s, got: %s", current.DNSClusterFirst, bp2.Spec.DNSPolicy) } policy := bp2.Spec.RestartPolicy if policy.Never != nil || policy.OnFailure != nil || policy.Always == nil { t.Errorf("Expected only policy.Always is set, got: %s", policy) } vsource := bp2.Spec.Volumes[0].Source if vsource.EmptyDir == nil { t.Errorf("Expected non-empty volume is set, got: %s", vsource.EmptyDir) } }
func TestDefaults_rollingParams(t *testing.T) { c := ¤t.DeploymentConfig{} o := roundTrip(t, runtime.Object(c)) config := o.(*current.DeploymentConfig) strat := config.Spec.Strategy if e, a := current.DeploymentStrategyTypeRolling, strat.Type; e != a { t.Errorf("expected strategy type %s, got %s", e, a) } if e, a := int64(1), *strat.RollingParams.UpdatePeriodSeconds; e != a { t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a) } if e, a := int64(1), *strat.RollingParams.IntervalSeconds; e != a { t.Errorf("expected IntervalSeconds %d, got %d", e, a) } if e, a := int64(120), *strat.RollingParams.TimeoutSeconds; e != a { t.Errorf("expected UpdatePeriodSeconds %d, got %d", e, a) } }
func TestEncode(t *testing.T) { scheme := runtime.NewScheme() scheme.AddKnownTypeWithName("", "Simple", &InternalSimple{}) scheme.AddKnownTypeWithName("externalVersion", "Simple", &ExternalSimple{}) codec := runtime.CodecFor(scheme, "externalVersion") test := &InternalSimple{ TestString: "I'm the same", } obj := runtime.Object(test) data, err := codec.Encode(obj) obj2, err2 := codec.Decode(data) if err != nil || err2 != nil { t.Fatalf("Failure: '%v' '%v'", err, err2) } if _, ok := obj2.(*InternalSimple); !ok { t.Fatalf("Got wrong type") } if !reflect.DeepEqual(obj2, test) { t.Errorf("Expected:\n %#v,\n Got:\n %#v", &test, obj2) } }
func TestSetDefaulEndpointsProtocol(t *testing.T) { in := &versioned.Endpoints{Subsets: []versioned.EndpointSubset{ {Ports: []versioned.EndpointPort{{}, {Protocol: "UDP"}, {}}}, }} obj := roundTrip(t, runtime.Object(in)) out := obj.(*versioned.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 != versioned.ProtocolTCP { t.Errorf("Expected protocol %s, got %s", versioned.ProtocolTCP, out.Subsets[i].Ports[j].Protocol) } } else { if out.Subsets[i].Ports[j].Protocol != in.Subsets[i].Ports[j].Protocol { t.Errorf("Expected protocol %s, got %s", in.Subsets[i].Ports[j].Protocol, out.Subsets[i].Ports[j].Protocol) } } } } }
func TestSetDefaultContainer(t *testing.T) { bp := ¤t.BoundPod{} bp.Spec.Containers = []current.Container{{}} bp.Spec.Containers[0].Ports = []current.Port{{}} obj2 := roundTrip(t, runtime.Object(bp)) bp2 := obj2.(*current.BoundPod) container := bp2.Spec.Containers[0] if container.TerminationMessagePath != current.TerminationMessagePathDefault { t.Errorf("Expected termination message path: %s, got: %s", current.TerminationMessagePathDefault, container.TerminationMessagePath) } if container.ImagePullPolicy != current.PullIfNotPresent { t.Errorf("Expected image pull policy: %s, got: %s", current.PullIfNotPresent, container.ImagePullPolicy) } if container.Ports[0].Protocol != current.ProtocolTCP { t.Errorf("Expected protocol: %s, got: %s", current.ProtocolTCP, container.Ports[0].Protocol) } }
func TestEncode_Ptr(t *testing.T) { pod := &api.Pod{ ObjectMeta: api.ObjectMeta{ Labels: map[string]string{"name": "foo"}, }, Spec: api.PodSpec{ RestartPolicy: api.RestartPolicyAlways, DNSPolicy: api.DNSClusterFirst, }, } obj := runtime.Object(pod) data, err := latest.Codec.Encode(obj) obj2, err2 := latest.Codec.Decode(data) if err != nil || err2 != nil { t.Fatalf("Failure: '%v' '%v'", err, err2) } if _, ok := obj2.(*api.Pod); !ok { t.Fatalf("Got wrong type") } if !api.Semantic.DeepEqual(obj2, pod) { t.Errorf("Expected:\n %#v,\n Got:\n %#v", pod, obj2) } }
func TestSetDefaultContainerManifestHostNetwork(t *testing.T) { portNum := 8080 s := current.ContainerManifest{} s.HostNetwork = true s.Containers = []current.Container{ { Ports: []current.ContainerPort{ { ContainerPort: portNum, }, }, }, } obj2 := roundTrip(t, runtime.Object(¤t.ContainerManifestList{ Items: []current.ContainerManifest{s}, })) sList2 := obj2.(*current.ContainerManifestList) s2 := sList2.Items[0] hostPortNum := s2.Containers[0].Ports[0].HostPort if hostPortNum != portNum { t.Errorf("Expected container port to be defaulted, was made %d instead of %d", hostPortNum, portNum) } }
// TODO: This should be done on types that are not part of our API func TestBeforeUpdate(t *testing.T) { testCases := []struct { name string tweakSvc func(oldSvc, newSvc *api.Service) // given basic valid services, each test case can customize them expectErr bool }{ { name: "no change", tweakSvc: func(oldSvc, newSvc *api.Service) { // nothing }, expectErr: false, }, { name: "change port", tweakSvc: func(oldSvc, newSvc *api.Service) { newSvc.Spec.Ports[0].Port++ }, expectErr: false, }, { name: "bad namespace", tweakSvc: func(oldSvc, newSvc *api.Service) { newSvc.Namespace = "#$%%invalid" }, expectErr: true, }, { name: "change name", tweakSvc: func(oldSvc, newSvc *api.Service) { newSvc.Name += "2" }, expectErr: true, }, { name: "change portal IP", tweakSvc: func(oldSvc, newSvc *api.Service) { oldSvc.Spec.PortalIP = "1.2.3.4" newSvc.Spec.PortalIP = "4.3.2.1" }, expectErr: true, }, { name: "change selectpor", tweakSvc: func(oldSvc, newSvc *api.Service) { newSvc.Spec.Selector = map[string]string{"newkey": "newvalue"} }, expectErr: false, }, } for _, tc := range testCases { oldSvc := makeValidService() newSvc := makeValidService() tc.tweakSvc(&oldSvc, &newSvc) ctx := api.NewDefaultContext() err := BeforeUpdate(Services, ctx, runtime.Object(&oldSvc), runtime.Object(&newSvc)) if tc.expectErr && err == nil { t.Errorf("unexpected non-error for %q", tc.name) } if !tc.expectErr && err != nil { t.Errorf("unexpected error for %q: %v", tc.name, err) } } }
func TestSetDefaultReplicationController(t *testing.T) { tests := []struct { rc *current.ReplicationController expectLabels bool expectSelector bool }{ { rc: ¤t.ReplicationController{ DesiredState: current.ReplicationControllerState{ PodTemplate: current.PodTemplate{ Labels: map[string]string{ "foo": "bar", }, }, }, }, expectLabels: true, expectSelector: true, }, { rc: ¤t.ReplicationController{ Labels: map[string]string{ "bar": "foo", }, DesiredState: current.ReplicationControllerState{ PodTemplate: current.PodTemplate{ Labels: map[string]string{ "foo": "bar", }, }, }, }, expectLabels: false, expectSelector: true, }, { rc: ¤t.ReplicationController{ Labels: map[string]string{ "bar": "foo", }, DesiredState: current.ReplicationControllerState{ ReplicaSelector: map[string]string{ "some": "other", }, PodTemplate: current.PodTemplate{ Labels: map[string]string{ "foo": "bar", }, }, }, }, expectLabels: false, expectSelector: false, }, { rc: ¤t.ReplicationController{ DesiredState: current.ReplicationControllerState{ ReplicaSelector: map[string]string{ "some": "other", }, PodTemplate: current.PodTemplate{ Labels: map[string]string{ "foo": "bar", }, }, }, }, expectLabels: true, expectSelector: false, }, } for _, test := range tests { rc := test.rc obj2 := roundTrip(t, runtime.Object(rc)) rc2, ok := obj2.(*current.ReplicationController) if !ok { t.Errorf("unexpected object: %v", rc2) t.FailNow() } if test.expectSelector != reflect.DeepEqual(rc2.DesiredState.ReplicaSelector, rc2.DesiredState.PodTemplate.Labels) { if test.expectSelector { t.Errorf("expected: %v, got: %v", rc2.DesiredState.PodTemplate.Labels, rc2.DesiredState.ReplicaSelector) } else { t.Errorf("unexpected equality: %v", rc2.DesiredState.PodTemplate.Labels) } } if test.expectLabels != reflect.DeepEqual(rc2.Labels, rc2.DesiredState.PodTemplate.Labels) { if test.expectLabels { t.Errorf("expected: %v, got: %v", rc2.DesiredState.PodTemplate.Labels, rc2.Labels) } else { t.Errorf("unexpected equality: %v", rc2.DesiredState.PodTemplate.Labels) } } } }
func TestSetDefaultReplicationController(t *testing.T) { tests := []struct { rc *versioned.ReplicationController expectLabels bool expectSelector bool }{ { rc: &versioned.ReplicationController{ Spec: versioned.ReplicationControllerSpec{ Template: &versioned.PodTemplateSpec{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "foo": "bar", }, }, }, }, }, expectLabels: true, expectSelector: true, }, { rc: &versioned.ReplicationController{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "bar": "foo", }, }, Spec: versioned.ReplicationControllerSpec{ Template: &versioned.PodTemplateSpec{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "foo": "bar", }, }, }, }, }, expectLabels: false, expectSelector: true, }, { rc: &versioned.ReplicationController{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "bar": "foo", }, }, Spec: versioned.ReplicationControllerSpec{ Selector: map[string]string{ "some": "other", }, Template: &versioned.PodTemplateSpec{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "foo": "bar", }, }, }, }, }, expectLabels: false, expectSelector: false, }, { rc: &versioned.ReplicationController{ Spec: versioned.ReplicationControllerSpec{ Selector: map[string]string{ "some": "other", }, Template: &versioned.PodTemplateSpec{ ObjectMeta: versioned.ObjectMeta{ Labels: map[string]string{ "foo": "bar", }, }, }, }, }, expectLabels: true, expectSelector: false, }, } for _, test := range tests { rc := test.rc obj2 := roundTrip(t, runtime.Object(rc)) rc2, ok := obj2.(*versioned.ReplicationController) if !ok { t.Errorf("unexpected object: %v", rc2) t.FailNow() } if test.expectSelector != reflect.DeepEqual(rc2.Spec.Selector, rc2.Spec.Template.Labels) { if test.expectSelector { t.Errorf("expected: %v, got: %v", rc2.Spec.Template.Labels, rc2.Spec.Selector) } else { t.Errorf("unexpected equality: %v", rc.Spec.Selector) } } if test.expectLabels != reflect.DeepEqual(rc2.Labels, rc2.Spec.Template.Labels) { if test.expectLabels { t.Errorf("expected: %v, got: %v", rc2.Spec.Template.Labels, rc2.Labels) } else { t.Errorf("unexpected equality: %v", rc.Labels) } } } }