[DPE-2057] Enable Discourse-K8S test (#180)

* Enable Discourse test

* Move Discourse test to the right file

* Add minor fixes and unit tests for db relation

* Change test condition

Author: marceloneppel

src/relations/db.py

@@ -146,6 +146,9 @@ def set_up_relation(self, relation: Relation) -> bool:
             self.charm.postgresql.create_user(user, password, self.admin)
             self.charm.postgresql.create_database(database, user)
 
+            # Enable/disable extensions in the new database.
+            self.charm.enable_disable_extensions(database)
+
             # Build the primary's connection string.
             primary = str(
                 ConnectionString(
@@ -201,6 +204,8 @@ def set_up_relation(self, relation: Relation) -> bool:
             )
             return False
 
+        self._update_unit_status(relation)
+
         return True
 
     def _check_for_blocking_relations(self, relation_id: int) -> bool:
@@ -277,12 +282,15 @@ def _on_relation_broken(self, event: RelationBrokenEvent) -> None:
                 f"Failed to delete user during {self.relation_name} relation broken event"
             )
 
-        # Clean up Blocked status if caused by the departed relation
+        self._update_unit_status(event.relation)
+
+    def _update_unit_status(self, relation: Relation) -> None:
+        """# Clean up Blocked status if it's due to extensions request."""
         if (
             self.charm._has_blocked_status
             and self.charm.unit.status.message == EXTENSIONS_BLOCKING_MESSAGE
         ):
-            if not self._check_for_blocking_relations(event.relation.id):
+            if not self._check_for_blocking_relations(relation.id):
                 self.charm.unit.status = ActiveStatus()
 
     def _get_allowed_subnets(self, relation: Relation) -> str:

tests/integration/helpers.py

@@ -132,16 +132,19 @@ async def check_database_users_existence(
         assert user not in output
 
 
-async def check_database_creation(ops_test: OpsTest, database: str) -> None:
+async def check_database_creation(
+    ops_test: OpsTest, database: str, database_app_name: str = DATABASE_APP_NAME
+) -> None:
     """Checks that database and tables are successfully created for the application.
 
     Args:
         ops_test: The ops test framework
         database: Name of the database that should have been created
+        database_app_name: Application name of the database charm
     """
-    password = await get_password(ops_test)
+    password = await get_password(ops_test, database_app_name=database_app_name)
 
-    for unit in ops_test.model.applications[DATABASE_APP_NAME].units:
+    for unit in ops_test.model.applications[database_app_name].units:
         unit_address = await get_unit_address(ops_test, unit.name)
 
         # Ensure database exists in PostgreSQL.

tests/integration/test_db.py

@@ -12,12 +12,15 @@
     check_database_creation,
     check_database_users_existence,
     deploy_and_relate_application_with_postgresql,
+    get_primary,
     wait_for_relation_removed_between,
 )
 
 EXTENSIONS_BLOCKING_MESSAGE = "extensions requested through relation"
 FINOS_WALTZ_APP_NAME = "finos-waltz"
 ANOTHER_FINOS_WALTZ_APP_NAME = "another-finos-waltz"
+DISCOURSE_APP_NAME = "discourse-k8s"
+REDIS_APP_NAME = "redis-k8s"
 APPLICATION_UNITS = 1
 DATABASE_UNITS = 3
 
@@ -196,7 +199,7 @@ async def test_indico_db_blocked(ops_test: OpsTest) -> None:
         )
         wait_for_relation_removed_between(ops_test, database_application_name, "indico1")
         await ops_test.model.wait_for_idle(
-            apps=[database_application_name], status="active", idle_period=15, timeout=2000
+            apps=[database_application_name, "indico1"], status="active", idle_period=15
         )
 
         await ops_test.model.relate(f"{database_application_name}:db", "indico1:db")
@@ -217,9 +220,62 @@ async def test_indico_db_blocked(ops_test: OpsTest) -> None:
 
         # Cleanup
         await gather(
-            ops_test.model.remove_application(database_application_name, block_until_done=True),
             ops_test.model.remove_application("indico1", block_until_done=True),
             ops_test.model.remove_application("indico2", block_until_done=True),
             ops_test.model.remove_application("redis-broker", block_until_done=True),
             ops_test.model.remove_application("redis-cache", block_until_done=True),
         )
+
+
+async def test_discourse(ops_test: OpsTest):
+    database_application_name = f"extensions-{DATABASE_APP_NAME}"
+
+    # Deploy Discourse and Redis.
+    await gather(
+        ops_test.model.deploy(DISCOURSE_APP_NAME, application_name=DISCOURSE_APP_NAME),
+        ops_test.model.deploy(REDIS_APP_NAME, application_name=REDIS_APP_NAME),
+    )
+
+    # Add both relations to Discourse (PostgreSQL and Redis)
+    # and wait for it to be ready.
+    relation = await ops_test.model.add_relation(
+        f"{database_application_name}:db",
+        DISCOURSE_APP_NAME,
+    )
+    await ops_test.model.add_relation(
+        REDIS_APP_NAME,
+        DISCOURSE_APP_NAME,
+    )
+
+    # Discourse requests extensions through relation, so check that the PostgreSQL charm
+    # becomes blocked.
+    primary_name = await get_primary(ops_test, database_app_name=database_application_name)
+    async with ops_test.fast_forward():
+        await gather(
+            ops_test.model.block_until(
+                lambda: ops_test.model.units[primary_name].workload_status == "blocked", timeout=60
+            ),
+            ops_test.model.wait_for_idle(
+                apps=[REDIS_APP_NAME], status="active", timeout=2000
+            ),  # Redis sometimes takes a longer time to become active.
+        )
+        assert (
+            ops_test.model.units[primary_name].workload_status_message
+            == EXTENSIONS_BLOCKING_MESSAGE
+        )
+
+        # Enable the plugins/extensions required by Discourse.
+        config = {"plugin_hstore_enable": "True", "plugin_pg_trgm_enable": "True"}
+        await ops_test.model.applications[database_application_name].set_config(config)
+        await ops_test.model.wait_for_idle(
+            apps=[database_application_name, DISCOURSE_APP_NAME, REDIS_APP_NAME], status="active"
+        )
+
+        # Check for the correct databases and users creation.
+        await check_database_creation(
+            ops_test, "discourse", database_app_name=database_application_name
+        )
+        discourse_users = [f"relation_id_{relation.id}"]
+        await check_database_users_existence(
+            ops_test, discourse_users, [], database_app_name=database_application_name
+        )

tests/integration/test_db_admin.py

@@ -6,99 +6,40 @@
 import pytest as pytest
 from pytest_operator.plugin import OpsTest
 
-from tests.helpers import METADATA
 from tests.integration.helpers import (
-    CHARM_SERIES,
     DATABASE_APP_NAME,
+    build_and_deploy,
     check_database_creation,
     check_database_users_existence,
-    get_primary,
     get_unit_address,
 )
 
-FIRST_DISCOURSE_APP_NAME = "discourse-k8s"
-SECOND_DISCOURSE_APP_NAME = "discourse-charmers-discourse-k8s"
+DISCOURSE_APP_NAME = "discourse-charmers-discourse-k8s"
 REDIS_APP_NAME = "redis-k8s"
 APPLICATION_UNITS = 1
 DATABASE_UNITS = 3
 
 
 @pytest.mark.abort_on_fail
-async def test_build_and_deploy(ops_test: OpsTest):
-    """Build the charm-under-test and deploy it.
-
-    Assert on the unit status before any relations/configurations take place.
-    """
+async def test_discourse_from_discourse_charmers(ops_test: OpsTest):
+    # Build and deploy charm from local source folder (and also redis from Charmhub).
+    # Both are needed by Discourse.
     async with ops_test.fast_forward():
-        # Build and deploy charm from local source folder (and also redis from Charmhub).
-        # Both are needed by Discourse charms.
-        charm = await ops_test.build_charm(".")
-        resources = {
-            "postgresql-image": METADATA["resources"]["postgresql-image"]["upstream-source"],
-        }
         await asyncio.gather(
-            ops_test.model.deploy(
-                charm,
-                resources=resources,
-                application_name=DATABASE_APP_NAME,
-                trust=True,
-                num_units=DATABASE_UNITS,
-                series=CHARM_SERIES,
-            ),
-            ops_test.model.deploy(
-                FIRST_DISCOURSE_APP_NAME, application_name=FIRST_DISCOURSE_APP_NAME
-            ),
+            build_and_deploy(ops_test, DATABASE_UNITS),
             ops_test.model.deploy(REDIS_APP_NAME, application_name=REDIS_APP_NAME),
         )
         await ops_test.model.wait_for_idle(
-            apps=[DATABASE_APP_NAME, REDIS_APP_NAME], status="active", timeout=1000
+            apps=[DATABASE_APP_NAME, REDIS_APP_NAME], status="active", timeout=1500
         )
-        # Discourse waits for relations.
-        await ops_test.model.wait_for_idle(
-            apps=[FIRST_DISCOURSE_APP_NAME], status="waiting", timeout=1000
-        )
-
-
-async def test_discourse(ops_test: OpsTest):
-    # Test the first Discourse charm.
-    # Add both relations to Discourse (PostgreSQL and Redis)
-    # and wait for it to be ready.
-    await ops_test.model.add_relation(
-        f"{DATABASE_APP_NAME}:db-admin",
-        FIRST_DISCOURSE_APP_NAME,
-    )
-    await ops_test.model.add_relation(
-        REDIS_APP_NAME,
-        FIRST_DISCOURSE_APP_NAME,
-    )
-
-    # Discourse requests extensions through relation, so check that the PostgreSQL charm
-    # becomes blocked.
-    primary_name = await get_primary(ops_test)
-    await ops_test.model.block_until(
-        lambda: ops_test.model.units[primary_name].workload_status == "blocked", timeout=60
-    )
-    assert (
-        ops_test.model.units[primary_name].workload_status_message
-        == "extensions requested through relation"
-    )
-
-    # Destroy the relation to remove the blocked status.
-    await ops_test.model.applications[DATABASE_APP_NAME].destroy_relation(
-        f"{DATABASE_APP_NAME}:db-admin", FIRST_DISCOURSE_APP_NAME
-    )
-
-
-async def test_discourse_from_discourse_charmers(ops_test: OpsTest):
-    # Test the second Discourse charm.
 
     # Get the Redis instance IP address.
     redis_host = await get_unit_address(ops_test, f"{REDIS_APP_NAME}/0")
 
     # Deploy Discourse and wait for it to be blocked waiting for database relation.
     await ops_test.model.deploy(
-        SECOND_DISCOURSE_APP_NAME,
-        application_name=SECOND_DISCOURSE_APP_NAME,
+        DISCOURSE_APP_NAME,
+        application_name=DISCOURSE_APP_NAME,
         config={
             "redis_host": redis_host,
             "developer_emails": "user@foo.internal",
@@ -108,17 +49,15 @@ async def test_discourse_from_discourse_charmers(ops_test: OpsTest):
         },
     )
     # Discourse becomes blocked waiting for PostgreSQL relation.
-    await ops_test.model.wait_for_idle(
-        apps=[SECOND_DISCOURSE_APP_NAME], status="blocked", timeout=1000
-    )
+    await ops_test.model.wait_for_idle(apps=[DISCOURSE_APP_NAME], status="blocked", timeout=1000)
 
     # Relate PostgreSQL and Discourse, waiting for Discourse to be ready.
     relation = await ops_test.model.add_relation(
         f"{DATABASE_APP_NAME}:db-admin",
-        SECOND_DISCOURSE_APP_NAME,
+        DISCOURSE_APP_NAME,
     )
     await ops_test.model.wait_for_idle(
-        apps=[DATABASE_APP_NAME, SECOND_DISCOURSE_APP_NAME, REDIS_APP_NAME],
+        apps=[DATABASE_APP_NAME, DISCOURSE_APP_NAME, REDIS_APP_NAME],
         status="active",
         timeout=2000,  # Discourse takes a longer time to become active (a lot of setup).
     )