1
16
17 package constants
18
19 import (
20 "path/filepath"
21 "testing"
22
23 "k8s.io/apimachinery/pkg/util/version"
24 apimachineryversion "k8s.io/apimachinery/pkg/version"
25 )
26
27 func TestGetStaticPodDirectory(t *testing.T) {
28 expected := filepath.FromSlash("/etc/kubernetes/manifests")
29 actual := GetStaticPodDirectory()
30
31 if actual != expected {
32 t.Errorf(
33 "failed GetStaticPodDirectory:\n\texpected: %s\n\t actual: %s",
34 expected,
35 actual,
36 )
37 }
38 }
39
40 func TestGetAdminKubeConfigPath(t *testing.T) {
41 expected := filepath.Join(KubernetesDir, AdminKubeConfigFileName)
42 actual := GetAdminKubeConfigPath()
43
44 if actual != expected {
45 t.Errorf(
46 "failed GetAdminKubeConfigPath:\n\texpected: %s\n\t actual: %s",
47 expected,
48 actual,
49 )
50 }
51 }
52
53 func TestGetSuperAdminKubeConfigPath(t *testing.T) {
54 expected := filepath.Join(KubernetesDir, SuperAdminKubeConfigFileName)
55 actual := GetSuperAdminKubeConfigPath()
56
57 if actual != expected {
58 t.Errorf(
59 "failed GetSuperAdminKubeConfigPath:\n\texpected: %s\n\t actual: %s",
60 expected,
61 actual,
62 )
63 }
64 }
65
66 func TestGetBootstrapKubeletKubeConfigPath(t *testing.T) {
67 expected := filepath.FromSlash("/etc/kubernetes/bootstrap-kubelet.conf")
68 actual := GetBootstrapKubeletKubeConfigPath()
69
70 if actual != expected {
71 t.Errorf(
72 "failed GetBootstrapKubeletKubeConfigPath:\n\texpected: %s\n\t actual: %s",
73 expected,
74 actual,
75 )
76 }
77 }
78
79 func TestGetKubeletKubeConfigPath(t *testing.T) {
80 expected := filepath.FromSlash("/etc/kubernetes/kubelet.conf")
81 actual := GetKubeletKubeConfigPath()
82
83 if actual != expected {
84 t.Errorf(
85 "failed GetKubeletKubeConfigPath:\n\texpected: %s\n\t actual: %s",
86 expected,
87 actual,
88 )
89 }
90 }
91
92 func TestGetStaticPodFilepath(t *testing.T) {
93 var tests = []struct {
94 componentName, manifestsDir, expected string
95 }{
96 {
97 componentName: "kube-apiserver",
98 manifestsDir: "/etc/kubernetes/manifests",
99 expected: "/etc/kubernetes/manifests/kube-apiserver.yaml",
100 },
101 {
102 componentName: "kube-controller-manager",
103 manifestsDir: "/etc/kubernetes/manifests/",
104 expected: "/etc/kubernetes/manifests/kube-controller-manager.yaml",
105 },
106 {
107 componentName: "foo",
108 manifestsDir: "/etc/bar/",
109 expected: "/etc/bar/foo.yaml",
110 },
111 }
112 for _, rt := range tests {
113 t.Run(rt.componentName, func(t *testing.T) {
114 actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir)
115 expected := filepath.FromSlash(rt.expected)
116 if actual != expected {
117 t.Errorf(
118 "failed GetStaticPodFilepath:\n\texpected: %s\n\t actual: %s",
119 rt.expected,
120 actual,
121 )
122 }
123 })
124 }
125 }
126
127 func TestEtcdSupportedVersion(t *testing.T) {
128 var supportedEtcdVersion = map[uint8]string{
129 13: "3.2.24",
130 14: "3.3.10",
131 15: "3.3.10",
132 16: "3.3.17-0",
133 17: "3.4.3-0",
134 18: "3.4.3-0",
135 }
136 var tests = []struct {
137 kubernetesVersion string
138 expectedVersion *version.Version
139 expectedWarning bool
140 expectedError bool
141 }{
142 {
143 kubernetesVersion: "1.x.1",
144 expectedVersion: nil,
145 expectedWarning: false,
146 expectedError: true,
147 },
148 {
149 kubernetesVersion: "1.10.1",
150 expectedVersion: version.MustParseSemantic("3.2.24"),
151 expectedWarning: true,
152 expectedError: false,
153 },
154 {
155 kubernetesVersion: "1.99.0",
156 expectedVersion: version.MustParseSemantic("3.4.3-0"),
157 expectedWarning: true,
158 expectedError: false,
159 },
160 {
161 kubernetesVersion: "v1.16.0",
162 expectedVersion: version.MustParseSemantic("3.3.17-0"),
163 expectedWarning: false,
164 expectedError: false,
165 },
166 {
167 kubernetesVersion: "1.17.2",
168 expectedVersion: version.MustParseSemantic("3.4.3-0"),
169 expectedWarning: false,
170 expectedError: false,
171 },
172 }
173 for _, rt := range tests {
174 t.Run(rt.kubernetesVersion, func(t *testing.T) {
175 actualVersion, actualWarning, actualError := EtcdSupportedVersion(supportedEtcdVersion, rt.kubernetesVersion)
176 if (actualError != nil) != rt.expectedError {
177 t.Fatalf("expected error %v, got %v", rt.expectedError, actualError != nil)
178 }
179 if (actualWarning != nil) != rt.expectedWarning {
180 t.Fatalf("expected warning %v, got %v", rt.expectedWarning, actualWarning != nil)
181 }
182 if actualError == nil && actualVersion.String() != rt.expectedVersion.String() {
183 t.Errorf("expected version %s, got %s", rt.expectedVersion.String(), actualVersion.String())
184 }
185 })
186 }
187 }
188
189 func TestGetKubernetesServiceCIDR(t *testing.T) {
190 var tests = []struct {
191 svcSubnetList string
192 isDualStack bool
193 expected string
194 expectedError bool
195 name string
196 }{
197 {
198 svcSubnetList: "192.168.10.0/24",
199 expected: "192.168.10.0/24",
200 expectedError: false,
201 name: "valid: valid IPv4 range from single-stack",
202 },
203 {
204 svcSubnetList: "fd03::/112",
205 expected: "fd03::/112",
206 expectedError: false,
207 name: "valid: valid IPv6 range from single-stack",
208 },
209 {
210 svcSubnetList: "192.168.10.0/24,fd03::/112",
211 expected: "192.168.10.0/24",
212 expectedError: false,
213 name: "valid: valid <IPv4,IPv6> ranges from dual-stack",
214 },
215 {
216 svcSubnetList: "fd03::/112,192.168.10.0/24",
217 expected: "fd03::/112",
218 expectedError: false,
219 name: "valid: valid <IPv6,IPv4> ranges from dual-stack",
220 },
221 {
222 svcSubnetList: "192.168.10.0/24,fd03:x::/112",
223 expected: "",
224 expectedError: true,
225 name: "invalid: failed to parse subnet range for dual-stack",
226 },
227 }
228
229 for _, rt := range tests {
230 t.Run(rt.name, func(t *testing.T) {
231 actual, actualError := GetKubernetesServiceCIDR(rt.svcSubnetList)
232 if rt.expectedError {
233 if actualError == nil {
234 t.Errorf("failed GetKubernetesServiceCIDR:\n\texpected error, but got no error")
235 }
236 } else if !rt.expectedError && actualError != nil {
237 t.Errorf("failed GetKubernetesServiceCIDR:\n\texpected no error, but got: %v", actualError)
238 } else {
239 if actual.String() != rt.expected {
240 t.Errorf(
241 "failed GetKubernetesServiceCIDR:\n\texpected: %s\n\t actual: %s",
242 rt.expected,
243 actual.String(),
244 )
245 }
246 }
247 })
248 }
249 }
250
251 func TestGetSkewedKubernetesVersionImpl(t *testing.T) {
252 tests := []struct {
253 name string
254 versionInfo *apimachineryversion.Info
255 n int
256 expectedResult *version.Version
257 }{
258 {
259 name: "invalid versionInfo; placeholder version is returned",
260 versionInfo: &apimachineryversion.Info{},
261 expectedResult: defaultKubernetesPlaceholderVersion,
262 },
263 {
264 name: "valid skew of -1",
265 versionInfo: &apimachineryversion.Info{Major: "1", GitVersion: "v1.23.0"},
266 n: -1,
267 expectedResult: version.MustParseSemantic("v1.22.0"),
268 },
269 {
270 name: "valid skew of 0",
271 versionInfo: &apimachineryversion.Info{Major: "1", GitVersion: "v1.23.0"},
272 n: 0,
273 expectedResult: version.MustParseSemantic("v1.23.0"),
274 },
275 {
276 name: "valid skew of +1",
277 versionInfo: &apimachineryversion.Info{Major: "1", GitVersion: "v1.23.0"},
278 n: 1,
279 expectedResult: version.MustParseSemantic("v1.24.0"),
280 },
281 }
282
283 for _, tc := range tests {
284 t.Run(tc.name, func(t *testing.T) {
285 result := getSkewedKubernetesVersionImpl(tc.versionInfo, tc.n)
286 if cmp, _ := result.Compare(tc.expectedResult.String()); cmp != 0 {
287 t.Errorf("expected result: %v, got %v", tc.expectedResult, result)
288 }
289 })
290 }
291 }
292
293 func TestGetAPIServerVirtualIP(t *testing.T) {
294 var tests = []struct {
295 name, svcSubnet, expectedIP string
296 expectedErr bool
297 }{
298 {
299 name: "subnet mask 24",
300 svcSubnet: "10.96.0.12/24",
301 expectedIP: "10.96.0.1",
302 expectedErr: false,
303 },
304 {
305 name: "subnet mask 12",
306 svcSubnet: "10.96.0.0/12",
307 expectedIP: "10.96.0.1",
308 expectedErr: false,
309 },
310 {
311 name: "subnet mask 26",
312 svcSubnet: "10.87.116.64/26",
313 expectedIP: "10.87.116.65",
314 expectedErr: false,
315 },
316 {
317 name: "dual-stack ipv4 primary, subnet mask 26",
318 svcSubnet: "10.87.116.64/26,fd03::/112",
319 expectedIP: "10.87.116.65",
320 expectedErr: false,
321 },
322 {
323 name: "dual-stack, subnet mask 26 , missing first ip segment",
324 svcSubnet: ",10.87.116.64/26",
325 expectedErr: true,
326 },
327 {
328 name: "dual-stack ipv4 primary, subnet mask 26, missing second ip segment",
329 svcSubnet: "10.87.116.64/26,",
330 expectedErr: true,
331 },
332 {
333 name: "dual-stack ipv6 primary, subnet mask 112",
334 svcSubnet: "fd03::/112,10.87.116.64/26",
335 expectedIP: "fd03::1",
336 expectedErr: false,
337 },
338 {
339 name: "dual-stack, subnet mask 26, missing first ip segment",
340 svcSubnet: ",fd03::/112",
341 expectedErr: true,
342 },
343 {
344 name: "dual-stack, subnet mask 26, missing second ip segment",
345 svcSubnet: "fd03::/112,",
346 expectedErr: true,
347 },
348 }
349 for _, rt := range tests {
350 t.Run(rt.name, func(t *testing.T) {
351 virtualIP, err := GetAPIServerVirtualIP(rt.svcSubnet)
352 if (err != nil) != rt.expectedErr {
353 t.Errorf("failed APIServerVirtualIP:\n\texpectedErr: %v, got: %v", rt.expectedErr, err)
354 } else if !rt.expectedErr {
355 if virtualIP.String() != rt.expectedIP {
356 t.Errorf(
357 "failed APIServerVirtualIP:\n\texpected: %s\n\t actual: %s",
358 rt.expectedIP,
359 virtualIP.String(),
360 )
361 }
362 }
363 })
364 }
365 }
366
367 func TestGetDNSIP(t *testing.T) {
368 tests := []struct {
369 name string
370 svcSubnetList string
371 expected string
372 expectedError bool
373 }{
374 {
375 name: "valid IPv4 range from single-stack",
376 svcSubnetList: "192.168.10.0/24",
377 expected: "192.168.10.10",
378 expectedError: false,
379 },
380 {
381 name: "valid IPv6 range from single-stack",
382 svcSubnetList: "fd03::/112",
383 expected: "fd03::a",
384 expectedError: false,
385 },
386 {
387 name: "valid <IPv4,IPv6> ranges from dual-stack",
388 svcSubnetList: "192.168.10.0/24,fd03::/112",
389 expected: "192.168.10.10",
390 expectedError: false,
391 },
392 {
393 name: "valid <IPv6,IPv4> ranges from dual-stack",
394 svcSubnetList: "fd03::/112,192.168.10.0/24",
395 expected: "fd03::a",
396 expectedError: false,
397 },
398 {
399 name: "invalid subnet range from dual-stack",
400 svcSubnetList: "192.168.10.0/24,fd03:x::/112",
401 expected: "",
402 expectedError: true,
403 },
404 }
405
406 for _, tt := range tests {
407 t.Run(tt.name, func(t *testing.T) {
408 actual, actualError := GetDNSIP(tt.svcSubnetList)
409 if tt.expectedError {
410 if actualError == nil {
411 t.Errorf("failed GetDNSIP:\n\texpected error, but got no error")
412 }
413 } else if !tt.expectedError && actualError != nil {
414 t.Errorf("failed GetDNSIP:\n\texpected no error, but got: %v", actualError)
415 } else {
416 if actual.String() != tt.expected {
417 t.Errorf(
418 "failed GetDNSIP:\n\texpected: %s\n\t actual: %s",
419 tt.expected,
420 actual.String(),
421 )
422 }
423 }
424 })
425 }
426 }
427
View as plain text