Integrate MON and Prometheus

[osm/devops.git] / installers / charm / osm-mon / tests / integration / test_charm.py

diff --git a/installers/charm/osm-mon/tests/integration/test_charm.py b/installers/charm/osm-mon/tests/integration/test_charm.py
index c5807e9..f5d0cea 100644 (file)
--- a/installers/charm/osm-mon/tests/integration/test_charm.py
+++ b/installers/charm/osm-mon/tests/integration/test_charm.py
@@ -42,7 +42,7 @@ MARIADB_CHARM = "charmed-osm-mariadb-k8s"
 MARIADB_APP = "mariadb"
 MONGO_DB_CHARM = "mongodb-k8s"
 MONGO_DB_APP = "mongodb"
-PROMETHEUS_CHARM = "osm-prometheus"
+PROMETHEUS_CHARM = "prometheus-k8s"
 PROMETHEUS_APP = "prometheus"
 ZOOKEEPER_CHARM = "zookeeper-k8s"
 ZOOKEEPER_APP = "zookeeper"
@@ -52,46 +52,89 @@ APPS = [KAFKA_APP, ZOOKEEPER_APP, KEYSTONE_APP, MONGO_DB_APP, MARIADB_APP, PROME
 
 
 @pytest.mark.abort_on_fail
-async def test_mon_is_deployed(ops_test: OpsTest):
+async def test_mon_and_other_charms_are_idle(ops_test: OpsTest):
     charm = await ops_test.build_charm(".")
     resources = {"mon-image": METADATA["resources"]["mon-image"]["upstream-source"]}
 
     await asyncio.gather(
         ops_test.model.deploy(
-            charm, resources=resources, application_name=MON_APP, series="focal"
+            charm, resources=resources, application_name=MON_APP, series="jammy"
         ),
         ops_test.model.deploy(KAFKA_CHARM, application_name=KAFKA_APP, channel="stable"),
-        ops_test.model.deploy(MONGO_DB_CHARM, application_name=MONGO_DB_APP, channel="edge"),
+        ops_test.model.deploy(MONGO_DB_CHARM, application_name=MONGO_DB_APP, channel="5/edge"),
         ops_test.model.deploy(MARIADB_CHARM, application_name=MARIADB_APP, channel="stable"),
-        ops_test.model.deploy(PROMETHEUS_CHARM, application_name=PROMETHEUS_APP, channel="stable"),
+        ops_test.model.deploy(PROMETHEUS_CHARM, application_name=PROMETHEUS_APP, channel="edge"),
         ops_test.model.deploy(ZOOKEEPER_CHARM, application_name=ZOOKEEPER_APP, channel="stable"),
     )
-    cmd = f"juju deploy {KEYSTONE_CHARM} {KEYSTONE_APP} --resource keystone-image=opensourcemano/keystone:12"
+    keystone_image = "opensourcemano/keystone:testing-daily"
+    cmd = f"juju deploy {KEYSTONE_CHARM} {KEYSTONE_APP} --resource keystone-image={keystone_image} --channel=latest/beta --series jammy"
     await ops_test.run(*shlex.split(cmd), check=True)
 
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS,
-        )
+        await ops_test.model.wait_for_idle(apps=APPS)
+
+
+@pytest.mark.abort_on_fail
+async def test_mon_is_blocked_due_to_missing_mandatory_config(ops_test: OpsTest):
     assert ops_test.model.applications[MON_APP].status == "blocked"
     unit = ops_test.model.applications[MON_APP].units[0]
+    assert (
+        unit.workload_status_message
+        == "need grafana-url, grafana-user, grafana-password, prometheus-url config"
+    )
+
+    await ops_test.model.applications[MON_APP].set_config({"prometheus-url": "a_value"})
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+    assert (
+        unit.workload_status_message == "need grafana-url, grafana-user, grafana-password config"
+    )
+
+    await ops_test.model.applications[MON_APP].set_config({"grafana-url": "new_value"})
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+    assert unit.workload_status_message == "need grafana-user, grafana-password config"
+
+    await ops_test.model.applications[MON_APP].set_config({"grafana-password": "new_value"})
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+    assert unit.workload_status_message == "need grafana-user config"
+
+    await ops_test.model.applications[MON_APP].set_config({"grafana-user": "new_value"})
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+
+    assert unit.workload_status_message == "Invalid value for grafana-url config: 'new_value'"
+    await ops_test.model.applications[MON_APP].set_config({"grafana-url": "http://valid:92"})
+
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+
+    assert unit.workload_status_message == "Invalid value for prometheus-url config: 'a_value'"
+    await ops_test.model.applications[MON_APP].set_config({"prometheus-url": "http://valid:95"})
+
+
+@pytest.mark.abort_on_fail
+async def test_mon_is_blocked_due_to_missing_relations(ops_test: OpsTest):
+    async with ops_test.fast_forward():
+        await ops_test.model.wait_for_idle(apps=[MON_APP], status="blocked")
+    unit = ops_test.model.applications[MON_APP].units[0]
     assert unit.workload_status_message == "need kafka, mongodb, prometheus, keystone relations"
 
     logger.info("Adding relations for other components")
     await ops_test.model.add_relation(KAFKA_APP, ZOOKEEPER_APP)
     await ops_test.model.add_relation(MARIADB_APP, KEYSTONE_APP)
 
-    logger.info("Adding relations")
-    await ops_test.model.add_relation(MON_APP, MONGO_DB_APP)
+    logger.info("Adding relations for MON")
+    await ops_test.model.add_relation(
+        "{}:mongodb".format(MON_APP), "{}:database".format(MONGO_DB_APP)
+    )
     await ops_test.model.add_relation(MON_APP, KAFKA_APP)
     await ops_test.model.add_relation(MON_APP, KEYSTONE_APP)
     await ops_test.model.add_relation(MON_APP, PROMETHEUS_APP)
 
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS,
-            status="active",
-        )
+        await ops_test.model.wait_for_idle(apps=APPS, status="active")
 
 
 @pytest.mark.abort_on_fail
@@ -106,39 +149,34 @@ async def test_mon_scales_up(ops_test: OpsTest):
         )
 
 
+app_to_relation = {
+    KAFKA_APP: KAFKA_APP,
+    MONGO_DB_APP: "database",
+    PROMETHEUS_APP: "metrics-endpoint",
+    KEYSTONE_APP: KEYSTONE_APP,
+}
+
+
 @pytest.mark.abort_on_fail
-@pytest.mark.parametrize(
-    "relation_to_remove", [KAFKA_APP, MONGO_DB_APP, PROMETHEUS_APP, KEYSTONE_APP]
-)
-async def test_mon_blocks_without_relation(ops_test: OpsTest, relation_to_remove):
-    logger.info("Removing relation: %s", relation_to_remove)
-    # mongoDB relation is named "database"
-    local_relation = relation_to_remove
-    if relation_to_remove == MONGO_DB_APP:
-        local_relation = "database"
-    await asyncio.gather(
-        ops_test.model.applications[relation_to_remove].remove_relation(local_relation, MON_APP)
-    )
+@pytest.mark.parametrize("app", app_to_relation.keys())
+async def test_mon_blocks_without_relation(ops_test: OpsTest, app):
+    logger.info("Removing relation with: %s", app)
+    relation = app_to_relation[app]
+    await ops_test.model.applications[app].remove_relation(relation, MON_APP)
     async with ops_test.fast_forward():
         await ops_test.model.wait_for_idle(apps=[MON_APP])
     assert ops_test.model.applications[MON_APP].status == "blocked"
     for unit in ops_test.model.applications[MON_APP].units:
-        assert unit.workload_status_message == f"need {relation_to_remove} relation"
-    await ops_test.model.add_relation(MON_APP, relation_to_remove)
+        assert unit.workload_status_message == f"need {app} relation"
+    await ops_test.model.add_relation(MON_APP, app)
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS,
-            status="active",
-        )
+        await ops_test.model.wait_for_idle(apps=APPS, status="active")
 
 
 @pytest.mark.abort_on_fail
 async def test_mon_action_debug_mode_disabled(ops_test: OpsTest):
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS,
-            status="active",
-        )
+        await ops_test.model.wait_for_idle(apps=APPS, status="active")
     logger.info("Running action 'get-debug-mode-information'")
     action = (
         await ops_test.model.applications[MON_APP]
@@ -178,13 +216,12 @@ async def test_mon_action_debug_mode_enabled(ops_test: OpsTest):
 
 @pytest.mark.abort_on_fail
 async def test_mon_integration_vca(ops_test: OpsTest):
-    await asyncio.gather(
-        ops_test.model.deploy(VCA_CHARM, application_name=VCA_APP, channel="beta"),
+    await ops_test.model.deploy(
+        VCA_CHARM, application_name=VCA_APP, channel="latest/beta", series="jammy"
     )
+
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=[VCA_APP],
-        )
+        await ops_test.model.wait_for_idle(apps=[VCA_APP])
     controllers = (Path.home() / ".local/share/juju/controllers.yaml").read_text()
     accounts = (Path.home() / ".local/share/juju/accounts.yaml").read_text()
     public_key = (Path.home() / ".local/share/juju/ssh/juju_id_rsa.pub").read_text()
@@ -197,13 +234,7 @@ async def test_mon_integration_vca(ops_test: OpsTest):
         }
     )
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS + [VCA_APP],
-            status="active",
-        )
+        await ops_test.model.wait_for_idle(apps=APPS + [VCA_APP], status="active")
     await ops_test.model.add_relation(MON_APP, VCA_APP)
     async with ops_test.fast_forward():
-        await ops_test.model.wait_for_idle(
-            apps=APPS + [VCA_APP],
-            status="active",
-        )
+        await ops_test.model.wait_for_idle(apps=APPS + [VCA_APP], status="active")