github.com/cilium/cilium@v1.16.2/pkg/k8s/utils/workload_test.go (about)

     1  // SPDX-License-Identifier: Apache-2.0
     2  // Copyright Authors of Cilium
     3  
     4  // Copyright Istio Authors
     5  // Copyright Authors of Hubble
     6  
     7  // Tests come from
     8  // https://github.com/istio/istio/blob/1aca7a67afd7b3e1d24fafb2fbfbeaf1e41534c0/pkg/kube/util_test.go
     9  // and have been modified to work with our version of GetWorkloadMetaFromPod.
    10  
    11  package utils
    12  
    13  import (
    14  	"reflect"
    15  	"testing"
    16  
    17  	slim_corev1 "github.com/cilium/cilium/pkg/k8s/slim/k8s/api/core/v1"
    18  	slim_metav1 "github.com/cilium/cilium/pkg/k8s/slim/k8s/apis/meta/v1"
    19  )
    20  
    21  func TestDeploymentMetadata(t *testing.T) {
    22  	controller := true
    23  	tests := []struct {
    24  		name               string
    25  		pod                *slim_corev1.Pod
    26  		wantTypeMetadata   slim_metav1.TypeMeta
    27  		wantObjectMetadata slim_metav1.ObjectMeta
    28  		expectOK           bool
    29  	}{
    30  		{
    31  			name: "deployment-name-deploy",
    32  			pod:  podForDeployment("deploy", "12345"),
    33  			wantTypeMetadata: slim_metav1.TypeMeta{
    34  				Kind: "Deployment",
    35  			},
    36  			wantObjectMetadata: slim_metav1.ObjectMeta{
    37  				Name:         "deploy",
    38  				GenerateName: "deploy-12345-",
    39  				Labels: map[string]string{
    40  					"pod-template-hash": "12345",
    41  				},
    42  			},
    43  			expectOK: true,
    44  		},
    45  		{
    46  			name: "deployment-name-deploy2",
    47  			pod:  podForDeployment("deploy2", "45678"),
    48  			wantTypeMetadata: slim_metav1.TypeMeta{
    49  				Kind: "Deployment",
    50  			},
    51  			wantObjectMetadata: slim_metav1.ObjectMeta{
    52  				Name:         "deploy2",
    53  				GenerateName: "deploy2-45678-",
    54  				Labels: map[string]string{
    55  					"pod-template-hash": "45678",
    56  				},
    57  			},
    58  			expectOK: true,
    59  		},
    60  		{
    61  			name: "non-deployment",
    62  			pod: &slim_corev1.Pod{
    63  				ObjectMeta: slim_metav1.ObjectMeta{
    64  					Name:         "replicaset0-abcd0",
    65  					GenerateName: "replicaset0-",
    66  					OwnerReferences: []slim_metav1.OwnerReference{{
    67  						Controller: &controller,
    68  						Kind:       "ReplicaSet",
    69  						Name:       "replicaset0",
    70  					}},
    71  				},
    72  			},
    73  			wantTypeMetadata: slim_metav1.TypeMeta{
    74  				Kind: "ReplicaSet",
    75  			},
    76  			wantObjectMetadata: slim_metav1.ObjectMeta{
    77  				Name:         "replicaset0",
    78  				GenerateName: "replicaset0-",
    79  			},
    80  			expectOK: true,
    81  		},
    82  		{
    83  			name: "bare-pod",
    84  			pod: &slim_corev1.Pod{
    85  				ObjectMeta: slim_metav1.ObjectMeta{
    86  					Name: "some-pod",
    87  				},
    88  			},
    89  			expectOK: false,
    90  		},
    91  	}
    92  
    93  	for _, tt := range tests {
    94  		t.Run(tt.name, func(t *testing.T) {
    95  			gotObjectMeta, gotTypeMeta, ok := GetWorkloadMetaFromPod(tt.pod)
    96  			if tt.expectOK != ok {
    97  				t.Fatalf("expected ok=%t, got ok=%t", tt.expectOK, ok)
    98  			}
    99  			if ok {
   100  				if !reflect.DeepEqual(gotObjectMeta, tt.wantObjectMetadata) {
   101  					t.Errorf("Object metadata got %+v want %+v", gotObjectMeta, tt.wantObjectMetadata)
   102  				}
   103  				if !reflect.DeepEqual(gotTypeMeta, tt.wantTypeMetadata) {
   104  					t.Errorf("Type metadata got %+v want %+v", gotTypeMeta, tt.wantTypeMetadata)
   105  				}
   106  			}
   107  		})
   108  	}
   109  }
   110  
   111  func podForDeployment(deploymentName string, hash string) *slim_corev1.Pod {
   112  	controller := true
   113  	labels := make(map[string]string)
   114  	if hash != "" {
   115  		labels["pod-template-hash"] = hash
   116  	}
   117  	return &slim_corev1.Pod{
   118  		ObjectMeta: slim_metav1.ObjectMeta{
   119  			Name:         deploymentName + "-" + hash + "-" + "asdf0",
   120  			GenerateName: deploymentName + "-" + hash + "-",
   121  			OwnerReferences: []slim_metav1.OwnerReference{{
   122  				Controller: &controller,
   123  				Kind:       "ReplicaSet",
   124  				Name:       deploymentName + "-" + hash,
   125  			}},
   126  			Labels: labels,
   127  		},
   128  	}
   129  }
   130  
   131  func TestCronJobMetadata(t *testing.T) {
   132  	tests := []struct {
   133  		name               string
   134  		jobName            string
   135  		wantTypeMetadata   slim_metav1.TypeMeta
   136  		wantObjectMetadata slim_metav1.ObjectMeta
   137  	}{
   138  		{
   139  			name:    "cron-job-name-sec",
   140  			jobName: "sec-1234567890",
   141  			wantTypeMetadata: slim_metav1.TypeMeta{
   142  				Kind: "CronJob",
   143  			},
   144  			wantObjectMetadata: slim_metav1.ObjectMeta{
   145  				Name:         "sec",
   146  				GenerateName: "sec-1234567890-pod",
   147  			},
   148  		},
   149  		{
   150  			name:    "cron-job-name-min",
   151  			jobName: "min-12345678",
   152  			wantTypeMetadata: slim_metav1.TypeMeta{
   153  				Kind: "CronJob",
   154  			},
   155  			wantObjectMetadata: slim_metav1.ObjectMeta{
   156  				Name:         "min",
   157  				GenerateName: "min-12345678-pod",
   158  			},
   159  		},
   160  		{
   161  			name:    "non-cron-job-name",
   162  			jobName: "job-123",
   163  			wantTypeMetadata: slim_metav1.TypeMeta{
   164  				Kind: "Job",
   165  			},
   166  			wantObjectMetadata: slim_metav1.ObjectMeta{
   167  				Name:         "job-123",
   168  				GenerateName: "job-123-pod",
   169  			},
   170  		},
   171  	}
   172  
   173  	for _, tt := range tests {
   174  		controller := true
   175  		t.Run(tt.name, func(t *testing.T) {
   176  			gotObjectMeta, gotTypeMeta, ok := GetWorkloadMetaFromPod(
   177  				&slim_corev1.Pod{
   178  					ObjectMeta: slim_metav1.ObjectMeta{
   179  						GenerateName: tt.jobName + "-pod",
   180  						OwnerReferences: []slim_metav1.OwnerReference{{
   181  							Controller: &controller,
   182  							Kind:       "Job",
   183  							Name:       tt.jobName,
   184  						}},
   185  					},
   186  				},
   187  			)
   188  			if !ok {
   189  				t.Fatalf("expected ok=true, got ok=%t", ok)
   190  			}
   191  			if ok {
   192  				if !reflect.DeepEqual(gotObjectMeta, tt.wantObjectMetadata) {
   193  					t.Errorf("Object metadata got %+v want %+v", gotObjectMeta, tt.wantObjectMetadata)
   194  				}
   195  				if !reflect.DeepEqual(gotTypeMeta, tt.wantTypeMetadata) {
   196  					t.Errorf("Type metadata got %+v want %+v", gotTypeMeta, tt.wantTypeMetadata)
   197  				}
   198  			}
   199  		})
   200  	}
   201  }
   202  
   203  func TestDeploymentConfigMetadata(t *testing.T) {
   204  	tests := []struct {
   205  		name               string
   206  		pod                *slim_corev1.Pod
   207  		wantTypeMetadata   slim_metav1.TypeMeta
   208  		wantObjectMetadata slim_metav1.ObjectMeta
   209  	}{
   210  		{
   211  			name: "deployconfig-name-deploy",
   212  			pod:  podForDeploymentConfig("deploy", true),
   213  			wantTypeMetadata: slim_metav1.TypeMeta{
   214  				Kind: "DeploymentConfig",
   215  			},
   216  			wantObjectMetadata: slim_metav1.ObjectMeta{
   217  				Name:         "deploy",
   218  				GenerateName: "deploy-rc-pod",
   219  				Labels:       map[string]string{},
   220  			},
   221  		},
   222  		{
   223  			name: "deployconfig-name-deploy2",
   224  			pod:  podForDeploymentConfig("deploy2", true),
   225  			wantTypeMetadata: slim_metav1.TypeMeta{
   226  				Kind: "DeploymentConfig",
   227  			},
   228  			wantObjectMetadata: slim_metav1.ObjectMeta{
   229  				Name:         "deploy2",
   230  				GenerateName: "deploy2-rc-pod",
   231  				Labels:       map[string]string{},
   232  			},
   233  		},
   234  		{
   235  			name: "non-deployconfig-label",
   236  			pod:  podForDeploymentConfig("dep", false),
   237  			wantTypeMetadata: slim_metav1.TypeMeta{
   238  				Kind: "ReplicationController",
   239  			},
   240  			wantObjectMetadata: slim_metav1.ObjectMeta{
   241  				Name:         "dep-rc",
   242  				GenerateName: "dep-rc-pod",
   243  				Labels:       map[string]string{},
   244  			},
   245  		},
   246  	}
   247  
   248  	for _, tt := range tests {
   249  		t.Run(tt.name, func(t *testing.T) {
   250  			gotObjectMeta, gotTypeMeta, ok := GetWorkloadMetaFromPod(tt.pod)
   251  			if !ok {
   252  				t.Fatalf("expected ok=true, got ok=%t", ok)
   253  			}
   254  			if !reflect.DeepEqual(gotObjectMeta, tt.wantObjectMetadata) {
   255  				t.Errorf("Object metadata got %+v want %+v", gotObjectMeta, tt.wantObjectMetadata)
   256  			}
   257  			if !reflect.DeepEqual(gotTypeMeta, tt.wantTypeMetadata) {
   258  				t.Errorf("Type metadata got %+v want %+v", gotTypeMeta, tt.wantTypeMetadata)
   259  			}
   260  		})
   261  	}
   262  }
   263  
   264  func podForDeploymentConfig(deployConfigName string, hasDeployConfigLabel bool) *slim_corev1.Pod {
   265  	controller := true
   266  	labels := make(map[string]string)
   267  	if hasDeployConfigLabel {
   268  		labels["deploymentconfig"] = deployConfigName
   269  	}
   270  	return &slim_corev1.Pod{
   271  		ObjectMeta: slim_metav1.ObjectMeta{
   272  			GenerateName: deployConfigName + "-rc-pod",
   273  			OwnerReferences: []slim_metav1.OwnerReference{{
   274  				Controller: &controller,
   275  				Kind:       "ReplicationController",
   276  				Name:       deployConfigName + "-rc",
   277  			}},
   278  			Labels: labels,
   279  		},
   280  	}
   281  }
   282  
   283  func TestStatefulSetMetadata(t *testing.T) {
   284  	tests := []struct {
   285  		name               string
   286  		statefulsetName    string
   287  		wantTypeMetadata   slim_metav1.TypeMeta
   288  		wantObjectMetadata slim_metav1.ObjectMeta
   289  	}{
   290  		{
   291  			name:            "statefulset-name-foo",
   292  			statefulsetName: "foo",
   293  			wantTypeMetadata: slim_metav1.TypeMeta{
   294  				Kind: "StatefulSet",
   295  			},
   296  			wantObjectMetadata: slim_metav1.ObjectMeta{
   297  				Name:         "foo",
   298  				GenerateName: "foo-",
   299  			},
   300  		},
   301  	}
   302  
   303  	for _, tt := range tests {
   304  		controller := true
   305  		t.Run(tt.name, func(t *testing.T) {
   306  			gotObjectMeta, gotTypeMeta, ok := GetWorkloadMetaFromPod(
   307  				&slim_corev1.Pod{
   308  					ObjectMeta: slim_metav1.ObjectMeta{
   309  						GenerateName: tt.statefulsetName + "-",
   310  						OwnerReferences: []slim_metav1.OwnerReference{{
   311  							Controller: &controller,
   312  							Kind:       "StatefulSet",
   313  							Name:       tt.statefulsetName,
   314  						}},
   315  					},
   316  				},
   317  			)
   318  			if !ok {
   319  				t.Fatalf("expected ok=true, got ok=%t", ok)
   320  			}
   321  			if ok {
   322  				if !reflect.DeepEqual(gotObjectMeta, tt.wantObjectMetadata) {
   323  					t.Errorf("Object metadata got %+v want %+v", gotObjectMeta, tt.wantObjectMetadata)
   324  				}
   325  				if !reflect.DeepEqual(gotTypeMeta, tt.wantTypeMetadata) {
   326  					t.Errorf("Type metadata got %+v want %+v", gotTypeMeta, tt.wantTypeMetadata)
   327  				}
   328  			}
   329  		})
   330  	}
   331  }