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": "mongo://mongo:27017",
 104                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 105                         "OSMNBI_STORAGE_DRIVER": "mongo",
 106                         "OSMNBI_STORAGE_PATH": "/app/storage",
 107                         "OSMNBI_STORAGE_COLLECTION": "files",
 108                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 109                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 110                         "OSMNBI_PROMETHEUS_PORT": 9090,
 111                         "OSMNBI_LOG_LEVEL": "INFO",
 112                         "OSMNBI_AUTHENTICATION_BACKEND": "internal",
 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": "mongo://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, "mongo://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": "mongo://mongo:27017",
 202                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 203                         "OSMNBI_STORAGE_DRIVER": "mongo",
 204                         "OSMNBI_STORAGE_PATH": "/app/storage",
 205                         "OSMNBI_STORAGE_COLLECTION": "files",
 206                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 207                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 208                         "OSMNBI_PROMETHEUS_PORT": 9090,
 209                         "OSMNBI_LOG_LEVEL": "INFO",
 210                         "OSMNBI_AUTHENTICATION_BACKEND": "keystone",
 211                         "OSMNBI_AUTHENTICATION_AUTH_URL": "keystone",
 212                         "OSMNBI_AUTHENTICATION_AUTH_PORT": 5000,
 213                         "OSMNBI_AUTHENTICATION_USER_DOMAIN_NAME": "default",
 214                         "OSMNBI_AUTHENTICATION_PROJECT_DOMAIN_NAME": "default",
 215                         "OSMNBI_AUTHENTICATION_SERVICE_USERNAME": "nbi",
 216                         "OSMNBI_AUTHENTICATION_SERVICE_PASSWORD": "nbi",
 217                         "OSMNBI_AUTHENTICATION_SERVICE_PROJECT": "service",
 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": "mongo://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, "mongo://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": "mongo://mongo:27017",
 346                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 347                         "OSMNBI_STORAGE_DRIVER": "mongo",
 348                         "OSMNBI_STORAGE_PATH": "/app/storage",
 349                         "OSMNBI_STORAGE_COLLECTION": "files",
 350                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 351                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 352                         "OSMNBI_PROMETHEUS_PORT": 9090,
 353                         "OSMNBI_LOG_LEVEL": "INFO",
 354                         "OSMNBI_AUTHENTICATION_BACKEND": "internal",
 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": "mongo://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": "mongo://mongo:27017",
 421                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 422                         "OSMNBI_STORAGE_DRIVER": "mongo",
 423                         "OSMNBI_STORAGE_PATH": "/app/storage",
 424                         "OSMNBI_STORAGE_COLLECTION": "files",
 425                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 426                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 427                         "OSMNBI_PROMETHEUS_PORT": 9090,
 428                         "OSMNBI_LOG_LEVEL": "INFO",
 429                         "OSMNBI_AUTHENTICATION_BACKEND": "internal",
 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                         },
 441                         "spec": {
 442                             "rules": [
 443                                 {
 444                                     "host": "nbi",
 445                                     "http": {
 446                                         "paths": [
 447                                             {
 448                                                 "path": "/",
 449                                                 "backend": {
 450                                                     "serviceName": "nbi",
 451                                                     "servicePort": 9999,
 452                                                 },
 453                                             }
 454                                         ]
 455                                     },
 456                                 }
 457                             ]
 458                         },
 459                     }
 460                 ],
 461             },
 462         }
 463
 464         self.harness.charm.on.start.emit()
 465
 466         # Initializing the kafka relation
 467         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 468         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 469         self.harness.update_relation_data(
 470             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 471         )
 472
 473         # Initializing the mongodb relation
 474         mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
 475         self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
 476         self.harness.update_relation_data(
 477             mongodb_relation_id,
 478             "mongodb/0",
 479             {"connection_string": "mongo://mongo:27017"},
 480         )
 481
 482         # Initializing the prometheus relation
 483         promethues_relation_id = self.harness.add_relation("prometheus", "prometheus")
 484         self.harness.add_relation_unit(promethues_relation_id, "prometheus/0")
 485         self.harness.update_relation_data(
 486             promethues_relation_id,
 487             "prometheus/0",
 488             {"hostname": "prometheus", "port": 9090},
 489         )
 490
 491         self.harness.update_config({"site_url": "http://nbi"})
 492
 493         pod_spec, _ = self.harness.get_pod_spec()
 494
 495         self.assertDictEqual(expected_result, pod_spec)
 496
 497     def test_ingress_resources_with_https(self) -> NoReturn:
 498         """Test ingress resources with HTTPS."""
 499         expected_result = {
 500             "version": 3,
 501             "containers": [
 502                 {
 503                     "name": "nbi",
 504                     "imageDetails": self.harness.charm.image.fetch(),
 505                     "imagePullPolicy": "Always",
 506                     "ports": [
 507                         {
 508                             "name": "nbi",
 509                             "containerPort": 9999,
 510                             "protocol": "TCP",
 511                         }
 512                     ],
 513                     "envConfig": {
 514                         "ALLOW_ANONYMOUS_LOGIN": "yes",
 515                         "OSMNBI_SERVER_ENABLE_TEST": False,
 516                         "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
 517                         "OSMNBI_MESSAGE_HOST": "kafka",
 518                         "OSMNBI_MESSAGE_DRIVER": "kafka",
 519                         "OSMNBI_MESSAGE_PORT": 9092,
 520                         "OSMNBI_DATABASE_DRIVER": "mongo",
 521                         "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
 522                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 523                         "OSMNBI_STORAGE_DRIVER": "mongo",
 524                         "OSMNBI_STORAGE_PATH": "/app/storage",
 525                         "OSMNBI_STORAGE_COLLECTION": "files",
 526                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 527                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 528                         "OSMNBI_PROMETHEUS_PORT": 9090,
 529                         "OSMNBI_LOG_LEVEL": "INFO",
 530                         "OSMNBI_AUTHENTICATION_BACKEND": "internal",
 531                     },
 532                 }
 533             ],
 534             "kubernetesResources": {
 535                 "ingressResources": [
 536                     {
 537                         "name": "nbi-ingress",
 538                         "annotations": {
 539                             "nginx.ingress.kubernetes.io/proxy-body-size": "0",
 540                         },
 541                         "spec": {
 542                             "rules": [
 543                                 {
 544                                     "host": "nbi",
 545                                     "http": {
 546                                         "paths": [
 547                                             {
 548                                                 "path": "/",
 549                                                 "backend": {
 550                                                     "serviceName": "nbi",
 551                                                     "servicePort": 9999,
 552                                                 },
 553                                             }
 554                                         ]
 555                                     },
 556                                 }
 557                             ],
 558                             "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
 559                         },
 560                     }
 561                 ],
 562             },
 563         }
 564
 565         self.harness.charm.on.start.emit()
 566
 567         # Initializing the kafka relation
 568         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 569         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 570         self.harness.update_relation_data(
 571             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 572         )
 573
 574         # Initializing the mongodb relation
 575         mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
 576         self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
 577         self.harness.update_relation_data(
 578             mongodb_relation_id,
 579             "mongodb/0",
 580             {"connection_string": "mongo://mongo:27017"},
 581         )
 582
 583         # Initializing the prometheus relation
 584         promethues_relation_id = self.harness.add_relation("prometheus", "prometheus")
 585         self.harness.add_relation_unit(promethues_relation_id, "prometheus/0")
 586         self.harness.update_relation_data(
 587             promethues_relation_id,
 588             "prometheus/0",
 589             {"hostname": "prometheus", "port": 9090},
 590         )
 591
 592         self.harness.update_config(
 593             {"site_url": "https://nbi", "tls_secret_name": "nbi"}
 594         )
 595
 596         pod_spec, _ = self.harness.get_pod_spec()
 597
 598         self.assertDictEqual(expected_result, pod_spec)
 599
 600     def test_ingress_resources_with_https_and_ingress_whitelist(self) -> NoReturn:
 601         """Test ingress resources with HTTPS and ingress whitelist."""
 602         expected_result = {
 603             "version": 3,
 604             "containers": [
 605                 {
 606                     "name": "nbi",
 607                     "imageDetails": self.harness.charm.image.fetch(),
 608                     "imagePullPolicy": "Always",
 609                     "ports": [
 610                         {
 611                             "name": "nbi",
 612                             "containerPort": 9999,
 613                             "protocol": "TCP",
 614                         }
 615                     ],
 616                     "envConfig": {
 617                         "ALLOW_ANONYMOUS_LOGIN": "yes",
 618                         "OSMNBI_SERVER_ENABLE_TEST": False,
 619                         "OSMNBI_STATIC_DIR": "/app/osm_nbi/html_public",
 620                         "OSMNBI_MESSAGE_HOST": "kafka",
 621                         "OSMNBI_MESSAGE_DRIVER": "kafka",
 622                         "OSMNBI_MESSAGE_PORT": 9092,
 623                         "OSMNBI_DATABASE_DRIVER": "mongo",
 624                         "OSMNBI_DATABASE_URI": "mongo://mongo:27017",
 625                         "OSMNBI_DATABASE_COMMONKEY": "osm",
 626                         "OSMNBI_STORAGE_DRIVER": "mongo",
 627                         "OSMNBI_STORAGE_PATH": "/app/storage",
 628                         "OSMNBI_STORAGE_COLLECTION": "files",
 629                         "OSMNBI_STORAGE_URI": "mongo://mongo:27017",
 630                         "OSMNBI_PROMETHEUS_HOST": "prometheus",
 631                         "OSMNBI_PROMETHEUS_PORT": 9090,
 632                         "OSMNBI_LOG_LEVEL": "INFO",
 633                         "OSMNBI_AUTHENTICATION_BACKEND": "internal",
 634                     },
 635                 }
 636             ],
 637             "kubernetesResources": {
 638                 "ingressResources": [
 639                     {
 640                         "name": "nbi-ingress",
 641                         "annotations": {
 642                             "nginx.ingress.kubernetes.io/proxy-body-size": "0",
 643                             "nginx.ingress.kubernetes.io/whitelist-source-range": "0.0.0.0/0",
 644                         },
 645                         "spec": {
 646                             "rules": [
 647                                 {
 648                                     "host": "nbi",
 649                                     "http": {
 650                                         "paths": [
 651                                             {
 652                                                 "path": "/",
 653                                                 "backend": {
 654                                                     "serviceName": "nbi",
 655                                                     "servicePort": 9999,
 656                                                 },
 657                                             }
 658                                         ]
 659                                     },
 660                                 }
 661                             ],
 662                             "tls": [{"hosts": ["nbi"], "secretName": "nbi"}],
 663                         },
 664                     }
 665                 ],
 666             },
 667         }
 668
 669         self.harness.charm.on.start.emit()
 670
 671         # Initializing the kafka relation
 672         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 673         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 674         self.harness.update_relation_data(
 675             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 676         )
 677
 678         # Initializing the mongodb relation
 679         mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
 680         self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
 681         self.harness.update_relation_data(
 682             mongodb_relation_id,
 683             "mongodb/0",
 684             {"connection_string": "mongo://mongo:27017"},
 685         )
 686
 687         # Initializing the prometheus relation
 688         promethues_relation_id = self.harness.add_relation("prometheus", "prometheus")
 689         self.harness.add_relation_unit(promethues_relation_id, "prometheus/0")
 690         self.harness.update_relation_data(
 691             promethues_relation_id,
 692             "prometheus/0",
 693             {"hostname": "prometheus", "port": 9090},
 694         )
 695
 696         self.harness.update_config(
 697             {
 698                 "site_url": "https://nbi",
 699                 "tls_secret_name": "nbi",
 700                 "ingress_whitelist_source_range": "0.0.0.0/0",
 701             }
 702         )
 703
 704         pod_spec, _ = self.harness.get_pod_spec()
 705
 706         self.assertDictEqual(expected_result, pod_spec)
 707
 708     def test_on_kafka_relation_changed(self) -> NoReturn:
 709         """Test to see if kafka relation is updated."""
 710         self.harness.charm.on.start.emit()
 711
 712         self.assertIsNone(self.harness.charm.state.message_host)
 713         self.assertIsNone(self.harness.charm.state.message_port)
 714
 715         relation_id = self.harness.add_relation("kafka", "kafka")
 716         self.harness.add_relation_unit(relation_id, "kafka/0")
 717         self.harness.update_relation_data(
 718             relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 719         )
 720
 721         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 722         self.assertEqual(self.harness.charm.state.message_port, 9092)
 723
 724         # Verifying status
 725         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 726
 727         # Verifying status message
 728         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 729         self.assertTrue(
 730             self.harness.charm.unit.status.message.startswith("Waiting for ")
 731         )
 732         self.assertNotIn("kafka", self.harness.charm.unit.status.message)
 733         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 734         self.assertIn("prometheus", self.harness.charm.unit.status.message)
 735         self.assertNotIn("keystone", self.harness.charm.unit.status.message)
 736         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 737
 738     def test_on_mongodb_relation_changed(self) -> NoReturn:
 739         """Test to see if mongodb relation is updated."""
 740         self.harness.charm.on.start.emit()
 741
 742         self.assertIsNone(self.harness.charm.state.database_uri)
 743
 744         relation_id = self.harness.add_relation("mongodb", "mongodb")
 745         self.harness.add_relation_unit(relation_id, "mongodb/0")
 746         self.harness.update_relation_data(
 747             relation_id, "mongodb/0", {"connection_string": "mongo://mongo:27017"}
 748         )
 749
 750         self.assertEqual(self.harness.charm.state.database_uri, "mongo://mongo:27017")
 751
 752         # Verifying status
 753         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 754
 755         # Verifying status message
 756         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 757         self.assertTrue(
 758             self.harness.charm.unit.status.message.startswith("Waiting for ")
 759         )
 760         self.assertIn("kafka", self.harness.charm.unit.status.message)
 761         self.assertNotIn("mongodb", self.harness.charm.unit.status.message)
 762         self.assertIn("prometheus", self.harness.charm.unit.status.message)
 763         self.assertNotIn("keystone", self.harness.charm.unit.status.message)
 764         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 765
 766     def test_on_prometheus_relation_changed(self) -> NoReturn:
 767         """Test to see if prometheus relation is updated."""
 768         self.harness.charm.on.start.emit()
 769
 770         self.assertIsNone(self.harness.charm.state.prometheus_host)
 771         self.assertIsNone(self.harness.charm.state.prometheus_port)
 772
 773         relation_id = self.harness.add_relation("prometheus", "prometheus")
 774         self.harness.add_relation_unit(relation_id, "prometheus/0")
 775         self.harness.update_relation_data(
 776             relation_id, "prometheus/0", {"hostname": "prometheus", "port": 9090}
 777         )
 778
 779         self.assertEqual(self.harness.charm.state.prometheus_host, "prometheus")
 780         self.assertEqual(self.harness.charm.state.prometheus_port, 9090)
 781
 782         # Verifying status
 783         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 784
 785         # Verifying status message
 786         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 787         self.assertTrue(
 788             self.harness.charm.unit.status.message.startswith("Waiting for ")
 789         )
 790         self.assertIn("kafka", self.harness.charm.unit.status.message)
 791         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 792         self.assertNotIn("prometheus", self.harness.charm.unit.status.message)
 793         self.assertNotIn("keystone", self.harness.charm.unit.status.message)
 794         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 795
 796     def test_on_keystone_relation_changed(self) -> NoReturn:
 797         """Test to see if keystone relation is updated."""
 798         self.harness.update_config({"auth_backend": "keystone"})
 799
 800         self.harness.charm.on.start.emit()
 801
 802         self.assertIsNone(self.harness.charm.state.keystone_host)
 803         self.assertIsNone(self.harness.charm.state.keystone_port)
 804         self.assertIsNone(self.harness.charm.state.keystone_user_domain_name)
 805         self.assertIsNone(self.harness.charm.state.keystone_project_domain_name)
 806         self.assertIsNone(self.harness.charm.state.keystone_username)
 807         self.assertIsNone(self.harness.charm.state.keystone_password)
 808         self.assertIsNone(self.harness.charm.state.keystone_service)
 809
 810         relation_id = self.harness.add_relation("keystone", "keystone")
 811         self.harness.add_relation_unit(relation_id, "keystone/0")
 812         self.harness.update_relation_data(
 813             relation_id,
 814             "keystone/0",
 815             {
 816                 "host": "keystone",
 817                 "port": 5000,
 818                 "user_domain_name": "default",
 819                 "project_domain_name": "default",
 820                 "username": "nbi",
 821                 "password": "nbi",
 822                 "service": "service",
 823             },
 824         )
 825
 826         self.assertEqual(self.harness.charm.state.keystone_host, "keystone")
 827         self.assertEqual(self.harness.charm.state.keystone_port, 5000)
 828         self.assertEqual(self.harness.charm.state.keystone_user_domain_name, "default")
 829         self.assertEqual(
 830             self.harness.charm.state.keystone_project_domain_name, "default"
 831         )
 832         self.assertEqual(self.harness.charm.state.keystone_username, "nbi")
 833         self.assertEqual(self.harness.charm.state.keystone_password, "nbi")
 834         self.assertEqual(self.harness.charm.state.keystone_service, "service")
 835
 836         # Verifying status
 837         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 838
 839         # Verifying status message
 840         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 841         self.assertTrue(
 842             self.harness.charm.unit.status.message.startswith("Waiting for ")
 843         )
 844         self.assertIn("kafka", self.harness.charm.unit.status.message)
 845         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 846         self.assertIn("prometheus", self.harness.charm.unit.status.message)
 847         self.assertNotIn("keystone", self.harness.charm.unit.status.message)
 848         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 849
 850     def test_publish_nbi_info(self) -> NoReturn:
 851         """Test to see if nbi relation is updated."""
 852         expected_result = {
 853             "host": "nbi",
 854             "port": "9999",
 855         }
 856
 857         self.harness.charm.on.start.emit()
 858
 859         relation_id = self.harness.add_relation("nbi", "ng-ui")
 860         self.harness.add_relation_unit(relation_id, "ng-ui/0")
 861         relation_data = self.harness.get_relation_data(relation_id, "nbi")
 862
 863         self.assertDictEqual(expected_result, relation_data)
 864
 865
 866 if __name__ == "__main__":
 867     unittest.main()