installers/charm/pol/tests/test_charm.py

   1 #!/usr/bin/env python3
   2 # Copyright 2021 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 import sys
  24 from typing import NoReturn
  25 import unittest
  26
  27 from charm import PolCharm
  28 from ops.model import ActiveStatus, BlockedStatus
  29 from ops.testing import Harness
  30
  31
  32 class TestCharm(unittest.TestCase):
  33     """Pol Charm unit tests."""
  34
  35     def setUp(self) -> NoReturn:
  36         """Test setup"""
  37         self.image_info = sys.modules["oci_image"].OCIImageResource().fetch()
  38         self.harness = Harness(PolCharm)
  39         self.harness.set_leader(is_leader=True)
  40         self.harness.begin()
  41         self.config = {
  42             "log_level": "INFO",
  43             "mongodb_uri": "",
  44         }
  45         self.harness.update_config(self.config)
  46
  47     def test_config_changed_no_relations(
  48         self,
  49     ) -> NoReturn:
  50         """Test ingress resources without HTTP."""
  51
  52         self.harness.charm.on.config_changed.emit()
  53
  54         # Assertions
  55         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
  56         self.assertTrue(
  57             all(
  58                 relation in self.harness.charm.unit.status.message
  59                 for relation in ["mongodb", "kafka"]
  60             )
  61         )
  62
  63     def test_config_changed_non_leader(
  64         self,
  65     ) -> NoReturn:
  66         """Test ingress resources without HTTP."""
  67         self.harness.set_leader(is_leader=False)
  68         self.harness.charm.on.config_changed.emit()
  69
  70         # Assertions
  71         self.assertIsInstance(self.harness.charm.unit.status, ActiveStatus)
  72
  73     def test_with_relations_and_mongodb_config(
  74         self,
  75     ) -> NoReturn:
  76         "Test with relations and mongodb config (internal)"
  77         self.initialize_mysql_relation()
  78         self.initialize_kafka_relation()
  79         self.initialize_mongo_config()
  80         # Verifying status
  81         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
  82
  83     def test_with_relations(
  84         self,
  85     ) -> NoReturn:
  86         "Test with relations (internal)"
  87         self.initialize_kafka_relation()
  88         self.initialize_mongo_relation()
  89         self.initialize_mysql_relation()
  90         # Verifying status
  91         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
  92
  93     def test_exception_mongodb_relation_and_config(
  94         self,
  95     ) -> NoReturn:
  96         "Test with relation and config for Mongodb. Must fail"
  97         self.initialize_mongo_relation()
  98         self.initialize_mongo_config()
  99         # Verifying status
 100         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 101
 102     def test_mysql_config_success(self):
 103         self.initialize_kafka_relation()
 104         self.initialize_mongo_relation()
 105         self.initialize_mysql_config()
 106         # Verifying status
 107         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
 108
 109     def test_mysql_config_wrong_value(self):
 110         self.initialize_kafka_relation()
 111         self.initialize_mongo_relation()
 112         self.initialize_mysql_config(uri="wrong_uri")
 113         # Verifying status
 114         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 115         self.assertIn(
 116             "mysql_uri is not properly formed",
 117             self.harness.charm.unit.status.message,
 118         )
 119
 120     def test_mysql_config_and_relation(self):
 121         self.initialize_mysql_relation()
 122         self.initialize_mysql_config()
 123         # Verifying status
 124         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 125         # import pdb; pdb.set_trace()
 126         self.assertIn(
 127             "Mysql data cannot be provided via config and relation",
 128             self.harness.charm.unit.status.message,
 129         )
 130
 131     def initialize_kafka_relation(self):
 132         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 133         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 134         self.harness.update_relation_data(
 135             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 136         )
 137
 138     def initialize_mongo_config(self):
 139         self.harness.update_config({"mongodb_uri": "mongodb://mongo:27017"})
 140
 141     def initialize_mongo_relation(self):
 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     def initialize_mysql_config(self, uri=None):
 151         self.harness.update_config(
 152             {"mysql_uri": uri or "mysql://user:pass@mysql-host:3306/database"}
 153         )
 154
 155     def initialize_mysql_relation(self):
 156         mongodb_relation_id = self.harness.add_relation("mysql", "mysql")
 157         self.harness.add_relation_unit(mongodb_relation_id, "mysql/0")
 158         self.harness.update_relation_data(
 159             mongodb_relation_id,
 160             "mysql/0",
 161             {
 162                 "user": "user",
 163                 "password": "pass",
 164                 "host": "host",
 165                 "port": "1234",
 166                 "database": "pol",
 167                 "root_password": "root_password",
 168             },
 169         )
 170
 171
 172 if __name__ == "__main__":
 173     unittest.main()
 174
 175
 176 # class TestCharm(unittest.TestCase):
 177 #     """POL Charm unit tests."""
 178
 179 #     def setUp(self) -> NoReturn:
 180 #         """Test setup"""
 181 #         self.harness = Harness(PolCharm)
 182 #         self.harness.set_leader(is_leader=True)
 183 #         self.harness.begin()
 184
 185 #     def test_on_start_without_relations(self) -> NoReturn:
 186 #         """Test installation without any relation."""
 187 #         self.harness.charm.on.start.emit()
 188
 189 #         # Verifying status
 190 #         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 191
 192 #         # Verifying status message
 193 #         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 194 #         self.assertTrue(
 195 #             self.harness.charm.unit.status.message.startswith("Waiting for ")
 196 #         )
 197 #         self.assertIn("kafka", self.harness.charm.unit.status.message)
 198 #         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 199 #         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 200
 201 #     def test_on_start_with_relations(self) -> NoReturn:
 202 #         """Test deployment without keystone."""
 203 #         expected_result = {
 204 #             "version": 3,
 205 #             "containers": [
 206 #                 {
 207 #                     "name": "pol",
 208 #                     "imageDetails": self.harness.charm.image.fetch(),
 209 #                     "imagePullPolicy": "Always",
 210 #                     "ports": [
 211 #                         {
 212 #                             "name": "pol",
 213 #                             "containerPort": 80,
 214 #                             "protocol": "TCP",
 215 #                         }
 216 #                     ],
 217 #                     "envConfig": {
 218 #                         "ALLOW_ANONYMOUS_LOGIN": "yes",
 219 #                         "OSMPOL_GLOBAL_LOGLEVEL": "INFO",
 220 #                         "OSMPOL_MESSAGE_HOST": "kafka",
 221 #                         "OSMPOL_MESSAGE_DRIVER": "kafka",
 222 #                         "OSMPOL_MESSAGE_PORT": 9092,
 223 #                         "OSMPOL_DATABASE_DRIVER": "mongo",
 224 #                         "OSMPOL_DATABASE_URI": "mongodb://mongo:27017",
 225 #                     },
 226 #                 }
 227 #             ],
 228 #             "kubernetesResources": {"ingressResources": []},
 229 #         }
 230
 231 #         self.harness.charm.on.start.emit()
 232
 233 #         # Check if kafka datastore is initialized
 234 #         self.assertIsNone(self.harness.charm.state.message_host)
 235 #         self.assertIsNone(self.harness.charm.state.message_port)
 236
 237 #         # Check if mongodb datastore is initialized
 238 #         self.assertIsNone(self.harness.charm.state.database_uri)
 239
 240 #         # Initializing the kafka relation
 241 #         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 242 #         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 243 #         self.harness.update_relation_data(
 244 #             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 245 #         )
 246
 247 #         # Initializing the mongo relation
 248 #         mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
 249 #         self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
 250 #         self.harness.update_relation_data(
 251 #             mongodb_relation_id,
 252 #             "mongodb/0",
 253 #             {"connection_string": "mongodb://mongo:27017"},
 254 #         )
 255
 256 #         # Checking if kafka data is stored
 257 #         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 258 #         self.assertEqual(self.harness.charm.state.message_port, 9092)
 259
 260 #         # Checking if mongodb data is stored
 261 #         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 262
 263 #         # Verifying status
 264 #         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
 265
 266 #         pod_spec, _ = self.harness.get_pod_spec()
 267
 268 #         self.assertDictEqual(expected_result, pod_spec)
 269
 270 #     def test_on_kafka_unit_relation_changed(self) -> NoReturn:
 271 #         """Test to see if kafka relation is updated."""
 272 #         self.harness.charm.on.start.emit()
 273
 274 #         self.assertIsNone(self.harness.charm.state.message_host)
 275 #         self.assertIsNone(self.harness.charm.state.message_port)
 276
 277 #         relation_id = self.harness.add_relation("kafka", "kafka")
 278 #         self.harness.add_relation_unit(relation_id, "kafka/0")
 279 #         self.harness.update_relation_data(
 280 #             relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 281 #         )
 282
 283 #         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 284 #         self.assertEqual(self.harness.charm.state.message_port, 9092)
 285
 286 #         # Verifying status
 287 #         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 288
 289 #         # Verifying status message
 290 #         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 291 #         self.assertTrue(
 292 #             self.harness.charm.unit.status.message.startswith("Waiting for ")
 293 #         )
 294 #         self.assertNotIn("kafka", self.harness.charm.unit.status.message)
 295 #         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 296 #         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relation"))
 297
 298 #     def test_on_mongodb_unit_relation_changed(self) -> NoReturn:
 299 #         """Test to see if mongodb relation is updated."""
 300 #         self.harness.charm.on.start.emit()
 301
 302 #         self.assertIsNone(self.harness.charm.state.database_uri)
 303
 304 #         relation_id = self.harness.add_relation("mongodb", "mongodb")
 305 #         self.harness.add_relation_unit(relation_id, "mongodb/0")
 306 #         self.harness.update_relation_data(
 307 #             relation_id, "mongodb/0", {"connection_string": "mongodb://mongo:27017"}
 308 #         )
 309
 310 #         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 311
 312 #         # Verifying status
 313 #         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 314
 315 #         # Verifying status message
 316 #         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 317 #         self.assertTrue(
 318 #             self.harness.charm.unit.status.message.startswith("Waiting for ")
 319 #         )
 320 #         self.assertIn("kafka", self.harness.charm.unit.status.message)
 321 #         self.assertNotIn("mongodb", self.harness.charm.unit.status.message)
 322 #         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relation"))
 323
 324
 325 # if __name__ == "__main__":
 326 #     unittest.main()