installers/charm/mon/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 MonCharm
  30
  31
  32 class TestCharm(unittest.TestCase):
  33     """MON Charm unit tests."""
  34
  35     def setUp(self) -> NoReturn:
  36         """Test setup"""
  37         self.harness = Harness(MonCharm)
  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.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
  57
  58     def test_on_start_with_relations(self) -> NoReturn:
  59         """Test deployment without keystone."""
  60         expected_result = {
  61             "version": 3,
  62             "containers": [
  63                 {
  64                     "name": "mon",
  65                     "imageDetails": self.harness.charm.image.fetch(),
  66                     "imagePullPolicy": "Always",
  67                     "ports": [
  68                         {
  69                             "name": "mon",
  70                             "containerPort": 8000,
  71                             "protocol": "TCP",
  72                         }
  73                     ],
  74                     "envConfig": {
  75                         "ALLOW_ANONYMOUS_LOGIN": "yes",
  76                         "OSMMON_OPENSTACK_DEFAULT_GRANULARITY": 300,
  77                         "OSMMON_GLOBAL_REQUEST_TIMEOUT": 10,
  78                         "OSMMON_GLOBAL_LOGLEVEL": "INFO",
  79                         "OSMMON_COLLECTOR_INTERVAL": 30,
  80                         "OSMMON_EVALUATOR_INTERVAL": 30,
  81                         "OSMMON_MESSAGE_DRIVER": "kafka",
  82                         "OSMMON_MESSAGE_HOST": "kafka",
  83                         "OSMMON_MESSAGE_PORT": 9092,
  84                         "OSMMON_DATABASE_DRIVER": "mongo",
  85                         "OSMMON_DATABASE_URI": "mongodb://mongo:27017",
  86                         "OSMMON_DATABASE_COMMONKEY": "osm",
  87                         "OSMMON_PROMETHEUS_URL": "http://prometheus:9090",
  88                         "OSMMON_VCA_HOST": "admin",
  89                         "OSMMON_VCA_USER": "admin",
  90                         "OSMMON_VCA_SECRET": "secret",
  91                         "OSMMON_VCA_CACERT": "",
  92                     },
  93                 }
  94             ],
  95             "kubernetesResources": {"ingressResources": []},
  96         }
  97
  98         self.harness.charm.on.start.emit()
  99
 100         # Check if kafka datastore is initialized
 101         self.assertIsNone(self.harness.charm.state.message_host)
 102         self.assertIsNone(self.harness.charm.state.message_port)
 103
 104         # Check if mongodb datastore is initialized
 105         self.assertIsNone(self.harness.charm.state.database_uri)
 106
 107         # Check if prometheus datastore is initialized
 108         self.assertIsNone(self.harness.charm.state.prometheus_host)
 109         self.assertIsNone(self.harness.charm.state.prometheus_port)
 110
 111         # Initializing the kafka relation
 112         kafka_relation_id = self.harness.add_relation("kafka", "kafka")
 113         self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
 114         self.harness.update_relation_data(
 115             kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 116         )
 117
 118         # Initializing the mongo relation
 119         mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
 120         self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
 121         self.harness.update_relation_data(
 122             mongodb_relation_id,
 123             "mongodb/0",
 124             {"connection_string": "mongodb://mongo:27017"},
 125         )
 126
 127         # Initializing the prometheus relation
 128         prometheus_relation_id = self.harness.add_relation("prometheus", "prometheus")
 129         self.harness.add_relation_unit(prometheus_relation_id, "prometheus/0")
 130         self.harness.update_relation_data(
 131             prometheus_relation_id,
 132             "prometheus/0",
 133             {"hostname": "prometheus", "port": 9090},
 134         )
 135
 136         # Checking if kafka data is stored
 137         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 138         self.assertEqual(self.harness.charm.state.message_port, 9092)
 139
 140         # Checking if mongodb data is stored
 141         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 142
 143         # Checking if prometheus data is stored
 144         self.assertEqual(self.harness.charm.state.prometheus_host, "prometheus")
 145         self.assertEqual(self.harness.charm.state.prometheus_port, 9090)
 146
 147         # Verifying status
 148         self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
 149
 150         pod_spec, _ = self.harness.get_pod_spec()
 151
 152         self.assertDictEqual(expected_result, pod_spec)
 153
 154     def test_on_kafka_unit_relation_changed(self) -> NoReturn:
 155         """Test to see if kafka relation is updated."""
 156         self.harness.charm.on.start.emit()
 157
 158         self.assertIsNone(self.harness.charm.state.message_host)
 159         self.assertIsNone(self.harness.charm.state.message_port)
 160
 161         relation_id = self.harness.add_relation("kafka", "kafka")
 162         self.harness.add_relation_unit(relation_id, "kafka/0")
 163         self.harness.update_relation_data(
 164             relation_id, "kafka/0", {"host": "kafka", "port": 9092}
 165         )
 166
 167         self.assertEqual(self.harness.charm.state.message_host, "kafka")
 168         self.assertEqual(self.harness.charm.state.message_port, 9092)
 169
 170         # Verifying status
 171         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 172
 173         # Verifying status message
 174         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 175         self.assertTrue(
 176             self.harness.charm.unit.status.message.startswith("Waiting for ")
 177         )
 178         self.assertNotIn("kafka", self.harness.charm.unit.status.message)
 179         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 180         self.assertIn("prometheus", self.harness.charm.unit.status.message)
 181         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 182
 183     def test_on_mongodb_unit_relation_changed(self) -> NoReturn:
 184         """Test to see if mongodb relation is updated."""
 185         self.harness.charm.on.start.emit()
 186
 187         self.assertIsNone(self.harness.charm.state.database_uri)
 188
 189         relation_id = self.harness.add_relation("mongodb", "mongodb")
 190         self.harness.add_relation_unit(relation_id, "mongodb/0")
 191         self.harness.update_relation_data(
 192             relation_id, "mongodb/0", {"connection_string": "mongodb://mongo:27017"}
 193         )
 194
 195         self.assertEqual(self.harness.charm.state.database_uri, "mongodb://mongo:27017")
 196
 197         # Verifying status
 198         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 199
 200         # Verifying status message
 201         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 202         self.assertTrue(
 203             self.harness.charm.unit.status.message.startswith("Waiting for ")
 204         )
 205         self.assertIn("kafka", self.harness.charm.unit.status.message)
 206         self.assertNotIn("mongodb", self.harness.charm.unit.status.message)
 207         self.assertIn("prometheus", self.harness.charm.unit.status.message)
 208         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 209
 210     def test_on_prometheus_unit_relation_changed(self) -> NoReturn:
 211         """Test to see if prometheus relation is updated."""
 212         self.harness.charm.on.start.emit()
 213
 214         self.assertIsNone(self.harness.charm.state.prometheus_host)
 215         self.assertIsNone(self.harness.charm.state.prometheus_port)
 216
 217         relation_id = self.harness.add_relation("prometheus", "prometheus")
 218         self.harness.add_relation_unit(relation_id, "prometheus/0")
 219         self.harness.update_relation_data(
 220             relation_id, "prometheus/0", {"hostname": "prometheus", "port": 9090}
 221         )
 222
 223         self.assertEqual(self.harness.charm.state.prometheus_host, "prometheus")
 224         self.assertEqual(self.harness.charm.state.prometheus_port, 9090)
 225
 226         # Verifying status
 227         self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
 228
 229         # Verifying status message
 230         self.assertGreater(len(self.harness.charm.unit.status.message), 0)
 231         self.assertTrue(
 232             self.harness.charm.unit.status.message.startswith("Waiting for ")
 233         )
 234         self.assertIn("kafka", self.harness.charm.unit.status.message)
 235         self.assertIn("mongodb", self.harness.charm.unit.status.message)
 236         self.assertNotIn("prometheus", self.harness.charm.unit.status.message)
 237         self.assertTrue(self.harness.charm.unit.status.message.endswith(" relations"))
 238
 239
 240 if __name__ == "__main__":
 241     unittest.main()