Move new data-replication tests to old files

Author: sinclert-canonical

tests/integration/helpers.py

@@ -7,7 +7,6 @@
 import secrets
 import string
 import subprocess
-import tempfile
 
 import juju.unit
 import yaml
@@ -830,142 +829,6 @@ async def get_cluster_status(unit: Unit, cluster_set: bool | None = False) -> di
     return result.get("status", {})
 
 
-async def delete_file_or_directory_in_unit(ops_test: OpsTest, unit_name: str, path: str) -> bool:
-    """Delete a file in the provided unit.
-
-    Args:
-        ops_test: The ops test framework
-        unit_name: The name unit on which to delete the file from
-        path: The path of file or directory to delete
-
-    Returns:
-        boolean indicating success
-    """
-    if path.strip() in ["/", "."]:
-        return
-
-    try:
-        return_code, _, _ = await ops_test.juju(
-            "ssh", unit_name, "sudo", "find", path, "-maxdepth", "1", "-delete"
-        )
-
-        return return_code == 0
-    except Exception:
-        return False
-
-
-async def write_content_to_file_in_unit(
-    ops_test: OpsTest, unit: Unit, path: str, content: str
-) -> None:
-    """Write content to the file in the provided unit.
-
-    Args:
-        ops_test: The ops test framework
-        unit: THe unit in which to write to file in
-        path: The path at which to write the content to
-        content: The content to write to the file.
-    """
-    with tempfile.NamedTemporaryFile(mode="w") as temp_file:
-        temp_file.write(content)
-        temp_file.flush()
-
-        await unit.scp_to(temp_file.name, "/tmp/file")
-
-    return_code, _, _ = await ops_test.juju("ssh", unit.name, "sudo", "mv", "/tmp/file", path)
-    assert return_code == 0
-
-    return_code, _, _ = await ops_test.juju(
-        "ssh", unit.name, "sudo", "chown", "snap_daemon:root", path
-    )
-    assert return_code == 0
-
-
-async def read_contents_from_file_in_unit(ops_test: OpsTest, unit: Unit, path: str) -> str:
-    """Read contents from file in the provided unit.
-
-    Args:
-        ops_test: The ops test framework
-        unit: The unit in which to read file from
-        path: The path from which to read content from
-
-    Returns:
-        the contents of the file
-    """
-    return_code, _, _ = await ops_test.juju("ssh", unit.name, "sudo", "cp", path, "/tmp/file")
-    assert return_code == 0
-
-    return_code, _, _ = await ops_test.juju(
-        "ssh", unit.name, "sudo", "chown", "ubuntu:ubuntu", "/tmp/file"
-    )
-    assert return_code == 0
-
-    with tempfile.NamedTemporaryFile(mode="r+") as temp_file:
-        await unit.scp_from("/tmp/file", temp_file.name)
-
-        temp_file.seek(0)
-
-        contents = ""
-        for line in temp_file:
-            contents += line
-            contents += "\n"
-
-    return_code, _, _ = await ops_test.juju("ssh", unit.name, "sudo", "rm", "/tmp/file")
-    assert return_code == 0
-
-    return contents
-
-
-async def ls_la_in_unit(ops_test: OpsTest, unit_name: str, directory: str) -> list[str]:
-    """Returns the output of ls -la in unit.
-
-    Args:
-        ops_test: The ops test framework
-        unit_name: The name of unit in which to run ls -la
-        path: The path from which to run ls -la
-
-    Returns:
-        a list of files returned by ls -la
-    """
-    return_code, output, _ = await ops_test.juju("ssh", unit_name, "sudo", "ls", "-la", directory)
-    assert return_code == 0
-
-    ls_output = output.split("\n")[1:]
-
-    return [
-        line.strip("\r")
-        for line in ls_output
-        if len(line.strip()) > 0 and line.split()[-1] not in [".", ".."]
-    ]
-
-
-async def stop_running_flush_mysql_cronjobs(ops_test: OpsTest, unit_name: str) -> None:
-    """Stop running any logrotate jobs that may have been triggered by cron.
-
-    Args:
-        ops_test: The ops test object passed into every test case
-        unit_name: The name of the unit to be tested
-    """
-    # send TERM signal to mysql daemon, which trigger shutdown process
-    await ops_test.juju(
-        "ssh",
-        unit_name,
-        "sudo",
-        "pkill",
-        "-15",
-        "-f",
-        "logrotate -f /etc/logrotate.d/flush_mysql_logs",
-    )
-
-    # hold execution until process is stopped
-    try:
-        for attempt in Retrying(stop=stop_after_attempt(45), wait=wait_fixed(2)):
-            with attempt:
-                if await get_process_pid(ops_test, unit_name, "logrotate"):
-                    raise Exception
-    except RetryError as e:
-        raise Exception("Failed to stop the flush_mysql_logs logrotate process.") from e
-
-
 def get_unit_by_index(app_name: str, units: list, index: int):
     """Get unit by index.
 

tests/integration/high_availability/test_replication_data_consistency.py

@@ -1,41 +1,72 @@
 # Copyright 2022 Canonical Ltd.
 # See LICENSE file for licensing details.
 
-
 import logging
-from pathlib import Path
 
+import jubilant_backports
 import pytest
-import yaml
-from pytest_operator.plugin import OpsTest
-
-from .high_availability_helpers import (
-    clean_up_database_and_table,
-    ensure_all_units_continuous_writes_incrementing,
-    get_application_name,
-    insert_data_into_mysql_and_validate_replication,
+from jubilant_backports import Juju
+
+from ..helpers import generate_random_string
+from .high_availability_helpers_new import (
+    check_mysql_units_writes_increment,
+    insert_mysql_test_data,
+    remove_mysql_test_data,
+    verify_mysql_test_data,
+    wait_for_apps_status,
 )
 
-logger = logging.getLogger(__name__)
+MYSQL_APP_NAME = "mysql"
+MYSQL_TEST_APP_NAME = "mysql-test-app"
+
+MINUTE_SECS = 60
 
-METADATA = yaml.safe_load(Path("./metadata.yaml").read_text())
-APP_NAME = METADATA["name"]
-ANOTHER_APP_NAME = f"second{APP_NAME}"
-TIMEOUT = 17 * 60
+logging.getLogger("jubilant.wait").setLevel(logging.WARNING)
 
 
 @pytest.mark.abort_on_fail
-async def test_consistent_data_replication_across_cluster(
-    ops_test: OpsTest, highly_available_cluster
-) -> None:
-    """Confirm that data is replicated from the primary node to all the replicas."""
-    mysql_application_name = get_application_name(ops_test, "mysql")
+def test_deploy_highly_available_cluster(juju: Juju, charm: str) -> None:
+    """Simple test to ensure that the MySQL and application charms get deployed."""
+    logging.info("Deploying MySQL cluster")
+    juju.deploy(
+        charm=charm,
+        app=MYSQL_APP_NAME,
+        base="ubuntu@22.04",
+        config={"profile": "testing"},
+        num_units=3,
+    )
+    juju.deploy(
+        charm=MYSQL_TEST_APP_NAME,
+        app=MYSQL_TEST_APP_NAME,
+        base="ubuntu@22.04",
+        channel="latest/edge",
+        config={"sleep_interval": 500},
+        num_units=1,
+    )
+
+    juju.integrate(
+        f"{MYSQL_APP_NAME}:database",
+        f"{MYSQL_TEST_APP_NAME}:database",
+    )
 
-    # assert that there are 3 units in the mysql cluster
-    assert len(ops_test.model.applications[mysql_application_name].units) == 3
+    logging.info("Wait for applications to become active")
+    juju.wait(
+        ready=wait_for_apps_status(
+            jubilant_backports.all_active, MYSQL_APP_NAME, MYSQL_TEST_APP_NAME
+        ),
+        error=jubilant_backports.any_blocked,
+        timeout=20 * MINUTE_SECS,
+    )
+
+
+@pytest.mark.abort_on_fail
+async def test_consistent_data_replication_across_cluster(juju: Juju) -> None:
+    """Confirm that data is replicated from the primary node to all the replicas."""
+    table_name = "data"
+    table_value = generate_random_string(255)
 
-    database_name, table_name = "test-check-consistency", "data"
-    await insert_data_into_mysql_and_validate_replication(ops_test, database_name, table_name)
-    await clean_up_database_and_table(ops_test, database_name, table_name)
+    await insert_mysql_test_data(juju, MYSQL_APP_NAME, table_name, table_value)
+    await verify_mysql_test_data(juju, MYSQL_APP_NAME, table_name, table_value)
+    await remove_mysql_test_data(juju, MYSQL_APP_NAME, table_name)
 
-    await ensure_all_units_continuous_writes_incrementing(ops_test)
+    await check_mysql_units_writes_increment(juju, MYSQL_APP_NAME)