Update Python files format

Author: sinclert-canonical

tests/integration/backups.py

@@ -160,9 +160,9 @@ async def pitr_operations(
         "restore", **{"backup-id": backup_id, "restore-to-time": "bad"}
     )
     await action.wait()
-    assert (
-        action.status == "failed"
-    ), "restore should fail with bad restore-to-time parameter, but it succeeded"
+    assert action.status == "failed", (
+        "restore should fail with bad restore-to-time parameter, but it succeeded"
+    )
 
     logger.info(f"Restoring backup {backup_id} with year_before restore-to-time parameter")
     await juju_.run_action(
@@ -172,9 +172,9 @@ async def pitr_operations(
         apps=[MYSQL_APPLICATION_NAME, S3_INTEGRATOR],
         timeout=TIMEOUT,
     )
-    assert await check_test_data_existence(
-        primary_ip, should_not_exist=[td1, td2]
-    ), "test data should not exist"
+    assert await check_test_data_existence(primary_ip, should_not_exist=[td1, td2]), (
+        "test data should not exist"
+    )
 
     logger.info(f"Restoring backup {backup_id} with year_after restore-to-time parameter")
     await juju_.run_action(
@@ -184,9 +184,9 @@ async def pitr_operations(
         apps=[MYSQL_APPLICATION_NAME, S3_INTEGRATOR],
         timeout=TIMEOUT,
     )
-    assert await check_test_data_existence(
-        primary_ip, should_exist=[td1, td2]
-    ), "both test data should exist"
+    assert await check_test_data_existence(primary_ip, should_exist=[td1, td2]), (
+        "both test data should exist"
+    )
 
     logger.info(f"Restoring backup {backup_id} with actual restore-to-time parameter")
     await juju_.run_action(
@@ -208,9 +208,9 @@ async def pitr_operations(
         apps=[MYSQL_APPLICATION_NAME, S3_INTEGRATOR],
         timeout=TIMEOUT,
     )
-    assert await check_test_data_existence(
-        primary_ip, should_exist=[td1, td2]
-    ), "both test data should exist"
+    assert await check_test_data_existence(primary_ip, should_exist=[td1, td2]), (
+        "both test data should exist"
+    )
     clean_backups_from_buckets(cloud_configs, cloud_credentials)
 
 

tests/integration/high_availability/high_availability_helpers.py

@@ -365,8 +365,8 @@ async def ensure_all_units_continuous_writes_incrementing(
                         ops_test, unit, server_config_credentials
                     )
                     logger.info(f"{max_written_value=} on unit {unit.name}")
-                    assert (
-                        max_written_value > last_max_written_value
-                    ), "Continuous writes not incrementing"
+                    assert max_written_value > last_max_written_value, (
+                        "Continuous writes not incrementing"
+                    )
 
                     last_max_written_value = max_written_value

tests/integration/high_availability/test_async_replication.py

@@ -230,9 +230,9 @@ async def test_standby_promotion(
     assert results[0] > 1, "No data was written to the database"
 
     cluster_set_status = await get_cluster_status(leader_unit, cluster_set=True)
-    assert (
-        cluster_set_status["clusters"]["cuzco"]["clusterrole"] == "primary"
-    ), "standby not promoted to primary"
+    assert cluster_set_status["clusters"]["cuzco"]["clusterrole"] == "primary", (
+        "standby not promoted to primary"
+    )
 
 
 @juju3
@@ -267,12 +267,12 @@ async def test_failover(ops_test: OpsTest, first_model: Model, second_model: Mod
 
     cluster_set_status = await get_cluster_status(leader_unit, cluster_set=True)
     logger.info("Checking clusters statuses")
-    assert (
-        cluster_set_status["clusters"]["lima"]["clusterrole"] == "primary"
-    ), "standby not promoted to primary"
-    assert (
-        cluster_set_status["clusters"]["cuzco"]["globalstatus"] == "invalidated"
-    ), "old primary not invalidated"
+    assert cluster_set_status["clusters"]["lima"]["clusterrole"] == "primary", (
+        "standby not promoted to primary"
+    )
+    assert cluster_set_status["clusters"]["cuzco"]["globalstatus"] == "invalidated", (
+        "old primary not invalidated"
+    )
 
 
 @juju3

tests/integration/high_availability/test_replication_logs_rotation.py

@@ -67,13 +67,13 @@ async def test_log_rotation(ops_test: OpsTest, highly_available_cluster) -> None
         ops_test, unit.name, f"{CHARMED_MYSQL_COMMON_DIRECTORY}/var/log/mysql/"
     )
 
-    assert len(ls_la_output) == len(
-        log_files
-    ), f"❌ files other than log files exist {ls_la_output}"
+    assert len(ls_la_output) == len(log_files), (
+        f"❌ files other than log files exist {ls_la_output}"
+    )
     directories = [line.split()[-1] for line in ls_la_output]
-    assert sorted(directories) == sorted(
-        log_files
-    ), f"❌ file other than logs files exist: {ls_la_output}"
+    assert sorted(directories) == sorted(log_files), (
+        f"❌ file other than logs files exist: {ls_la_output}"
+    )
 
     logger.info("Executing logrotate")
     return_code, stdout, _ = await ops_test.juju(
@@ -86,13 +86,13 @@ async def test_log_rotation(ops_test: OpsTest, highly_available_cluster) -> None
         ops_test, unit.name, f"{CHARMED_MYSQL_COMMON_DIRECTORY}/var/log/mysql/"
     )
 
-    assert len(ls_la_output) == len(
-        log_files + archive_directories
-    ), f"❌ unexpected files/directories in log directory: {ls_la_output}"
+    assert len(ls_la_output) == len(log_files + archive_directories), (
+        f"❌ unexpected files/directories in log directory: {ls_la_output}"
+    )
     directories = [line.split()[-1] for line in ls_la_output]
-    assert sorted(directories) == sorted(
-        log_files + archive_directories
-    ), f"❌ unexpected files/directories in log directory: {ls_la_output}"
+    assert sorted(directories) == sorted(log_files + archive_directories), (
+        f"❌ unexpected files/directories in log directory: {ls_la_output}"
+    )
 
     logger.info("Ensuring log files were rotated")
     for log in set(log_types):

tests/integration/high_availability/test_replication_reelection.py

@@ -65,9 +65,9 @@ async def test_kill_primary_check_reelection(ops_test: OpsTest, highly_available
         await scale_application(ops_test, mysql_application_name, 3)
 
         # wait (and retry) until the killed pod is back online in the mysql cluster
-        assert await ensure_n_online_mysql_members(
-            ops_test, 3
-        ), "Old primary has not come back online after being killed"
+        assert await ensure_n_online_mysql_members(ops_test, 3), (
+            "Old primary has not come back online after being killed"
+        )
 
     await ensure_all_units_continuous_writes_incrementing(ops_test)
 

tests/integration/high_availability/test_self_healing_network_cut.py

@@ -63,25 +63,25 @@ async def test_network_cut(ops_test: OpsTest, highly_available_cluster, continuo
     }
 
     # verify that connection is possible
-    assert is_connection_possible(
-        config
-    ), f"❌ Connection to host {primary_unit_ip} is not possible"
+    assert is_connection_possible(config), (
+        f"❌ Connection to host {primary_unit_ip} is not possible"
+    )
 
     logger.info(f"Cutting network for {primary_hostname}")
     cut_network_from_unit(primary_hostname)
 
     # verify machine is not reachable from peer units
     for unit in set(all_units) - {primary_unit}:
         hostname = await unit_hostname(ops_test, unit.name)
-        assert not is_machine_reachable_from(
-            hostname, primary_hostname
-        ), "❌ unit is reachable from peer"
+        assert not is_machine_reachable_from(hostname, primary_hostname), (
+            "❌ unit is reachable from peer"
+        )
 
     # verify machine is not reachable from controller
     controller = await get_controller_machine(ops_test)
-    assert not is_machine_reachable_from(
-        controller, primary_hostname
-    ), "❌ unit is reachable from controller"
+    assert not is_machine_reachable_from(controller, primary_hostname), (
+        "❌ unit is reachable from controller"
+    )
 
     # verify that connection is not possible
     assert not is_connection_possible(config), "❌ Connection is possible after network cut"
@@ -107,9 +107,9 @@ async def test_network_cut(ops_test: OpsTest, highly_available_cluster, continuo
                 logger.debug(
                     f"Waiting until connection possible after network restore on {new_unit_ip}"
                 )
-                assert is_connection_possible(
-                    new_unit_config
-                ), "❌ Connection is not possible after network restore"
+                assert is_connection_possible(new_unit_config), (
+                    "❌ Connection is not possible after network restore"
+                )
 
         logger.info(f"Waiting for {primary_unit.name} to enter active")
         await ops_test.model.block_until(

tests/integration/high_availability/test_self_healing_process_killed.py

@@ -40,9 +40,9 @@ async def test_kill_db_process(
     primary_unit = await get_primary_unit_wrapper(ops_test, mysql_application_name)
 
     # ensure all units in the cluster are online
-    assert await ensure_n_online_mysql_members(
-        ops_test, 3
-    ), "The deployed mysql application is not fully online"
+    assert await ensure_n_online_mysql_members(ops_test, 3), (
+        "The deployed mysql application is not fully online"
+    )
 
     # get running mysqld PID
     pid = await get_process_pid(ops_test, primary_unit.name, MYSQL_DAEMON)

tests/integration/high_availability/test_self_healing_restart_forceful.py

@@ -97,9 +97,9 @@ async def test_sst_test(ops_test: OpsTest, highly_available_cluster, continuous_
 
     # verify instance is part of the cluster
     logger.info("Check if instance in cluster")
-    assert await is_unit_in_cluster(
-        primary_unit.name, new_primary_unit
-    ), "❌ Unit not online in the cluster"
+    assert await is_unit_in_cluster(primary_unit.name, new_primary_unit), (
+        "❌ Unit not online in the cluster"
+    )
 
     await ensure_all_units_continuous_writes_incrementing(ops_test)
 

tests/integration/high_availability/test_self_healing_stop_all.py

@@ -64,9 +64,9 @@ async def test_cluster_pause(ops_test: OpsTest, highly_available_cluster, contin
     for unit in all_units:
         unit_ip = await get_unit_ip(ops_test, unit.name)
         config["host"] = unit_ip
-        assert not is_connection_possible(
-            config
-        ), f"❌ connection to unit {unit.name} is still possible"
+        assert not is_connection_possible(config), (
+            f"❌ connection to unit {unit.name} is still possible"
+        )
 
     # restart all instances
     logger.info("Starting all instances")

tests/integration/high_availability/test_self_healing_stop_primary.py

@@ -56,9 +56,9 @@ async def test_replicate_data_on_restart(
     }
 
     # verify that connection is possible
-    assert is_connection_possible(
-        config
-    ), f"❌ Connection to host {primary_unit_ip} is not possible"
+    assert is_connection_possible(config), (
+        f"❌ Connection to host {primary_unit_ip} is not possible"
+    )
 
     # it's necessary to inhibit update-status-hook to stop the service
     # since the charm will restart the service on the hook
@@ -67,9 +67,9 @@ async def test_replicate_data_on_restart(
     await graceful_stop_server(ops_test, primary_unit.name)
 
     # verify that connection is gone
-    assert not is_connection_possible(
-        config
-    ), f"❌ Connection to host {primary_unit_ip} is possible"
+    assert not is_connection_possible(config), (
+        f"❌ Connection to host {primary_unit_ip} is possible"
+    )
 
     # get primary to write to it
     server_config_password = await get_system_user_password(primary_unit, SERVER_CONFIG_USERNAME)
@@ -89,9 +89,9 @@ async def test_replicate_data_on_restart(
     await ops_test.model.set_config({"update-status-hook-interval": "5m"})
 
     # verify/wait availability
-    assert is_connection_possible(
-        config, retry_if_not_possible=True
-    ), "❌ 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 = [