2 # Copyright 2020 Canonical Ltd.
4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
5 # not use this file except in compliance with the License. You may obtain
6 # a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 # License for the specific language governing permissions and limitations
16 # For those usages not covered by the Apache License, Version 2.0 please
17 # contact: legal@canonical.com
19 # To get in touch with the maintainers, please contact:
20 # osm-charmers@lists.launchpad.net
23 from typing
import NoReturn
25 from ops
.model
import BlockedStatus
27 from ops
.testing
import Harness
29 from charm
import NbiCharm
32 class TestCharm(unittest
.TestCase
):
33 """NBI Charm unit tests."""
35 def setUp(self
) -> NoReturn
:
37 self
.harness
= Harness(NbiCharm
)
38 self
.harness
.set_leader(is_leader
=True)
41 def test_on_start_without_relations(self
) -> NoReturn
:
42 """Test installation without any relation."""
43 self
.harness
.charm
.on
.start
.emit()
46 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
48 # Verifying status message
49 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
51 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
53 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
54 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
55 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
56 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
57 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
59 def test_on_start_without_relations_with_keystone(self
) -> NoReturn
:
60 """Test installation without any relation and keystone enabled."""
61 self
.harness
.update_config({"auth_backend": "keystone"})
63 self
.harness
.charm
.on
.start
.emit()
66 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
68 # Verifying status message
69 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
71 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
73 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
74 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
75 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
76 self
.assertIn("keystone", self
.harness
.charm
.unit
.status
.message
)
77 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
79 def test_on_start_with_relations(self
) -> NoReturn
:
80 """Test deployment without keystone."""
86 "imageDetails": self
.harness
.charm
.image
.fetch(),
87 "imagePullPolicy": "Always",
91 "containerPort": 9999,
96 "ALLOW_ANONYMOUS_LOGIN": "yes",
97 "OSMNBI_SERVER_ENABLE_TEST": False,
98 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
99 "OSMNBI_MESSAGE_HOST": "kafka",
100 "OSMNBI_MESSAGE_DRIVER": "kafka",
101 "OSMNBI_MESSAGE_PORT": 9092,
102 "OSMNBI_DATABASE_DRIVER": "mongo",
103 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
104 "OSMNBI_DATABASE_COMMONKEY": "osm",
105 "OSMNBI_STORAGE_DRIVER": "mongo",
106 "OSMNBI_STORAGE_PATH": "/app/storage",
107 "OSMNBI_STORAGE_COLLECTION": "files",
108 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
109 "OSMNBI_PROMETHEUS_HOST": "prometheus",
110 "OSMNBI_PROMETHEUS_PORT": 9090,
111 "OSMNBI_LOG_LEVEL": "INFO",
112 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
116 "kubernetesResources": {
117 "ingressResources": [],
121 self
.harness
.charm
.on
.start
.emit()
123 # Check if kafka datastore is initialized
124 self
.assertIsNone(self
.harness
.charm
.state
.message_host
)
125 self
.assertIsNone(self
.harness
.charm
.state
.message_port
)
127 # Check if mongodb datastore is initialized
128 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
130 # Check if prometheus datastore is initialized
131 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
132 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
134 # Initializing the kafka relation
135 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
136 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
137 self
.harness
.update_relation_data(
138 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
141 # Initializing the mongo relation
142 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
143 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
144 self
.harness
.update_relation_data(
147 {"connection_string": "mongo://mongo:27017"},
150 # Initializing the prometheus relation
151 prometheus_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
152 self
.harness
.add_relation_unit(prometheus_relation_id
, "prometheus/0")
153 self
.harness
.update_relation_data(
154 prometheus_relation_id
,
156 {"hostname": "prometheus", "port": 9090},
159 # Checking if kafka data is stored
160 self
.assertEqual(self
.harness
.charm
.state
.message_host
, "kafka")
161 self
.assertEqual(self
.harness
.charm
.state
.message_port
, 9092)
163 # Checking if mongodb data is stored
164 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongo://mongo:27017")
166 # Checking if prometheus data is stored
167 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
168 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
171 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
173 pod_spec
, _
= self
.harness
.get_pod_spec()
175 self
.assertDictEqual(expected_result
, pod_spec
)
177 def test_on_start_with_relations_with_keystone(self
) -> NoReturn
:
178 """Test deployment with keystone."""
184 "imageDetails": self
.harness
.charm
.image
.fetch(),
185 "imagePullPolicy": "Always",
189 "containerPort": 9999,
194 "ALLOW_ANONYMOUS_LOGIN": "yes",
195 "OSMNBI_SERVER_ENABLE_TEST": False,
196 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
197 "OSMNBI_MESSAGE_HOST": "kafka",
198 "OSMNBI_MESSAGE_DRIVER": "kafka",
199 "OSMNBI_MESSAGE_PORT": 9092,
200 "OSMNBI_DATABASE_DRIVER": "mongo",
201 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
202 "OSMNBI_DATABASE_COMMONKEY": "osm",
203 "OSMNBI_STORAGE_DRIVER": "mongo",
204 "OSMNBI_STORAGE_PATH": "/app/storage",
205 "OSMNBI_STORAGE_COLLECTION": "files",
206 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
207 "OSMNBI_PROMETHEUS_HOST": "prometheus",
208 "OSMNBI_PROMETHEUS_PORT": 9090,
209 "OSMNBI_LOG_LEVEL": "INFO",
210 "OSMNBI_AUTHENTICATION_BACKEND": "keystone",
211 "OSMNBI_AUTHENTICATION_AUTH_URL": "keystone",
212 "OSMNBI_AUTHENTICATION_AUTH_PORT": 5000,
213 "OSMNBI_AUTHENTICATION_USER_DOMAIN_NAME": "default",
214 "OSMNBI_AUTHENTICATION_PROJECT_DOMAIN_NAME": "default",
215 "OSMNBI_AUTHENTICATION_SERVICE_USERNAME": "nbi",
216 "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD": "nbi",
217 "OSMNBI_AUTHENTICATION_SERVICE_PROJECT": "service",
221 "kubernetesResources": {
222 "ingressResources": [],
226 self
.harness
.update_config({"auth_backend": "keystone"})
228 self
.harness
.charm
.on
.start
.emit()
230 # Check if kafka datastore is initialized
231 self
.assertIsNone(self
.harness
.charm
.state
.message_host
)
232 self
.assertIsNone(self
.harness
.charm
.state
.message_port
)
234 # Check if mongodb datastore is initialized
235 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
237 # Check if prometheus datastore is initialized
238 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
239 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
241 # Check if keystone datastore is initialized
242 self
.assertIsNone(self
.harness
.charm
.state
.keystone_host
)
243 self
.assertIsNone(self
.harness
.charm
.state
.keystone_port
)
244 self
.assertIsNone(self
.harness
.charm
.state
.keystone_user_domain_name
)
245 self
.assertIsNone(self
.harness
.charm
.state
.keystone_project_domain_name
)
246 self
.assertIsNone(self
.harness
.charm
.state
.keystone_username
)
247 self
.assertIsNone(self
.harness
.charm
.state
.keystone_password
)
248 self
.assertIsNone(self
.harness
.charm
.state
.keystone_service
)
250 # Initializing the kafka relation
251 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
252 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
253 self
.harness
.update_relation_data(
254 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
257 # Initializing the mongodb relation
258 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
259 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
260 self
.harness
.update_relation_data(
263 {"connection_string": "mongo://mongo:27017"},
266 # Initializing the prometheus relation
267 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
268 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
269 self
.harness
.update_relation_data(
270 promethues_relation_id
,
272 {"hostname": "prometheus", "port": 9090},
275 # Initializing the keystone relation
276 keystone_relation_id
= self
.harness
.add_relation("keystone", "keystone")
277 self
.harness
.add_relation_unit(keystone_relation_id
, "keystone/0")
278 self
.harness
.update_relation_data(
279 keystone_relation_id
,
284 "user_domain_name": "default",
285 "project_domain_name": "default",
288 "service": "service",
292 # Checking if kafka data is stored
293 self
.assertEqual(self
.harness
.charm
.state
.message_host
, "kafka")
294 self
.assertEqual(self
.harness
.charm
.state
.message_port
, 9092)
296 # Checking if mongodb data is stored
297 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongo://mongo:27017")
299 # Checking if prometheus data is stored
300 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
301 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
303 # Checking if keystone data is stored
304 self
.assertEqual(self
.harness
.charm
.state
.keystone_host
, "keystone")
305 self
.assertEqual(self
.harness
.charm
.state
.keystone_port
, 5000)
306 self
.assertEqual(self
.harness
.charm
.state
.keystone_user_domain_name
, "default")
308 self
.harness
.charm
.state
.keystone_project_domain_name
, "default"
310 self
.assertEqual(self
.harness
.charm
.state
.keystone_username
, "nbi")
311 self
.assertEqual(self
.harness
.charm
.state
.keystone_password
, "nbi")
312 self
.assertEqual(self
.harness
.charm
.state
.keystone_service
, "service")
315 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
317 pod_spec
, _
= self
.harness
.get_pod_spec()
319 self
.assertDictEqual(expected_result
, pod_spec
)
321 def test_ingress_resources_without_http(self
) -> NoReturn
:
322 """Test ingress resources without HTTP."""
328 "imageDetails": self
.harness
.charm
.image
.fetch(),
329 "imagePullPolicy": "Always",
333 "containerPort": 9999,
338 "ALLOW_ANONYMOUS_LOGIN": "yes",
339 "OSMNBI_SERVER_ENABLE_TEST": False,
340 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
341 "OSMNBI_MESSAGE_HOST": "kafka",
342 "OSMNBI_MESSAGE_DRIVER": "kafka",
343 "OSMNBI_MESSAGE_PORT": 9092,
344 "OSMNBI_DATABASE_DRIVER": "mongo",
345 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
346 "OSMNBI_DATABASE_COMMONKEY": "osm",
347 "OSMNBI_STORAGE_DRIVER": "mongo",
348 "OSMNBI_STORAGE_PATH": "/app/storage",
349 "OSMNBI_STORAGE_COLLECTION": "files",
350 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
351 "OSMNBI_PROMETHEUS_HOST": "prometheus",
352 "OSMNBI_PROMETHEUS_PORT": 9090,
353 "OSMNBI_LOG_LEVEL": "INFO",
354 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
358 "kubernetesResources": {
359 "ingressResources": [],
363 self
.harness
.charm
.on
.start
.emit()
365 # Initializing the kafka relation
366 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
367 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
368 self
.harness
.update_relation_data(
369 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
372 # Initializing the mongodb relation
373 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
374 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
375 self
.harness
.update_relation_data(
378 {"connection_string": "mongo://mongo:27017"},
381 # Initializing the prometheus relation
382 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
383 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
384 self
.harness
.update_relation_data(
385 promethues_relation_id
,
387 {"hostname": "prometheus", "port": 9090},
390 self
.harness
.update_config({"site_url": "nbi"})
392 pod_spec
, _
= self
.harness
.get_pod_spec()
394 self
.assertDictEqual(expected_result
, pod_spec
)
396 def test_ingress_resources_with_http(self
) -> NoReturn
:
397 """Test ingress resources with HTTP."""
403 "imageDetails": self
.harness
.charm
.image
.fetch(),
404 "imagePullPolicy": "Always",
408 "containerPort": 9999,
413 "ALLOW_ANONYMOUS_LOGIN": "yes",
414 "OSMNBI_SERVER_ENABLE_TEST": False,
415 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
416 "OSMNBI_MESSAGE_HOST": "kafka",
417 "OSMNBI_MESSAGE_DRIVER": "kafka",
418 "OSMNBI_MESSAGE_PORT": 9092,
419 "OSMNBI_DATABASE_DRIVER": "mongo",
420 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
421 "OSMNBI_DATABASE_COMMONKEY": "osm",
422 "OSMNBI_STORAGE_DRIVER": "mongo",
423 "OSMNBI_STORAGE_PATH": "/app/storage",
424 "OSMNBI_STORAGE_COLLECTION": "files",
425 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
426 "OSMNBI_PROMETHEUS_HOST": "prometheus",
427 "OSMNBI_PROMETHEUS_PORT": 9090,
428 "OSMNBI_LOG_LEVEL": "INFO",
429 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
433 "kubernetesResources": {
434 "ingressResources": [
436 "name": "nbi-ingress",
438 "nginx.ingress.kubernetes.io/proxy-body-size": "0",
439 "nginx.ingress.kubernetes.io/ssl-redirect": "false",
450 "serviceName": "nbi",
464 self
.harness
.charm
.on
.start
.emit()
466 # Initializing the kafka relation
467 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
468 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
469 self
.harness
.update_relation_data(
470 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
473 # Initializing the mongodb relation
474 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
475 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
476 self
.harness
.update_relation_data(
479 {"connection_string": "mongo://mongo:27017"},
482 # Initializing the prometheus relation
483 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
484 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
485 self
.harness
.update_relation_data(
486 promethues_relation_id
,
488 {"hostname": "prometheus", "port": 9090},
491 self
.harness
.update_config({"site_url": "http://nbi"})
493 pod_spec
, _
= self
.harness
.get_pod_spec()
495 self
.assertDictEqual(expected_result
, pod_spec
)
497 def test_ingress_resources_with_https(self
) -> NoReturn
:
498 """Test ingress resources with HTTPS."""
504 "imageDetails": self
.harness
.charm
.image
.fetch(),
505 "imagePullPolicy": "Always",
509 "containerPort": 9999,
514 "ALLOW_ANONYMOUS_LOGIN": "yes",
515 "OSMNBI_SERVER_ENABLE_TEST": False,
516 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
517 "OSMNBI_MESSAGE_HOST": "kafka",
518 "OSMNBI_MESSAGE_DRIVER": "kafka",
519 "OSMNBI_MESSAGE_PORT": 9092,
520 "OSMNBI_DATABASE_DRIVER": "mongo",
521 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
522 "OSMNBI_DATABASE_COMMONKEY": "osm",
523 "OSMNBI_STORAGE_DRIVER": "mongo",
524 "OSMNBI_STORAGE_PATH": "/app/storage",
525 "OSMNBI_STORAGE_COLLECTION": "files",
526 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
527 "OSMNBI_PROMETHEUS_HOST": "prometheus",
528 "OSMNBI_PROMETHEUS_PORT": 9090,
529 "OSMNBI_LOG_LEVEL": "INFO",
530 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
534 "kubernetesResources": {
535 "ingressResources": [
537 "name": "nbi-ingress",
539 "nginx.ingress.kubernetes.io/proxy-body-size": "0",
550 "serviceName": "nbi",
558 "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
565 self
.harness
.charm
.on
.start
.emit()
567 # Initializing the kafka relation
568 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
569 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
570 self
.harness
.update_relation_data(
571 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
574 # Initializing the mongodb relation
575 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
576 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
577 self
.harness
.update_relation_data(
580 {"connection_string": "mongo://mongo:27017"},
583 # Initializing the prometheus relation
584 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
585 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
586 self
.harness
.update_relation_data(
587 promethues_relation_id
,
589 {"hostname": "prometheus", "port": 9090},
592 self
.harness
.update_config(
593 {"site_url": "https://nbi", "tls_secret_name": "nbi"}
596 pod_spec
, _
= self
.harness
.get_pod_spec()
598 self
.assertDictEqual(expected_result
, pod_spec
)
600 def test_ingress_resources_with_https_and_ingress_whitelist(self
) -> NoReturn
:
601 """Test ingress resources with HTTPS and ingress whitelist."""
607 "imageDetails": self
.harness
.charm
.image
.fetch(),
608 "imagePullPolicy": "Always",
612 "containerPort": 9999,
617 "ALLOW_ANONYMOUS_LOGIN": "yes",
618 "OSMNBI_SERVER_ENABLE_TEST": False,
619 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
620 "OSMNBI_MESSAGE_HOST": "kafka",
621 "OSMNBI_MESSAGE_DRIVER": "kafka",
622 "OSMNBI_MESSAGE_PORT": 9092,
623 "OSMNBI_DATABASE_DRIVER": "mongo",
624 "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
625 "OSMNBI_DATABASE_COMMONKEY": "osm",
626 "OSMNBI_STORAGE_DRIVER": "mongo",
627 "OSMNBI_STORAGE_PATH": "/app/storage",
628 "OSMNBI_STORAGE_COLLECTION": "files",
629 "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
630 "OSMNBI_PROMETHEUS_HOST": "prometheus",
631 "OSMNBI_PROMETHEUS_PORT": 9090,
632 "OSMNBI_LOG_LEVEL": "INFO",
633 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
637 "kubernetesResources": {
638 "ingressResources": [
640 "name": "nbi-ingress",
642 "nginx.ingress.kubernetes.io/proxy-body-size": "0",
643 "nginx.ingress.kubernetes.io/whitelist-source-range": "0.0.0.0/0",
654 "serviceName": "nbi",
662 "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
669 self
.harness
.charm
.on
.start
.emit()
671 # Initializing the kafka relation
672 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
673 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
674 self
.harness
.update_relation_data(
675 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
678 # Initializing the mongodb relation
679 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
680 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
681 self
.harness
.update_relation_data(
684 {"connection_string": "mongo://mongo:27017"},
687 # Initializing the prometheus relation
688 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
689 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
690 self
.harness
.update_relation_data(
691 promethues_relation_id
,
693 {"hostname": "prometheus", "port": 9090},
696 self
.harness
.update_config(
698 "site_url": "https://nbi",
699 "tls_secret_name": "nbi",
700 "ingress_whitelist_source_range": "0.0.0.0/0",
704 pod_spec
, _
= self
.harness
.get_pod_spec()
706 self
.assertDictEqual(expected_result
, pod_spec
)
708 def test_on_kafka_relation_changed(self
) -> NoReturn
:
709 """Test to see if kafka relation is updated."""
710 self
.harness
.charm
.on
.start
.emit()
712 self
.assertIsNone(self
.harness
.charm
.state
.message_host
)
713 self
.assertIsNone(self
.harness
.charm
.state
.message_port
)
715 relation_id
= self
.harness
.add_relation("kafka", "kafka")
716 self
.harness
.add_relation_unit(relation_id
, "kafka/0")
717 self
.harness
.update_relation_data(
718 relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
721 self
.assertEqual(self
.harness
.charm
.state
.message_host
, "kafka")
722 self
.assertEqual(self
.harness
.charm
.state
.message_port
, 9092)
725 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
727 # Verifying status message
728 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
730 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
732 self
.assertNotIn("kafka", self
.harness
.charm
.unit
.status
.message
)
733 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
734 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
735 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
736 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
738 def test_on_mongodb_relation_changed(self
) -> NoReturn
:
739 """Test to see if mongodb relation is updated."""
740 self
.harness
.charm
.on
.start
.emit()
742 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
744 relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
745 self
.harness
.add_relation_unit(relation_id
, "mongodb/0")
746 self
.harness
.update_relation_data(
747 relation_id
, "mongodb/0", {"connection_string": "mongo://mongo:27017"}
750 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongo://mongo:27017")
753 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
755 # Verifying status message
756 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
758 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
760 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
761 self
.assertNotIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
762 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
763 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
764 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
766 def test_on_prometheus_relation_changed(self
) -> NoReturn
:
767 """Test to see if prometheus relation is updated."""
768 self
.harness
.charm
.on
.start
.emit()
770 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
771 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
773 relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
774 self
.harness
.add_relation_unit(relation_id
, "prometheus/0")
775 self
.harness
.update_relation_data(
776 relation_id
, "prometheus/0", {"hostname": "prometheus", "port": 9090}
779 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
780 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
783 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
785 # Verifying status message
786 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
788 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
790 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
791 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
792 self
.assertNotIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
793 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
794 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
796 def test_on_keystone_relation_changed(self
) -> NoReturn
:
797 """Test to see if keystone relation is updated."""
798 self
.harness
.update_config({"auth_backend": "keystone"})
800 self
.harness
.charm
.on
.start
.emit()
802 self
.assertIsNone(self
.harness
.charm
.state
.keystone_host
)
803 self
.assertIsNone(self
.harness
.charm
.state
.keystone_port
)
804 self
.assertIsNone(self
.harness
.charm
.state
.keystone_user_domain_name
)
805 self
.assertIsNone(self
.harness
.charm
.state
.keystone_project_domain_name
)
806 self
.assertIsNone(self
.harness
.charm
.state
.keystone_username
)
807 self
.assertIsNone(self
.harness
.charm
.state
.keystone_password
)
808 self
.assertIsNone(self
.harness
.charm
.state
.keystone_service
)
810 relation_id
= self
.harness
.add_relation("keystone", "keystone")
811 self
.harness
.add_relation_unit(relation_id
, "keystone/0")
812 self
.harness
.update_relation_data(
818 "user_domain_name": "default",
819 "project_domain_name": "default",
822 "service": "service",
826 self
.assertEqual(self
.harness
.charm
.state
.keystone_host
, "keystone")
827 self
.assertEqual(self
.harness
.charm
.state
.keystone_port
, 5000)
828 self
.assertEqual(self
.harness
.charm
.state
.keystone_user_domain_name
, "default")
830 self
.harness
.charm
.state
.keystone_project_domain_name
, "default"
832 self
.assertEqual(self
.harness
.charm
.state
.keystone_username
, "nbi")
833 self
.assertEqual(self
.harness
.charm
.state
.keystone_password
, "nbi")
834 self
.assertEqual(self
.harness
.charm
.state
.keystone_service
, "service")
837 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
839 # Verifying status message
840 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
842 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
844 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
845 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
846 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
847 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
848 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
850 def test_publish_nbi_info(self
) -> NoReturn
:
851 """Test to see if nbi relation is updated."""
857 self
.harness
.charm
.on
.start
.emit()
859 relation_id
= self
.harness
.add_relation("nbi", "ng-ui")
860 self
.harness
.add_relation_unit(relation_id
, "ng-ui/0")
861 relation_data
= self
.harness
.get_relation_data(relation_id
, "nbi")
863 self
.assertDictEqual(expected_result
, relation_data
)
866 if __name__
== "__main__":