mapbasedselectorforobject_test.go

Documentation: k8s.io/kubectl/pkg/polymorphichelpers

     1  /*
     2  Copyright 2018 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 polymorphichelpers
    18  
    19  import (
    20  	"testing"
    21  
    22  	appsv1 "k8s.io/api/apps/v1"
    23  	appsv1beta1 "k8s.io/api/apps/v1beta1"
    24  	appsv1beta2 "k8s.io/api/apps/v1beta2"
    25  	corev1 "k8s.io/api/core/v1"
    26  	extensionsv1beta1 "k8s.io/api/extensions/v1beta1"
    27  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    28  	"k8s.io/apimachinery/pkg/runtime"
    29  )
    30  
    31  func TestMapBasedSelectorForObject(t *testing.T) {
    32  	tests := []struct {
    33  		object         runtime.Object
    34  		expectSelector string
    35  		expectErr      bool
    36  	}{
    37  		{
    38  			object: &corev1.ReplicationController{
    39  				Spec: corev1.ReplicationControllerSpec{
    40  					Selector: map[string]string{
    41  						"foo": "bar",
    42  					},
    43  				},
    44  			},
    45  			expectSelector: "foo=bar",
    46  		},
    47  		{
    48  			object:    &corev1.Pod{},
    49  			expectErr: true,
    50  		},
    51  		{
    52  			object: &corev1.Pod{
    53  				ObjectMeta: metav1.ObjectMeta{
    54  					Labels: map[string]string{
    55  						"foo": "bar",
    56  					},
    57  				},
    58  			},
    59  			expectSelector: "foo=bar",
    60  		},
    61  		{
    62  			object: &corev1.Service{
    63  				Spec: corev1.ServiceSpec{
    64  					Selector: map[string]string{
    65  						"foo": "bar",
    66  					},
    67  				},
    68  			},
    69  			expectSelector: "foo=bar",
    70  		},
    71  		{
    72  			object:    &corev1.Service{},
    73  			expectErr: true,
    74  		},
    75  		// extensions/v1beta1 Deployment with labels and selectors
    76  		{
    77  			object: &extensionsv1beta1.Deployment{
    78  				Spec: extensionsv1beta1.DeploymentSpec{
    79  					Selector: &metav1.LabelSelector{
    80  						MatchLabels: map[string]string{
    81  							"foo": "bar",
    82  						},
    83  					},
    84  					Template: corev1.PodTemplateSpec{
    85  						ObjectMeta: metav1.ObjectMeta{
    86  							Labels: map[string]string{
    87  								"foo": "bar",
    88  							},
    89  						},
    90  					},
    91  				},
    92  			},
    93  			expectSelector: "foo=bar",
    94  		},
    95  		// extensions/v1beta1 Deployment with only labels (no selectors) -- use labels
    96  		{
    97  			object: &extensionsv1beta1.Deployment{
    98  				Spec: extensionsv1beta1.DeploymentSpec{
    99  					Template: corev1.PodTemplateSpec{
   100  						ObjectMeta: metav1.ObjectMeta{
   101  							Labels: map[string]string{
   102  								"foo": "bar",
   103  							},
   104  						},
   105  					},
   106  				},
   107  			},
   108  			expectSelector: "foo=bar",
   109  		},
   110  		// extensions/v1beta1 Deployment with bad selector
   111  		{
   112  			object: &extensionsv1beta1.Deployment{
   113  				Spec: extensionsv1beta1.DeploymentSpec{
   114  					Selector: &metav1.LabelSelector{
   115  						MatchExpressions: []metav1.LabelSelectorRequirement{
   116  							{
   117  								Key: "foo",
   118  							},
   119  						},
   120  					},
   121  				},
   122  			},
   123  			expectErr: true,
   124  		},
   125  		// apps/v1 Deployment with labels and selectors
   126  		{
   127  			object: &appsv1.Deployment{
   128  				Spec: appsv1.DeploymentSpec{
   129  					Template: corev1.PodTemplateSpec{
   130  						ObjectMeta: metav1.ObjectMeta{
   131  							Labels: map[string]string{
   132  								"foo": "bar",
   133  							},
   134  						},
   135  					},
   136  					Selector: &metav1.LabelSelector{
   137  						MatchLabels: map[string]string{
   138  							"foo": "bar",
   139  						},
   140  					},
   141  				},
   142  			},
   143  			expectSelector: "foo=bar",
   144  		},
   145  		// apps/v1 Deployment with only labels (no selectors) -- error
   146  		{
   147  			object: &appsv1.Deployment{
   148  				Spec: appsv1.DeploymentSpec{
   149  					Template: corev1.PodTemplateSpec{
   150  						ObjectMeta: metav1.ObjectMeta{
   151  							Labels: map[string]string{
   152  								"foo": "bar",
   153  							},
   154  						},
   155  					},
   156  				},
   157  			},
   158  			expectErr: true,
   159  		},
   160  		// apps/v1 Deployment with no labels or selectors -- error
   161  		{
   162  			object: &appsv1.Deployment{
   163  				Spec: appsv1.DeploymentSpec{},
   164  			},
   165  			expectErr: true,
   166  		},
   167  		// apps/v1 Deployment with empty labels -- error
   168  		{
   169  			object: &appsv1.Deployment{
   170  				Spec: appsv1.DeploymentSpec{
   171  					Template: corev1.PodTemplateSpec{
   172  						ObjectMeta: metav1.ObjectMeta{
   173  							Labels: map[string]string{}, // Empty labels map
   174  						},
   175  					},
   176  				},
   177  			},
   178  			expectErr: true,
   179  		},
   180  		// apps/v1beta2 Deployment with labels and selectors
   181  		{
   182  			object: &appsv1beta2.Deployment{
   183  				Spec: appsv1beta2.DeploymentSpec{
   184  					Template: corev1.PodTemplateSpec{
   185  						ObjectMeta: metav1.ObjectMeta{
   186  							Labels: map[string]string{
   187  								"foo": "bar",
   188  							},
   189  						},
   190  					},
   191  					Selector: &metav1.LabelSelector{
   192  						MatchLabels: map[string]string{
   193  							"foo": "bar",
   194  						},
   195  					},
   196  				},
   197  			},
   198  			expectSelector: "foo=bar",
   199  		},
   200  		// apps/v1beta2 Deployment with only labels (no selectors) -- error
   201  		{
   202  			object: &appsv1beta2.Deployment{
   203  				Spec: appsv1beta2.DeploymentSpec{
   204  					Template: corev1.PodTemplateSpec{
   205  						ObjectMeta: metav1.ObjectMeta{
   206  							Labels: map[string]string{
   207  								"foo": "bar",
   208  							},
   209  						},
   210  					},
   211  				},
   212  			},
   213  			expectErr: true,
   214  		},
   215  		// apps/v1beta2 Deployment with no labels or selectors -- error
   216  		{
   217  			object: &appsv1beta2.Deployment{
   218  				Spec: appsv1beta2.DeploymentSpec{},
   219  			},
   220  			expectErr: true,
   221  		},
   222  		// apps/v1beta1 Deployment with labels and selectors
   223  		{
   224  			object: &appsv1beta1.Deployment{
   225  				Spec: appsv1beta1.DeploymentSpec{
   226  					Template: corev1.PodTemplateSpec{
   227  						ObjectMeta: metav1.ObjectMeta{
   228  							Labels: map[string]string{
   229  								"foo": "bar",
   230  							},
   231  						},
   232  					},
   233  					Selector: &metav1.LabelSelector{
   234  						MatchLabels: map[string]string{
   235  							"foo": "bar",
   236  						},
   237  					},
   238  				},
   239  			},
   240  			expectSelector: "foo=bar",
   241  		},
   242  		// apps/v1beta1 Deployment with only labels (no selectors) -- error
   243  		{
   244  			object: &appsv1beta1.Deployment{
   245  				Spec: appsv1beta1.DeploymentSpec{
   246  					Template: corev1.PodTemplateSpec{
   247  						ObjectMeta: metav1.ObjectMeta{
   248  							Labels: map[string]string{
   249  								"foo": "bar",
   250  							},
   251  						},
   252  					},
   253  				},
   254  			},
   255  			expectErr: true,
   256  		},
   257  		// apps/v1beta1 Deployment with no labels or selectors -- error
   258  		{
   259  			object: &appsv1beta1.Deployment{
   260  				Spec: appsv1beta1.DeploymentSpec{},
   261  			},
   262  			expectErr: true,
   263  		},
   264  		// extensions/v1beta1 ReplicaSet with labels and selectors
   265  		{
   266  			object: &extensionsv1beta1.ReplicaSet{
   267  				Spec: extensionsv1beta1.ReplicaSetSpec{
   268  					Template: corev1.PodTemplateSpec{
   269  						ObjectMeta: metav1.ObjectMeta{
   270  							Labels: map[string]string{
   271  								"foo": "bar",
   272  							},
   273  						},
   274  					},
   275  					Selector: &metav1.LabelSelector{
   276  						MatchLabels: map[string]string{
   277  							"foo": "bar",
   278  						},
   279  					},
   280  				},
   281  			},
   282  			expectSelector: "foo=bar",
   283  		},
   284  		// extensions/v1beta1 ReplicaSet with only labels -- no selectors; use labels
   285  		{
   286  			object: &extensionsv1beta1.ReplicaSet{
   287  				Spec: extensionsv1beta1.ReplicaSetSpec{
   288  					Template: corev1.PodTemplateSpec{
   289  						ObjectMeta: metav1.ObjectMeta{
   290  							Labels: map[string]string{
   291  								"foo": "bar",
   292  							},
   293  						},
   294  					},
   295  				},
   296  			},
   297  			expectSelector: "foo=bar",
   298  		},
   299  		// extensions/v1beta1 ReplicaSet with bad label selector -- error
   300  		{
   301  			object: &extensionsv1beta1.ReplicaSet{
   302  				Spec: extensionsv1beta1.ReplicaSetSpec{
   303  					Selector: &metav1.LabelSelector{
   304  						MatchExpressions: []metav1.LabelSelectorRequirement{
   305  							{
   306  								Key: "foo",
   307  							},
   308  						},
   309  					},
   310  				},
   311  			},
   312  			expectErr: true,
   313  		},
   314  		// apps/v1 ReplicaSet with labels and selectors
   315  		{
   316  			object: &appsv1.ReplicaSet{
   317  				Spec: appsv1.ReplicaSetSpec{
   318  					Template: corev1.PodTemplateSpec{
   319  						ObjectMeta: metav1.ObjectMeta{
   320  							Labels: map[string]string{
   321  								"foo": "bar",
   322  							},
   323  						},
   324  					},
   325  					Selector: &metav1.LabelSelector{
   326  						MatchLabels: map[string]string{
   327  							"foo": "bar",
   328  						},
   329  					},
   330  				},
   331  			},
   332  			expectSelector: "foo=bar",
   333  		},
   334  		// apps/v1 ReplicaSet with only labels (no selectors) -- error
   335  		{
   336  			object: &appsv1.ReplicaSet{
   337  				Spec: appsv1.ReplicaSetSpec{
   338  					Template: corev1.PodTemplateSpec{
   339  						ObjectMeta: metav1.ObjectMeta{
   340  							Labels: map[string]string{
   341  								"foo": "bar",
   342  							},
   343  						},
   344  					},
   345  				},
   346  			},
   347  			expectErr: true,
   348  		},
   349  		// apps/v1beta2 ReplicaSet with labels and selectors
   350  		{
   351  			object: &appsv1beta2.ReplicaSet{
   352  				Spec: appsv1beta2.ReplicaSetSpec{
   353  					Template: corev1.PodTemplateSpec{
   354  						ObjectMeta: metav1.ObjectMeta{
   355  							Labels: map[string]string{
   356  								"foo": "bar",
   357  							},
   358  						},
   359  					},
   360  					Selector: &metav1.LabelSelector{
   361  						MatchLabels: map[string]string{
   362  							"foo": "bar",
   363  						},
   364  					},
   365  				},
   366  			},
   367  			expectSelector: "foo=bar",
   368  		},
   369  		// apps/v1beta2 ReplicaSet with only labels (no selectors) -- error
   370  		{
   371  			object: &appsv1beta2.ReplicaSet{
   372  				Spec: appsv1beta2.ReplicaSetSpec{
   373  					Template: corev1.PodTemplateSpec{
   374  						ObjectMeta: metav1.ObjectMeta{
   375  							Labels: map[string]string{
   376  								"foo": "bar",
   377  							},
   378  						},
   379  					},
   380  				},
   381  			},
   382  			expectErr: true,
   383  		},
   384  		// Node can not be exposed -- error
   385  		{
   386  			object: &appsv1.Deployment{
   387  				Spec: appsv1.DeploymentSpec{
   388  					Selector: &metav1.LabelSelector{
   389  						MatchLabels: map[string]string{
   390  							"foo": "bar",
   391  						},
   392  					},
   393  				},
   394  			},
   395  			expectSelector: "foo=bar",
   396  		},
   397  		{
   398  			object: &appsv1.Deployment{
   399  				Spec: appsv1.DeploymentSpec{
   400  					Selector: &metav1.LabelSelector{
   401  						MatchExpressions: []metav1.LabelSelectorRequirement{
   402  							{
   403  								Key: "foo",
   404  							},
   405  						},
   406  					},
   407  				},
   408  			},
   409  			expectErr: true,
   410  		},
   411  		{
   412  			object: &appsv1.ReplicaSet{
   413  				Spec: appsv1.ReplicaSetSpec{
   414  					Selector: &metav1.LabelSelector{
   415  						MatchLabels: map[string]string{
   416  							"foo": "bar",
   417  						},
   418  					},
   419  				},
   420  			},
   421  			expectSelector: "foo=bar",
   422  		},
   423  		{
   424  			object: &appsv1.ReplicaSet{
   425  				Spec: appsv1.ReplicaSetSpec{
   426  					Selector: &metav1.LabelSelector{
   427  						MatchExpressions: []metav1.LabelSelectorRequirement{
   428  							{
   429  								Key: "foo",
   430  							},
   431  						},
   432  					},
   433  				},
   434  			},
   435  			expectErr: true,
   436  		},
   437  
   438  		{
   439  			object: &appsv1.Deployment{
   440  				Spec: appsv1.DeploymentSpec{
   441  					Selector: nil,
   442  				},
   443  			},
   444  			expectErr: true,
   445  		},
   446  		{
   447  			object: &appsv1.Deployment{
   448  				Spec: appsv1.DeploymentSpec{
   449  					Selector: nil,
   450  				},
   451  			},
   452  			expectErr: true,
   453  		},
   454  		{
   455  			object: &appsv1.ReplicaSet{
   456  				Spec: appsv1.ReplicaSetSpec{
   457  					Selector: nil,
   458  				},
   459  			},
   460  			expectErr: true,
   461  		},
   462  		{
   463  			object: &appsv1.ReplicaSet{
   464  				Spec: appsv1.ReplicaSetSpec{
   465  					Selector: nil,
   466  				},
   467  			},
   468  			expectErr: true,
   469  		},
   470  
   471  		{
   472  			object:    &corev1.Node{},
   473  			expectErr: true,
   474  		},
   475  	}
   476  
   477  	for _, test := range tests {
   478  		actual, err := mapBasedSelectorForObject(test.object)
   479  		if test.expectErr && err == nil {
   480  			t.Error("unexpected non-error")
   481  		}
   482  		if !test.expectErr && err != nil {
   483  			t.Errorf("unexpected error: %v", err)
   484  		}
   485  		if actual != test.expectSelector {
   486  			t.Errorf("expected selector %q, but got %q", test.expectSelector, actual)
   487  		}
   488  	}
   489  }
   490
View as plain text