installers/charm/nbi/tests/test_charm.py

   1 #!/usr/bin/env python3
   2 # Copyright 2020 Canonical Ltd.
   3 #
   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
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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
  14 # under the License.
  15 #
  16 # For those usages not covered by the Apache License, Version 2.0 please
  17 # contact: legal@canonical.com
  18 #
  19 # To get in touch with the maintainers, please contact:
  20 # osm-charmers@lists.launchpad.net
  21 ##
  22
  23 from typing import NoReturn
  24 import unittest
  25 from ops.model import BlockedStatus
  26
  27 from ops.testing import Harness
  28
  29 from charm import NbiCharm
  30
  31
  32 class TestCharm(unittest.TestCase):
  33     """NBI Charm unit tests."""
  34
  35     def setUp(self) -> NoReturn:
  36         """Test setup"""
  37         self.harness = Harness(NbiCharm)
  38         self.harness.set_leader(is_leader=True)
  39         self.harness.begin()
  40
  41     def test_on_start_without_relations(self) -> NoReturn:
  42         """Test installation without any relation."""
  43         self.harness.charm.on.start.emit()
  44
  45         # Verifying status
  46         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
  47
  48         # Verifying status message
  49         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
  50         self.assertTrue(
  51             self.harness.charm.unit.status.message.startswith("Waiting for ")
  52         )
  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"))
  58
  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"})
  62
  63         self.harness.charm.on.start.emit()
  64
  65         # Verifying status
  66         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
  67
  68         # Verifying status message
  69         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
  70         self.assertTrue(
  71             self.harness.charm.unit.status.message.startswith("Waiting for ")
  72         )
  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"))
  78
  79     def test_on_start_with_relations(self) -> NoReturn:
  80         """Test deployment without keystone."""
  81         expected_result = {
  82             "version": 3,
  83             "containers": [
  84                 {
  85                     "name": "nbi",
  86                     "imageDetails": self.harness.charm.image.fetch(),
  87                     "imagePullPolicy": "Always",
  88                     "ports": [
  89                         {
  90                             "name": "nbi",
  91                             "containerPort": 9999,
  92                             "protocol": "TCP",
  93                         }
  94                     ],
  95                     "envConfig": {
  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",
 113                     },
 114                 }
 115             ],
 116             "kubernetesResources": {
 117                 "ingressResources": [],
 118             },
 119         }
 120
 121         self.harness.charm.on.start.emit()
 122
 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)
 126
 127         # Check if mongodb datastore is initialized
 128         self.assertIsNone(self.harness.charm.state.database_uri)
 129
 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)
 133
 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}
 139         )
 140
 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(
 145             mongodb_relation_id,
 146             "mongodb/0",
 147             {"connection_string": "mongodb://mongo:27017"},
 148         )
 149
 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,
 155             "prometheus/0",
 156             {"hostname": "prometheus", "port": 9090},
 157         )
 158
 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)
 162
 163         # Checking if mongodb data is stored
 164         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 165
 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)
 169
 170         # Verifying status
 171         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
 172
 173         pod_spec, _ = self.harness.get_pod_spec()
 174
 175         self.assertDictEqual(expected_result, pod_spec)
 176
 177     def test_on_start_with_relations_with_keystone(self) -> NoReturn:
 178         """Test deployment with keystone."""
 179         expected_result = {
 180             "version": 3,
 181             "containers": [
 182                 {
 183                     "name": "nbi",
 184                     "imageDetails": self.harness.charm.image.fetch(),
 185                     "imagePullPolicy": "Always",
 186                     "ports": [
 187                         {
 188                             "name": "nbi",
 189                             "containerPort": 9999,
 190                             "protocol": "TCP",
 191                         }
 192                     ],
 193                     "envConfig": {
 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",
 218                     },
 219                 }
 220             ],
 221             "kubernetesResources": {
 222                 "ingressResources": [],
 223             },
 224         }
 225
 226         self.harness.update_config({"auth_backend": "keystone"})
 227
 228         self.harness.charm.on.start.emit()
 229
 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)
 233
 234         # Check if mongodb datastore is initialized
 235         self.assertIsNone(self.harness.charm.state.database_uri)
 236
 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)
 240
 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)
 249
 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}
 255         )
 256
 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(
 261             mongodb_relation_id,
 262             "mongodb/0",
 263             {"connection_string": "mongodb://mongo:27017"},
 264         )
 265
 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,
 271             "prometheus/0",
 272             {"hostname": "prometheus", "port": 9090},
 273         )
 274
 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,
 280             "keystone/0",
 281             {
 282                 "host": "keystone",
 283                 "port": 5000,
 284                 "user_domain_name": "default",
 285                 "project_domain_name": "default",
 286                 "username": "nbi",
 287                 "password": "nbi",
 288                 "service": "service",
 289             },
 290         )
 291
 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)
 295
 296         # Checking if mongodb data is stored
 297         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 298
 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)
 302
 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")
 307         self.assertEqual(
 308             self.harness.charm.state.keystone_project_domain_name, "default"
 309         )
 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")
 313
 314         # Verifying status
 315         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
 316
 317         pod_spec, _ = self.harness.get_pod_spec()
 318
 319         self.assertDictEqual(expected_result, pod_spec)
 320
 321     def test_ingress_resources_without_http(self) -> NoReturn:
 322         """Test ingress resources without HTTP."""
 323         expected_result = {
 324             "version": 3,
 325             "containers": [
 326                 {
 327                     "name": "nbi",
 328                     "imageDetails": self.harness.charm.image.fetch(),
 329                     "imagePullPolicy": "Always",
 330                     "ports": [
 331                         {
 332                             "name": "nbi",
 333                             "containerPort": 9999,
 334                             "protocol": "TCP",
 335                         }
 336                     ],
 337                     "envConfig": {
 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",
 355                     },
 356                 }
 357             ],
 358             "kubernetesResources": {
 359                 "ingressResources": [],
 360             },
 361         }
 362
 363         self.harness.charm.on.start.emit()
 364
 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}
 370         )
 371
 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(
 376             mongodb_relation_id,
 377             "mongodb/0",
 378             {"connection_string": "mongodb://mongo:27017"},
 379         )
 380
 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,
 386             "prometheus/0",
 387             {"hostname": "prometheus", "port": 9090},
 388         )
 389
 390         self.harness.update_config({"site_url": "nbi"})
 391
 392         pod_spec, _ = self.harness.get_pod_spec()
 393
 394         self.assertDictEqual(expected_result, pod_spec)
 395
 396     def test_ingress_resources_with_http(self) -> NoReturn:
 397         """Test ingress resources with HTTP."""
 398         expected_result = {
 399             "version": 3,
 400             "containers": [
 401                 {
 402                     "name": "nbi",
 403                     "imageDetails": self.harness.charm.image.fetch(),
 404                     "imagePullPolicy": "Always",
 405                     "ports": [
 406                         {
 407                             "name": "nbi",
 408                             "containerPort": 9999,
 409                             "protocol": "TCP",
 410                         }
 411                     ],
 412                     "envConfig": {
 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",
 430                     },
 431                 }
 432             ],
 433             "kubernetesResources": {
 434                 "ingressResources": [
 435                     {
 436                         "name": "nbi-ingress",
 437                         "annotations": {
 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",
 441                         },
 442                         "spec": {
 443                             "rules": [
 444                                 {
 445                                     "host": "nbi",
 446                                     "http": {
 447                                         "paths": [
 448                                             {
 449                                                 "path": "/",
 450                                                 "backend": {
 451                                                     "serviceName": "nbi",
 452                                                     "servicePort": 9999,
 453                                                 },
 454                                             }
 455                                         ]
 456                                     },
 457                                 }
 458                             ]
 459                         },
 460                     }
 461                 ],
 462             },
 463         }
 464
 465         self.harness.charm.on.start.emit()
 466
 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}
 472         )
 473
 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(
 478             mongodb_relation_id,
 479             "mongodb/0",
 480             {"connection_string": "mongodb://mongo:27017"},
 481         )
 482
 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,
 488             "prometheus/0",
 489             {"hostname": "prometheus", "port": 9090},
 490         )
 491
 492         self.harness.update_config({"site_url": "http://nbi"})
 493
 494         pod_spec, _ = self.harness.get_pod_spec()
 495
 496         self.assertDictEqual(expected_result, pod_spec)
 497
 498     def test_ingress_resources_with_https(self) -> NoReturn:
 499         """Test ingress resources with HTTPS."""
 500         expected_result = {
 501             "version": 3,
 502             "containers": [
 503                 {
 504                     "name": "nbi",
 505                     "imageDetails": self.harness.charm.image.fetch(),
 506                     "imagePullPolicy": "Always",
 507                     "ports": [
 508                         {
 509                             "name": "nbi",
 510                             "containerPort": 9999,
 511                             "protocol": "TCP",
 512                         }
 513                     ],
 514                     "envConfig": {
 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",
 532                     },
 533                 }
 534             ],
 535             "kubernetesResources": {
 536                 "ingressResources": [
 537                     {
 538                         "name": "nbi-ingress",
 539                         "annotations": {
 540                             "nginx.ingress.kubernetes.io/proxy-body-size": "0",
 541                             "nginx.ingress.kubernetes.io/backend-protocol": "HTTPS",
 542                         },
 543                         "spec": {
 544                             "rules": [
 545                                 {
 546                                     "host": "nbi",
 547                                     "http": {
 548                                         "paths": [
 549                                             {
 550                                                 "path": "/",
 551                                                 "backend": {
 552                                                     "serviceName": "nbi",
 553                                                     "servicePort": 9999,
 554                                                 },
 555                                             }
 556                                         ]
 557                                     },
 558                                 }
 559                             ],
 560                             "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
 561                         },
 562                     }
 563                 ],
 564             },
 565         }
 566
 567         self.harness.charm.on.start.emit()
 568
 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}
 574         )
 575
 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(
 580             mongodb_relation_id,
 581             "mongodb/0",
 582             {"connection_string": "mongodb://mongo:27017"},
 583         )
 584
 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,
 590             "prometheus/0",
 591             {"hostname": "prometheus", "port": 9090},
 592         )
 593
 594         self.harness.update_config(
 595             {"site_url": "https://nbi", "tls_secret_name": "nbi"}
 596         )
 597
 598         pod_spec, _ = self.harness.get_pod_spec()
 599
 600         self.assertDictEqual(expected_result, pod_spec)
 601
 602     def test_ingress_resources_with_https_and_ingress_whitelist(self) -> NoReturn:
 603         """Test ingress resources with HTTPS and ingress whitelist."""
 604         expected_result = {
 605             "version": 3,
 606             "containers": [
 607                 {
 608                     "name": "nbi",
 609                     "imageDetails": self.harness.charm.image.fetch(),
 610                     "imagePullPolicy": "Always",
 611                     "ports": [
 612                         {
 613                             "name": "nbi",
 614                             "containerPort": 9999,
 615                             "protocol": "TCP",
 616                         }
 617                     ],
 618                     "envConfig": {
 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",
 636                     },
 637                 }
 638             ],
 639             "kubernetesResources": {
 640                 "ingressResources": [
 641                     {
 642                         "name": "nbi-ingress",
 643                         "annotations": {
 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",
 647                         },
 648                         "spec": {
 649                             "rules": [
 650                                 {
 651                                     "host": "nbi",
 652                                     "http": {
 653                                         "paths": [
 654                                             {
 655                                                 "path": "/",
 656                                                 "backend": {
 657                                                     "serviceName": "nbi",
 658                                                     "servicePort": 9999,
 659                                                 },
 660                                             }
 661                                         ]
 662                                     },
 663                                 }
 664                             ],
 665                             "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
 666                         },
 667                     }
 668                 ],
 669             },
 670         }
 671
 672         self.harness.charm.on.start.emit()
 673
 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}
 679         )
 680
 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(
 685             mongodb_relation_id,
 686             "mongodb/0",
 687             {"connection_string": "mongodb://mongo:27017"},
 688         )
 689
 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,
 695             "prometheus/0",
 696             {"hostname": "prometheus", "port": 9090},
 697         )
 698
 699         self.harness.update_config(
 700             {
 701                 "site_url": "https://nbi",
 702                 "tls_secret_name": "nbi",
 703                 "ingress_whitelist_source_range": "0.0.0.0/0",
 704             }
 705         )
 706
 707         pod_spec, _ = self.harness.get_pod_spec()
 708
 709         self.assertDictEqual(expected_result, pod_spec)
 710
 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()
 714
 715         self.assertIsNone(self.harness.charm.state.message_host)
 716         self.assertIsNone(self.harness.charm.state.message_port)
 717
 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}
 722         )
 723
 724         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 725         self.assertEqual(self.harness.charm.state.message_port, 9092)
 726
 727         # Verifying status
 728         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 729
 730         # Verifying status message
 731         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 732         self.assertTrue(
 733             self.harness.charm.unit.status.message.startswith("Waiting for ")
 734         )
 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"))
 740
 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()
 744
 745         self.assertIsNone(self.harness.charm.state.database_uri)
 746
 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"}
 751         )
 752
 753         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 754
 755         # Verifying status
 756         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 757
 758         # Verifying status message
 759         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 760         self.assertTrue(
 761             self.harness.charm.unit.status.message.startswith("Waiting for ")
 762         )
 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"))
 768
 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()
 772
 773         self.assertIsNone(self.harness.charm.state.prometheus_host)
 774         self.assertIsNone(self.harness.charm.state.prometheus_port)
 775
 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}
 780         )
 781
 782         self.assertEqual(self.harness.charm.state.prometheus_host, "prometheus")
 783         self.assertEqual(self.harness.charm.state.prometheus_port, 9090)
 784
 785         # Verifying status
 786         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 787
 788         # Verifying status message
 789         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 790         self.assertTrue(
 791             self.harness.charm.unit.status.message.startswith("Waiting for ")
 792         )
 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"))
 798
 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"})
 802
 803         self.harness.charm.on.start.emit()
 804
 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)
 812
 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(
 816             relation_id,
 817             "keystone/0",
 818             {
 819                 "host": "keystone",
 820                 "port": 5000,
 821                 "user_domain_name": "default",
 822                 "project_domain_name": "default",
 823                 "username": "nbi",
 824                 "password": "nbi",
 825                 "service": "service",
 826             },
 827         )
 828
 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")
 832         self.assertEqual(
 833             self.harness.charm.state.keystone_project_domain_name, "default"
 834         )
 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")
 838
 839         # Verifying status
 840         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 841
 842         # Verifying status message
 843         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 844         self.assertTrue(
 845             self.harness.charm.unit.status.message.startswith("Waiting for ")
 846         )
 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"))
 852
 853     def test_publish_nbi_info(self) -> NoReturn:
 854         """Test to see if nbi relation is updated."""
 855         expected_result = {
 856             "host": "nbi",
 857             "port": "9999",
 858         }
 859
 860         self.harness.charm.on.start.emit()
 861
 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")
 865
 866         self.assertDictEqual(expected_result, relation_data)
 867
 868
 869 if __name__ == "__main__":
 870     unittest.main()