Build & release arm64 (#472)

Author: carlcsaposs-canonical

charmcraft.yaml

@@ -3,15 +3,12 @@
 
 type: charm
 bases:
-  # Whenever "bases" is changed:
-  # - Update tests/integration/conftest.py::pytest_configure()
-  # - Update .github/workflow/ci.yaml integration-test matrix
-  - build-on:
-      - name: "ubuntu"
-        channel: "22.04"
-    run-on:
-      - name: "ubuntu"
-        channel: "22.04"
+  - name: ubuntu
+    channel: "22.04"
+    architectures: [amd64]
+  - name: ubuntu
+    channel: "22.04"
+    architectures: [arm64]
 parts:
   charm:
     override-pull: |
@@ -22,6 +19,8 @@ parts:
           exit 1
       fi
     charm-strict-dependencies: true
+    prime:
+      - snap_revisions.json
     build-packages:
       - libffi-dev
       - libssl-dev

snap_revisions.json

@@ -0,0 +1,4 @@
+{
+  "x86_64": "106",
+  "aarch64": "107"
+}

src/constants.py

@@ -25,7 +25,6 @@
 TLS_SSL_CERT_FILE = "custom-server-cert.pem"
 MYSQL_EXPORTER_PORT = 9104
 CHARMED_MYSQL_SNAP_NAME = "charmed-mysql"
-CHARMED_MYSQL_SNAP_REVISION = 105  # MySQL v8.0.37
 CHARMED_MYSQLD_EXPORTER_SERVICE = "mysqld-exporter"
 CHARMED_MYSQLD_SERVICE = "mysqld"
 CHARMED_MYSQL = "charmed-mysql.mysql"

src/mysql_vm_helpers.py

@@ -3,9 +3,11 @@
 
 """Helper class to manage the MySQL InnoDB cluster lifecycle with MySQL Shell."""
 
+import json
 import logging
 import os
 import pathlib
+import platform
 import shutil
 import subprocess
 import tempfile
@@ -35,7 +37,6 @@
     CHARMED_MYSQL,
     CHARMED_MYSQL_COMMON_DIRECTORY,
     CHARMED_MYSQL_SNAP_NAME,
-    CHARMED_MYSQL_SNAP_REVISION,
     CHARMED_MYSQL_XBCLOUD_LOCATION,
     CHARMED_MYSQL_XBSTREAM_LOCATION,
     CHARMED_MYSQL_XTRABACKUP_LOCATION,
@@ -167,10 +168,10 @@ def install_and_configure_mysql_dependencies() -> None:
 
         try:
             # install the charmed-mysql snap
-            logger.debug(
-                f"Installing {CHARMED_MYSQL_SNAP_NAME} revision {CHARMED_MYSQL_SNAP_REVISION}"
-            )
-            charmed_mysql.ensure(snap.SnapState.Present, revision=str(CHARMED_MYSQL_SNAP_REVISION))
+            with pathlib.Path("snap_revisions.json").open("r") as file:
+                revision = json.load(file)[platform.machine()]
+            logger.debug(f"Installing {CHARMED_MYSQL_SNAP_NAME} revision {revision}")
+            charmed_mysql.ensure(snap.SnapState.Present, revision=revision)
             if not charmed_mysql.held:
                 # hold the snap in charm determined revision
                 charmed_mysql.hold()

tests/conftest.py

@@ -110,7 +110,6 @@ async def ensure_n_online_mysql_members(
 
 async def deploy_and_scale_mysql(
     ops_test: OpsTest,
-    mysql_charm_series: str,
     check_for_existing_application: bool = True,
     mysql_application_name: str = MYSQL_DEFAULT_APP_NAME,
     num_units: int = 3,
@@ -119,7 +118,6 @@ async def deploy_and_scale_mysql(
 
     Args:
         ops_test: The ops test framework
-        mysql_charm_series: series to test on
         check_for_existing_application: Whether to check for existing mysql applications
             in the model
         mysql_application_name: The name of the mysql application if it is to be deployed
@@ -144,7 +142,7 @@ async def deploy_and_scale_mysql(
             application_name=mysql_application_name,
             config=config,
             num_units=num_units,
-            series=mysql_charm_series,
+            series="jammy",
         )
 
         await ops_test.model.wait_for_idle(
@@ -219,16 +217,13 @@ async def relate_mysql_and_application(
     )
 
 
-async def high_availability_test_setup(
-    ops_test: OpsTest, mysql_charm_series: str
-) -> Tuple[str, str]:
+async def high_availability_test_setup(ops_test: OpsTest) -> Tuple[str, str]:
     """Run the set up for high availability tests.
 
     Args:
         ops_test: The ops test framework
-        mysql_charm_series: Series to run mysql charm (defaults to focal)
     """
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
     application_name = await deploy_and_scale_application(ops_test)
 
     await relate_mysql_and_application(ops_test, mysql_application_name, application_name)

tests/integration/conftest.py

@@ -48,16 +48,16 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Build the charm and deploy 3 units to ensure a cluster is formed."""
-    await high_availability_test_setup(ops_test, mysql_charm_series)
+    await high_availability_test_setup(ops_test)
 
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_exporter_endpoints(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_exporter_endpoints(ops_test: OpsTest) -> None:
     """Test that endpoints are running."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     application = ops_test.model.applications[mysql_application_name]
     http = urllib3.PoolManager()
 
@@ -116,9 +116,9 @@ async def test_exporter_endpoints(ops_test: OpsTest, mysql_charm_series: str) ->
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_custom_variables(ops_test: OpsTest, mysql_charm_series) -> None:
+async def test_custom_variables(ops_test: OpsTest) -> None:
     """Query database for custom variables."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     application = ops_test.model.applications[mysql_application_name]
 
     for unit in application.units:
@@ -132,11 +132,9 @@ async def test_custom_variables(ops_test: OpsTest, mysql_charm_series) -> None:
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_consistent_data_replication_across_cluster(
-    ops_test: OpsTest, mysql_charm_series: str
-) -> None:
+async def test_consistent_data_replication_across_cluster(ops_test: OpsTest) -> None:
     """Confirm that data is replicated from the primary node to all the replicas."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
 
     # assert that there are 3 units in the mysql cluster
     assert len(ops_test.model.applications[mysql_application_name].units) == 3
@@ -150,9 +148,9 @@ async def test_consistent_data_replication_across_cluster(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_kill_primary_check_reelection(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_kill_primary_check_reelection(ops_test: OpsTest) -> None:
     """Confirm that a new primary is elected when the current primary is torn down."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     application = ops_test.model.applications[mysql_application_name]
 
     await ensure_all_units_continuous_writes_incrementing(ops_test)
@@ -198,10 +196,10 @@ async def test_kill_primary_check_reelection(ops_test: OpsTest, mysql_charm_seri
 
 @pytest.mark.group(2)
 @pytest.mark.abort_on_fail
-async def test_scaling_without_data_loss(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_scaling_without_data_loss(ops_test: OpsTest) -> None:
     """Test that data is preserved during scale up and scale down."""
     # Insert values into test table from the primary unit
-    app, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    app, _ = await high_availability_test_setup(ops_test)
     application = ops_test.model.applications[app]
 
     random_unit = application.units[0]
@@ -275,14 +273,14 @@ async def test_scaling_without_data_loss(ops_test: OpsTest, mysql_charm_series:
 
 
 @pytest.mark.group(3)
-async def test_cluster_isolation(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_cluster_isolation(ops_test: OpsTest) -> None:
     """Test for cluster data isolation.
 
     This test creates a new cluster, create a new table on both cluster, write a single record with
     the application name for each cluster, retrieve and compare these records, asserting they are
     not the same.
     """
-    app, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    app, _ = await high_availability_test_setup(ops_test)
     apps = [app, ANOTHER_APP_NAME]
 
     # Build and deploy secondary charm
@@ -292,7 +290,7 @@ async def test_cluster_isolation(ops_test: OpsTest, mysql_charm_series: str) ->
         charm,
         application_name=ANOTHER_APP_NAME,
         num_units=1,
-        series=mysql_charm_series,
+        series="jammy",
     )
     async with ops_test.fast_forward("60s"):
         await ops_test.model.block_until(
@@ -358,9 +356,9 @@ async def test_cluster_isolation(ops_test: OpsTest, mysql_charm_series: str) ->
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_log_rotation(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_log_rotation(ops_test: OpsTest) -> None:
     """Test the log rotation of text files."""
-    app, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    app, _ = await high_availability_test_setup(ops_test)
     unit = ops_test.model.applications[app].units[0]
 
     # Exclude slowquery log files as slowquery logs are not enabled by default

tests/integration/high_availability/high_availability_helpers.py

@@ -49,18 +49,16 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Build and deploy."""
-    await high_availability_test_setup(ops_test, mysql_charm_series)
+    await high_availability_test_setup(ops_test)
 
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_kill_db_process(
-    ops_test: OpsTest, continuous_writes, mysql_charm_series: str
-) -> None:
+async def test_kill_db_process(ops_test: OpsTest, continuous_writes) -> None:
     """Kill mysqld process and check for auto cluster recovery."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
 
     await ensure_all_units_continuous_writes_incrementing(ops_test)
 
@@ -97,9 +95,9 @@ async def test_kill_db_process(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_freeze_db_process(ops_test: OpsTest, continuous_writes, mysql_charm_series: str):
+async def test_freeze_db_process(ops_test: OpsTest, continuous_writes):
     """Freeze and unfreeze process and check for auto cluster recovery."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     # ensure continuous writes still incrementing for all units
     await ensure_all_units_continuous_writes_incrementing(ops_test)
 
@@ -144,9 +142,9 @@ async def test_freeze_db_process(ops_test: OpsTest, continuous_writes, mysql_cha
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_network_cut(ops_test: OpsTest, continuous_writes, mysql_charm_series: str):
+async def test_network_cut(ops_test: OpsTest, continuous_writes):
     """Completely cut and restore network."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     primary_unit = await get_primary_unit_wrapper(ops_test, mysql_application_name)
     all_units = ops_test.model.applications[mysql_application_name].units
 
@@ -224,11 +222,9 @@ async def test_network_cut(ops_test: OpsTest, continuous_writes, mysql_charm_ser
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_replicate_data_on_restart(
-    ops_test: OpsTest, continuous_writes, mysql_charm_series: str
-):
+async def test_replicate_data_on_restart(ops_test: OpsTest, continuous_writes):
     """Stop server, write data, start and validate replication."""
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
 
     # ensure continuous writes still incrementing for all units
     await ensure_all_units_continuous_writes_incrementing(ops_test)
@@ -309,13 +305,13 @@ async def test_replicate_data_on_restart(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_cluster_pause(ops_test: OpsTest, continuous_writes, mysql_charm_series: str):
+async def test_cluster_pause(ops_test: OpsTest, continuous_writes):
     """Pause test.
 
     A graceful simultaneous restart of all instances,
     check primary election after the start, write and read data
     """
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     all_units = ops_test.model.applications[mysql_application_name].units
 
     config = {
@@ -374,12 +370,12 @@ async def test_cluster_pause(ops_test: OpsTest, continuous_writes, mysql_charm_s
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_sst_test(ops_test: OpsTest, continuous_writes, mysql_charm_series: str):
+async def test_sst_test(ops_test: OpsTest, continuous_writes):
     """The SST test.
 
     A forceful restart instance with deleted data and without transaction logs (forced clone).
     """
-    mysql_application_name, _ = await high_availability_test_setup(ops_test, mysql_charm_series)
+    mysql_application_name, _ = await high_availability_test_setup(ops_test)
     primary_unit = await get_primary_unit_wrapper(ops_test, mysql_application_name)
     server_config_password = await get_system_user_password(primary_unit, SERVER_CONFIG_USERNAME)
     all_units = ops_test.model.applications[mysql_application_name].units

tests/integration/high_availability/test_replication.py

@@ -35,7 +35,7 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_deploy_latest(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_deploy_latest(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql and application charms get deployed."""
     await asyncio.gather(
         ops_test.model.deploy(
@@ -44,7 +44,7 @@ async def test_deploy_latest(ops_test: OpsTest, mysql_charm_series: str) -> None
             num_units=3,
             channel="8.0/edge",
             config={"profile": "testing"},
-            series=mysql_charm_series,
+            series="jammy",
         ),
         ops_test.model.deploy(
             TEST_APP_NAME,

tests/integration/high_availability/test_self_healing.py

@@ -24,15 +24,15 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_deploy_stable(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_deploy_stable(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql and application charms get deployed."""
     await asyncio.gather(
         ops_test.model.deploy(
             MYSQL_APP_NAME,
             application_name=MYSQL_APP_NAME,
             num_units=3,
             channel="8.0/stable",
-            series=mysql_charm_series,
+            series="jammy",
             config={"profile": "testing"},
         ),
         ops_test.model.deploy(

tests/integration/high_availability/test_upgrade.py

@@ -2,6 +2,7 @@
 # See LICENSE file for licensing details.
 
 import ast
+import json
 import logging
 import os
 import pathlib
@@ -29,13 +30,20 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql and application charms get deployed."""
-    sub_regex_older_snap = "s/CHARMED_MYSQL_SNAP_REVISION.*/CHARMED_MYSQL_SNAP_REVISION = 69/"
-    src_patch(sub_regex=sub_regex_older_snap, file_name="src/constants.py")
+    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
+    new_revisions["x86_64"] = "69"
+    with snap_revisions.open("w") as file:
+        json.dump(new_revisions, file)
     charm = await charm_local_build(ops_test)
 
-    src_patch(revert=True)
+    with snap_revisions.open("w") as file:
+        json.dump(old_revisions, file)
     config = {"profile": "testing"}
 
     async with ops_test.fast_forward("10s"):
@@ -44,7 +52,7 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
             application_name=MYSQL_APP_NAME,
             config=config,
             num_units=3,
-            series=mysql_charm_series,
+            series="jammy",
         )
 
         await ops_test.model.deploy(
@@ -124,9 +132,15 @@ async def test_upgrade_to_failling(
 async def test_rollback(ops_test, continuous_writes) -> None:
     application = ops_test.model.applications[MYSQL_APP_NAME]
 
-    sub_regex_older_snap = "s/CHARMED_MYSQL_SNAP_REVISION.*/CHARMED_MYSQL_SNAP_REVISION = 69/"
-    src_patch(sub_regex=sub_regex_older_snap, file_name="src/constants.py")
-    charm = await charm_local_build(ops_test, refresh=True)
+    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
+    new_revisions["x86_64"] = "69"
+    with snap_revisions.open("w") as file:
+        json.dump(new_revisions, file)
+    charm = await charm_local_build(ops_test)
 
     logger.info("Get leader unit")
     leader_unit = await get_leader_unit(ops_test, MYSQL_APP_NAME)
@@ -177,7 +191,7 @@ async def charm_local_build(ops_test: OpsTest, refresh: bool = False):
         # CI will get charm from common cache
         # make local copy and update charm zip
 
-        update_files = ["src/constants.py", "src/upgrade.py"]
+        update_files = ["snap_revisions.json", "src/upgrade.py"]
 
         charm = pathlib.Path(shutil.copy(charm, f"local-{charm.stem}.charm"))
 

tests/integration/high_availability/test_upgrade_from_stable.py

@@ -45,7 +45,7 @@
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
 @pytest.mark.skip_if_deployed
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Build the charm and deploy 3 units to ensure a cluster is formed."""
     db_charm = await ops_test.build_charm(".")
 
@@ -57,7 +57,7 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
             application_name=DATABASE_APP_NAME,
             config=config,
             num_units=3,
-            series=mysql_charm_series,
+            series="jammy",
         ),
         ops_test.model.deploy(
             APPLICATION_APP_NAME,

tests/integration/high_availability/test_upgrade_rollback_incompat.py

@@ -107,19 +107,18 @@ async def check_keystone_users_existence(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_keystone_bundle_db_router(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_keystone_bundle_db_router(ops_test: OpsTest) -> None:
     """Deploy the keystone bundle to test the 'db-router' relation.
 
     Args:
         ops_test: The ops test framework
-        mysql_charm_series: The series for the database machine
     """
     charm = await ops_test.build_charm(".")
 
     config = {"cluster-name": CLUSTER_NAME, "profile": "testing"}
 
     mysql_app = await ops_test.model.deploy(
-        charm, application_name=APP_NAME, config=config, num_units=1, series=mysql_charm_series
+        charm, application_name=APP_NAME, config=config, num_units=1, series="jammy"
     )
 
     # Deploy keystone

tests/integration/relations/test_database.py

@@ -36,7 +36,7 @@
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
 @pytest.mark.skip_if_deployed
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Build the charm and deploy 3 units to ensure a cluster is formed."""
     db_charm = await ops_test.build_charm(".")
 
@@ -52,7 +52,7 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
             application_name=DATABASE_APP_NAME,
             config=config,
             num_units=3,
-            series=mysql_charm_series,
+            series="jammy",
         ),
         ops_test.model.deploy(
             APPLICATION_APP_NAME,

tests/integration/relations/test_db_router.py

@@ -147,12 +147,11 @@ async def check_keystone_users_existence(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_keystone_bundle_shared_db(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_keystone_bundle_shared_db(ops_test: OpsTest) -> None:
     """Deploy the keystone bundle to test the 'shared-db' relation.
 
     Args:
         ops_test: The ops test framework
-        mysql_charm_series: The series for the database machine
     """
     charm = await ops_test.build_charm(".")
 
@@ -162,7 +161,7 @@ async def test_keystone_bundle_shared_db(ops_test: OpsTest, mysql_charm_series:
         application_name=APP_NAME,
         config=config,
         num_units=3,
-        series=mysql_charm_series,
+        series="jammy",
     )
 
     # Reduce the update_status frequency for the duration of the test

tests/integration/relations/test_relation_mysql_legacy.py

@@ -83,9 +83,9 @@ def clean_backups_from_buckets(cloud_configs, cloud_credentials):
 
 
 @pytest.mark.group(1)
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql charm gets deployed."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     primary_mysql = await get_primary_unit_wrapper(ops_test, mysql_application_name)
 
@@ -114,11 +114,9 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_backup(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_backup(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to create a backup and list backups."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     global backup_id, value_before_backup, value_after_backup
 
@@ -190,10 +188,10 @@ async def test_backup(
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
 async def test_restore_on_same_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
+    ops_test: OpsTest, cloud_configs, cloud_credentials
 ) -> None:
     """Test to restore a backup to the same mysql cluster."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     logger.info("Scaling mysql application to 1 unit")
     async with ops_test.fast_forward():
@@ -281,15 +279,12 @@ async def test_restore_on_same_cluster(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_restore_on_new_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_restore_on_new_cluster(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to restore a backup on a new mysql cluster."""
     logger.info("Deploying a new mysql cluster")
 
     new_mysql_application_name = await deploy_and_scale_mysql(
         ops_test,
-        mysql_charm_series,
         check_for_existing_application=False,
         mysql_application_name="another-mysql",
         num_units=1,

tests/integration/relations/test_shared_db.py

@@ -83,9 +83,9 @@ def clean_backups_from_buckets(cloud_configs, cloud_credentials):
 
 
 @pytest.mark.group(1)
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql charm gets deployed."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     primary_mysql = await get_primary_unit_wrapper(ops_test, mysql_application_name)
 
@@ -114,11 +114,9 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_backup(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_backup(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to create a backup and list backups."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     global backup_id, value_before_backup, value_after_backup
 
@@ -190,10 +188,10 @@ async def test_backup(
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
 async def test_restore_on_same_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
+    ops_test: OpsTest, cloud_configs, cloud_credentials
 ) -> None:
     """Test to restore a backup to the same mysql cluster."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     logger.info("Scaling mysql application to 1 unit")
     async with ops_test.fast_forward():
@@ -281,15 +279,12 @@ async def test_restore_on_same_cluster(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_restore_on_new_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_restore_on_new_cluster(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to restore a backup on a new mysql cluster."""
     logger.info("Deploying a new mysql cluster")
 
     new_mysql_application_name = await deploy_and_scale_mysql(
         ops_test,
-        mysql_charm_series,
         check_for_existing_application=False,
         mysql_application_name="another-mysql",
         num_units=1,

tests/integration/test_backup_aws.py

@@ -83,9 +83,9 @@ def clean_backups_from_buckets(cloud_configs, cloud_credentials):
 
 
 @pytest.mark.group(1)
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Simple test to ensure that the mysql charm gets deployed."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     primary_mysql = await get_primary_unit_wrapper(ops_test, mysql_application_name)
 
@@ -114,11 +114,9 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_backup(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_backup(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to create a backup and list backups."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     global backup_id, value_before_backup, value_after_backup
 
@@ -190,10 +188,10 @@ async def test_backup(
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
 async def test_restore_on_same_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
+    ops_test: OpsTest, cloud_configs, cloud_credentials
 ) -> None:
     """Test to restore a backup to the same mysql cluster."""
-    mysql_application_name = await deploy_and_scale_mysql(ops_test, mysql_charm_series)
+    mysql_application_name = await deploy_and_scale_mysql(ops_test)
 
     logger.info("Scaling mysql application to 1 unit")
     async with ops_test.fast_forward():
@@ -281,15 +279,12 @@ async def test_restore_on_same_cluster(
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_restore_on_new_cluster(
-    ops_test: OpsTest, mysql_charm_series: str, cloud_configs, cloud_credentials
-) -> None:
+async def test_restore_on_new_cluster(ops_test: OpsTest, cloud_configs, cloud_credentials) -> None:
     """Test to restore a backup on a new mysql cluster."""
     logger.info("Deploying a new mysql cluster")
 
     new_mysql_application_name = await deploy_and_scale_mysql(
         ops_test,
-        mysql_charm_series,
         check_for_existing_application=False,
         mysql_application_name="another-mysql",
         num_units=1,

tests/integration/test_backup_ceph.py

@@ -14,14 +14,14 @@
 
 
 @pytest.mark.group(1)
-async def test_ubuntu_pro(ops_test, mysql_charm_series, github_secrets):
+async def test_ubuntu_pro(ops_test, github_secrets):
     db_charm = await ops_test.build_charm(".")
     await asyncio.gather(
         ops_test.model.deploy(
             db_charm,
             application_name=DATABASE_APP_NAME,
             config={"cluster-name": CLUSTER_NAME, "profile": "testing"},
-            series=mysql_charm_series,
+            series="jammy",
         ),
         ops_test.model.deploy(
             APPLICATION_APP_NAME,

tests/integration/test_backup_gcp.py

@@ -38,7 +38,7 @@
 
 @pytest.mark.group(1)
 @pytest.mark.abort_on_fail
-async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> None:
+async def test_build_and_deploy(ops_test: OpsTest) -> None:
     """Build the charm and deploy 3 units to ensure a cluster is formed."""
     if app := await app_name(ops_test):
         if len(ops_test.model.applications[app].units) == 3:
@@ -54,7 +54,7 @@ async def test_build_and_deploy(ops_test: OpsTest, mysql_charm_series: str) -> N
         charm,
         application_name=APP_NAME,
         num_units=3,
-        series=mysql_charm_series,
+        series="jammy",
     )
 
     # Reduce the update_status frequency until the cluster is deployed

tests/integration/test_subordinate_charms.py

@@ -451,22 +451,32 @@ def test_start_mysqld_failure(
             self.mysql.start_mysqld()
 
     @patch("os.system")
-    @patch("pathlib.Path")
+    @patch("pathlib.Path.touch")
+    @patch("pathlib.Path.owner")
+    @patch("pathlib.Path.exists")
     @patch("subprocess.check_call")
     @patch("subprocess.run")
     @patch("os.path.exists", return_value=True)
     @patch("mysql_vm_helpers.snap.SnapCache")
-    def test_install_snap(self, _cache, _path_exists, _run, _check_call, _pathlib, _system):
+    def test_install_snap(
+        self,
+        _cache,
+        _path_exists,
+        _run,
+        _check_call,
+        _pathlib_exists,
+        _pathlib_owner,
+        _touch,
+        _system,
+    ):
         """Test execution of install_snap()."""
         _mysql_snap = MagicMock()
         _cache.return_value = {CHARMED_MYSQL_SNAP_NAME: _mysql_snap}
 
-        common_path_mock = MagicMock()
-
         _mysql_snap.present = False
         _path_exists.return_value = False
-        _pathlib.return_value = common_path_mock
-        common_path_mock.exists.return_value = False
+        _pathlib_exists.return_value = False
+        _pathlib_owner.return_value = None
 
         self.mysql.install_and_configure_mysql_dependencies()