pin pytest-asyncio (#430)

* pin pytest-asyncio

* updated, accelerated mysql-root test with current osm bundle

* bump lib

* wait mongo be ready to workaround initalization issue

* juju 2 compatible mongodb-k8s

* bump lib

Author: paulomach

lib/charms/data_platform_libs/v0/upgrade.py

@@ -285,7 +285,7 @@ def restart(self, event) -> None:
 
 # Increment this PATCH version before using `charmcraft publish-lib` or reset
 # to 0 if you are raising the major API version
-LIBPATCH = 16
+LIBPATCH = 17
 
 PYDEPS = ["pydantic>=1.10,<2", "poetry-core"]
 
@@ -907,6 +907,17 @@ def _on_upgrade_charm(self, event: UpgradeCharmEvent) -> None:
                     logger.error(e)
                     self.set_unit_failed()
                     return
+                top_unit_id = self.upgrade_stack[-1]
+                top_unit = self.charm.model.get_unit(f"{self.charm.app.name}/{top_unit_id}")
+                if (
+                    top_unit == self.charm.unit
+                    and self.peer_relation.data[self.charm.unit].get("state") == "recovery"
+                ):
+                    # While in a rollback and the Juju leader unit is the top unit in the upgrade stack, emit the event
+                    # for this unit to start the rollback.
+                    self.peer_relation.data[self.charm.unit].update({"state": "ready"})
+                    self.on_upgrade_changed(event)
+                    return
             self.charm.unit.status = WaitingStatus("other units upgrading first...")
             self.peer_relation.data[self.charm.unit].update({"state": "ready"})
 

lib/charms/grafana_k8s/v0/grafana_dashboard.py

@@ -219,7 +219,7 @@ def __init__(self, *args):
 # Increment this PATCH version before using `charmcraft publish-lib` or reset
 # to 0 if you are raising the major API version
 
-LIBPATCH = 35
+LIBPATCH = 36
 
 logger = logging.getLogger(__name__)
 
@@ -1050,6 +1050,7 @@ def __init__(
 
         self.framework.observe(self._charm.on.leader_elected, self._update_all_dashboards_from_dir)
         self.framework.observe(self._charm.on.upgrade_charm, self._update_all_dashboards_from_dir)
+        self.framework.observe(self._charm.on.config_changed, self._update_all_dashboards_from_dir)
 
         self.framework.observe(
             self._charm.on[self._relation_name].relation_created,

poetry.lock

@@ -77,7 +77,7 @@ urllib3 = "^1.26.16"
 lightkube = "^0.14.0"
 kubernetes = "^27.2.0"
 allure-pytest = "^2.13.2"
-
+pytest-asyncio = "^0.21.1"
 
 [tool.coverage.run]
 branch = true
@@ -89,6 +89,7 @@ show_missing = true
 minversion = "6.0"
 log_cli_level = "INFO"
 markers = ["unstable", "juju3", "only_with_juju_secrets", "only_without_juju_secrets"]
+asyncio_mode = "auto"
 
 # Formatting tools configuration
 [tool.black]

pyproject.toml

@@ -48,7 +48,7 @@ async def test_deploy_and_relate_osm_bundle(ops_test: OpsTest) -> None:
                 application_name=APP_NAME,
                 resources=resources,
                 config=config,
-                num_units=3,
+                num_units=1,
                 series="jammy",
                 trust=True,
             ),
@@ -57,70 +57,71 @@ async def test_deploy_and_relate_osm_bundle(ops_test: OpsTest) -> None:
             # not correctly deploy with the correct resources)
             ops_test.juju(
                 "deploy",
-                "--channel=latest/edge",
-                "--trust",
+                "--channel=latest/beta",
                 "--resource",
                 "keystone-image=opensourcemano/keystone:testing-daily",
                 "osm-keystone",
-                "osm-keystone",
             ),
             ops_test.model.deploy(
                 "osm-pol",
                 application_name="osm-pol",
-                channel="latest/candidate",
+                channel="latest/beta",
                 resources=osm_pol_resources,
+                trust=True,
+            ),
+            ops_test.model.deploy(
+                "kafka-k8s", application_name="kafka", trust=True, channel="latest/stable"
             ),
             ops_test.model.deploy(
-                "charmed-osm-kafka-k8s",
-                application_name="osm-kafka",
+                "zookeeper-k8s", application_name="zookeeper", channel="latest/stable"
+            ),
+            # sticking to revision that support both juju 2.9.x and 3.x
+            ops_test.model.deploy(
+                "mongodb-k8s",
+                application_name="mongodb",
+                channel="5/edge",
+                revision=36,
+                series="jammy",
             ),
-            ops_test.model.deploy("charmed-osm-zookeeper-k8s", application_name="osm-zookeeper"),
-            ops_test.model.deploy("charmed-osm-mongodb-k8s", application_name="osm-mongodb"),
         )
 
         # cannot block until "osm-keystone" units are available since they are not
         # registered with ops_test.model.applications (due to the way it's deployed)
-        await ops_test.model.block_until(
-            lambda: len(ops_test.model.applications[APP_NAME].units) == 3,
+        await ops_test.model.wait_for_idle(
+            apps=[APP_NAME, "mongodb"],
+            status="active",
             timeout=1000,
         )
         await ops_test.model.block_until(
             lambda: len(ops_test.model.applications["osm-pol"].units) == 1,
             timeout=1000,
         )
         await ops_test.model.block_until(
-            lambda: len(ops_test.model.applications["osm-kafka"].units) == 1,
+            lambda: len(ops_test.model.applications["kafka"].units) == 1,
             timeout=1000,
         )
         await ops_test.model.block_until(
-            lambda: len(ops_test.model.applications["osm-zookeeper"].units) == 1,
+            lambda: len(ops_test.model.applications["zookeeper"].units) == 1,
             timeout=1000,
         )
         await ops_test.model.block_until(
-            lambda: len(ops_test.model.applications["osm-mongodb"].units) == 1,
+            lambda: len(ops_test.model.applications["mongodb"].units) == 1,
             timeout=1000,
         )
 
-        await ops_test.model.relate("osm-kafka:zookeeper", "osm-zookeeper:zookeeper")
+        logger.info("Relate kafka and zookeeper")
+        await ops_test.model.relate("kafka:zookeeper", "zookeeper:zookeeper")
         await ops_test.model.block_until(
             lambda: is_relation_joined(ops_test, "zookeeper", "zookeeper"),
             timeout=1000,
         )
 
-        # osm-zookeeper is never `active` long enough (15 seconds is necessary),
-        # it constantly changes state `active`<>`maintenance`:
-        # > osm-zookeeper/0 [idle] maintenance: Sending Zookeeper configuration
-        await ops_test.model.wait_for_idle(
-            apps=[APP_NAME, "osm-kafka", "osm-mongodb"],
-            status="active",
-            raise_on_blocked=True,
-            timeout=1000,
-        )
         await ops_test.model.block_until(
-            lambda: ops_test.model.applications["osm-zookeeper"].status == "active",
+            lambda: ops_test.model.applications["zookeeper"].status == "active",
             timeout=1000,
         )
 
+        logger.info("Relate keystone and mysql")
         await ops_test.model.relate("osm-keystone:db", f"{APP_NAME}:mysql-root")
         await ops_test.model.block_until(
             lambda: is_relation_joined(ops_test, "db", "mysql-root"), timeout=1000
@@ -133,16 +134,19 @@ async def test_deploy_and_relate_osm_bundle(ops_test: OpsTest) -> None:
             timeout=1000,
         )
 
-        await ops_test.model.relate("osm-pol:mongodb", "osm-mongodb:mongo")
+        logger.info("Relate osm-pol and mongo")
+        await ops_test.model.relate("osm-pol:mongodb", "mongodb:database")
         await ops_test.model.block_until(
-            lambda: is_relation_joined(ops_test, "mongodb", "mongo"), timeout=1000
+            lambda: is_relation_joined(ops_test, "mongodb", "database"), timeout=1000
         )
 
-        await ops_test.model.relate("osm-pol:kafka", "osm-kafka:kafka")
+        logger.info("Relate osm-pol and kafka")
+        await ops_test.model.relate("osm-pol:kafka", "kafka:kafka")
         await ops_test.model.block_until(
             lambda: is_relation_joined(ops_test, "kafka", "kafka"), timeout=1000
         )
 
+        logger.info("Relate osm-pol and mysql")
         await ops_test.model.relate("osm-pol:mysql", f"{APP_NAME}:mysql-root")
         await ops_test.model.block_until(
             lambda: is_relation_joined(ops_test, "mysql", "mysql-root"),