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_kafka_app_relation_changed(self
) -> NoReturn
:
742 """Test to see if kafka relation is updated."""
743 self
.harness
.charm
.on
.start
.emit()
745 self
.assertIsNone(self
.harness
.charm
.state
.message_host
)
746 self
.assertIsNone(self
.harness
.charm
.state
.message_port
)
748 relation_id
= self
.harness
.add_relation("kafka", "kafka")
749 self
.harness
.add_relation_unit(relation_id
, "kafka/0")
750 self
.harness
.update_relation_data(
751 relation_id
, "kafka", {"host": "kafka", "port": 9092}
754 self
.assertEqual(self
.harness
.charm
.state
.message_host
, "kafka")
755 self
.assertEqual(self
.harness
.charm
.state
.message_port
, 9092)
758 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
760 # Verifying status message
761 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
763 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
765 self
.assertNotIn("kafka", self
.harness
.charm
.unit
.status
.message
)
766 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
767 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
768 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
769 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
771 def test_on_mongodb_unit_relation_changed(self
) -> NoReturn
:
772 """Test to see if mongodb relation is updated."""
773 self
.harness
.charm
.on
.start
.emit()
775 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
777 relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
778 self
.harness
.add_relation_unit(relation_id
, "mongodb/0")
779 self
.harness
.update_relation_data(
780 relation_id
, "mongodb/0", {"connection_string": "mongodb://mongo:27017"}
783 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongodb://mongo:27017")
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
.assertNotIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
795 self
.assertIn("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_mongodb_app_relation_changed(self
) -> NoReturn
:
800 """Test to see if mongodb relation is updated."""
801 self
.harness
.charm
.on
.start
.emit()
803 self
.assertIsNone(self
.harness
.charm
.state
.database_uri
)
805 relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
806 self
.harness
.add_relation_unit(relation_id
, "mongodb/0")
807 self
.harness
.update_relation_data(
808 relation_id
, "mongodb", {"connection_string": "mongodb://mongo:27017"}
811 self
.assertEqual(self
.harness
.charm
.state
.database_uri
, "mongodb://mongo:27017")
814 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
816 # Verifying status message
817 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
819 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
821 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
822 self
.assertNotIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
823 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
824 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
825 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
827 def test_on_prometheus_unit_relation_changed(self
) -> NoReturn
:
828 """Test to see if prometheus relation is updated."""
829 self
.harness
.charm
.on
.start
.emit()
831 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
832 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
834 relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
835 self
.harness
.add_relation_unit(relation_id
, "prometheus/0")
836 self
.harness
.update_relation_data(
837 relation_id
, "prometheus/0", {"hostname": "prometheus", "port": 9090}
840 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
841 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
844 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
846 # Verifying status message
847 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
849 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
851 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
852 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
853 self
.assertNotIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
854 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
855 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
857 def test_on_prometheus_app_relation_changed(self
) -> NoReturn
:
858 """Test to see if prometheus relation is updated."""
859 self
.harness
.charm
.on
.start
.emit()
861 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_host
)
862 self
.assertIsNone(self
.harness
.charm
.state
.prometheus_port
)
864 relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
865 self
.harness
.add_relation_unit(relation_id
, "prometheus/0")
866 self
.harness
.update_relation_data(
867 relation_id
, "prometheus", {"hostname": "prometheus", "port": 9090}
870 self
.assertEqual(self
.harness
.charm
.state
.prometheus_host
, "prometheus")
871 self
.assertEqual(self
.harness
.charm
.state
.prometheus_port
, 9090)
874 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
876 # Verifying status message
877 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
879 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
881 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
882 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
883 self
.assertNotIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
884 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
885 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
887 def test_on_keystone_unit_relation_changed(self
) -> NoReturn
:
888 """Test to see if keystone relation is updated."""
889 self
.harness
.update_config({"auth_backend": "keystone"})
891 self
.harness
.charm
.on
.start
.emit()
893 self
.assertIsNone(self
.harness
.charm
.state
.keystone_host
)
894 self
.assertIsNone(self
.harness
.charm
.state
.keystone_port
)
895 self
.assertIsNone(self
.harness
.charm
.state
.keystone_user_domain_name
)
896 self
.assertIsNone(self
.harness
.charm
.state
.keystone_project_domain_name
)
897 self
.assertIsNone(self
.harness
.charm
.state
.keystone_username
)
898 self
.assertIsNone(self
.harness
.charm
.state
.keystone_password
)
899 self
.assertIsNone(self
.harness
.charm
.state
.keystone_service
)
901 relation_id
= self
.harness
.add_relation("keystone", "keystone")
902 self
.harness
.add_relation_unit(relation_id
, "keystone/0")
903 self
.harness
.update_relation_data(
909 "user_domain_name": "default",
910 "project_domain_name": "default",
913 "service": "service",
917 self
.assertEqual(self
.harness
.charm
.state
.keystone_host
, "keystone")
918 self
.assertEqual(self
.harness
.charm
.state
.keystone_port
, 5000)
919 self
.assertEqual(self
.harness
.charm
.state
.keystone_user_domain_name
, "default")
921 self
.harness
.charm
.state
.keystone_project_domain_name
, "default"
923 self
.assertEqual(self
.harness
.charm
.state
.keystone_username
, "nbi")
924 self
.assertEqual(self
.harness
.charm
.state
.keystone_password
, "nbi")
925 self
.assertEqual(self
.harness
.charm
.state
.keystone_service
, "service")
928 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
930 # Verifying status message
931 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
933 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
935 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
936 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
937 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
938 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
939 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
941 def test_on_keystone_app_relation_changed(self
) -> NoReturn
:
942 """Test to see if keystone relation is updated."""
943 self
.harness
.update_config({"auth_backend": "keystone"})
945 self
.harness
.charm
.on
.start
.emit()
947 self
.assertIsNone(self
.harness
.charm
.state
.keystone_host
)
948 self
.assertIsNone(self
.harness
.charm
.state
.keystone_port
)
949 self
.assertIsNone(self
.harness
.charm
.state
.keystone_user_domain_name
)
950 self
.assertIsNone(self
.harness
.charm
.state
.keystone_project_domain_name
)
951 self
.assertIsNone(self
.harness
.charm
.state
.keystone_username
)
952 self
.assertIsNone(self
.harness
.charm
.state
.keystone_password
)
953 self
.assertIsNone(self
.harness
.charm
.state
.keystone_service
)
955 relation_id
= self
.harness
.add_relation("keystone", "keystone")
956 self
.harness
.add_relation_unit(relation_id
, "keystone/0")
957 self
.harness
.update_relation_data(
963 "user_domain_name": "default",
964 "project_domain_name": "default",
967 "service": "service",
971 self
.assertEqual(self
.harness
.charm
.state
.keystone_host
, "keystone")
972 self
.assertEqual(self
.harness
.charm
.state
.keystone_port
, 5000)
973 self
.assertEqual(self
.harness
.charm
.state
.keystone_user_domain_name
, "default")
975 self
.harness
.charm
.state
.keystone_project_domain_name
, "default"
977 self
.assertEqual(self
.harness
.charm
.state
.keystone_username
, "nbi")
978 self
.assertEqual(self
.harness
.charm
.state
.keystone_password
, "nbi")
979 self
.assertEqual(self
.harness
.charm
.state
.keystone_service
, "service")
982 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
984 # Verifying status message
985 self
.assertGreater(len(self
.harness
.charm
.unit
.status
.message
), 0)
987 self
.harness
.charm
.unit
.status
.message
.startswith("Waiting for ")
989 self
.assertIn("kafka", self
.harness
.charm
.unit
.status
.message
)
990 self
.assertIn("mongodb", self
.harness
.charm
.unit
.status
.message
)
991 self
.assertIn("prometheus", self
.harness
.charm
.unit
.status
.message
)
992 self
.assertNotIn("keystone", self
.harness
.charm
.unit
.status
.message
)
993 self
.assertTrue(self
.harness
.charm
.unit
.status
.message
.endswith(" relations"))
995 def test_publish_nbi_info(self
) -> NoReturn
:
996 """Test to see if nbi relation is updated."""
1002 self
.harness
.charm
.on
.start
.emit()
1004 relation_id
= self
.harness
.add_relation("nbi", "ng-ui")
1005 self
.harness
.add_relation_unit(relation_id
, "ng-ui/0")
1006 relation_data
= self
.harness
.get_relation_data(relation_id
, "nbi")
1008 self
.assertDictEqual(expected_result
, relation_data
)
1011 if __name__
== "__main__":