59a27fb735f4827ffddc8c5ccb85936b78c294ec
2 # Copyright 2021 Canonical Ltd.
4 # Licensed under the Apache License, Version 2.0 (the "License"); you may
5 # not use this file except in compliance with the License. You may obtain
6 # a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 # License for the specific language governing permissions and limitations
16 # For those usages not covered by the Apache License, Version 2.0 please
17 # contact: legal@canonical.com
19 # To get in touch with the maintainers, please contact:
20 # osm-charmers@lists.launchpad.net
24 from typing
import NoReturn
28 from charm
import NbiCharm
29 from ops
.model
import ActiveStatus
, BlockedStatus
30 from ops
.testing
import Harness
33 class TestCharm(unittest
.TestCase
):
34 """Prometheus Charm unit tests."""
36 def setUp(self
) -> NoReturn
:
38 self
.image_info
= sys
.modules
["oci_image"].OCIImageResource().fetch()
39 self
.harness
= Harness(NbiCharm
)
40 self
.harness
.set_leader(is_leader
=True)
44 "auth_backend": "internal",
45 "database_commonkey": "key",
49 "ingress_whitelist_source_range": "",
50 "tls_secret_name": "",
51 "site_url": "https://nbi.192.168.100.100.nip.io",
52 "cluster_issuer": "vault-issuer",
54 self
.harness
.update_config(self
.config
)
56 def test_config_changed_no_relations(
59 """Test ingress resources without HTTP."""
61 self
.harness
.charm
.on
.config_changed
.emit()
64 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
67 relation
in self
.harness
.charm
.unit
.status
.message
68 for relation
in ["mongodb", "kafka", "prometheus"]
72 def test_config_changed_non_leader(
75 """Test ingress resources without HTTP."""
76 self
.harness
.set_leader(is_leader
=False)
77 self
.harness
.charm
.on
.config_changed
.emit()
80 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, ActiveStatus
)
82 def test_with_relations_internal_and_mongodb_config(
85 "Test with relations and mongodb config (internal)"
86 self
.initialize_kafka_relation()
87 self
.initialize_mongo_config()
88 self
.initialize_prometheus_relation()
90 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
92 def test_with_relations_internal(
95 "Test with relations (internal)"
96 self
.initialize_kafka_relation()
97 self
.initialize_mongo_relation()
98 self
.initialize_prometheus_relation()
100 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
102 def test_with_relations_and_mongodb_config_with_keystone_missing(
105 "Test with relations and mongodb config (keystone)"
106 self
.harness
.update_config({"auth_backend": "keystone"})
107 self
.initialize_kafka_relation()
108 self
.initialize_mongo_config()
109 self
.initialize_prometheus_relation()
111 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
112 self
.assertTrue("keystone" in self
.harness
.charm
.unit
.status
.message
)
114 def test_with_relations_keystone_missing(
117 "Test with relations (keystone)"
118 self
.harness
.update_config({"auth_backend": "keystone"})
119 self
.initialize_kafka_relation()
120 self
.initialize_mongo_relation()
121 self
.initialize_prometheus_relation()
123 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
124 self
.assertTrue("keystone" in self
.harness
.charm
.unit
.status
.message
)
126 def test_with_relations_and_mongodb_config_with_keystone(
129 "Test with relations (keystone)"
130 self
.harness
.update_config({"auth_backend": "keystone"})
131 self
.initialize_kafka_relation()
132 self
.initialize_mongo_config()
133 self
.initialize_prometheus_relation()
134 self
.initialize_keystone_relation()
136 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
138 def test_with_relations_keystone(
141 "Test with relations (keystone)"
142 self
.harness
.update_config({"auth_backend": "keystone"})
143 self
.initialize_kafka_relation()
144 self
.initialize_mongo_relation()
145 self
.initialize_prometheus_relation()
146 self
.initialize_keystone_relation()
148 self
.assertNotIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
150 def test_mongodb_exception_relation_and_config(
153 self
.initialize_mongo_config()
154 self
.initialize_mongo_relation()
156 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
158 def test_config_liveness_probe_with_relations(
161 "Test configuration of liveness probe with relations"
162 self
.initialize_nbi_with_keystone()
163 self
.config_liveness_probe()
165 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, ActiveStatus
)
167 def test_wrong_config_liveness_probe_with_relations(
170 "Test wrong configuration of liveness probe with relations"
171 self
.initialize_nbi_with_keystone()
172 self
.wrong_config_liveness_probe()
174 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
176 def test_config_readiness_probe_with_relations(
179 "Test configuration of readiness probe with relations"
180 self
.initialize_nbi_with_keystone()
181 self
.config_readiness_probe()
183 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, ActiveStatus
)
185 def test_wrong_config_readiness_probe_with_relations(
188 "Test wrong configuration of readiness probe with relations"
189 self
.initialize_nbi_with_keystone()
190 self
.wrong_config_readiness_probe()
192 self
.assertIsInstance(self
.harness
.charm
.unit
.status
, BlockedStatus
)
194 def initialize_kafka_relation(self
):
195 kafka_relation_id
= self
.harness
.add_relation("kafka", "kafka")
196 self
.harness
.add_relation_unit(kafka_relation_id
, "kafka/0")
197 self
.harness
.update_relation_data(
198 kafka_relation_id
, "kafka", {"host": "kafka", "port": 9092}
201 def initialize_mongo_config(self
):
202 self
.harness
.update_config({"mongodb_uri": "mongodb://mongo:27017"})
204 def initialize_nbi_with_keystone(self
):
205 self
.harness
.update_config({"auth_backend": "keystone"})
206 self
.initialize_kafka_relation()
207 self
.initialize_mongo_relation()
208 self
.initialize_prometheus_relation()
209 self
.initialize_keystone_relation()
211 def config_liveness_probe(self
):
212 self
.harness
.update_config(
213 {"tcpsocket_liveness_probe": '{"initial_delay_seconds": 10}'}
216 def wrong_config_liveness_probe(self
):
217 self
.harness
.update_config(
218 {"tcpsocket_liveness_probe": "{initial_delay_seconds: 10}"}
221 def wrong_config_readiness_probe(self
):
222 self
.harness
.update_config(
223 {"tcpsocket_readiness_probe": "{initial_delay_seconds: 10}"}
226 def config_readiness_probe(self
):
227 self
.harness
.update_config(
228 {"tcpsocket_readiness_probe": '{"initial_delay_seconds": 10}'}
231 def initialize_mongo_relation(self
):
232 mongodb_relation_id
= self
.harness
.add_relation("mongodb", "mongodb")
233 self
.harness
.add_relation_unit(mongodb_relation_id
, "mongodb/0")
234 self
.harness
.update_relation_data(
237 {"connection_string": "mongodb://mongo:27017"},
240 def initialize_keystone_relation(self
):
241 keystone_relation_id
= self
.harness
.add_relation("keystone", "keystone")
242 self
.harness
.add_relation_unit(keystone_relation_id
, "keystone/0")
243 self
.harness
.update_relation_data(
244 keystone_relation_id
,
249 "user_domain_name": "ud",
250 "project_domain_name": "pd",
254 "keystone_db_password": "something",
255 "region_id": "something",
256 "admin_username": "something",
257 "admin_password": "something",
258 "admin_project_name": "something",
262 def initialize_prometheus_relation(self
):
263 prometheus_relation_id
= self
.harness
.add_relation("prometheus", "prometheus")
264 self
.harness
.add_relation_unit(prometheus_relation_id
, "prometheus/0")
265 self
.harness
.update_relation_data(
266 prometheus_relation_id
,
268 {"hostname": "prometheus", "port": 9090},
272 if __name__
== "__main__":
276 # class TestCharm(unittest.TestCase):
277 # """Prometheus Charm unit tests."""
279 # def setUp(self) -> NoReturn:
281 # self.image_info = sys.modules["oci_image"].OCIImageResource().fetch()
282 # self.harness = Harness(NbiCharm)
283 # self.harness.set_leader(is_leader=True)
284 # self.harness.begin()
286 # "enable_ng_ro": True,
287 # "database_commonkey": "commonkey",
288 # "log_level": "INFO",
289 # "vim_database": "db_name",
290 # "ro_database": "ro_db_name",
291 # "openmano_tenant": "mano",
294 # def test_config_changed_no_relations(
297 # """Test ingress resources without HTTP."""
299 # self.harness.charm.on.config_changed.emit()
302 # self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
305 # relation in self.harness.charm.unit.status.message
306 # for relation in ["mongodb", "kafka"]
311 # self.harness.update_config({"enable_ng_ro": False})
312 # self.assertIsInstance(self.harness.charm.unit.status, BlockedStatus)
315 # relation in self.harness.charm.unit.status.message
316 # for relation in ["mysql"]
320 # def test_config_changed_non_leader(
323 # """Test ingress resources without HTTP."""
324 # self.harness.set_leader(is_leader=False)
325 # self.harness.charm.on.config_changed.emit()
328 # self.assertIsInstance(self.harness.charm.unit.status, ActiveStatus)
330 # def test_with_relations_ng(
333 # "Test with relations (ng-ro)"
335 # # Initializing the kafka relation
336 # kafka_relation_id = self.harness.add_relation("kafka", "kafka")
337 # self.harness.add_relation_unit(kafka_relation_id, "kafka/0")
338 # self.harness.update_relation_data(
339 # kafka_relation_id, "kafka/0", {"host": "kafka", "port": 9092}
342 # # Initializing the mongo relation
343 # mongodb_relation_id = self.harness.add_relation("mongodb", "mongodb")
344 # self.harness.add_relation_unit(mongodb_relation_id, "mongodb/0")
345 # self.harness.update_relation_data(
346 # mongodb_relation_id,
348 # {"connection_string": "mongodb://mongo:27017"},
351 # self.harness.charm.on.config_changed.emit()
354 # self.assertNotIsInstance(self.harness.charm.unit.status, BlockedStatus)
357 # if __name__ == "__main__":