1 package k8s
2
3 import (
4 "context"
5 "fmt"
6 "io"
7 "strings"
8 "testing"
9
10 "github.com/go-test/deep"
11 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
12 "k8s.io/apimachinery/pkg/runtime"
13 "k8s.io/apimachinery/pkg/runtime/schema"
14 )
15
16 func TestNewFakeAPI(t *testing.T) {
17
18 k8sConfigs := []string{
19 `
20 apiVersion: apps/v1
21 kind: Deployment
22 metadata:
23 name: dep-name
24 namespace: dep-ns
25 `, `
26 apiVersion: apiextensions.k8s.io/v1beta1
27 kind: CustomResourceDefinition
28 metadata:
29 name: fakecrd.linkerd.io
30 spec:
31 group: my-group.io
32 version: v1alpha1
33 scope: Namespaced
34 names:
35 plural: fakecrds
36 singular: fakecrd
37 kind: FakeCRD
38 shortNames:
39 - fc
40 `, `
41 apiVersion: apiregistration.k8s.io/v1
42 kind: APIService
43 metadata:
44 name: v1alpha1.tap.linkerd.io
45 labels:
46 linkerd.io/control-plane-component: tap
47 linkerd.io/control-plane-ns: linkerd
48 spec:
49 group: tap.linkerd.io
50 version: v1alpha1
51 groupPriorityMinimum: 1000
52 versionPriority: 100
53 service:
54 name: linkerd-tap
55 namespace: linkerd
56 caBundle: dGFwIGNydA==`,
57 }
58
59 api, err := NewFakeAPI(k8sConfigs...)
60 if err != nil {
61 t.Fatalf("Unexpected error: %s", err)
62 }
63
64 ctx := context.Background()
65 deploy, err := api.AppsV1().Deployments("dep-ns").Get(ctx, "dep-name", metav1.GetOptions{})
66 if err != nil {
67 t.Fatalf("Unexpected error: %s", err)
68 }
69 gvk := schema.GroupVersionKind{
70 Group: "apps",
71 Version: "v1",
72 Kind: "Deployment",
73 }
74 if diff := deep.Equal(deploy.GroupVersionKind(), gvk); diff != nil {
75 t.Errorf("%+v", diff)
76 }
77
78 crd, err := api.Apiextensions.ApiextensionsV1beta1().CustomResourceDefinitions().Get(ctx, "fakecrd.linkerd.io", metav1.GetOptions{})
79 if err != nil {
80 t.Fatalf("Unexpected error: %s", err)
81 }
82 gvk = schema.GroupVersionKind{
83 Group: "apiextensions.k8s.io",
84 Version: "v1beta1",
85 Kind: "CustomResourceDefinition",
86 }
87 if diff := deep.Equal(crd.GroupVersionKind(), gvk); diff != nil {
88 t.Errorf("%+v", diff)
89 }
90 }
91
92 func TestNewFakeAPIFromManifests(t *testing.T) {
93 k8sConfigs := []string{
94 `
95 apiVersion: apps/v1
96 kind: Deployment
97 metadata:
98 name: dep-name
99 namespace: dep-ns
100 `, `
101 apiVersion: apiextensions.k8s.io/v1beta1
102 kind: CustomResourceDefinition
103 metadata:
104 name: fakecrd.linkerd.io
105 spec:
106 group: my-group.io
107 version: v1alpha1
108 scope: Namespaced
109 names:
110 plural: fakecrds
111 singular: fakecrd
112 kind: FakeCRD
113 shortNames:
114 - fc
115 `, `
116 apiVersion: apiregistration.k8s.io/v1
117 kind: APIService
118 metadata:
119 name: v1alpha1.tap.linkerd.io
120 labels:
121 linkerd.io/control-plane-component: tap
122 linkerd.io/control-plane-ns: linkerd
123 spec:
124 group: tap.linkerd.io
125 version: v1alpha1
126 groupPriorityMinimum: 1000
127 versionPriority: 100
128 service:
129 name: linkerd-tap
130 namespace: linkerd
131 caBundle: dGFwIGNydA==`,
132 }
133
134 readers := []io.Reader{}
135 for _, m := range k8sConfigs {
136 readers = append(readers, strings.NewReader(m))
137 }
138
139 api, err := NewFakeAPIFromManifests(readers)
140 if err != nil {
141 t.Fatalf("Unexpected error: %s", err)
142 }
143
144 ctx := context.Background()
145 deploy, err := api.AppsV1().Deployments("dep-ns").Get(ctx, "dep-name", metav1.GetOptions{})
146 if err != nil {
147 t.Fatalf("Unexpected error: %s", err)
148 }
149 gvk := schema.GroupVersionKind{
150 Group: "apps",
151 Version: "v1",
152 Kind: "Deployment",
153 }
154 if diff := deep.Equal(deploy.GroupVersionKind(), gvk); diff != nil {
155 t.Errorf("%+v", diff)
156 }
157
158 crd, err := api.Apiextensions.ApiextensionsV1beta1().CustomResourceDefinitions().Get(ctx, "fakecrd.linkerd.io", metav1.GetOptions{})
159 if err != nil {
160 t.Fatalf("Unexpected error: %s", err)
161 }
162 gvk = schema.GroupVersionKind{
163 Group: "apiextensions.k8s.io",
164 Version: "v1beta1",
165 Kind: "CustomResourceDefinition",
166 }
167 if diff := deep.Equal(crd.GroupVersionKind(), gvk); diff != nil {
168 t.Errorf("%+v", diff)
169 }
170 }
171
172 func TestNewFakeClientSets(t *testing.T) {
173 testCases := []struct {
174 k8sConfigs []string
175 err error
176 }{
177 {
178 []string{
179 `kind: Secret
180 apiVersion: v1
181 metadata:
182 name: fake-secret
183 namespace: ns
184 data:
185 foo: YmFyCg==`,
186 },
187 nil,
188 },
189 {
190 []string{`
191 apiVersion: linkerd.io/v1alpha2
192 kind: ServiceProfile
193 metadata:
194 name: foobar.ns.svc.cluster.local
195 namespace: linkerd
196 spec:
197 routes:
198 - condition:
199 pathRegex: "/x/y/z"`,
200 },
201 nil,
202 },
203 {
204 []string{`
205 apiVersion: apiregistration.k8s.io/v1
206 kind: APIService
207 metadata:
208 name: v1alpha1.tap.linkerd.io
209 labels:
210 linkerd.io/control-plane-component: tap
211 linkerd.io/control-plane-ns: linkerd
212 spec:
213 group: tap.linkerd.io
214 version: v1alpha1
215 groupPriorityMinimum: 1000
216 versionPriority: 100
217 service:
218 name: linkerd-tap
219 namespace: linkerd
220 caBundle: dGFwIGNydA==`,
221 },
222 nil,
223 },
224 {
225 []string{""},
226 runtime.NewMissingKindErr(""),
227 },
228 }
229
230 for i, tc := range testCases {
231 tc := tc
232
233 t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
234 _, _, _, _, err := NewFakeClientSets(tc.k8sConfigs...)
235 if diff := deep.Equal(err, tc.err); diff != nil {
236 t.Errorf("%+v", diff)
237 }
238 })
239 }
240 }
241
242 func TestNewFakeClientSetsFromManifests(t *testing.T) {
243 testCases := []struct {
244 manifests []string
245 err error
246 }{
247 {
248 []string{
249 `kind: Secret
250 apiVersion: v1
251 metadata:
252 name: fake-secret
253 namespace: ns
254 data:
255 foo: YmFyCg==`,
256 },
257 nil,
258 },
259 {
260 []string{`
261 apiVersion: linkerd.io/v1alpha2
262 kind: ServiceProfile
263 metadata:
264 name: foobar.ns.svc.cluster.local
265 namespace: linkerd
266 spec:
267 routes:
268 - condition:
269 pathRegex: "/x/y/z"`,
270 },
271 nil,
272 },
273 {
274 []string{`
275 kind: List
276 apiVersion: v1
277 items:
278 - kind: Secret
279 apiVersion: v1
280 metadata:
281 name: fake-secret
282 namespace: ns
283 data:
284 foo: YmFyCg==
285 - apiVersion: linkerd.io/v1alpha2
286 kind: ServiceProfile
287 metadata:
288 name: foobar.ns.svc.cluster.local
289 namespace: linkerd
290 spec:
291 routes:
292 - condition:
293 pathRegex: "/x/y/z"`,
294 },
295 nil,
296 },
297 {
298 []string{`
299 apiVersion: apiregistration.k8s.io/v1
300 kind: APIService
301 metadata:
302 name: v1alpha1.tap.linkerd.io
303 labels:
304 linkerd.io/control-plane-component: tap
305 linkerd.io/control-plane-ns: linkerd
306 spec:
307 group: tap.linkerd.io
308 version: v1alpha1
309 groupPriorityMinimum: 1000
310 versionPriority: 100
311 service:
312 name: linkerd-tap
313 namespace: linkerd
314 caBundle: dGFwIGNydA==`,
315 },
316 nil,
317 },
318 {
319 []string{"---"},
320 nil,
321 },
322 }
323
324 for i, tc := range testCases {
325 tc := tc
326
327 t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
328 readers := []io.Reader{}
329 for _, m := range tc.manifests {
330 readers = append(readers, strings.NewReader(m))
331 }
332
333 _, _, _, _, err := newFakeClientSetsFromManifests(readers)
334 if diff := deep.Equal(err, tc.err); diff != nil {
335 t.Errorf("%+v", diff)
336 }
337 })
338 }
339 }
340
341 func TestToRuntimeObject(t *testing.T) {
342 testCases := []struct {
343 config string
344 err error
345 }{
346 {
347 `kind: ConfigMap
348 apiVersion: v1
349 metadata:
350 name: fake-cm
351 namespace: ns
352 data:
353 foo: bar`,
354 nil,
355 },
356 {
357 `kind: Secret
358 apiVersion: v1
359 metadata:
360 name: fake-secret
361 namespace: ns
362 data:
363 foo: YmFyCg==`,
364 nil,
365 },
366 {
367 `
368 apiVersion: linkerd.io/v1alpha2
369 kind: ServiceProfile
370 metadata:
371 name: foobar.ns.svc.cluster.local
372 namespace: linkerd
373 spec:
374 routes:
375 - condition:
376 pathRegex: "/x/y/z"`,
377 nil,
378 },
379 {
380 "",
381 runtime.NewMissingKindErr(""),
382 },
383 {
384 "---",
385 runtime.NewMissingKindErr("---"),
386 },
387 {
388 `
389 apiVersion: apiextensions.k8s.io/v1beta1
390 kind: CustomResourceDefinition
391 metadata:
392 name: fakecrd.linkerd.io
393 spec:
394 group: my-group.io
395 version: v1alpha1
396 scope: Namespaced
397 names:
398 plural: fakecrds
399 singular: fakecrd
400 kind: FakeCRD
401 shortNames:
402 - fc`,
403 nil,
404 },
405 {
406 `
407 apiVersion: apiregistration.k8s.io/v1
408 kind: APIService
409 metadata:
410 name: v1alpha1.tap.linkerd.io
411 labels:
412 linkerd.io/control-plane-component: tap
413 linkerd.io/control-plane-ns: linkerd
414 spec:
415 group: tap.linkerd.io
416 version: v1alpha1
417 groupPriorityMinimum: 1000
418 versionPriority: 100
419 service:
420 name: linkerd-tap
421 namespace: linkerd
422 caBundle: dGFwIGNydA==`,
423 nil,
424 },
425 }
426
427 for i, tc := range testCases {
428 tc := tc
429
430 t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
431 _, err := ToRuntimeObject(tc.config)
432 if diff := deep.Equal(err, tc.err); diff != nil {
433 t.Errorf("%+v", diff)
434 }
435 })
436 }
437 }
438
View as plain text