flags_test.go

Documentation: k8s.io/kubernetes/cmd/kubeadm/app/phases/kubelet

     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 kubelet
    18  
    19  import (
    20  	"os"
    21  	"reflect"
    22  	"strings"
    23  	"testing"
    24  
    25  	v1 "k8s.io/api/core/v1"
    26  
    27  	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
    28  )
    29  
    30  func TestBuildKubeletArgs(t *testing.T) {
    31  	tests := []struct {
    32  		name     string
    33  		opts     kubeletFlagsOpts
    34  		expected []kubeadmapi.Arg
    35  	}{
    36  		{
    37  			name: "hostname override",
    38  			opts: kubeletFlagsOpts{
    39  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
    40  					CRISocket: "unix:///var/run/containerd/containerd.sock",
    41  					KubeletExtraArgs: []kubeadmapi.Arg{
    42  						{Name: "hostname-override", Value: "override-name"},
    43  					},
    44  				},
    45  			},
    46  			expected: []kubeadmapi.Arg{
    47  				{Name: "container-runtime-endpoint", Value: "unix:///var/run/containerd/containerd.sock"},
    48  				{Name: "hostname-override", Value: "override-name"},
    49  			},
    50  		},
    51  		{
    52  			name: "register with taints",
    53  			opts: kubeletFlagsOpts{
    54  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
    55  					CRISocket: "unix:///var/run/containerd/containerd.sock",
    56  					Taints: []v1.Taint{
    57  						{
    58  							Key:    "foo",
    59  							Value:  "bar",
    60  							Effect: "baz",
    61  						},
    62  						{
    63  							Key:    "key",
    64  							Value:  "val",
    65  							Effect: "eff",
    66  						},
    67  					},
    68  				},
    69  				registerTaintsUsingFlags: true,
    70  			},
    71  			expected: []kubeadmapi.Arg{
    72  				{Name: "container-runtime-endpoint", Value: "unix:///var/run/containerd/containerd.sock"},
    73  				{Name: "register-with-taints", Value: "foo=bar:baz,key=val:eff"},
    74  			},
    75  		},
    76  		{
    77  			name: "pause image is set",
    78  			opts: kubeletFlagsOpts{
    79  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
    80  					CRISocket: "unix:///var/run/containerd/containerd.sock",
    81  				},
    82  				pauseImage: "registry.k8s.io/pause:3.9",
    83  			},
    84  			expected: []kubeadmapi.Arg{
    85  				{Name: "container-runtime-endpoint", Value: "unix:///var/run/containerd/containerd.sock"},
    86  				{Name: "pod-infra-container-image", Value: "registry.k8s.io/pause:3.9"},
    87  			},
    88  		},
    89  	}
    90  
    91  	for _, test := range tests {
    92  		t.Run(test.name, func(t *testing.T) {
    93  			actual := buildKubeletArgs(test.opts)
    94  			if !reflect.DeepEqual(actual, test.expected) {
    95  				t.Errorf(
    96  					"failed buildKubeletArgs:\n\texpected: %v\n\t  actual: %v",
    97  					test.expected,
    98  					actual,
    99  				)
   100  			}
   101  		})
   102  	}
   103  }
   104  
   105  func TestGetNodeNameAndHostname(t *testing.T) {
   106  	hostname, err := os.Hostname()
   107  	if err != nil {
   108  		t.Errorf("unexpected error: %v", err)
   109  	}
   110  
   111  	testCases := []struct {
   112  		name             string
   113  		opts             kubeletFlagsOpts
   114  		expectedNodeName string
   115  		expectedHostName string
   116  	}{
   117  		{
   118  			name: "overridden hostname",
   119  			opts: kubeletFlagsOpts{
   120  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
   121  					KubeletExtraArgs: []kubeadmapi.Arg{
   122  						{Name: "hostname-override", Value: "override-name"},
   123  					},
   124  				},
   125  			},
   126  			expectedNodeName: "override-name",
   127  			expectedHostName: strings.ToLower(hostname),
   128  		},
   129  		{
   130  			name: "overridden hostname uppercase",
   131  			opts: kubeletFlagsOpts{
   132  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
   133  					KubeletExtraArgs: []kubeadmapi.Arg{
   134  						{Name: "hostname-override", Value: "OVERRIDE-NAME"},
   135  					},
   136  				},
   137  			},
   138  			expectedNodeName: "OVERRIDE-NAME",
   139  			expectedHostName: strings.ToLower(hostname),
   140  		},
   141  		{
   142  			name: "hostname contains only spaces",
   143  			opts: kubeletFlagsOpts{
   144  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
   145  					KubeletExtraArgs: []kubeadmapi.Arg{
   146  						{Name: "hostname-override", Value: " "},
   147  					},
   148  				},
   149  			},
   150  			expectedNodeName: " ",
   151  			expectedHostName: strings.ToLower(hostname),
   152  		},
   153  		{
   154  			name: "empty parameter",
   155  			opts: kubeletFlagsOpts{
   156  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
   157  					KubeletExtraArgs: []kubeadmapi.Arg{
   158  						{Name: "hostname-override", Value: ""},
   159  					},
   160  				},
   161  			},
   162  			expectedNodeName: "",
   163  			expectedHostName: strings.ToLower(hostname),
   164  		},
   165  		{
   166  			name: "nil parameter",
   167  			opts: kubeletFlagsOpts{
   168  				nodeRegOpts: &kubeadmapi.NodeRegistrationOptions{
   169  					KubeletExtraArgs: nil,
   170  				},
   171  			},
   172  			expectedNodeName: strings.ToLower(hostname),
   173  			expectedHostName: strings.ToLower(hostname),
   174  		},
   175  	}
   176  
   177  	for _, tc := range testCases {
   178  		t.Run(tc.name, func(t *testing.T) {
   179  			nodeName, hostname, err := GetNodeNameAndHostname(tc.opts.nodeRegOpts)
   180  			if err != nil {
   181  				t.Errorf("unexpected error: %v", err)
   182  			}
   183  			if nodeName != tc.expectedNodeName {
   184  				t.Errorf("expected nodeName: %v, got %v", tc.expectedNodeName, nodeName)
   185  			}
   186  			if hostname != tc.expectedHostName {
   187  				t.Errorf("expected hostname: %v, got %v", tc.expectedHostName, hostname)
   188  			}
   189  		})
   190  	}
   191  }
   192
View as plain text