Run integration tests on arm64 (#473)

Author: carlcsaposs-canonical

.github/workflows/ci.yaml

@@ -67,21 +67,29 @@ jobs:
         juju:
           - agent: 2.9.49  # renovate: juju-agent-pin-minor
             libjuju: ^2
-            allure: false
+            allure_on_amd64: false
           - agent: 3.4.3  # renovate: juju-agent-pin-minor
-            allure: true
-    name: Integration test charm | ${{ matrix.juju.agent }}
+            allure_on_amd64: true
+        architecture:
+          - amd64
+        include:
+          - juju:
+              agent: 3.4.3  # renovate: juju-agent-pin-minor
+              allure_on_amd64: true
+            architecture: arm64
+    name: Integration test charm | ${{ matrix.juju.agent }} | ${{ matrix.architecture }}
     needs:
       - lint
       - unit-test
       - build
     uses: canonical/data-platform-workflows/.github/workflows/[email protected]
     with:
       artifact-prefix: ${{ needs.build.outputs.artifact-prefix }}
+      architecture: ${{ matrix.architecture }}
       cloud: lxd
       juju-agent-version: ${{ matrix.juju.agent }}
       libjuju-version-constraint: ${{ matrix.juju.libjuju }}
-      _beta_allure_report: ${{ matrix.juju.allure }}
+      _beta_allure_report: ${{ matrix.juju.allure_on_amd64 && matrix.architecture == 'amd64' }}
     secrets:
       # GitHub appears to redact each line of a multi-line secret
       # Avoid putting `{` or `}` on a line by itself so that it doesn't get redacted in logs

tests/integration/architecture.py

@@ -0,0 +1,7 @@
+# Copyright 2024 Canonical Ltd.
+# See LICENSE file for licensing details.
+import subprocess
+
+architecture = subprocess.run(
+    ["dpkg", "--print-architecture"], capture_output=True, check=True, encoding="utf-8"
+).stdout.strip()

tests/integration/helpers.py

@@ -267,11 +267,14 @@ def is_relation_broken(ops_test: OpsTest, endpoint_one: str, endpoint_two: str)
 
 
 @retry(stop=stop_after_attempt(8), wait=wait_fixed(15), reraise=True)
-def is_connection_possible(credentials: Dict, **extra_opts) -> bool:
+def is_connection_possible(
+    credentials: Dict, *, retry_if_not_possible=False, **extra_opts
+) -> bool:
     """Test a connection to a MySQL server.
 
     Args:
         credentials: A dictionary with the credentials to test
+        retry_if_not_possible: Retry if connection not possible
         extra_opts: extra options for mysql connection
     """
     config = {
@@ -289,6 +292,9 @@ def is_connection_possible(credentials: Dict, **extra_opts) -> bool:
             return cursor.fetchone()[0] == 1
     except (DatabaseError, InterfaceError, OperationalError, ProgrammingError):
         # Errors raised when the connection is not possible
+        if retry_if_not_possible:
+            # Retry
+            raise
         return False
 
 

tests/integration/high_availability/test_async_replication.py

@@ -4,6 +4,7 @@
 
 
 import logging
+import subprocess
 from asyncio import gather
 from pathlib import Path
 from time import sleep
@@ -14,7 +15,7 @@
 from juju.model import Model
 from pytest_operator.plugin import OpsTest
 
-from .. import juju_
+from .. import architecture, juju_
 from ..helpers import execute_queries_on_unit, get_cluster_status, get_leader_unit
 from ..markers import juju3
 from .high_availability_helpers import DATABASE_NAME, TABLE_NAME
@@ -47,6 +48,11 @@ async def second_model(
     second_model_name = f"{first_model.info.name}-other"
     logger.info(f"Creating second model {second_model_name}")
     await ops_test._controller.add_model(second_model_name)
+    subprocess.run(["juju", "switch", second_model_name], check=True)
+    subprocess.run(
+        ["juju", "set-model-constraints", f"arch={architecture.architecture}"], check=True
+    )
+    subprocess.run(["juju", "switch", first_model.info.name], check=True)
     second_model = Model()
     await second_model.connect(model_name=second_model_name)
     yield second_model  # pyright: ignore [reportReturnType]
@@ -180,7 +186,7 @@ async def test_deploy_router_and_app(first_model: Model) -> None:
         APPLICATION_APP_NAME,
         application_name=APPLICATION_APP_NAME,
         series="jammy",
-        channel="latest/stable",
+        channel="latest/edge",
         num_units=1,
     )
 

tests/integration/high_availability/test_self_healing.py

@@ -272,7 +272,9 @@ async def test_replicate_data_on_restart(ops_test: OpsTest, continuous_writes):
     await ops_test.model.set_config({"update-status-hook-interval": "5m"})
 
     # verify/wait availability
-    assert is_connection_possible(config), "❌ Connection not possible after restart"
+    assert is_connection_possible(
+        config, retry_if_not_possible=True
+    ), "❌ Connection not possible after restart"
 
     # read and verify data
     select_data_sql = [

tests/integration/high_availability/test_upgrade_from_stable.py

@@ -7,7 +7,7 @@
 import pytest
 from pytest_operator.plugin import OpsTest
 
-from .. import juju_
+from .. import juju_, markers
 from ..helpers import get_leader_unit, get_primary_unit_wrapper, retrieve_database_variable_value
 from .high_availability_helpers import (
     ensure_all_units_continuous_writes_incrementing,
@@ -23,6 +23,7 @@
 
 
 @pytest.mark.group(1)
+@markers.amd64_only  # TODO: remove after arm64 stable release
 @pytest.mark.abort_on_fail
 async def test_deploy_stable(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql and application charms get deployed."""
@@ -53,6 +54,7 @@ async def test_deploy_stable(ops_test: OpsTest) -> None:
 
 
 @pytest.mark.group(1)
+@markers.amd64_only  # TODO: remove after arm64 stable release
 @pytest.mark.abort_on_fail
 async def test_pre_upgrade_check(ops_test: OpsTest) -> None:
     """Test that the pre-upgrade-check action runs successfully."""
@@ -77,6 +79,7 @@ async def test_pre_upgrade_check(ops_test: OpsTest) -> None:
 
 
 @pytest.mark.group(1)
+@markers.amd64_only  # TODO: remove after arm64 stable release
 async def test_upgrade_from_stable(ops_test: OpsTest):
     """Test updating from stable channel."""
     application = ops_test.model.applications[MYSQL_APP_NAME]

tests/integration/high_availability/test_upgrade_rollback_incompat.py

@@ -14,7 +14,7 @@
 import pytest
 from pytest_operator.plugin import OpsTest
 
-from .. import juju_
+from .. import juju_, markers
 from ..helpers import get_leader_unit, get_relation_data, get_unit_by_index
 from .high_availability_helpers import (
     ensure_all_units_continuous_writes_incrementing,
@@ -29,14 +29,17 @@
 
 
 @pytest.mark.group(1)
+# TODO: remove after next incompatible MySQL server version released in our snap
+# (details: https://github.com/canonical/mysql-operator/pull/472#discussion_r1659300069)
+@markers.amd64_only
 @pytest.mark.abort_on_fail
 async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql and application charms get deployed."""
     snap_revisions = pathlib.Path("snap_revisions.json")
     with snap_revisions.open("r") as file:
         old_revisions: dict = json.load(file)
     new_revisions = old_revisions.copy()
-    # TODO: mark as amd64 only or support arm64
+    # TODO: support arm64
     new_revisions["x86_64"] = "69"
     with snap_revisions.open("w") as file:
         json.dump(new_revisions, file)
@@ -71,6 +74,9 @@ async def test_build_and_deploy(ops_test: OpsTest) -> None:
 
 
 @pytest.mark.group(1)
+# TODO: remove after next incompatible MySQL server version released in our snap
+# (details: https://github.com/canonical/mysql-operator/pull/472#discussion_r1659300069)
+@markers.amd64_only
 @pytest.mark.abort_on_fail
 async def test_pre_upgrade_check(ops_test: OpsTest) -> None:
     """Test that the pre-upgrade-check action runs successfully."""
@@ -83,6 +89,9 @@ async def test_pre_upgrade_check(ops_test: OpsTest) -> None:
 
 
 @pytest.mark.group(1)
+# TODO: remove after next incompatible MySQL server version released in our snap
+# (details: https://github.com/canonical/mysql-operator/pull/472#discussion_r1659300069)
+@markers.amd64_only
 @pytest.mark.abort_on_fail
 async def test_upgrade_to_failling(
     ops_test: OpsTest,
@@ -127,6 +136,9 @@ async def test_upgrade_to_failling(
 
 
 @pytest.mark.group(1)
+# TODO: remove after next incompatible MySQL server version released in our snap
+# (details: https://github.com/canonical/mysql-operator/pull/472#discussion_r1659300069)
+@markers.amd64_only
 @pytest.mark.abort_on_fail
 @pytest.mark.unstable
 async def test_rollback(ops_test, continuous_writes) -> None:

tests/integration/markers.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from . import juju_
+from . import architecture, juju_
 
 juju3 = pytest.mark.skipif(juju_.juju_major_version < 3, reason="Requires juju 3+")
 only_with_juju_secrets = pytest.mark.skipif(
@@ -12,3 +12,9 @@
 only_without_juju_secrets = pytest.mark.skipif(
     juju_.has_secrets, reason="Requires juju version w/o secrets"
 )
+amd64_only = pytest.mark.skipif(
+    architecture.architecture != "amd64", reason="Requires amd64 architecture"
+)
+arm64_only = pytest.mark.skipif(
+    architecture.architecture != "arm64", reason="Requires arm64 architecture"
+)

tests/integration/test_tls.py

@@ -11,7 +11,7 @@
 
 from constants import CLUSTER_ADMIN_USERNAME, TLS_SSL_CERT_FILE
 
-from . import juju_
+from . import architecture, juju_
 from .helpers import (
     app_name,
     get_system_user_password,
@@ -29,11 +29,19 @@
 APP_NAME = METADATA["name"]
 
 if juju_.has_secrets:
-    TLS_APP_NAME = "self-signed-certificates"
-    TLS_CONFIG = {"ca-common-name": "Test CA"}
+    tls_app_name = "self-signed-certificates"
+    if architecture.architecture == "arm64":
+        tls_channel = "latest/edge"
+    else:
+        tls_channel = "latest/stable"
+    tls_config = {"ca-common-name": "Test CA"}
 else:
-    TLS_APP_NAME = "tls-certificates-operator"
-    TLS_CONFIG = {"generate-self-signed-certificates": "true", "ca-common-name": "Test CA"}
+    tls_app_name = "tls-certificates-operator"
+    if architecture.architecture == "arm64":
+        tls_channel = "legacy/edge"
+    else:
+        tls_channel = "legacy/stable"
+    tls_config = {"generate-self-signed-certificates": "true", "ca-common-name": "Test CA"}
 
 
 @pytest.mark.group(1)
@@ -109,12 +117,12 @@ async def test_enable_tls(ops_test: OpsTest) -> None:
     # Deploy TLS Certificates operator.
     logger.info("Deploy TLS operator")
     async with ops_test.fast_forward("60s"):
-        await ops_test.model.deploy(TLS_APP_NAME, channel="latest/stable", config=TLS_CONFIG)
-        await ops_test.model.wait_for_idle(apps=[TLS_APP_NAME], status="active", timeout=15 * 60)
+        await ops_test.model.deploy(tls_app_name, channel=tls_channel, config=tls_config)
+        await ops_test.model.wait_for_idle(apps=[tls_app_name], status="active", timeout=15 * 60)
 
     # Relate with TLS charm
     logger.info("Relate to TLS operator")
-    await ops_test.model.relate(app, TLS_APP_NAME)
+    await ops_test.model.relate(app, tls_app_name)
 
     # Wait for hooks start reconfiguring app
     # add as a wait since app state does not change
@@ -207,7 +215,7 @@ async def test_disable_tls(ops_test: OpsTest) -> None:
 
     logger.info("Removing relation")
     await ops_test.model.applications[app].remove_relation(
-        f"{app}:certificates", f"{TLS_APP_NAME}:certificates"
+        f"{app}:certificates", f"{tls_app_name}:certificates"
     )
 
     # Allow time for reconfigure