Fix unit tests, add ops-scenario.

Author: Zvirovyi

poetry.lock

@@ -40,6 +40,7 @@ coverage = {extras = ["toml"], version = "^7.8.0"}
 pytest = "^8.4.1"
 pytest-mock = "^3.14.1"
 ops = {version = "^2.22.0", extras = ["testing"]}
+ops-scenario = "^7.23.0"
 
 [tool.poetry.group.integration]
 optional = true

pyproject.toml

@@ -12,103 +12,111 @@
 from core.state import PEER_RELATION
 
 
-def test_start_maintenance_status_when_starting():
+def test_start_maintenance_status():
     """Charm enters MaintenanceStatus when Cassandra is not yet healthy."""
     ctx = testing.Context(CassandraCharm)
     relation = testing.PeerRelation(id=1, endpoint=PEER_RELATION)
-    state_in = testing.State(leader=True, relations={relation})
+    state = testing.State(leader=True, relations={relation})
 
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart"),
-        patch("workload.CassandraWorkload.is_alive"),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload"),
         patch(
             "managers.cluster.ClusterManager.is_healthy",
             new_callable=PropertyMock(return_value=False),
         ),
     ):
-        state_out = ctx.run(ctx.on.start(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
-        assert state_out.get_relation(1).local_unit_data.get("workload_state") == "active"
-        assert state_out.get_relation(1).local_app_data.get("cluster_state") == "active"
+        state = ctx.run(ctx.on.start(), state)
+        assert state.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "starting"
+        assert not state.get_relation(1).local_app_data.get("cluster_state")
 
+        state = ctx.run(ctx.on.update_status(), state)
+        assert state.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "starting"
+        assert not state.get_relation(1).local_app_data.get("cluster_state")
 
-def test_start_sets_active_status_when_healthy():
+
+def test_start_active_status_when_healthy():
     """Charm enters ActiveStatus when Cassandra is healthy after start."""
     ctx = testing.Context(CassandraCharm)
     relation = testing.PeerRelation(id=1, endpoint=PEER_RELATION)
-    state_in = testing.State(leader=True, relations={relation})
+    state = testing.State(leader=True, relations={relation})
 
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart"),
-        patch("workload.CassandraWorkload.is_alive"),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload"),
         patch(
             "managers.cluster.ClusterManager.is_healthy",
             new_callable=PropertyMock(return_value=True),
         ),
     ):
-        state_out = ctx.run(ctx.on.start(), state_in)
-        assert state_out.unit_status == ops.ActiveStatus()
-        assert state_out.get_relation(1).local_unit_data.get("workload_state") == "active"
-        assert state_out.get_relation(1).local_app_data.get("cluster_state") == "active"
+        state = ctx.run(ctx.on.start(), state)
+        assert state.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "starting"
+        assert not state.get_relation(1).local_app_data.get("cluster_state")
+
+        state = ctx.run(ctx.on.update_status(), state)
+        assert state.unit_status == ops.ActiveStatus()
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "active"
+        assert state.get_relation(1).local_app_data.get("cluster_state") == "active"
 
 
 def test_start_only_after_leader_active():
     """Ensure Cassandra node starts only after leader is active and cluster_state is 'active'."""
     ctx = testing.Context(CassandraCharm)
     relation = testing.PeerRelation(id=1, endpoint=PEER_RELATION)
-    state_in = testing.State(leader=False, relations={relation})
+    state = testing.State(leader=False, relations={relation})
 
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart") as restart,
-        patch("workload.CassandraWorkload.is_alive"),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload") as workload,
         patch(
             "managers.cluster.ClusterManager.is_healthy",
             new_callable=PropertyMock(return_value=False),
         ),
     ):
-        state_out = ctx.run(ctx.on.start(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("installing Cassandra")
-        restart.assert_not_called()
+        state = ctx.run(ctx.on.start(), state)
+        assert state.unit_status == ops.WaitingStatus("waiting for cluster to start")
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "waiting_for_start"
+        workload.return_value.start.assert_not_called()
 
     relation = testing.PeerRelation(
         id=1, endpoint=PEER_RELATION, local_app_data={"cluster_state": "active"}
     )
-    state_in = testing.State(leader=False, relations={relation})
+    state = testing.State(leader=False, relations={relation})
 
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart") as restart,
-        patch("workload.CassandraWorkload.is_alive"),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload") as workload,
         patch(
             "managers.cluster.ClusterManager.is_healthy",
             new_callable=PropertyMock(return_value=False),
         ),
     ):
-        state_out = ctx.run(ctx.on.start(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
-        assert state_out.get_relation(1).local_unit_data.get("workload_state") == "active"
-        restart.assert_called()
+        state = ctx.run(ctx.on.start(), state)
+        assert state.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
+        assert state.get_relation(1).local_unit_data.get("workload_state") == "starting"
+        workload.return_value.start.assert_called()
 
 
 def test_config_changed_invalid_config():
     """Ensure charm enters BlockedStatus if config is invalid during config_changed event."""
     ctx = testing.Context(CassandraCharm)
     relation = testing.PeerRelation(id=1, endpoint=PEER_RELATION)
-    state_in = testing.State(leader=True, relations={relation}, config={"profile": "invalid"})
+    state = testing.State(leader=True, relations={relation}, config={"profile": "invalid"})
+
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart"),
-        patch("workload.CassandraWorkload.is_alive"),
-        patch(
-            "managers.cluster.ClusterManager.is_healthy",
-            new_callable=PropertyMock(return_value=False),
-        ),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload"),
     ):
-        state_out = ctx.run(ctx.on.config_changed(), state_in)
-        assert state_out.unit_status == ops.BlockedStatus("invalid config")
+        state = ctx.run(ctx.on.config_changed(), state)
+        assert state.unit_status == ops.BlockedStatus("invalid config")
 
 
 def test_config_changed_no_restart():
@@ -117,59 +125,12 @@ def test_config_changed_no_restart():
     relation = testing.PeerRelation(
         id=1, endpoint=PEER_RELATION, local_unit_data={"workload_state": "starting"}
     )
-    state_in = testing.State(leader=True, relations={relation})
+    state = testing.State(leader=True, relations={relation})
     with (
         patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart") as restart,
-        patch("workload.CassandraWorkload.is_alive"),
-        patch(
-            "managers.cluster.ClusterManager.is_healthy",
-            new_callable=PropertyMock(return_value=False),
-        ),
-    ):
-        state_out = ctx.run(ctx.on.config_changed(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
-        restart.assert_not_called()
-
-
-def test_collect_unit_status_active_but_not_healthy():
-    """Ensure unit is MaintenanceStatus if workload_state is 'active' but node is not healthy."""
-    ctx = testing.Context(CassandraCharm)
-    relation = testing.PeerRelation(
-        id=1,
-        endpoint=PEER_RELATION,
-        local_unit_data={"workload_state": "active"},
-    )
-    state_in = testing.State(leader=True, relations={relation})
-    with (
-        patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart"),
-        patch("workload.CassandraWorkload.is_alive"),
-        patch(
-            "managers.cluster.ClusterManager.is_healthy",
-            new_callable=PropertyMock(return_value=False),
-        ),
-    ):
-        state_out = ctx.run(ctx.on.collect_unit_status(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
-
-
-def test_start_not_leader_and_cluster_state_not_active():
-    """Ensure charm does not start Cassandra if not leader and cluster_state is not 'active'."""
-    ctx = testing.Context(CassandraCharm)
-    relation = testing.PeerRelation(
-        id=1, endpoint=PEER_RELATION, local_app_data={"cluster_state": "pending"}
-    )
-    state_in = testing.State(leader=False, relations={relation})
-    with (
-        patch("managers.config.ConfigManager.render_env"),
-        patch("workload.CassandraWorkload.restart") as restart,
-        patch("workload.CassandraWorkload.is_alive"),
-        patch(
-            "managers.cluster.ClusterManager.is_healthy",
-            new_callable=PropertyMock(return_value=False),
-        ),
+        patch("managers.config.ConfigManager.render_cassandra_config"),
+        patch("charm.CassandraWorkload") as workload,
     ):
-        state_out = ctx.run(ctx.on.start(), state_in)
-        assert state_out.unit_status == ops.MaintenanceStatus("installing Cassandra")
-        restart.assert_not_called()
+        state = ctx.run(ctx.on.config_changed(), state)
+        assert state.unit_status == ops.MaintenanceStatus("waiting for Cassandra to start")
+        workload.return_value.restart.assert_not_called()

tests/unit/test_charm.py

@@ -27,7 +27,7 @@ def test_alive_false_if_service_missing(mock_snap_cache):
     assert workload.is_alive() is False
 
 
-def test_exec_successful_command_returns_output():
+def test_exec_successful_command_returns_output(mock_snap_cache):
     with patch("workload.subprocess.run") as mock_run:
         mock_run.return_value = subprocess.CompletedProcess(
             args=["echo", "hello"], returncode=0, stdout="hello\n", stderr=""
@@ -38,7 +38,7 @@ def test_exec_successful_command_returns_output():
         assert stderr == ""
 
 
-def test_exec_command_raises_on_failure():
+def test_exec_command_raises_on_failure(mock_snap_cache):
     with patch("workload.subprocess.run") as mock_run:
         mock_run.side_effect = subprocess.CalledProcessError(
             returncode=1, cmd=["false"], output="", stderr="error"