Debian Codegraph @

magnum_capi_helm/tests/test_kubernetes.py

raw
1 # Licensed under the Apache License, Version 2.0 (the "License"); you may
2 # not use this file except in compliance with the License. You may obtain
3 # a copy of the License at
4 #
5 # http://www.apache.org/licenses/LICENSE-2.0
6 #
7 # Unless required by applicable law or agreed to in writing, software
8 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
9 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
10 # License for the specific language governing permissions and limitations
11 # under the License.
12
13 import base64
14 import os
15 import pathlib
16 import tempfile
17 from unittest import mock
18 import yaml
19
20 import requests
21
22 from magnum_capi_helm import kubernetes
23 from magnum_capi_helm.tests import base
24
25 TEST_SERVER = "https://test:6443"
26 TEST_KUBECONFIG_YAML = f"""\
27 apiVersion: v1
28 clusters:
29 - cluster:
30 certificate-authority: "cafile"
31 server: {TEST_SERVER}
32 name: default
33 contexts:
34 - context:
35 cluster: default
36 user: default
37 name: default
38 current-context: default
39 kind: Config
40 users:
41 - name: default
42 user:
43 client-certificate: "certfile"
44 client-key: "keyfile"
45 """
46 TEST_KUBECONFIG = yaml.safe_load(TEST_KUBECONFIG_YAML)
47
48
49 class TestKubernetesClient(base.TestCase):
50 # Basic lookup, non "-data" key
51 def test_file_or_data(self):
52 data, cleanup = kubernetes.ensure_file_cert(dict(key="mydata"), "key")
53 self.assertEqual("mydata", data)
54 self.assertFalse(cleanup)
55
56 # Lookup with a "-data" key, requiring temporary file
57 @mock.patch.object(tempfile, "NamedTemporaryFile")
58 def test_file_or_data_create_temp(self, mock_temp):
59 data, cleanup = kubernetes.ensure_file_cert(
60 {"key-data": base64.b64encode(b"mydata").decode("utf-8")}, "key"
61 )
62 mock_temp.assert_has_calls(
63 [
64 mock.call(delete=False),
65 mock.call().__enter__(),
66 mock.call().__enter__().write(b"mydata"),
67 mock.call().__exit__(None, None, None),
68 ]
69 )
70 self.assertEqual(mock_temp().__enter__().name, data)
71 self.assertTrue(cleanup)
72
73 # Lookup with no key, expecting no error, and no data returned.
74 def test_file_or_data_missing(self):
75 data, cleanup = kubernetes.ensure_file_cert(dict(), "key")
76 self.assertIsNone(data)
77 self.assertFalse(cleanup)
78
79 def test_client_constructor(self):
80 client = kubernetes.Client(TEST_KUBECONFIG)
81
82 self.assertEqual(TEST_SERVER, client.server)
83 self.assertEqual("cafile", client.verify)
84 self.assertEqual(("certfile", "keyfile"), client.cert)
85
86 @mock.patch.object(tempfile, "NamedTemporaryFile")
87 @mock.patch.object(os, "remove")
88 def test_client_certificate_finalizer(self, mock_remove, mock_temp):
89 kubeconfig = yaml.safe_load(TEST_KUBECONFIG_YAML)
90
91 # Set -data in base64 to create tmp files.
92 del kubeconfig["users"][0]["user"]["client-certificate"]
93 kubeconfig["users"][0]["user"]["client-certificate-data"] = (
94 base64.b64encode(b"client cert data").decode("utf-8")
95 )
96
97 client = kubernetes.Client(kubeconfig)
98
99 # Ensure a temporary file was created
100 mock_temp.assert_has_calls(
101 [
102 mock.call(delete=False),
103 mock.call().__enter__(),
104 mock.call().__enter__().write(b"client cert data"),
105 mock.call().__exit__(None, None, None),
106 ]
107 )
108
109 # Call finalizer method directly
110 client.__del__()
111
112 # Exactly one temp file should be cleaned up
113 mock_remove.assert_called_once()
114
115 def test_get_kubeconfig_path_default(self):
116 self.assertEqual(
117 pathlib.Path.home() / ".kube" / "config",
118 kubernetes.Client._get_kubeconfig_path(),
119 )
120
121 @mock.patch.object(kubernetes.CONF, "capi_helm")
122 def test_get_kubeconfig_path_config(self, mock_conf):
123 mock_conf.kubeconfig_file = "foo"
124 os.environ["KUBECONFIG"] = "bar"
125
126 path = kubernetes.Client._get_kubeconfig_path()
127
128 del os.environ["KUBECONFIG"]
129 self.assertEqual("foo", path)
130
131 def test_get_kubeconfig_path_env(self):
132 os.environ["KUBECONFIG"] = "bar"
133
134 path = kubernetes.Client._get_kubeconfig_path()
135
136 del os.environ["KUBECONFIG"]
137 self.assertEqual("bar", path)
138
139 @mock.patch.object(kubernetes.CONF, "capi_helm")
140 @mock.patch(
141 "builtins.open",
142 new_callable=mock.mock_open,
143 read_data=TEST_KUBECONFIG_YAML,
144 )
145 def test_client_load(self, mock_open, mock_conf):
146 mock_conf.kubeconfig_file = "mypath"
147
148 client = kubernetes.Client.load()
149
150 self.assertEqual(TEST_SERVER, client.server)
151 mock_open.assert_called_once_with("mypath")
152
153 @mock.patch.object(requests.Session, "request")
154 def test_ensure_namespace(self, mock_request):
155 client = kubernetes.Client(TEST_KUBECONFIG)
156
157 client.ensure_namespace("namespace1")
158
159 mock_request.assert_called_once_with(
160 "PATCH",
161 "https://test:6443/api/v1/namespaces/namespace1",
162 data=None,
163 json={
164 "apiVersion": "v1",
165 "kind": "Namespace",
166 "metadata": {"name": "namespace1"},
167 },
168 headers={"Content-Type": "application/apply-patch+yaml"},
169 params={"fieldManager": "magnum", "force": "true"},
170 )
171
172 @mock.patch.object(requests.Session, "request")
173 def test_apply_secret(self, mock_request):
174 client = kubernetes.Client(TEST_KUBECONFIG)
175 test_data = dict(
176 stringData=dict(foo="bar"), metadata=dict(labels=dict(baz="asdf"))
177 )
178
179 client.apply_secret("secname", test_data, "ns1")
180
181 mock_request.assert_called_once_with(
182 "PATCH",
183 "https://test:6443/api/v1/namespaces/ns1/secrets/secname",
184 data=None,
185 json={
186 "stringData": {"foo": "bar"},
187 "apiVersion": "v1",
188 "kind": "Secret",
189 "metadata": {
190 "labels": {"baz": "asdf"},
191 "name": "secname",
192 "namespace": "ns1",
193 },
194 },
195 headers={"Content-Type": "application/apply-patch+yaml"},
196 params={"fieldManager": "magnum", "force": "true"},
197 )
198
199 @mock.patch.object(requests.Session, "request")
200 def test_delete_all_secrets_by_label(self, mock_request):
201 client = kubernetes.Client(TEST_KUBECONFIG)
202 mock_response = mock.MagicMock()
203 mock_request.return_value = mock_response
204
205 client.delete_all_secrets_by_label("label", "cluster1", "ns1")
206
207 mock_request.assert_called_once_with(
208 "DELETE",
209 "https://test:6443/api/v1/namespaces/ns1/secrets",
210 params={"labelSelector": "label=cluster1"},
211 )
212 mock_response.raise_for_status.assert_called_once_with()
213
214 @mock.patch.object(requests.Session, "request")
215 def test_get_capi_cluster_found(self, mock_request):
216 client = kubernetes.Client(TEST_KUBECONFIG)
217 mock_response = mock.MagicMock()
218 mock_response.status_code = 200
219 mock_response.json.return_value = "mock_json"
220 mock_request.return_value = mock_response
221
222 cluster = client.get_capi_cluster("name", "ns1")
223
224 mock_request.assert_called_once_with(
225 "GET",
226 (
227 "https://test:6443/apis/cluster.x-k8s.io/"
228 "v1beta1/namespaces/ns1/clusters/name"
229 ),
230 allow_redirects=True,
231 )
232 self.assertEqual("mock_json", cluster)
233
234 @mock.patch.object(requests.Session, "request")
235 def test_get_capi_cluster_not_found(self, mock_request):
236 client = kubernetes.Client(TEST_KUBECONFIG)
237 mock_response = mock.MagicMock()
238 mock_response.status_code = 404
239 mock_request.return_value = mock_response
240
241 cluster = client.get_capi_cluster("name", "ns1")
242
243 self.assertIsNone(cluster)
244
245 @mock.patch.object(requests.Session, "request")
246 def test_get_capi_cluster_error(self, mock_request):
247 client = kubernetes.Client(TEST_KUBECONFIG)
248 mock_response = mock.MagicMock()
249 mock_response.status_code = 500
250 mock_response.raise_for_status.side_effect = requests.HTTPError
251 mock_request.return_value = mock_response
252
253 self.assertRaises(
254 requests.HTTPError, client.get_capi_cluster, "name", "ns1"
255 )
256
257 @mock.patch.object(requests.Session, "request")
258 def test_get_kubeadm_control_plane_found(self, mock_request):
259 client = kubernetes.Client(TEST_KUBECONFIG)
260 mock_response = mock.MagicMock()
261 mock_response.status_code = 200
262 mock_response.json.return_value = "mock_json"
263 mock_request.return_value = mock_response
264
265 cluster = client.get_kubeadm_control_plane("name", "ns1")
266
267 mock_request.assert_called_once_with(
268 "GET",
269 (
270 "https://test:6443/apis/controlplane.cluster.x-k8s.io/"
271 "v1beta1/namespaces/ns1/kubeadmcontrolplanes/name"
272 ),
273 allow_redirects=True,
274 )
275 self.assertEqual("mock_json", cluster)
276
277 @mock.patch.object(requests.Session, "request")
278 def test_get_machine_deployment_found(self, mock_request):
279 client = kubernetes.Client(TEST_KUBECONFIG)
280 mock_response = mock.MagicMock()
281 mock_response.status_code = 200
282 mock_response.json.return_value = "mock_json"
283 mock_request.return_value = mock_response
284
285 cluster = client.get_machine_deployment("name", "ns1")
286
287 mock_request.assert_called_once_with(
288 "GET",
289 (
290 "https://test:6443/apis/cluster.x-k8s.io/"
291 "v1beta1/namespaces/ns1/machinedeployments/name"
292 ),
293 allow_redirects=True,
294 )
295 self.assertEqual("mock_json", cluster)
296
297 @mock.patch.object(requests.Session, "request")
298 def test_get_manifests_by_label(self, mock_request):
299 items = [
300 {
301 "kind": "Manifests",
302 "metadata": {"name": f"manifests{idx}", "namespace": "ns1"},
303 }
304 for idx in range(5)
305 ]
306
307 mock_response = mock.Mock()
308 mock_response.status_code = 200
309 mock_response.json.return_value = {
310 "metadata": {
311 "continue": "",
312 },
313 "items": items,
314 }
315 mock_request.return_value = mock_response
316
317 client = kubernetes.Client(TEST_KUBECONFIG)
318 manifests = client.get_manifests_by_label({"label": "cluster1"}, "ns1")
319
320 mock_request.assert_called_once_with(
321 "GET",
322 (
323 "https://test:6443/apis/addons.stackhpc.com/"
324 "v1alpha1/namespaces/ns1/manifests"
325 ),
326 params={"labelSelector": "label=cluster1"},
327 allow_redirects=True,
328 )
329 self.assertEqual(items, manifests)
330
331 @mock.patch.object(requests.Session, "request")
332 def test_get_helm_releases_by_label(self, mock_request):
333 items = [
334 {
335 "kind": "HelmRelease",
336 "metadata": {"name": f"helmrelease{idx}", "namespace": "ns1"},
337 }
338 for idx in range(5)
339 ]
340
341 mock_response = mock.Mock()
342 mock_response.status_code = 200
343 mock_response.json.return_value = {
344 "metadata": {
345 "continue": "",
346 },
347 "items": items,
348 }
349 mock_request.return_value = mock_response
350
351 client = kubernetes.Client(TEST_KUBECONFIG)
352 helm_releases = client.get_helm_releases_by_label(
353 {"label": "cluster1"}, "ns1"
354 )
355
356 mock_request.assert_called_once_with(
357 "GET",
358 (
359 "https://test:6443/apis/addons.stackhpc.com/"
360 "v1alpha1/namespaces/ns1/helmreleases"
361 ),
362 params={"labelSelector": "label=cluster1"},
363 allow_redirects=True,
364 )
365 self.assertEqual(items, helm_releases)
366
367 @mock.patch.object(requests.Session, "request")
368 def test_get_helm_releases_by_label_multipage(self, mock_request):
369 items = [
370 {
371 "kind": "HelmRelease",
372 "metadata": {"name": f"helmrelease{idx}", "namespace": "ns1"},
373 }
374 for idx in range(10)
375 ]
376
377 mock_response_page1 = mock.Mock()
378 mock_response_page1.raise_for_status.return_value = None
379 mock_response_page1.json.return_value = {
380 "metadata": {
381 "continue": "continuetoken",
382 },
383 "items": items[:5],
384 }
385 mock_response_page2 = mock.Mock()
386 mock_response_page2.raise_for_status.return_value = None
387 mock_response_page2.json.return_value = {
388 "metadata": {
389 "continue": "",
390 },
391 "items": items[5:],
392 }
393 mock_request.side_effect = [
394 mock_response_page1,
395 mock_response_page2,
396 ]
397
398 client = kubernetes.Client(TEST_KUBECONFIG)
399 helm_releases = client.get_helm_releases_by_label(
400 {"label": "cluster1"}, "ns1"
401 )
402
403 self.assertEqual(mock_request.call_count, 2)
404 mock_request.assert_has_calls(
405 [
406 mock.call(
407 "GET",
408 (
409 "https://test:6443/apis/addons.stackhpc.com/"
410 "v1alpha1/namespaces/ns1/helmreleases"
411 ),
412 params={"labelSelector": "label=cluster1"},
413 allow_redirects=True,
414 ),
415 mock.call(
416 "GET",
417 (
418 "https://test:6443/apis/addons.stackhpc.com/"
419 "v1alpha1/namespaces/ns1/helmreleases"
420 ),
421 params={
422 "labelSelector": "label=cluster1",
423 "continue": "continuetoken",
424 },
425 allow_redirects=True,
426 ),
427 ]
428 )
429 self.assertEqual(items, helm_releases)
430
431 @mock.patch.object(kubernetes.Client, "get_helm_releases_by_label")
432 @mock.patch.object(kubernetes.Client, "get_manifests_by_label")
433 def test_get_addons_by_label(
434 self, mock_get_manifests, mock_get_helm_releases
435 ):
436 manifests = [
437 {
438 "kind": "Manifests",
439 "metadata": {"name": f"manifests{idx}", "namespace": "ns1"},
440 }
441 for idx in range(5)
442 ]
443 helm_releases = [
444 {
445 "kind": "HelmRelease",
446 "metadata": {"name": f"helmrelease{idx}", "namespace": "ns1"},
447 }
448 for idx in range(5)
449 ]
450
451 mock_get_manifests.return_value = manifests
452 mock_get_helm_releases.return_value = helm_releases
453
454 client = kubernetes.Client(TEST_KUBECONFIG)
455 addons = client.get_addons_by_label({"label": "cluster1"}, "ns1")
456
457 mock_get_manifests.assert_called_once_with(
458 {"label": "cluster1"}, "ns1"
459 )
460 mock_get_helm_releases.assert_called_once_with(
461 {"label": "cluster1"}, "ns1"
462 )
463 self.assertEqual(manifests + helm_releases, addons)
464
465 @mock.patch.object(requests.Session, "request")
466 def test_get_all_machines_by_label(self, mock_request):
467 items = [
468 {
469 "kind": "Machine",
470 "metadata": {"name": f"machine{idx}", "namespace": "ns1"},
471 }
472 for idx in range(5)
473 ]
474
475 mock_response = mock.Mock()
476 mock_response.status_code = 200
477 mock_response.json.return_value = {
478 "metadata": {
479 "continue": "",
480 },
481 "items": items,
482 }
483 mock_request.return_value = mock_response
484
485 client = kubernetes.Client(TEST_KUBECONFIG)
486 machines = client.get_all_machines_by_label(
487 {"capi.stackhpc.com/cluster": "cluster_name", "foo": "bar"}, "ns1"
488 )
489
490 mock_request.assert_called_once_with(
491 "GET",
492 (
493 "https://test:6443/apis/cluster.x-k8s.io/"
494 "v1beta1/namespaces/ns1/machines"
495 ),
496 params={
497 "labelSelector": (
498 "capi.stackhpc.com/cluster=cluster_name,foo=bar"
499 )
500 },
501 allow_redirects=True,
502 )
503 self.assertEqual(items, machines)