Debian Codegraph @

pkg/server/resourceconfig/helpers_test.go

raw
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 resourceconfig
18
19 import (
20 "reflect"
21 "testing"
22
23 "github.com/stretchr/testify/require"
24
25 appsv1 "k8s.io/api/apps/v1"
26 apiv1 "k8s.io/api/core/v1"
27 extensionsapiv1beta1 "k8s.io/api/extensions/v1beta1"
28 "k8s.io/apimachinery/pkg/runtime"
29 "k8s.io/apimachinery/pkg/runtime/schema"
30 runtimetesting "k8s.io/apimachinery/pkg/runtime/testing"
31 serverstore "k8s.io/apiserver/pkg/server/storage"
32 )
33
34 func TestParseRuntimeConfig(t *testing.T) {
35 scheme := newFakeScheme(t)
36 apiv1GroupVersion := apiv1.SchemeGroupVersion
37 testCases := []struct {
38 name string
39 runtimeConfig map[string]string
40 defaultResourceConfig func() *serverstore.ResourceConfig
41 expectedAPIConfig func() *serverstore.ResourceConfig
42 expectedEnabledAPIs map[schema.GroupVersionResource]bool
43 err bool
44 }{
45 {
46 name: "using-kind",
47 runtimeConfig: map[string]string{
48 "apps/v1/Deployment": "false",
49 },
50 defaultResourceConfig: func() *serverstore.ResourceConfig {
51 return newFakeAPIResourceConfigSource()
52 },
53 expectedAPIConfig: func() *serverstore.ResourceConfig {
54 config := newFakeAPIResourceConfigSource()
55 config.ExplicitlyEnableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
56 return config
57 },
58 expectedEnabledAPIs: defaultFakeEnabledResources(),
59 err: true,
60 },
61 {
62 name: "everything-default-value",
63 runtimeConfig: map[string]string{},
64 defaultResourceConfig: func() *serverstore.ResourceConfig {
65 return newFakeAPIResourceConfigSource()
66 },
67 expectedAPIConfig: func() *serverstore.ResourceConfig {
68 return newFakeAPIResourceConfigSource()
69 },
70 expectedEnabledAPIs: defaultFakeEnabledResources(),
71 err: false,
72 },
73 {
74 name: "no-runtimeConfig-override",
75 runtimeConfig: map[string]string{},
76 defaultResourceConfig: func() *serverstore.ResourceConfig {
77 config := newFakeAPIResourceConfigSource()
78 config.DisableVersions(extensionsapiv1beta1.SchemeGroupVersion)
79 return config
80 },
81 expectedAPIConfig: func() *serverstore.ResourceConfig {
82 config := newFakeAPIResourceConfigSource()
83 config.DisableVersions(extensionsapiv1beta1.SchemeGroupVersion)
84 return config
85 },
86 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
87 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): false, // this becomes false because the DisableVersions set in the defaultConfig is now order dependent.
88 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
89 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
90 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
91 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
92 apiv1.SchemeGroupVersion.WithResource("pods"): true,
93 },
94 err: false,
95 },
96 {
97 name: "version-enabled-by-runtimeConfig-override",
98 runtimeConfig: map[string]string{
99 "apps/v1": "",
100 },
101 defaultResourceConfig: func() *serverstore.ResourceConfig {
102 config := newFakeAPIResourceConfigSource()
103 return config
104 },
105 expectedAPIConfig: func() *serverstore.ResourceConfig {
106 config := newFakeAPIResourceConfigSource()
107 config.ExplicitlyEnableVersions(appsv1.SchemeGroupVersion)
108 return config
109 },
110 expectedEnabledAPIs: defaultFakeEnabledResources(),
111 err: false,
112 },
113 {
114 name: "disable-v1",
115 runtimeConfig: map[string]string{
116 "/v1": "false",
117 },
118 defaultResourceConfig: func() *serverstore.ResourceConfig {
119 return newFakeAPIResourceConfigSource()
120 },
121 expectedAPIConfig: func() *serverstore.ResourceConfig {
122 config := newFakeAPIResourceConfigSource()
123 config.ExplicitlyDisableVersions(apiv1GroupVersion)
124 return config
125 },
126 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
127 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
128 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
129 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
130 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
131 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
132 apiv1.SchemeGroupVersion.WithResource("pods"): false,
133 },
134 err: false,
135 },
136 {
137 name: "invalid-runtime-config",
138 runtimeConfig: map[string]string{
139 "invalidgroup/version": "false",
140 },
141 defaultResourceConfig: func() *serverstore.ResourceConfig {
142 return newFakeAPIResourceConfigSource()
143 },
144 expectedAPIConfig: func() *serverstore.ResourceConfig {
145 return newFakeAPIResourceConfigSource()
146 },
147 expectedEnabledAPIs: defaultFakeEnabledResources(),
148 err: false,
149 },
150 {
151 name: "enable-all",
152 runtimeConfig: map[string]string{
153 "api/all": "true",
154 },
155 defaultResourceConfig: func() *serverstore.ResourceConfig {
156 return newFakeAPIResourceConfigSource()
157 },
158 expectedAPIConfig: func() *serverstore.ResourceConfig {
159 config := newFakeAPIResourceConfigSource()
160 config.EnableVersions(scheme.PrioritizedVersionsAllGroups()...)
161 return config
162 },
163 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
164 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
165 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): true,
166 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): true,
167 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): true,
168 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
169 apiv1.SchemeGroupVersion.WithResource("pods"): true,
170 },
171 err: false,
172 },
173 {
174 name: "only-enable-v1",
175 runtimeConfig: map[string]string{
176 "api/all": "false",
177 "/v1": "true",
178 },
179 defaultResourceConfig: func() *serverstore.ResourceConfig {
180 return newFakeAPIResourceConfigSource()
181 },
182 expectedAPIConfig: func() *serverstore.ResourceConfig {
183 config := newFakeAPIResourceConfigSource()
184 config.ExplicitlyEnableVersions(apiv1GroupVersion)
185 config.DisableVersions(appsv1.SchemeGroupVersion)
186 config.DisableVersions(extensionsapiv1beta1.SchemeGroupVersion)
187 return config
188 },
189 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
190 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): false,
191 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
192 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
193 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
194 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
195 apiv1.SchemeGroupVersion.WithResource("pods"): true,
196 },
197 err: false,
198 },
199 {
200 name: "enable-specific-extensions-resources",
201 runtimeConfig: map[string]string{
202 "extensions/v1beta1/deployments": "true",
203 },
204 defaultResourceConfig: func() *serverstore.ResourceConfig {
205 return newFakeAPIResourceConfigSource()
206 },
207 expectedAPIConfig: func() *serverstore.ResourceConfig {
208 config := newFakeAPIResourceConfigSource()
209 config.ExplicitlyEnableResources(extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"))
210 return config
211 },
212 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
213 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
214 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): true,
215 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
216 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
217 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
218 apiv1.SchemeGroupVersion.WithResource("pods"): true,
219 }, err: false,
220 },
221 {
222 name: "disable-specific-extensions-resources",
223 runtimeConfig: map[string]string{
224 "extensions/v1beta1/ingresses": "false",
225 },
226 defaultResourceConfig: func() *serverstore.ResourceConfig {
227 return newFakeAPIResourceConfigSource()
228 },
229 expectedAPIConfig: func() *serverstore.ResourceConfig {
230 config := newFakeAPIResourceConfigSource()
231 config.ExplicitlyDisableResources(extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"))
232 return config
233 },
234 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
235 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): false,
236 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
237 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
238 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
239 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
240 apiv1.SchemeGroupVersion.WithResource("pods"): true,
241 }, err: false,
242 },
243 {
244 name: "disable-all-extensions-resources",
245 runtimeConfig: map[string]string{
246 "extensions/v1beta1": "false",
247 },
248 defaultResourceConfig: func() *serverstore.ResourceConfig {
249 return newFakeAPIResourceConfigSource()
250 },
251 expectedAPIConfig: func() *serverstore.ResourceConfig {
252 config := newFakeAPIResourceConfigSource()
253 config.ExplicitlyDisableVersions(extensionsapiv1beta1.SchemeGroupVersion)
254 return config
255 },
256 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
257 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): false,
258 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
259 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
260 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
261 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
262 apiv1.SchemeGroupVersion.WithResource("pods"): true,
263 }, err: false,
264 },
265 {
266 name: "disable-a-no-extensions-resources",
267 runtimeConfig: map[string]string{
268 "apps/v1/deployments": "false",
269 },
270 defaultResourceConfig: func() *serverstore.ResourceConfig {
271 return newFakeAPIResourceConfigSource()
272 },
273 expectedAPIConfig: func() *serverstore.ResourceConfig {
274 config := newFakeAPIResourceConfigSource()
275 config.ExplicitlyDisableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
276 return config
277 },
278 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
279 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
280 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
281 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
282 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
283 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
284 apiv1.SchemeGroupVersion.WithResource("pods"): true,
285 },
286 err: false, // no error for backwards compatibility
287 },
288 {
289 name: "disable-all-beta-resources",
290 runtimeConfig: map[string]string{
291 "api/beta": "false",
292 },
293 defaultResourceConfig: func() *serverstore.ResourceConfig {
294 return newFakeAPIResourceConfigSource()
295 },
296 expectedAPIConfig: func() *serverstore.ResourceConfig {
297 config := newFakeAPIResourceConfigSource()
298 config.DisableVersions(extensionsapiv1beta1.SchemeGroupVersion)
299 return config
300 },
301 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
302 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): false,
303 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
304 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
305 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
306 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
307 apiv1.SchemeGroupVersion.WithResource("pods"): true,
308 },
309 err: false, // no error for backwards compatibility
310 },
311 {
312 name: "user-explicit-disable-resource-over-user-version-enable",
313 runtimeConfig: map[string]string{
314 "apps/v1": "true",
315 "apps/v1/deployments": "false",
316 },
317 defaultResourceConfig: func() *serverstore.ResourceConfig {
318 return newFakeAPIResourceConfigSource()
319 },
320 expectedAPIConfig: func() *serverstore.ResourceConfig {
321 config := newFakeAPIResourceConfigSource()
322 config.ExplicitlyEnableVersions(appsv1.SchemeGroupVersion)
323 config.ExplicitlyDisableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
324 return config
325 },
326 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
327 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
328 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
329 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
330 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
331 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
332 apiv1.SchemeGroupVersion.WithResource("pods"): true,
333 },
334 err: false, // no error for backwards compatibility
335 },
336 {
337 name: "user-explicit-enable-resource-over-user-version-disable",
338 runtimeConfig: map[string]string{
339 "apps/v1": "false",
340 "apps/v1/deployments": "true",
341 },
342 defaultResourceConfig: func() *serverstore.ResourceConfig {
343 return newFakeAPIResourceConfigSource()
344 },
345 expectedAPIConfig: func() *serverstore.ResourceConfig {
346 config := newFakeAPIResourceConfigSource()
347 config.ExplicitlyDisableVersions(appsv1.SchemeGroupVersion)
348 config.ExplicitlyEnableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
349 return config
350 },
351 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
352 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
353 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
354 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
355 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
356 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
357 appsv1.SchemeGroupVersion.WithResource("other"): false,
358 apiv1.SchemeGroupVersion.WithResource("pods"): true,
359 },
360 err: false, // no error for backwards compatibility
361 },
362 {
363 name: "user-explicit-disable-resource-over-user-stability-enable",
364 runtimeConfig: map[string]string{
365 "api/ga": "true",
366 "apps/v1/deployments": "false",
367 },
368 defaultResourceConfig: func() *serverstore.ResourceConfig {
369 return newFakeAPIResourceConfigSource()
370 },
371 expectedAPIConfig: func() *serverstore.ResourceConfig {
372 config := newFakeAPIResourceConfigSource()
373 config.ExplicitlyDisableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
374 return config
375 },
376 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
377 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
378 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
379 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
380 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
381 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
382 apiv1.SchemeGroupVersion.WithResource("pods"): true,
383 },
384 err: false, // no error for backwards compatibility
385 },
386 {
387 name: "user-explicit-enable-resource-over-user-stability-disable",
388 runtimeConfig: map[string]string{
389 "api/ga": "false",
390 "apps/v1/deployments": "true",
391 },
392 defaultResourceConfig: func() *serverstore.ResourceConfig {
393 return newFakeAPIResourceConfigSource()
394 },
395 expectedAPIConfig: func() *serverstore.ResourceConfig {
396 config := newFakeAPIResourceConfigSource()
397 config.DisableVersions(apiv1.SchemeGroupVersion)
398 config.DisableVersions(appsv1.SchemeGroupVersion)
399 config.ExplicitlyEnableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
400 return config
401 },
402 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
403 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
404 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
405 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
406 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
407 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
408 apiv1.SchemeGroupVersion.WithResource("pods"): false,
409 },
410 err: false, // no error for backwards compatibility
411 },
412 {
413 name: "user-explicit-disable-resource-over-user-version-enable-over-user-stability-disable",
414 runtimeConfig: map[string]string{
415 "api/ga": "false",
416 "apps/v1": "true",
417 "apps/v1/deployments": "false",
418 },
419 defaultResourceConfig: func() *serverstore.ResourceConfig {
420 return newFakeAPIResourceConfigSource()
421 },
422 expectedAPIConfig: func() *serverstore.ResourceConfig {
423 config := newFakeAPIResourceConfigSource()
424 config.DisableVersions(apiv1.SchemeGroupVersion)
425 config.ExplicitlyEnableVersions(appsv1.SchemeGroupVersion)
426 config.ExplicitlyDisableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
427 return config
428 },
429 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
430 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
431 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
432 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
433 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
434 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
435 appsv1.SchemeGroupVersion.WithResource("other"): true,
436 apiv1.SchemeGroupVersion.WithResource("pods"): false,
437 },
438 err: false, // no error for backwards compatibility
439 },
440 {
441 name: "user-explicit-enable-resource-over-user-version-disable-over-user-stability-disable",
442 runtimeConfig: map[string]string{
443 "api/ga": "false",
444 "apps/v1": "false",
445 "apps/v1/deployments": "true",
446 },
447 defaultResourceConfig: func() *serverstore.ResourceConfig {
448 return newFakeAPIResourceConfigSource()
449 },
450 expectedAPIConfig: func() *serverstore.ResourceConfig {
451 config := newFakeAPIResourceConfigSource()
452 config.DisableVersions(apiv1.SchemeGroupVersion)
453 config.ExplicitlyDisableVersions(appsv1.SchemeGroupVersion)
454 config.ExplicitlyEnableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
455 return config
456 },
457 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
458 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
459 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
460 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
461 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
462 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
463 apiv1.SchemeGroupVersion.WithResource("pods"): false,
464 },
465 err: false, // no error for backwards compatibility
466 },
467 {
468 name: "user-explicit-disable-resource-over-user-version-enable-over-user-stability-enable",
469 runtimeConfig: map[string]string{
470 "api/ga": "true",
471 "apps/v1": "true",
472 "apps/v1/deployments": "false",
473 },
474 defaultResourceConfig: func() *serverstore.ResourceConfig {
475 return newFakeAPIResourceConfigSource()
476 },
477 expectedAPIConfig: func() *serverstore.ResourceConfig {
478 config := newFakeAPIResourceConfigSource()
479 config.ExplicitlyEnableVersions(appsv1.SchemeGroupVersion)
480 config.ExplicitlyDisableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
481 return config
482 },
483 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
484 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
485 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
486 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
487 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
488 appsv1.SchemeGroupVersion.WithResource("deployments"): false,
489 apiv1.SchemeGroupVersion.WithResource("pods"): true,
490 },
491 err: false, // no error for backwards compatibility
492 },
493 {
494 name: "user-explicit-enable-resource-over-user-version-disable-over-user-stability-enable",
495 runtimeConfig: map[string]string{
496 "api/ga": "true",
497 "apps/v1": "false",
498 "apps/v1/deployments": "true",
499 },
500 defaultResourceConfig: func() *serverstore.ResourceConfig {
501 return newFakeAPIResourceConfigSource()
502 },
503 expectedAPIConfig: func() *serverstore.ResourceConfig {
504 config := newFakeAPIResourceConfigSource()
505 config.ExplicitlyDisableVersions(appsv1.SchemeGroupVersion)
506 config.ExplicitlyEnableResources(appsv1.SchemeGroupVersion.WithResource("deployments"))
507 return config
508 },
509 expectedEnabledAPIs: map[schema.GroupVersionResource]bool{
510 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
511 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
512 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
513 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
514 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
515 appsv1.SchemeGroupVersion.WithResource("other"): false,
516 apiv1.SchemeGroupVersion.WithResource("pods"): true,
517 },
518 err: false, // no error for backwards compatibility
519 },
520 }
521 for _, test := range testCases {
522 t.Run(test.name, func(t *testing.T) {
523 t.Log(scheme.PrioritizedVersionsAllGroups())
524 actualDisablers, err := MergeAPIResourceConfigs(test.defaultResourceConfig(), test.runtimeConfig, scheme)
525 if err == nil && test.err {
526 t.Fatalf("expected error")
527 } else if err != nil && !test.err {
528 t.Fatalf("unexpected error: %s, for test: %v", err, test)
529 }
530 if err != nil {
531 return
532 }
533
534 expectedConfig := test.expectedAPIConfig()
535 if !reflect.DeepEqual(actualDisablers, expectedConfig) {
536 t.Fatalf("%v: unexpected apiResourceDisablers. Actual: %v\n expected: %v", test.runtimeConfig, actualDisablers, expectedConfig)
537 }
538
539 for _, resourceToCheck := range apiResourcesToCheck() {
540 actual := actualDisablers.ResourceEnabled(resourceToCheck)
541 expected := test.expectedEnabledAPIs[resourceToCheck]
542 if actual != expected {
543 t.Errorf("for %v, actual=%v, expected=%v", resourceToCheck, actual, expected)
544 }
545 }
546 for resourceToCheck, expected := range test.expectedEnabledAPIs {
547 actual := actualDisablers.ResourceEnabled(resourceToCheck)
548 if actual != expected {
549 t.Errorf("for %v, actual=%v, expected=%v", resourceToCheck, actual, expected)
550 }
551 }
552 })
553 }
554 }
555
556 func TestEmulationForwardCompatibleResourceConfig(t *testing.T) {
557 scheme := newFakeScheme(t)
558 addTestGVs(t, scheme)
559 testGroup := "test"
560 v1 := schema.GroupVersion{Group: testGroup, Version: "v1"}
561 v2alpha1 := schema.GroupVersion{Group: "test", Version: "v2alpha1"}
562 v2beta1 := schema.GroupVersion{Group: testGroup, Version: "v2beta1"}
563 v2beta2 := schema.GroupVersion{Group: testGroup, Version: "v2beta2"}
564 v2 := schema.GroupVersion{Group: testGroup, Version: "v2"}
565
566 testCases := []struct {
567 name string
568 resourceConfig func() *serverstore.ResourceConfig
569 resourceConfigOverrides map[string]string
570 expectedAPIConfig func() *serverstore.ResourceConfig
571 err bool
572 }{
573 {
574 name: "emulation-forward-compatible-enabled-no-higher-priority",
575 resourceConfig: func() *serverstore.ResourceConfig {
576 config := serverstore.NewResourceConfig()
577 config.EnableVersions(v2)
578 return config
579 },
580 resourceConfigOverrides: map[string]string{},
581 expectedAPIConfig: func() *serverstore.ResourceConfig {
582 config := serverstore.NewResourceConfig()
583 config.EnableVersions(v2)
584 return config
585 },
586 err: false,
587 },
588 {
589 name: "emulation-forward-compatible-alpha-version",
590 resourceConfig: func() *serverstore.ResourceConfig {
591 config := serverstore.NewResourceConfig()
592 config.EnableVersions(v2alpha1)
593 return config
594 },
595 resourceConfigOverrides: map[string]string{},
596 expectedAPIConfig: func() *serverstore.ResourceConfig {
597 config := serverstore.NewResourceConfig()
598 config.EnableVersions(v2alpha1)
599 return config
600 },
601 err: false,
602 },
603 {
604 name: "emulation-forward-compatible-enabled-higher-priority-ga",
605 resourceConfig: func() *serverstore.ResourceConfig {
606 config := serverstore.NewResourceConfig()
607 config.EnableVersions(v1)
608 return config
609 },
610 resourceConfigOverrides: map[string]string{},
611 expectedAPIConfig: func() *serverstore.ResourceConfig {
612 config := serverstore.NewResourceConfig()
613 config.EnableVersions(v1, v2)
614 return config
615 },
616 err: false,
617 },
618 {
619 name: "emulation-forward-compatible-enabled-higher-priority",
620 resourceConfig: func() *serverstore.ResourceConfig {
621 config := serverstore.NewResourceConfig()
622 config.EnableVersions(v2beta1)
623 return config
624 },
625 resourceConfigOverrides: map[string]string{},
626 expectedAPIConfig: func() *serverstore.ResourceConfig {
627 config := serverstore.NewResourceConfig()
628 config.EnableVersions(v2beta1, v2beta2, v1, v2)
629 return config
630 },
631 err: false,
632 },
633 {
634 name: "emulation-forward-compatible-enabled-higher-priority-with-override",
635 resourceConfig: func() *serverstore.ResourceConfig {
636 config := serverstore.NewResourceConfig()
637 config.EnableVersions(v2beta1)
638 return config
639 },
640 resourceConfigOverrides: map[string]string{
641 "test/v2beta2": "false",
642 },
643 expectedAPIConfig: func() *serverstore.ResourceConfig {
644 config := serverstore.NewResourceConfig()
645 config.EnableVersions(v2beta1, v1, v2)
646 config.ExplicitlyDisableVersions(v2beta2)
647 return config
648 },
649 err: false,
650 },
651 {
652 name: "emulation-forward-compatible-enabled-resource-no-higher-priority",
653 resourceConfig: func() *serverstore.ResourceConfig {
654 config := serverstore.NewResourceConfig()
655 config.EnableResources(v2.WithResource("testtype1"))
656 return config
657 },
658 resourceConfigOverrides: map[string]string{},
659 expectedAPIConfig: func() *serverstore.ResourceConfig {
660 config := serverstore.NewResourceConfig()
661 config.EnableResources(v2.WithResource("testtype1"))
662 return config
663 },
664 err: false,
665 },
666 {
667 name: "emulation-forward-compatible-alpha-resource",
668 resourceConfig: func() *serverstore.ResourceConfig {
669 config := serverstore.NewResourceConfig()
670 config.EnableResources(v2alpha1.WithResource("testtype1"))
671 return config
672 },
673 resourceConfigOverrides: map[string]string{},
674 expectedAPIConfig: func() *serverstore.ResourceConfig {
675 config := serverstore.NewResourceConfig()
676 config.EnableResources(v2alpha1.WithResource("testtype1"))
677 return config
678 },
679 err: false,
680 },
681 {
682 name: "emulation-forward-compatible-enabled-resource-higher-priority",
683 resourceConfig: func() *serverstore.ResourceConfig {
684 config := serverstore.NewResourceConfig()
685 config.EnableResources(v2beta1.WithResource("testtype1"))
686 return config
687 },
688 resourceConfigOverrides: map[string]string{},
689 expectedAPIConfig: func() *serverstore.ResourceConfig {
690 config := serverstore.NewResourceConfig()
691 config.EnableResources(v2beta1.WithResource("testtype1"), v2beta2.WithResource("testtype1"), v1.WithResource("testtype1"), v2.WithResource("testtype1"))
692 return config
693 },
694 err: false,
695 },
696 {
697 name: "emulation-forward-compatible-enabled-resource-higher-priority-with-override",
698 resourceConfig: func() *serverstore.ResourceConfig {
699 config := serverstore.NewResourceConfig()
700 config.EnableResources(v2beta1.WithResource("testtype1"))
701 return config
702 },
703 resourceConfigOverrides: map[string]string{
704 "test/v2beta2/testtype1": "false",
705 },
706 expectedAPIConfig: func() *serverstore.ResourceConfig {
707 config := serverstore.NewResourceConfig()
708 config.EnableResources(v2beta1.WithResource("testtype1"), v1.WithResource("testtype1"), v2.WithResource("testtype1"))
709 config.ExplicitlyDisableResources(v2beta2.WithResource("testtype1"))
710 return config
711 },
712 err: false,
713 },
714 }
715
716 for _, test := range testCases {
717 t.Run(test.name, func(t *testing.T) {
718 actualAPIConfig, err := EmulationForwardCompatibleResourceConfig(test.resourceConfig(), test.resourceConfigOverrides, scheme)
719 if err == nil && test.err {
720 t.Fatalf("expected error")
721 } else if err != nil && !test.err {
722 t.Fatalf("unexpected error: %s, for test: %v", err, test)
723 }
724 if err != nil {
725 return
726 }
727
728 expectedConfig := test.expectedAPIConfig()
729 if !reflect.DeepEqual(actualAPIConfig, expectedConfig) {
730 t.Fatalf("unexpected apiResourceConfig. Actual: %v\n expected: %v", actualAPIConfig, expectedConfig)
731 }
732 })
733 }
734 }
735
736 func newFakeAPIResourceConfigSource() *serverstore.ResourceConfig {
737 ret := serverstore.NewResourceConfig()
738 // NOTE: GroupVersions listed here will be enabled by default. Don't put alpha versions in the list.
739 ret.EnableVersions(
740 apiv1.SchemeGroupVersion,
741 appsv1.SchemeGroupVersion,
742 extensionsapiv1beta1.SchemeGroupVersion,
743 )
744 ret.EnableResources(
745 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"),
746 )
747 ret.DisableResources(
748 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"),
749 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"),
750 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"),
751 )
752
753 return ret
754 }
755
756 // apiResourcesToCheck are the apis we use in this set of unit tests. They will be check for enable/disable status
757 func apiResourcesToCheck() []schema.GroupVersionResource {
758 return []schema.GroupVersionResource{
759 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"),
760 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"),
761 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"),
762 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"),
763 appsv1.SchemeGroupVersion.WithResource("deployments"),
764 apiv1.SchemeGroupVersion.WithResource("pods"),
765 }
766 }
767
768 func defaultFakeEnabledResources() map[schema.GroupVersionResource]bool {
769 return map[schema.GroupVersionResource]bool{
770 extensionsapiv1beta1.SchemeGroupVersion.WithResource("ingresses"): true,
771 extensionsapiv1beta1.SchemeGroupVersion.WithResource("deployments"): false,
772 extensionsapiv1beta1.SchemeGroupVersion.WithResource("replicasets"): false,
773 extensionsapiv1beta1.SchemeGroupVersion.WithResource("daemonsets"): false,
774 appsv1.SchemeGroupVersion.WithResource("deployments"): true,
775 apiv1.SchemeGroupVersion.WithResource("pods"): true,
776 }
777 }
778
779 func newFakeScheme(t *testing.T) *runtime.Scheme {
780 ret := runtime.NewScheme()
781 require.NoError(t, apiv1.AddToScheme(ret))
782 require.NoError(t, appsv1.AddToScheme(ret))
783 require.NoError(t, extensionsapiv1beta1.AddToScheme(ret))
784
785 require.NoError(t, ret.SetVersionPriority(apiv1.SchemeGroupVersion))
786 require.NoError(t, ret.SetVersionPriority(extensionsapiv1beta1.SchemeGroupVersion))
787
788 return ret
789 }
790
791 func addTestGVs(t *testing.T, s *runtime.Scheme) {
792 v1 := schema.GroupVersion{Group: "test", Version: "v1"}
793 v2alpha1 := schema.GroupVersion{Group: "test", Version: "v2alpha1"}
794 v2beta1 := schema.GroupVersion{Group: "test", Version: "v2beta1"}
795 v2beta2 := schema.GroupVersion{Group: "test", Version: "v2beta2"}
796 v2 := schema.GroupVersion{Group: "test", Version: "v2"}
797
798 s.AddKnownTypes(v1, &runtimetesting.TestType1{})
799 s.AddKnownTypes(v2alpha1, &runtimetesting.TestType1{})
800 s.AddKnownTypes(v2beta1, &runtimetesting.TestType1{})
801 s.AddKnownTypes(v2beta2, &runtimetesting.TestType1{}, &runtimetesting.TestType2{})
802 s.AddKnownTypes(v2, &runtimetesting.TestType1{}, &runtimetesting.TestType2{})
803
804 require.NoError(t, runtimetesting.RegisterConversions(s))
805 require.NoError(t, s.SetVersionPriority(v2, v1, v2beta1, v2beta2))
806 }