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": "mongodb://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": "mongodb://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": "mongodb://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
, "mongodb://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": "mongodb://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": "mongodb://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": "mongodb://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
, "mongodb://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": "mongodb://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": "mongodb://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": "mongodb://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": "mongodb://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": "mongodb://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",
440 "nginx.ingress.kubernetes.io/backend-protocol": "HTTPS",
451 "serviceName": "nbi",
465 self
.harness
.charm
.on
.start
.emit()
467 # Initializing the kafka relation
468 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
469 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
470 self
.harness
.update_relation_data(
471 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
474 # Initializing the mongodb relation
475 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
476 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
477 self
.harness
.update_relation_data(
480 {"connection_string": "mongodb://mongo:27017"},
483 # Initializing the prometheus relation
484 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
485 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
486 self
.harness
.update_relation_data(
487 promethues_relation_id
,
489 {"hostname": "prometheus", "port": 9090},
492 self
.harness
.update_config({"site_url": "http://nbi"})
494 pod_spec
, _
= self
.harness
.get_pod_spec()
496 self
.assertDictEqual(expected_result
, pod_spec
)
498 def test_ingress_resources_with_https(self
) -> NoReturn
:
499 """Test ingress resources with HTTPS."""
505 "imageDetails": self
.harness
.charm
.image
.fetch(),
506 "imagePullPolicy": "Always",
510 "containerPort": 9999,
515 "ALLOW_ANONYMOUS_LOGIN": "yes",
516 "OSMNBI_SERVER_ENABLE_TEST": False,
517 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
518 "OSMNBI_MESSAGE_HOST": "kafka",
519 "OSMNBI_MESSAGE_DRIVER": "kafka",
520 "OSMNBI_MESSAGE_PORT": 9092,
521 "OSMNBI_DATABASE_DRIVER": "mongo",
522 "OSMNBI_DATABASE_URI": "mongodb://mongo:27017",
523 "OSMNBI_DATABASE_COMMONKEY": "osm",
524 "OSMNBI_STORAGE_DRIVER": "mongo",
525 "OSMNBI_STORAGE_PATH": "/app/storage",
526 "OSMNBI_STORAGE_COLLECTION": "files",
527 "OSMNBI_STORAGE_URI": "mongodb://mongo:27017",
528 "OSMNBI_PROMETHEUS_HOST": "prometheus",
529 "OSMNBI_PROMETHEUS_PORT": 9090,
530 "OSMNBI_LOG_LEVEL": "INFO",
531 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
535 "kubernetesResources": {
536 "ingressResources": [
538 "name": "nbi-ingress",
540 "nginx.ingress.kubernetes.io/proxy-body-size": "0",
541 "nginx.ingress.kubernetes.io/backend-protocol": "HTTPS",
552 "serviceName": "nbi",
560 "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
567 self
.harness
.charm
.on
.start
.emit()
569 # Initializing the kafka relation
570 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
571 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
572 self
.harness
.update_relation_data(
573 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
576 # Initializing the mongodb relation
577 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
578 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
579 self
.harness
.update_relation_data(
582 {"connection_string": "mongodb://mongo:27017"},
585 # Initializing the prometheus relation
586 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
587 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
588 self
.harness
.update_relation_data(
589 promethues_relation_id
,
591 {"hostname": "prometheus", "port": 9090},
594 self
.harness
.update_config(
595 {"site_url": "https://nbi", "tls_secret_name": "nbi"}
598 pod_spec
, _
= self
.harness
.get_pod_spec()
600 self
.assertDictEqual(expected_result
, pod_spec
)
602 def test_ingress_resources_with_https_and_ingress_whitelist(self
) -> NoReturn
:
603 """Test ingress resources with HTTPS and ingress whitelist."""
609 "imageDetails": self
.harness
.charm
.image
.fetch(),
610 "imagePullPolicy": "Always",
614 "containerPort": 9999,
619 "ALLOW_ANONYMOUS_LOGIN": "yes",
620 "OSMNBI_SERVER_ENABLE_TEST": False,
621 "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
622 "OSMNBI_MESSAGE_HOST": "kafka",
623 "OSMNBI_MESSAGE_DRIVER": "kafka",
624 "OSMNBI_MESSAGE_PORT": 9092,
625 "OSMNBI_DATABASE_DRIVER": "mongo",
626 "OSMNBI_DATABASE_URI": "mongodb://mongo:27017",
627 "OSMNBI_DATABASE_COMMONKEY": "osm",
628 "OSMNBI_STORAGE_DRIVER": "mongo",
629 "OSMNBI_STORAGE_PATH": "/app/storage",
630 "OSMNBI_STORAGE_COLLECTION": "files",
631 "OSMNBI_STORAGE_URI": "mongodb://mongo:27017",
632 "OSMNBI_PROMETHEUS_HOST": "prometheus",
633 "OSMNBI_PROMETHEUS_PORT": 9090,
634 "OSMNBI_LOG_LEVEL": "INFO",
635 "OSMNBI_AUTHENTICATION_BACKEND": "internal",
639 "kubernetesResources": {
640 "ingressResources": [
642 "name": "nbi-ingress",
644 "nginx.ingress.kubernetes.io/proxy-body-size": "0",
645 "nginx.ingress.kubernetes.io/backend-protocol": "HTTPS",
646 "nginx.ingress.kubernetes.io/whitelist-source-range": "0.0.0.0/0",
657 "serviceName": "nbi",
665 "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
672 self
.harness
.charm
.on
.start
.emit()
674 # Initializing the kafka relation
675 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
676 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
677 self
.harness
.update_relation_data(
678 kafka_relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
681 # Initializing the mongodb relation
682 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
683 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
684 self
.harness
.update_relation_data(
687 {"connection_string": "mongodb://mongo:27017"},
690 # Initializing the prometheus relation
691 promethues_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
692 self
.harness
.add_relation_unit(promethues_relation_id
, "prometheus/0")
693 self
.harness
.update_relation_data(
694 promethues_relation_id
,
696 {"hostname": "prometheus", "port": 9090},
699 self
.harness
.update_config(
701 "site_url": "https://nbi",
702 "tls_secret_name": "nbi",
703 "ingress_whitelist_source_range": "0.0.0.0/0",
707 pod_spec
, _
= self
.harness
.get_pod_spec()
709 self
.assertDictEqual(expected_result
, pod_spec
)
711 def test_on_kafka_unit_relation_changed(self
) -> NoReturn
:
712 """Test to see if kafka relation is updated."""
713 self
.harness
.charm
.on
.start
.emit()
715 self
.assertIsNone(self
.harness
.charm
.state
.message_host
)
716 self
.assertIsNone(self
.harness
.charm
.state
.message_port
)
718 relation_id
= self
.harness
.add_relation("kafka", "kafka")
719 self
.harness
.add_relation_unit(relation_id
, "kafka/0")
720 self
.harness
.update_relation_data(
721 relation_id
, "kafka/0", {"host": "kafka", "port": 9092}
724 self
.assertEqual(self
.harness
.charm
.state
.message_host
, "kafka")
725 self
.assertEqual(self
.harness
.charm
.state
.message_port
, 9092)
728 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
730 # Verifying status message
731 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
733 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
735 self
.assertNotIn("kafka", self
.harness
.charm
.unit
.status
.message
)
736 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
737 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
738 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
739 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
741 def test_on_mongodb_unit_relation_changed(self
) -> NoReturn
:
742 """Test to see if mongodb relation is updated."""
743 self
.harness
.charm
.on
.start
.emit()
745 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
747 relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
748 self
.harness
.add_relation_unit(relation_id
, "mongodb/0")
749 self
.harness
.update_relation_data(
750 relation_id
, "mongodb/0", {"connection_string": "mongodb://mongo:27017"}
753 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongodb://mongo:27017")
756 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
758 # Verifying status message
759 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
761 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
763 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
764 self
.assertNotIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
765 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
766 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
767 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
769 def test_on_prometheus_unit_relation_changed(self
) -> NoReturn
:
770 """Test to see if prometheus relation is updated."""
771 self
.harness
.charm
.on
.start
.emit()
773 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
774 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
776 relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
777 self
.harness
.add_relation_unit(relation_id
, "prometheus/0")
778 self
.harness
.update_relation_data(
779 relation_id
, "prometheus/0", {"hostname": "prometheus", "port": 9090}
782 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
783 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
786 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
788 # Verifying status message
789 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
791 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
793 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
794 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
795 self
.assertNotIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
796 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
797 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
799 def test_on_keystone_unit_relation_changed(self
) -> NoReturn
:
800 """Test to see if keystone relation is updated."""
801 self
.harness
.update_config({"auth_backend": "keystone"})
803 self
.harness
.charm
.on
.start
.emit()
805 self
.assertIsNone(self
.harness
.charm
.state
.keystone_host
)
806 self
.assertIsNone(self
.harness
.charm
.state
.keystone_port
)
807 self
.assertIsNone(self
.harness
.charm
.state
.keystone_user_domain_name
)
808 self
.assertIsNone(self
.harness
.charm
.state
.keystone_project_domain_name
)
809 self
.assertIsNone(self
.harness
.charm
.state
.keystone_username
)
810 self
.assertIsNone(self
.harness
.charm
.state
.keystone_password
)
811 self
.assertIsNone(self
.harness
.charm
.state
.keystone_service
)
813 relation_id
= self
.harness
.add_relation("keystone", "keystone")
814 self
.harness
.add_relation_unit(relation_id
, "keystone/0")
815 self
.harness
.update_relation_data(
821 "user_domain_name": "default",
822 "project_domain_name": "default",
825 "service": "service",
829 self
.assertEqual(self
.harness
.charm
.state
.keystone_host
, "keystone")
830 self
.assertEqual(self
.harness
.charm
.state
.keystone_port
, 5000)
831 self
.assertEqual(self
.harness
.charm
.state
.keystone_user_domain_name
, "default")
833 self
.harness
.charm
.state
.keystone_project_domain_name
, "default"
835 self
.assertEqual(self
.harness
.charm
.state
.keystone_username
, "nbi")
836 self
.assertEqual(self
.harness
.charm
.state
.keystone_password
, "nbi")
837 self
.assertEqual(self
.harness
.charm
.state
.keystone_service
, "service")
840 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
842 # Verifying status message
843 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
845 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
847 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
848 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
849 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
850 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
851 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
853 def test_publish_nbi_info(self
) -> NoReturn
:
854 """Test to see if nbi relation is updated."""
860 self
.harness
.charm
.on
.start
.emit()
862 relation_id
= self
.harness
.add_relation("nbi", "ng-ui")
863 self
.harness
.add_relation_unit(relation_id
, "ng-ui/0")
864 relation_data
= self
.harness
.get_relation_data(relation_id
, "nbi/0")
866 self
.assertDictEqual(expected_result
, relation_data
)
869 if __name__
== "__main__":