conversion_test.go

Documentation: k8s.io/kubernetes/pkg/apis/apps/v1beta2

     1  /*
     2  Copyright 2017 The Kubernetes Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package v1beta2_test
    18  
    19  import (
    20  	"testing"
    21  
    22  	"k8s.io/api/apps/v1beta2"
    23  	v1 "k8s.io/api/core/v1"
    24  	"k8s.io/apimachinery/pkg/util/intstr"
    25  	"k8s.io/kubernetes/pkg/api/legacyscheme"
    26  	"k8s.io/kubernetes/pkg/apis/apps"
    27  	"k8s.io/kubernetes/pkg/apis/autoscaling"
    28  	api "k8s.io/kubernetes/pkg/apis/core"
    29  
    30  	apiequality "k8s.io/apimachinery/pkg/api/equality"
    31  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    32  	utilpointer "k8s.io/utils/pointer"
    33  )
    34  
    35  func TestV1beta2StatefulSetSpecConversion(t *testing.T) {
    36  	replicas := utilpointer.Int32(2)
    37  	selector := &metav1.LabelSelector{MatchLabels: map[string]string{"foo": "bar"}}
    38  	v1beta2Template := v1.PodTemplateSpec{
    39  		ObjectMeta: metav1.ObjectMeta{Name: "foo"},
    40  		Spec: v1.PodSpec{
    41  			RestartPolicy:   v1.RestartPolicy("bar"),
    42  			SecurityContext: new(v1.PodSecurityContext),
    43  		},
    44  	}
    45  	apiTemplate := api.PodTemplateSpec{
    46  		ObjectMeta: metav1.ObjectMeta{Name: "foo"},
    47  		Spec: api.PodSpec{
    48  			RestartPolicy:   api.RestartPolicy("bar"),
    49  			SecurityContext: new(api.PodSecurityContext),
    50  		},
    51  	}
    52  	testcases := map[string]struct {
    53  		stsSpec1 *apps.StatefulSetSpec
    54  		stsSepc2 *v1beta2.StatefulSetSpec
    55  	}{
    56  		"StatefulSetSpec Conversion 1": {
    57  			stsSpec1: &apps.StatefulSetSpec{
    58  				Replicas: *replicas,
    59  				Template: apiTemplate,
    60  			},
    61  			stsSepc2: &v1beta2.StatefulSetSpec{
    62  				Replicas: replicas,
    63  				Template: v1beta2Template,
    64  			},
    65  		},
    66  		"StatefulSetSpec Conversion 2": {
    67  			stsSpec1: &apps.StatefulSetSpec{
    68  				Replicas:            *replicas,
    69  				Selector:            selector,
    70  				Template:            apiTemplate,
    71  				ServiceName:         "foo",
    72  				PodManagementPolicy: apps.PodManagementPolicyType("bar"),
    73  			},
    74  			stsSepc2: &v1beta2.StatefulSetSpec{
    75  				Replicas:            replicas,
    76  				Selector:            selector,
    77  				Template:            v1beta2Template,
    78  				ServiceName:         "foo",
    79  				PodManagementPolicy: v1beta2.PodManagementPolicyType("bar"),
    80  			},
    81  		},
    82  	}
    83  
    84  	for k, tc := range testcases {
    85  		// apps -> v1beta2
    86  		internal1 := &v1beta2.StatefulSetSpec{}
    87  		if err := legacyscheme.Scheme.Convert(tc.stsSpec1, internal1, nil); err != nil {
    88  			t.Errorf("%q - %q: unexpected error: %v", k, "from extensions to v1beta2", err)
    89  		}
    90  
    91  		if !apiequality.Semantic.DeepEqual(internal1, tc.stsSepc2) {
    92  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from extensions to v1beta2", tc.stsSepc2, internal1)
    93  		}
    94  
    95  		// v1beta2 -> apps
    96  		internal2 := &apps.StatefulSetSpec{}
    97  		if err := legacyscheme.Scheme.Convert(tc.stsSepc2, internal2, nil); err != nil {
    98  			t.Errorf("%q - %q: unexpected error: %v", k, "from v1beta2 to extensions", err)
    99  		}
   100  		if !apiequality.Semantic.DeepEqual(internal2, tc.stsSpec1) {
   101  			t.Errorf("%q- %q: expected\n\t%#v, got \n\t%#v", k, "from v1beta2 to extensions", tc.stsSpec1, internal2)
   102  		}
   103  	}
   104  }
   105  
   106  func TestV1beta2StatefulSetUpdateStrategyConversion(t *testing.T) {
   107  	partition := utilpointer.Int32(2)
   108  	v1beta2rollingUpdate := new(v1beta2.RollingUpdateStatefulSetStrategy)
   109  	v1beta2rollingUpdate.Partition = partition
   110  	appsrollingUpdate := new(apps.RollingUpdateStatefulSetStrategy)
   111  	appsrollingUpdate.Partition = *partition
   112  	testcases := map[string]struct {
   113  		stsUpdateStrategy1 *apps.StatefulSetUpdateStrategy
   114  		stsUpdateStrategy2 *v1beta2.StatefulSetUpdateStrategy
   115  	}{
   116  		"StatefulSetUpdateStrategy Conversion 1": {
   117  			stsUpdateStrategy1: &apps.StatefulSetUpdateStrategy{Type: apps.StatefulSetUpdateStrategyType("foo")},
   118  			stsUpdateStrategy2: &v1beta2.StatefulSetUpdateStrategy{Type: v1beta2.StatefulSetUpdateStrategyType("foo")},
   119  		},
   120  		"StatefulSetUpdateStrategy Conversion 2": {
   121  			stsUpdateStrategy1: &apps.StatefulSetUpdateStrategy{
   122  				Type:          apps.StatefulSetUpdateStrategyType("foo"),
   123  				RollingUpdate: appsrollingUpdate,
   124  			},
   125  			stsUpdateStrategy2: &v1beta2.StatefulSetUpdateStrategy{
   126  				Type:          v1beta2.StatefulSetUpdateStrategyType("foo"),
   127  				RollingUpdate: v1beta2rollingUpdate,
   128  			},
   129  		},
   130  	}
   131  
   132  	for k, tc := range testcases {
   133  		// apps -> v1beta2
   134  		internal1 := &v1beta2.StatefulSetUpdateStrategy{}
   135  		if err := legacyscheme.Scheme.Convert(tc.stsUpdateStrategy1, internal1, nil); err != nil {
   136  			t.Errorf("%q - %q: unexpected error: %v", "apps -> v1beta2", k, err)
   137  		}
   138  
   139  		if !apiequality.Semantic.DeepEqual(internal1, tc.stsUpdateStrategy2) {
   140  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", "apps -> v1beta2", k, tc.stsUpdateStrategy2, internal1)
   141  		}
   142  
   143  		// v1beta2 -> apps
   144  		internal2 := &apps.StatefulSetUpdateStrategy{}
   145  		if err := legacyscheme.Scheme.Convert(tc.stsUpdateStrategy2, internal2, nil); err != nil {
   146  			t.Errorf("%q - %q: unexpected error: %v", "v1beta2 -> apps", k, err)
   147  		}
   148  		if !apiequality.Semantic.DeepEqual(internal2, tc.stsUpdateStrategy1) {
   149  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", "v1beta2 -> apps", k, tc.stsUpdateStrategy1, internal2)
   150  		}
   151  	}
   152  }
   153  
   154  func TestV1beta2RollingUpdateDaemonSetConversion(t *testing.T) {
   155  	intorstr := intstr.FromInt32(1)
   156  	maxSurge := intstr.FromInt32(0)
   157  	testcases := map[string]struct {
   158  		rollingUpdateDs1 *apps.RollingUpdateDaemonSet
   159  		rollingUpdateDs2 *v1beta2.RollingUpdateDaemonSet
   160  	}{
   161  		"RollingUpdateDaemonSet Conversion 2": {
   162  			rollingUpdateDs1: &apps.RollingUpdateDaemonSet{MaxUnavailable: intorstr, MaxSurge: maxSurge},
   163  			rollingUpdateDs2: &v1beta2.RollingUpdateDaemonSet{MaxUnavailable: &intorstr, MaxSurge: &maxSurge},
   164  		},
   165  	}
   166  
   167  	for k, tc := range testcases {
   168  		// extensions -> v1beta2
   169  		internal1 := &v1beta2.RollingUpdateDaemonSet{}
   170  		if err := legacyscheme.Scheme.Convert(tc.rollingUpdateDs1, internal1, nil); err != nil {
   171  			t.Errorf("%q - %q: unexpected error: %v", k, "from extensions to v1beta2", err)
   172  		}
   173  		if !apiequality.Semantic.DeepEqual(internal1, tc.rollingUpdateDs2) {
   174  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from extensions to v1beta2", tc.rollingUpdateDs2, internal1)
   175  		}
   176  
   177  		// v1beta2 -> extensions
   178  		internal2 := &apps.RollingUpdateDaemonSet{}
   179  		if err := legacyscheme.Scheme.Convert(tc.rollingUpdateDs2, internal2, nil); err != nil {
   180  			t.Errorf("%q - %q: unexpected error: %v", k, "from v1beta2 to extensions", err)
   181  		}
   182  		if !apiequality.Semantic.DeepEqual(internal2, tc.rollingUpdateDs1) {
   183  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from v1beta2 to extensions", tc.rollingUpdateDs1, internal2)
   184  		}
   185  	}
   186  }
   187  
   188  func TestV1beta2StatefulSetStatusConversion(t *testing.T) {
   189  	observedGeneration := new(int64)
   190  	*observedGeneration = 2
   191  	collisionCount := new(int32)
   192  	*collisionCount = 1
   193  	testcases := map[string]struct {
   194  		stsStatus1 *apps.StatefulSetStatus
   195  		stsStatus2 *v1beta2.StatefulSetStatus
   196  	}{
   197  		"StatefulSetStatus Conversion 1": {
   198  			stsStatus1: &apps.StatefulSetStatus{
   199  				Replicas:           int32(3),
   200  				ReadyReplicas:      int32(1),
   201  				CurrentReplicas:    int32(3),
   202  				UpdatedReplicas:    int32(3),
   203  				CurrentRevision:    "12345",
   204  				UpdateRevision:     "23456",
   205  				ObservedGeneration: observedGeneration,
   206  			},
   207  			stsStatus2: &v1beta2.StatefulSetStatus{
   208  				Replicas:           int32(3),
   209  				ReadyReplicas:      int32(1),
   210  				CurrentReplicas:    int32(3),
   211  				UpdatedReplicas:    int32(3),
   212  				CurrentRevision:    "12345",
   213  				UpdateRevision:     "23456",
   214  				ObservedGeneration: *observedGeneration,
   215  			},
   216  		},
   217  		"StatefulSetStatus Conversion 2": {
   218  			stsStatus1: &apps.StatefulSetStatus{
   219  				ObservedGeneration: observedGeneration,
   220  				Replicas:           int32(3),
   221  				ReadyReplicas:      int32(1),
   222  				CurrentReplicas:    int32(3),
   223  				UpdatedReplicas:    int32(3),
   224  				CurrentRevision:    "12345",
   225  				UpdateRevision:     "23456",
   226  				CollisionCount:     collisionCount,
   227  			},
   228  			stsStatus2: &v1beta2.StatefulSetStatus{
   229  				ObservedGeneration: *observedGeneration,
   230  				Replicas:           int32(3),
   231  				ReadyReplicas:      int32(1),
   232  				CurrentReplicas:    int32(3),
   233  				UpdatedReplicas:    int32(3),
   234  				CurrentRevision:    "12345",
   235  				UpdateRevision:     "23456",
   236  				CollisionCount:     collisionCount,
   237  			},
   238  		},
   239  	}
   240  
   241  	for k, tc := range testcases {
   242  		// apps -> v1beta2
   243  		internal1 := &v1beta2.StatefulSetStatus{}
   244  		if err := legacyscheme.Scheme.Convert(tc.stsStatus1, internal1, nil); err != nil {
   245  			t.Errorf("%q - %q: unexpected error: %v", k, "from apps to v1beta2", err)
   246  		}
   247  
   248  		if !apiequality.Semantic.DeepEqual(internal1, tc.stsStatus2) {
   249  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from apps to v1beta2", tc.stsStatus2, internal1)
   250  		}
   251  
   252  		// v1beta2 -> apps
   253  		internal2 := &apps.StatefulSetStatus{}
   254  		if err := legacyscheme.Scheme.Convert(tc.stsStatus2, internal2, nil); err != nil {
   255  			t.Errorf("%q - %q: unexpected error: %v", k, "from v1beta2 to apps", err)
   256  		}
   257  		if !apiequality.Semantic.DeepEqual(internal2, tc.stsStatus1) {
   258  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from v1beta2 to apps", tc.stsStatus1, internal2)
   259  		}
   260  	}
   261  }
   262  
   263  func TestV1beta2DeploymentConversion(t *testing.T) {
   264  	replica := utilpointer.Int32(2)
   265  	rollbackTo := new(apps.RollbackConfig)
   266  	rollbackTo.Revision = int64(2)
   267  	testcases := map[string]struct {
   268  		deployment1 *apps.Deployment
   269  		deployment2 *v1beta2.Deployment
   270  	}{
   271  		"Deployment Conversion 1": {
   272  			deployment1: &apps.Deployment{
   273  				Spec: apps.DeploymentSpec{
   274  					Replicas:   *replica,
   275  					RollbackTo: rollbackTo,
   276  					Template: api.PodTemplateSpec{
   277  						Spec: api.PodSpec{
   278  							SecurityContext: new(api.PodSecurityContext),
   279  						},
   280  					},
   281  				},
   282  			},
   283  			deployment2: &v1beta2.Deployment{
   284  				ObjectMeta: metav1.ObjectMeta{
   285  					Annotations: map[string]string{v1beta2.DeprecatedRollbackTo: "2"},
   286  				},
   287  				Spec: v1beta2.DeploymentSpec{
   288  					Replicas: replica,
   289  					Template: v1.PodTemplateSpec{
   290  						Spec: v1.PodSpec{
   291  							SecurityContext: new(v1.PodSecurityContext),
   292  						},
   293  					},
   294  				},
   295  			},
   296  		},
   297  		"Deployment Conversion 2": {
   298  			deployment1: &apps.Deployment{
   299  				Spec: apps.DeploymentSpec{
   300  					Replicas: *replica,
   301  					Template: api.PodTemplateSpec{
   302  						Spec: api.PodSpec{
   303  							SecurityContext: new(api.PodSecurityContext),
   304  						},
   305  					},
   306  				},
   307  			},
   308  			deployment2: &v1beta2.Deployment{
   309  				Spec: v1beta2.DeploymentSpec{
   310  					Replicas: replica,
   311  					Template: v1.PodTemplateSpec{
   312  						Spec: v1.PodSpec{
   313  							SecurityContext: new(v1.PodSecurityContext),
   314  						},
   315  					},
   316  				},
   317  			},
   318  		},
   319  	}
   320  
   321  	for k, tc := range testcases {
   322  		// extensions -> v1beta2
   323  		internal1 := &v1beta2.Deployment{}
   324  		if err := legacyscheme.Scheme.Convert(tc.deployment1, internal1, nil); err != nil {
   325  			t.Errorf("%q - %q: unexpected error: %v", k, "from extensions to v1beta2", err)
   326  		}
   327  		if !apiequality.Semantic.DeepEqual(internal1, tc.deployment2) {
   328  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from extensions to v1beta2", tc.deployment2, internal1)
   329  		}
   330  
   331  		// v1beta2 -> extensions
   332  		internal2 := &apps.Deployment{}
   333  		if err := legacyscheme.Scheme.Convert(tc.deployment2, internal2, nil); err != nil {
   334  			t.Errorf("%q - %q: unexpected error: %v", k, "from v1beta2 to extensions", err)
   335  		}
   336  		if !apiequality.Semantic.DeepEqual(internal2, tc.deployment1) {
   337  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "from v1beta2 to extensions", tc.deployment1, internal2)
   338  		}
   339  	}
   340  }
   341  
   342  func TestV1beta2ScaleStatusConversion(t *testing.T) {
   343  	matchLabels := map[string]string{"foo": "bar"}
   344  	selector1 := &metav1.LabelSelector{MatchLabels: matchLabels}
   345  	labelsSelector1, _ := metav1.LabelSelectorAsSelector(selector1)
   346  
   347  	matchExpressions := []metav1.LabelSelectorRequirement{
   348  		{Key: "foo", Operator: metav1.LabelSelectorOpIn, Values: []string{"foo"}},
   349  	}
   350  	selector2 := &metav1.LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions}
   351  	labelsSelector2, _ := metav1.LabelSelectorAsSelector(selector2)
   352  
   353  	testcases := map[string]struct {
   354  		scaleStatus1 *autoscaling.ScaleStatus
   355  		scaleStatus2 *v1beta2.ScaleStatus
   356  	}{
   357  		"ScaleStatus Conversion 1": {
   358  			scaleStatus1: &autoscaling.ScaleStatus{Replicas: 2},
   359  			scaleStatus2: &v1beta2.ScaleStatus{Replicas: 2},
   360  		},
   361  		"ScaleStatus Conversion 2": {
   362  			scaleStatus1: &autoscaling.ScaleStatus{Replicas: 2, Selector: labelsSelector1.String()},
   363  			scaleStatus2: &v1beta2.ScaleStatus{Replicas: 2, Selector: matchLabels, TargetSelector: labelsSelector1.String()},
   364  		},
   365  		"ScaleStatus Conversion 3": {
   366  			scaleStatus1: &autoscaling.ScaleStatus{Replicas: 2, Selector: labelsSelector2.String()},
   367  			scaleStatus2: &v1beta2.ScaleStatus{Replicas: 2, Selector: map[string]string{}, TargetSelector: labelsSelector2.String()},
   368  		},
   369  	}
   370  
   371  	for k, tc := range testcases {
   372  		// autoscaling -> v1beta2
   373  		internal1 := &v1beta2.ScaleStatus{}
   374  		if err := legacyscheme.Scheme.Convert(tc.scaleStatus1, internal1, nil); err != nil {
   375  			t.Errorf("%q - %q: unexpected error: %v", k, "autoscaling -> v1beta2", err)
   376  		}
   377  
   378  		if !apiequality.Semantic.DeepEqual(internal1, tc.scaleStatus2) {
   379  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "autoscaling -> v1beta2", tc.scaleStatus2, internal1)
   380  		}
   381  
   382  		// v1beta2 -> autoscaling
   383  		internal2 := &autoscaling.ScaleStatus{}
   384  		if err := legacyscheme.Scheme.Convert(tc.scaleStatus2, internal2, nil); err != nil {
   385  			t.Errorf("%q - %q: unexpected error: %v", k, "v1beta2 -> autoscaling", err)
   386  		}
   387  		if !apiequality.Semantic.DeepEqual(internal2, tc.scaleStatus1) {
   388  			t.Errorf("%q - %q: expected\n\t%+v, got \n\t%+v", k, "v1beta2 -> autoscaling", tc.scaleStatus1, internal2)
   389  		}
   390  	}
   391  }
   392  
   393  func TestV1beta2DeploymentSpecConversion(t *testing.T) {
   394  	replica := utilpointer.Int32(2)
   395  	revisionHistoryLimit := utilpointer.Int32(2)
   396  	progressDeadlineSeconds := utilpointer.Int32(2)
   397  
   398  	testcases := map[string]struct {
   399  		deploymentSpec1 *apps.DeploymentSpec
   400  		deploymentSpec2 *v1beta2.DeploymentSpec
   401  	}{
   402  		"DeploymentSpec Conversion 1": {
   403  			deploymentSpec1: &apps.DeploymentSpec{
   404  				Replicas: *replica,
   405  				Template: api.PodTemplateSpec{
   406  					Spec: api.PodSpec{
   407  						SecurityContext: new(api.PodSecurityContext),
   408  					},
   409  				},
   410  			},
   411  			deploymentSpec2: &v1beta2.DeploymentSpec{
   412  				Replicas: replica,
   413  				Template: v1.PodTemplateSpec{
   414  					Spec: v1.PodSpec{
   415  						SecurityContext: new(v1.PodSecurityContext),
   416  					},
   417  				},
   418  			},
   419  		},
   420  		"DeploymentSpec Conversion 2": {
   421  			deploymentSpec1: &apps.DeploymentSpec{
   422  				Replicas:             *replica,
   423  				RevisionHistoryLimit: revisionHistoryLimit,
   424  				MinReadySeconds:      2,
   425  				Paused:               true,
   426  				Template: api.PodTemplateSpec{
   427  					Spec: api.PodSpec{
   428  						SecurityContext: new(api.PodSecurityContext),
   429  					},
   430  				},
   431  			},
   432  			deploymentSpec2: &v1beta2.DeploymentSpec{
   433  				Replicas:             replica,
   434  				RevisionHistoryLimit: revisionHistoryLimit,
   435  				MinReadySeconds:      2,
   436  				Paused:               true,
   437  				Template: v1.PodTemplateSpec{
   438  					Spec: v1.PodSpec{
   439  						SecurityContext: new(v1.PodSecurityContext),
   440  					},
   441  				},
   442  			},
   443  		},
   444  		"DeploymentSpec Conversion 3": {
   445  			deploymentSpec1: &apps.DeploymentSpec{
   446  				Replicas:                *replica,
   447  				ProgressDeadlineSeconds: progressDeadlineSeconds,
   448  				Template: api.PodTemplateSpec{
   449  					Spec: api.PodSpec{
   450  						SecurityContext: new(api.PodSecurityContext),
   451  					},
   452  				},
   453  			},
   454  			deploymentSpec2: &v1beta2.DeploymentSpec{
   455  				Replicas:                replica,
   456  				ProgressDeadlineSeconds: progressDeadlineSeconds,
   457  				Template: v1.PodTemplateSpec{
   458  					Spec: v1.PodSpec{
   459  						SecurityContext: new(v1.PodSecurityContext),
   460  					},
   461  				},
   462  			},
   463  		},
   464  	}
   465  
   466  	// extensions -> v1beta2
   467  	for k, tc := range testcases {
   468  		internal := &v1beta2.DeploymentSpec{}
   469  		if err := legacyscheme.Scheme.Convert(tc.deploymentSpec1, internal, nil); err != nil {
   470  			t.Errorf("%q - %q: unexpected error: %v", "extensions -> v1beta2", k, err)
   471  		}
   472  
   473  		if !apiequality.Semantic.DeepEqual(internal, tc.deploymentSpec2) {
   474  			t.Errorf("%q - %q: expected\n\t%+v, got \n\t%+v", "extensions -> v1beta2", k, tc.deploymentSpec2, internal)
   475  		}
   476  	}
   477  
   478  	// v1beta2 -> extensions
   479  	for k, tc := range testcases {
   480  		internal := &apps.DeploymentSpec{}
   481  		if err := legacyscheme.Scheme.Convert(tc.deploymentSpec2, internal, nil); err != nil {
   482  			t.Errorf("%q - %q: unexpected error: %v", "v1beta2 -> extensions", k, err)
   483  		}
   484  		if !apiequality.Semantic.DeepEqual(internal, tc.deploymentSpec1) {
   485  			t.Errorf("%q - %q: expected\n\t%+v, got \n\t%+v", "v1beta2 -> extensions", k, tc.deploymentSpec1, internal)
   486  		}
   487  	}
   488  
   489  }
   490  
   491  func TestV1beta2DeploymentStrategyConversion(t *testing.T) {
   492  	maxUnavailable := intstr.FromInt32(2)
   493  	maxSurge := intstr.FromInt32(2)
   494  	extensionsRollingUpdate := apps.RollingUpdateDeployment{MaxUnavailable: maxUnavailable, MaxSurge: maxSurge}
   495  	v1beta2RollingUpdate := v1beta2.RollingUpdateDeployment{MaxUnavailable: &maxUnavailable, MaxSurge: &maxSurge}
   496  	testcases := map[string]struct {
   497  		deploymentStrategy1 *apps.DeploymentStrategy
   498  		deploymentStrategy2 *v1beta2.DeploymentStrategy
   499  	}{
   500  		"DeploymentStrategy Conversion 1": {
   501  			deploymentStrategy1: &apps.DeploymentStrategy{Type: apps.DeploymentStrategyType("foo")},
   502  			deploymentStrategy2: &v1beta2.DeploymentStrategy{Type: v1beta2.DeploymentStrategyType("foo")},
   503  		},
   504  		"DeploymentStrategy Conversion 2": {
   505  			deploymentStrategy1: &apps.DeploymentStrategy{Type: apps.DeploymentStrategyType("foo"), RollingUpdate: &extensionsRollingUpdate},
   506  			deploymentStrategy2: &v1beta2.DeploymentStrategy{Type: v1beta2.DeploymentStrategyType("foo"), RollingUpdate: &v1beta2RollingUpdate},
   507  		},
   508  	}
   509  
   510  	for k, tc := range testcases {
   511  		// extensions -> v1beta2
   512  		internal1 := &v1beta2.DeploymentStrategy{}
   513  		if err := legacyscheme.Scheme.Convert(tc.deploymentStrategy1, internal1, nil); err != nil {
   514  			t.Errorf("%q - %q: unexpected error: %v", k, "extensions -> v1beta2", err)
   515  		}
   516  		if !apiequality.Semantic.DeepEqual(internal1, tc.deploymentStrategy2) {
   517  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "extensions -> v1beta2", tc.deploymentStrategy2, internal1)
   518  		}
   519  
   520  		// v1beta2 -> extensions
   521  		internal2 := &apps.DeploymentStrategy{}
   522  		if err := legacyscheme.Scheme.Convert(tc.deploymentStrategy2, internal2, nil); err != nil {
   523  			t.Errorf("%q - %q: unexpected error: %v", k, "v1beta2 -> extensions", err)
   524  		}
   525  		if !apiequality.Semantic.DeepEqual(internal2, tc.deploymentStrategy1) {
   526  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "v1beta2 -> extensions", tc.deploymentStrategy1, internal2)
   527  		}
   528  	}
   529  }
   530  
   531  func TestV1beta2RollingUpdateDeploymentConversion(t *testing.T) {
   532  	nilIntStr := intstr.IntOrString{}
   533  	maxUnavailable := intstr.FromInt32(2)
   534  	maxSurge := intstr.FromInt32(2)
   535  	testcases := map[string]struct {
   536  		rollingUpdateDeployment1 *apps.RollingUpdateDeployment
   537  		rollingUpdateDeployment2 *v1beta2.RollingUpdateDeployment
   538  	}{
   539  		"RollingUpdateDeployment Conversion 1": {
   540  			rollingUpdateDeployment1: &apps.RollingUpdateDeployment{},
   541  			rollingUpdateDeployment2: &v1beta2.RollingUpdateDeployment{MaxUnavailable: &nilIntStr, MaxSurge: &nilIntStr},
   542  		},
   543  		"RollingUpdateDeployment Conversion 2": {
   544  			rollingUpdateDeployment1: &apps.RollingUpdateDeployment{MaxUnavailable: maxUnavailable},
   545  			rollingUpdateDeployment2: &v1beta2.RollingUpdateDeployment{MaxUnavailable: &maxUnavailable, MaxSurge: &nilIntStr},
   546  		},
   547  		"RollingUpdateDeployment Conversion 3": {
   548  			rollingUpdateDeployment1: &apps.RollingUpdateDeployment{MaxSurge: maxSurge},
   549  			rollingUpdateDeployment2: &v1beta2.RollingUpdateDeployment{MaxSurge: &maxSurge, MaxUnavailable: &nilIntStr},
   550  		},
   551  		"RollingUpdateDeployment Conversion 4": {
   552  			rollingUpdateDeployment1: &apps.RollingUpdateDeployment{MaxUnavailable: maxUnavailable, MaxSurge: maxSurge},
   553  			rollingUpdateDeployment2: &v1beta2.RollingUpdateDeployment{MaxUnavailable: &maxUnavailable, MaxSurge: &maxSurge},
   554  		},
   555  	}
   556  
   557  	for k, tc := range testcases {
   558  		// extensions -> v1beta2
   559  		internal1 := &v1beta2.RollingUpdateDeployment{}
   560  		if err := legacyscheme.Scheme.Convert(tc.rollingUpdateDeployment1, internal1, nil); err != nil {
   561  			t.Errorf("%q - %q: unexpected error: %v", k, "extensions -> v1beta2", err)
   562  		}
   563  		if !apiequality.Semantic.DeepEqual(internal1, tc.rollingUpdateDeployment2) {
   564  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "extensions -> v1beta2", tc.rollingUpdateDeployment2, internal1)
   565  		}
   566  
   567  		// v1beta2 -> extensions
   568  		internal2 := &apps.RollingUpdateDeployment{}
   569  		if err := legacyscheme.Scheme.Convert(tc.rollingUpdateDeployment2, internal2, nil); err != nil {
   570  			t.Errorf("%q - %q: unexpected error: %v", k, "v1beta2 -> extensions", err)
   571  		}
   572  		if !apiequality.Semantic.DeepEqual(internal2, tc.rollingUpdateDeployment1) {
   573  			t.Errorf("%q - %q: expected\n\t%#v, got \n\t%#v", k, "v1beta2 -> extensions", tc.rollingUpdateDeployment1, internal2)
   574  		}
   575  	}
   576  }
   577  
   578  func TestV1beta2ReplicaSetSpecConversion(t *testing.T) {
   579  	replicas := new(int32)
   580  	*replicas = 2
   581  	matchExpressions := []metav1.LabelSelectorRequirement{
   582  		{Key: "foo", Operator: metav1.LabelSelectorOpIn, Values: []string{"foo"}},
   583  	}
   584  	matchLabels := map[string]string{"foo": "bar"}
   585  	selector := &metav1.LabelSelector{MatchLabels: matchLabels, MatchExpressions: matchExpressions}
   586  
   587  	testcases := map[string]struct {
   588  		replicaset1 *apps.ReplicaSetSpec
   589  		replicaset2 *v1beta2.ReplicaSetSpec
   590  	}{
   591  		"ReplicaSetSpec Conversion 1": {
   592  			replicaset1: &apps.ReplicaSetSpec{
   593  				Replicas:        *replicas,
   594  				MinReadySeconds: 2,
   595  				Template: api.PodTemplateSpec{
   596  					Spec: api.PodSpec{
   597  						SecurityContext: new(api.PodSecurityContext),
   598  					},
   599  				},
   600  			},
   601  			replicaset2: &v1beta2.ReplicaSetSpec{
   602  				Replicas:        replicas,
   603  				MinReadySeconds: 2,
   604  				Template: v1.PodTemplateSpec{
   605  					Spec: v1.PodSpec{
   606  						SecurityContext: new(v1.PodSecurityContext),
   607  					},
   608  				},
   609  			},
   610  		},
   611  		"ReplicaSetSpec Conversion 2": {
   612  			replicaset1: &apps.ReplicaSetSpec{
   613  				Replicas: *replicas,
   614  				Selector: selector,
   615  				Template: api.PodTemplateSpec{
   616  					Spec: api.PodSpec{
   617  						SecurityContext: new(api.PodSecurityContext),
   618  					},
   619  				},
   620  			},
   621  			replicaset2: &v1beta2.ReplicaSetSpec{
   622  				Replicas: replicas,
   623  				Selector: selector,
   624  				Template: v1.PodTemplateSpec{
   625  					Spec: v1.PodSpec{
   626  						SecurityContext: new(v1.PodSecurityContext),
   627  					},
   628  				},
   629  			},
   630  		},
   631  	}
   632  
   633  	for k, tc := range testcases {
   634  		// extensions -> v1beta2
   635  		internal1 := &v1beta2.ReplicaSetSpec{}
   636  		if err := legacyscheme.Scheme.Convert(tc.replicaset1, internal1, nil); err != nil {
   637  			t.Errorf("%q - %q: unexpected error: %v", k, "extensions -> v1beta2", err)
   638  		}
   639  
   640  		if !apiequality.Semantic.DeepEqual(internal1, tc.replicaset2) {
   641  			t.Errorf("%q - %q: expected\n\t%+v, got \n\t%+v", k, "extensions -> v1beta2", tc.replicaset2, internal1)
   642  		}
   643  
   644  		// v1beta2 -> extensions
   645  		internal2 := &apps.ReplicaSetSpec{}
   646  		if err := legacyscheme.Scheme.Convert(tc.replicaset2, internal2, nil); err != nil {
   647  			t.Errorf("%q - %q: unexpected error: %v", k, "v1beta2 -> extensions", err)
   648  		}
   649  		if !apiequality.Semantic.DeepEqual(internal2, tc.replicaset1) {
   650  			t.Errorf("%q - %q: expected\n\t%+v, got \n\t%+v", k, "v1beta2 -> extensions", tc.replicaset1, internal2)
   651  		}
   652  	}
   653  }
   654
View as plain text