[DPE-4213] Tests legacy and modern endpoints simultaneously (#434)

* deployment legacy + modern endpoints

* deployment legacy + modern endpoints

* fix postgresql_provider

* fix test group

* simplifying test

Author: BalabaDmitri

src/constants.py

@@ -39,3 +39,12 @@
 
 SECRET_KEY_OVERRIDES = {"ca": "cauth"}
 BACKUP_TYPE_OVERRIDES = {"full": "full", "differential": "diff", "incremental": "incr"}
+
+DATABASE = "database"
+LEGACY_DB = "db"
+LEGACY_DB_ADMIN = "db-admin"
+ALL_LEGACY_RELATIONS = [LEGACY_DB, LEGACY_DB_ADMIN]
+
+ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE = (
+    "Please choose one endpoint to use. No need to relate all of them simultaneously!"
+)

src/relations/db.py

@@ -22,7 +22,7 @@
 from ops.model import ActiveStatus, BlockedStatus, Relation, Unit
 from pgconnstr import ConnectionString
 
-from constants import DATABASE_PORT
+from constants import ALL_LEGACY_RELATIONS, DATABASE_PORT, ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE
 from utils import new_password
 
 logger = logging.getLogger(__name__)
@@ -90,10 +90,28 @@ def _on_relation_changed(self, event: RelationChangedEvent) -> None:
         if not self.charm.unit.is_leader():
             return
 
+        if self._check_multiple_endpoints():
+            self.charm.unit.status = BlockedStatus(ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE)
+            return
+
         logger.warning(f"DEPRECATION WARNING - `{self.relation_name}` is a legacy interface")
 
         self.set_up_relation(event.relation)
 
+    def _check_exist_current_relation(self) -> bool:
+        for r in self.charm.client_relations:
+            if r in ALL_LEGACY_RELATIONS:
+                return True
+        return False
+
+    def _check_multiple_endpoints(self) -> bool:
+        """Checks if there are relations with other endpoints."""
+        is_exist = self._check_exist_current_relation()
+        for relation in self.charm.client_relations:
+            if relation.name not in ALL_LEGACY_RELATIONS and is_exist:
+                return True
+        return False
+
     def _get_extensions(self, relation: Relation) -> Tuple[List, Set]:
         """Returns the list of required and disabled extensions."""
         requested_extensions = relation.data.get(relation.app, {}).get("extensions", "").split(",")
@@ -320,6 +338,24 @@ def _update_unit_status(self, relation: Relation) -> None:
             if not self._check_for_blocking_relations(relation.id):
                 self.charm.unit.status = ActiveStatus()
 
+        self._update_unit_status_on_blocking_endpoint_simultaneously()
+
+    def _update_unit_status_on_blocking_endpoint_simultaneously(self):
+        """Clean up Blocked status if this is due related of multiple endpoints."""
+        if (
+            self.charm._has_blocked_status
+            and self.charm.unit.status.message == ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE
+        ):
+            if not self._check_multiple_endpoints():
+                self.charm.unit.status = ActiveStatus()
+
+    def _check_multiple_endpoints(self) -> bool:
+        """Checks if there are relations with other endpoints."""
+        relation_names = {relation.name for relation in self.charm.client_relations}
+        if "database" in relation_names and len(relation_names) > 1:
+            return True
+        return False
+
     def _get_allowed_subnets(self, relation: Relation) -> str:
         """Build the list of allowed subnets as in the legacy charm."""
 

src/relations/postgresql_provider.py

@@ -16,11 +16,11 @@
     PostgreSQLDeleteUserError,
     PostgreSQLGetPostgreSQLVersionError,
 )
-from ops.charm import CharmBase, RelationBrokenEvent, RelationDepartedEvent
+from ops.charm import CharmBase, RelationBrokenEvent, RelationChangedEvent, RelationDepartedEvent
 from ops.framework import Object
 from ops.model import ActiveStatus, BlockedStatus, Relation
 
-from constants import DATABASE_PORT
+from constants import DATABASE_PORT, ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE
 from utils import new_password
 
 logger = logging.getLogger(__name__)
@@ -50,7 +50,10 @@ def __init__(self, charm: CharmBase, relation_name: str = "database") -> None:
         self.framework.observe(
             charm.on[self.relation_name].relation_broken, self._on_relation_broken
         )
-
+        self.framework.observe(
+            charm.on[self.relation_name].relation_changed,
+            self._on_relation_changed_event,
+        )
         self.charm = charm
 
         # Charm events defined in the database provides charm library.
@@ -193,6 +196,22 @@ def update_read_only_endpoint(self, event: DatabaseRequestedEvent = None) -> Non
                 endpoints,
             )
 
+    def _check_multiple_endpoints(self) -> bool:
+        """Checks if there are relations with other endpoints."""
+        relation_names = {relation.name for relation in self.charm.client_relations}
+        if "database" in relation_names and len(relation_names) > 1:
+            return True
+        return False
+
+    def _update_unit_status_on_blocking_endpoint_simultaneously(self):
+        """Clean up Blocked status if this is due related of multiple endpoints."""
+        if (
+            self.charm._has_blocked_status
+            and self.charm.unit.status.message == ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE
+        ):
+            if not self._check_multiple_endpoints():
+                self.charm.unit.status = ActiveStatus()
+
     def _update_unit_status(self, relation: Relation) -> None:
         """# Clean up Blocked status if it's due to extensions request."""
         if (
@@ -202,6 +221,18 @@ def _update_unit_status(self, relation: Relation) -> None:
             if not self.check_for_invalid_extra_user_roles(relation.id):
                 self.charm.unit.status = ActiveStatus()
 
+        self._update_unit_status_on_blocking_endpoint_simultaneously()
+
+    def _on_relation_changed_event(self, event: RelationChangedEvent) -> None:
+        """Event emitted when the relation has changed."""
+        # Leader only
+        if not self.charm.unit.is_leader():
+            return
+
+        if self._check_multiple_endpoints():
+            self.charm.unit.status = BlockedStatus(ENDPOINT_SIMULTANEOUSLY_BLOCKING_MESSAGE)
+            return
+
     def check_for_invalid_extra_user_roles(self, relation_id: int) -> bool:
         """Checks if there are relations with invalid extra user roles.
 

tests/integration/relations/__init__.py

@@ -0,0 +1,2 @@
+# Copyright 2024 Canonical Ltd.
+# See LICENSE file for licensing details.

tests/integration/relations/helpers.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+# Copyright 2024 Canonical Ltd.
+# See LICENSE file for licensing details.
+
+
+from ..helpers import METADATA
+from ..new_relations.test_new_relations import (
+    APPLICATION_APP_NAME,
+)
+
+APP_NAME = METADATA["name"]
+DB_RELATION = "db"
+DATABASE_RELATION = "database"
+FIRST_DATABASE_RELATION = "first-database"
+APP_NAMES = [APP_NAME, APPLICATION_APP_NAME]

tests/integration/relations/test_relations.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# Copyright 2024 Canonical Ltd.
+# See LICENSE file for licensing details.
+import asyncio
+import logging
+
+import pytest
+from pytest_operator.plugin import OpsTest
+
+from ..helpers import CHARM_SERIES
+from ..new_relations.test_new_relations import (
+    APPLICATION_APP_NAME,
+    DATABASE_APP_METADATA,
+)
+from ..relations.helpers import (
+    APP_NAME,
+    DATABASE_RELATION,
+    DB_RELATION,
+    FIRST_DATABASE_RELATION,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.group(1)
+@pytest.mark.abort_on_fail
+async def test_deploy_charms(ops_test: OpsTest, database_charm):
+    """Deploy both charms (application and database) to use in the tests."""
+    # Deploy both charms (multiple units for each application to test that later they correctly
+    # set data in the relation application databag using only the leader unit).
+    async with ops_test.fast_forward():
+        await asyncio.gather(
+            ops_test.model.deploy(
+                APPLICATION_APP_NAME,
+                application_name=APPLICATION_APP_NAME,
+                num_units=1,
+                series=CHARM_SERIES,
+                channel="edge",
+            ),
+            ops_test.model.deploy(
+                database_charm,
+                resources={
+                    "postgresql-image": DATABASE_APP_METADATA["resources"]["postgresql-image"][
+                        "upstream-source"
+                    ]
+                },
+                application_name=APP_NAME,
+                num_units=1,
+                series=CHARM_SERIES,
+                config={
+                    "profile": "testing",
+                    "plugin_unaccent_enable": "True",
+                    "plugin_pg_trgm_enable": "True",
+                },
+            ),
+        )
+
+        await ops_test.model.wait_for_idle(
+            apps=[APP_NAME, APPLICATION_APP_NAME], status="active", timeout=3000
+        )
+
+
+@pytest.mark.group(1)
+async def test_legacy_and_modern_endpoints_simultaneously(ops_test: OpsTest):
+    await ops_test.model.relate(APPLICATION_APP_NAME, f"{APP_NAME}:{DB_RELATION}")
+    await ops_test.model.wait_for_idle(
+        status="active",
+        timeout=1500,
+        raise_on_error=False,
+    )
+
+    logger.info(" add relation with modern endpoints")
+    app = ops_test.model.applications[APP_NAME]
+    async with ops_test.fast_forward():
+        await ops_test.model.relate(APP_NAME, f"{APPLICATION_APP_NAME}:{FIRST_DATABASE_RELATION}")
+        await ops_test.model.block_until(
+            lambda: "blocked" in {unit.workload_status for unit in app.units},
+            timeout=1500,
+        )
+
+    logger.info(" remove relation with legacy endpoints")
+    await ops_test.model.applications[APP_NAME].destroy_relation(
+        f"{APP_NAME}:{DB_RELATION}", f"{APPLICATION_APP_NAME}:{DB_RELATION}"
+    )
+    await ops_test.model.wait_for_idle(status="active", timeout=1500)
+
+    logger.info(" add relation with legacy endpoints")
+    async with ops_test.fast_forward():
+        await ops_test.model.relate(APPLICATION_APP_NAME, f"{APP_NAME}:{DB_RELATION}")
+        await ops_test.model.block_until(
+            lambda: "blocked" in {unit.workload_status for unit in app.units},
+            timeout=1500,
+        )
+
+    logger.info(" remove relation with modern endpoints")
+    await ops_test.model.applications[APP_NAME].destroy_relation(
+        f"{APP_NAME}:{DATABASE_RELATION}", f"{APPLICATION_APP_NAME}:{FIRST_DATABASE_RELATION}"
+    )
+    await ops_test.model.wait_for_idle(status="active", timeout=1500)
+
+    logger.info(" remove relation with legacy endpoints")
+    await ops_test.model.applications[APP_NAME].destroy_relation(
+        f"{APP_NAME}:{DB_RELATION}", f"{APPLICATION_APP_NAME}:{DB_RELATION}"
+    )
+    await ops_test.model.wait_for_idle(status="active", timeout=1500)
+
+    logger.info(" add relation with modern endpoints")
+    await ops_test.model.relate(APP_NAME, f"{APPLICATION_APP_NAME}:{FIRST_DATABASE_RELATION}")
+    await ops_test.model.wait_for_idle(status="active", timeout=1500)