Debian Codegraph @

pkg/authentication/request/headerrequest/requestheader_controller_test.go

raw
1 /*
2 Copyright 2020 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 headerrequest
18
19 import (
20 "context"
21 "encoding/json"
22 "testing"
23
24 corev1 "k8s.io/api/core/v1"
25 "k8s.io/apimachinery/pkg/api/equality"
26 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
27 "k8s.io/client-go/kubernetes/fake"
28 corev1listers "k8s.io/client-go/listers/core/v1"
29 "k8s.io/client-go/tools/cache"
30 )
31
32 const (
33 defConfigMapName = "extension-apiserver-authentication"
34 defConfigMapNamespace = "kube-system"
35
36 defUsernameHeadersKey = "user-key"
37 defUIDHeadersKey = "uid-key"
38 defGroupHeadersKey = "group-key"
39 defExtraHeaderPrefixesKey = "extra-key"
40 defAllowedClientNamesKey = "names-key"
41 )
42
43 type expectedHeadersHolder struct {
44 usernameHeaders []string
45 uidHeaders []string
46 groupHeaders []string
47 extraHeaderPrefixes []string
48 allowedClientNames []string
49 }
50
51 func TestRequestHeaderAuthRequestController(t *testing.T) {
52 scenarios := []struct {
53 name string
54 cm *corev1.ConfigMap
55 expectedHeader expectedHeadersHolder
56 expectErr bool
57 }{
58 {
59 name: "happy-path: headers values are populated form a config map",
60 cm: defaultConfigMap(t, []string{"user-val"}, []string{"uid-val"}, []string{"group-val"}, []string{"extra-val"}, []string{"names-val"}),
61 expectedHeader: expectedHeadersHolder{
62 usernameHeaders: []string{"user-val"},
63 uidHeaders: []string{"uid-val"},
64 groupHeaders: []string{"group-val"},
65 extraHeaderPrefixes: []string{"extra-val"},
66 allowedClientNames: []string{"names-val"},
67 },
68 },
69 {
70 name: "passing an empty config map doesn't break the controller",
71 cm: func() *corev1.ConfigMap {
72 c := defaultConfigMap(t, nil, nil, nil, nil, nil)
73 c.Data = map[string]string{}
74 return c
75 }(),
76 },
77 {
78 name: "an invalid config map produces an error",
79 cm: func() *corev1.ConfigMap {
80 c := defaultConfigMap(t, nil, nil, nil, nil, nil)
81 c.Data = map[string]string{
82 defUsernameHeadersKey: "incorrect-json-array",
83 }
84 return c
85 }(),
86 expectErr: true,
87 },
88 }
89
90 for _, scenario := range scenarios {
91 t.Run(scenario.name, func(t *testing.T) {
92 // test data
93 indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
94 if err := indexer.Add(scenario.cm); err != nil {
95 t.Fatal(err.Error())
96 }
97 target := newDefaultTarget()
98 target.configmapLister = corev1listers.NewConfigMapLister(indexer).ConfigMaps(defConfigMapNamespace)
99
100 // act
101 err := target.sync()
102
103 if err != nil && !scenario.expectErr {
104 t.Errorf("got unexpected error %v", err)
105 }
106 if err == nil && scenario.expectErr {
107 t.Error("expected an error but didn't get one")
108 }
109
110 // validate
111 validateExpectedHeaders(t, target, scenario.expectedHeader)
112 })
113 }
114 }
115
116 func TestRequestHeaderAuthRequestControllerPreserveState(t *testing.T) {
117 scenarios := []struct {
118 name string
119 cm *corev1.ConfigMap
120 expectedHeader expectedHeadersHolder
121 expectErr bool
122 }{
123 {
124 name: "scenario 1: headers values are populated form a config map",
125 cm: defaultConfigMap(t, []string{"user-val"}, []string{"uid-val"}, []string{"group-val"}, []string{"extra-val"}, []string{"names-val"}),
126 expectedHeader: expectedHeadersHolder{
127 usernameHeaders: []string{"user-val"},
128 uidHeaders: []string{"uid-val"},
129 groupHeaders: []string{"group-val"},
130 extraHeaderPrefixes: []string{"extra-val"},
131 allowedClientNames: []string{"names-val"},
132 },
133 },
134 {
135 name: "scenario 2: an invalid config map produces an error but doesn't destroy the state (scenario 1)",
136 cm: func() *corev1.ConfigMap {
137 c := defaultConfigMap(t, nil, nil, nil, nil, nil)
138 c.Data = map[string]string{
139 defUsernameHeadersKey: "incorrect-json-array",
140 }
141 return c
142 }(),
143 expectErr: true,
144 expectedHeader: expectedHeadersHolder{
145 usernameHeaders: []string{"user-val"},
146 uidHeaders: []string{"uid-val"},
147 groupHeaders: []string{"group-val"},
148 extraHeaderPrefixes: []string{"extra-val"},
149 allowedClientNames: []string{"names-val"},
150 },
151 },
152 {
153 name: "scenario 3: some headers values have changed (prev set by scenario 1)",
154 cm: defaultConfigMap(t, []string{"user-val"}, []string{"uid-val"}, []string{"group-val-scenario-3"}, []string{"extra-val"}, []string{"names-val"}),
155 expectedHeader: expectedHeadersHolder{
156 usernameHeaders: []string{"user-val"},
157 uidHeaders: []string{"uid-val"},
158 groupHeaders: []string{"group-val-scenario-3"},
159 extraHeaderPrefixes: []string{"extra-val"},
160 allowedClientNames: []string{"names-val"},
161 },
162 },
163 {
164 name: "scenario 4: all headers values have changed (prev set by scenario 3)",
165 cm: defaultConfigMap(t, []string{"user-val-scenario-4"}, []string{"uid-val-scenario-4"}, []string{"group-val-scenario-4"}, []string{"extra-val-scenario-4"}, []string{"names-val-scenario-4"}),
166 expectedHeader: expectedHeadersHolder{
167 usernameHeaders: []string{"user-val-scenario-4"},
168 uidHeaders: []string{"uid-val-scenario-4"},
169 groupHeaders: []string{"group-val-scenario-4"},
170 extraHeaderPrefixes: []string{"extra-val-scenario-4"},
171 allowedClientNames: []string{"names-val-scenario-4"},
172 },
173 },
174 }
175
176 target := newDefaultTarget()
177
178 for _, scenario := range scenarios {
179 t.Run(scenario.name, func(t *testing.T) {
180 // test data
181 if scenario.cm != nil {
182 indexer := cache.NewIndexer(cache.MetaNamespaceKeyFunc, cache.Indexers{})
183 if err := indexer.Add(scenario.cm); err != nil {
184 t.Fatal(err.Error())
185 }
186 target.configmapLister = corev1listers.NewConfigMapLister(indexer).ConfigMaps(defConfigMapNamespace)
187 }
188
189 // act
190 err := target.sync()
191
192 if err != nil && !scenario.expectErr {
193 t.Errorf("got unexpected error %v", err)
194 }
195 if err == nil && scenario.expectErr {
196 t.Error("expected an error but didn't get one")
197 }
198
199 // validate
200 validateExpectedHeaders(t, target, scenario.expectedHeader)
201 })
202 }
203 }
204
205 func TestRequestHeaderAuthRequestControllerSyncOnce(t *testing.T) {
206 scenarios := []struct {
207 name string
208 cm *corev1.ConfigMap
209 expectedHeader expectedHeadersHolder
210 expectErr bool
211 }{
212 {
213 name: "headers values are populated form a config map",
214 cm: defaultConfigMap(t, []string{"user-val"}, []string{"uid-val"}, []string{"group-val"}, []string{"extra-val"}, []string{"names-val"}),
215 expectedHeader: expectedHeadersHolder{
216 usernameHeaders: []string{"user-val"},
217 uidHeaders: []string{"uid-val"},
218 groupHeaders: []string{"group-val"},
219 extraHeaderPrefixes: []string{"extra-val"},
220 allowedClientNames: []string{"names-val"},
221 },
222 },
223 }
224
225 for _, scenario := range scenarios {
226 t.Run(scenario.name, func(t *testing.T) {
227 // test data
228 target := newDefaultTarget()
229 fakeKubeClient := fake.NewSimpleClientset(scenario.cm)
230 target.client = fakeKubeClient
231
232 // act
233 ctx := context.TODO()
234 err := target.RunOnce(ctx)
235
236 if err != nil && !scenario.expectErr {
237 t.Errorf("got unexpected error %v", err)
238 }
239 if err == nil && scenario.expectErr {
240 t.Error("expected an error but didn't get one")
241 }
242
243 // validate
244 validateExpectedHeaders(t, target, scenario.expectedHeader)
245 })
246 }
247 }
248
249 func defaultConfigMap(t *testing.T, usernameHeaderVal, uidHeaderVal, groupHeadersVal, extraHeaderPrefixesVal, allowedClientNamesVal []string) *corev1.ConfigMap {
250 encode := func(val []string) string {
251 encodedVal, err := json.Marshal(val)
252 if err != nil {
253 t.Fatalf("unable to marshal %q , due to %v", usernameHeaderVal, err)
254 }
255 return string(encodedVal)
256 }
257 return &corev1.ConfigMap{
258 ObjectMeta: metav1.ObjectMeta{
259 Name: defConfigMapName,
260 Namespace: defConfigMapNamespace,
261 },
262 Data: map[string]string{
263 defUsernameHeadersKey: encode(usernameHeaderVal),
264 defUIDHeadersKey: encode(uidHeaderVal),
265 defGroupHeadersKey: encode(groupHeadersVal),
266 defExtraHeaderPrefixesKey: encode(extraHeaderPrefixesVal),
267 defAllowedClientNamesKey: encode(allowedClientNamesVal),
268 },
269 }
270 }
271
272 func newDefaultTarget() *RequestHeaderAuthRequestController {
273 return &RequestHeaderAuthRequestController{
274 configmapName: defConfigMapName,
275 configmapNamespace: defConfigMapNamespace,
276 usernameHeadersKey: defUsernameHeadersKey,
277 uidHeadersKey: defUIDHeadersKey,
278 groupHeadersKey: defGroupHeadersKey,
279 extraHeaderPrefixesKey: defExtraHeaderPrefixesKey,
280 allowedClientNamesKey: defAllowedClientNamesKey,
281 }
282 }
283
284 func validateExpectedHeaders(t *testing.T, target *RequestHeaderAuthRequestController, expected expectedHeadersHolder) {
285 if !equality.Semantic.DeepEqual(target.UsernameHeaders(), expected.usernameHeaders) {
286 t.Fatalf("incorrect usernameHeaders, got %v, wanted %v", target.UsernameHeaders(), expected.usernameHeaders)
287 }
288 if !equality.Semantic.DeepEqual(target.GroupHeaders(), expected.groupHeaders) {
289 t.Fatalf("incorrect groupHeaders, got %v, wanted %v", target.GroupHeaders(), expected.groupHeaders)
290 }
291 if !equality.Semantic.DeepEqual(target.ExtraHeaderPrefixes(), expected.extraHeaderPrefixes) {
292 t.Fatalf("incorrect extraheaderPrefixes, got %v, wanted %v", target.ExtraHeaderPrefixes(), expected.extraHeaderPrefixes)
293 }
294 if !equality.Semantic.DeepEqual(target.AllowedClientNames(), expected.allowedClientNames) {
295 t.Fatalf("incorrect expectedAllowedClientNames, got %v, wanted %v", target.AllowedClientNames(), expected.allowedClientNames)
296 }
297 }