chore: refactor tests to match new transition name

Author: Apolo151

test/conftest.py

@@ -109,22 +109,20 @@ def start(self):
         def stop(self):
             self.started = False
 
-    class DummyVisualizationLauncher:
+    class DummyToolsLauncher:
         def __init__(self, *args, **kwargs):
             self.launchers = []
 
-        def run(self):
-            # Simulate running the visualization launcher
+        def run(self, consumer):
+            # Simulate running the tools launcher
             return
 
         def terminate(self):
             pass
 
-    monkeypatch.setattr(
-        "manager.manager.manager.LauncherVisualization", DummyVisualizationLauncher
-    )
-    monkeypatch.setattr("manager.manager.manager.Server", DummyServer)
-    monkeypatch.setattr("manager.manager.manager.FileWatchdog", DummyFileWatchdog)
+    monkeypatch.setattr("manager.manager.manager.LauncherTools", DummyToolsLauncher)
+    # monkeypatch.setattr("manager.manager.manager.Server", DummyServer)
+    # monkeypatch.setattr("manager.manager.manager.FileWatchdog", DummyFileWatchdog)
 
     # Setup Manager with dummy consumer
     m = Manager(host="localhost", port=12345)

test/test_connected_to_world_ready.py

@@ -1,27 +1,34 @@
 """Tests for transitioning Manager from 'connected' to 'world_ready' state."""
 
 import pytest
+from manager.libs.launch_world_model import ConfigurationModel
 from test_utils import setup_manager_to_connected
+from manager.manager.launcher.launcher_robot import worlds
+
+valid_world_cfg = ConfigurationModel(
+    type=next(iter(worlds)), launch_file_path="/path/to/launch_file.launch"
+).model_dump()
+
+valid_robot_cfg = {
+    "world": None,  # No robot specified
+    "type": next(iter(worlds)),  # Use the first world type
+    "start_pose": [0, 0, 0, 0, 0, 0],
+    "launch_file_path": "/path/to/robot_launch_file.launch",
+}
+
+invalid_world_cfg = {
+    "world": "bad_world",
+    "type": next(iter(worlds)),
+    "launch_file_path": None,  # No launch file specified
+}  # missing launch_file_path
 
 
 def test_connected_to_world_ready(manager, monkeypatch):
     """Test transitioning Manager from 'connected' to 'world_ready' state."""
     # Initial state should be 'connected'
     setup_manager_to_connected(manager, monkeypatch)
 
-    # Use ConfigurationModel for valid world config
-    from manager.libs.launch_world_model import ConfigurationModel
-
-    valid_world_cfg = ConfigurationModel(
-        world="test_world", launch_file_path="/path/to/launch_file.launch"
-    ).model_dump()
-    event_data = {
-        "world": valid_world_cfg,
-        "robot": {
-            "world": None,  # No robot specified
-            "robot_config": {"name": "test_robot", "type": "simple"},
-        },
-    }
+    event_data = {"world": valid_world_cfg, "robot": valid_robot_cfg}
     manager.trigger("launch_world", data=event_data)
 
     # State should now be 'world_ready'
@@ -51,19 +58,18 @@ def fake_validate(cfg):
         # Simulate logging error, but return a dummy config to avoid UnboundLocalError
         return DummyConfig()
 
+    def fake_prepare_custom_universe(cfg):
+        raise ValueError("Invalid world configuration")
+
     monkeypatch.setattr(
         "manager.libs.launch_world_model.ConfigurationManager.validate", fake_validate
     )
+    manager.prepare_custom_universe = fake_prepare_custom_universe
 
-    invalid_world_cfg = {"world": "bad_world"}  # missing launch_file_path
-    event_data = {
-        "world": invalid_world_cfg,
-        "robot": {
-            "world": None,
-            "robot_config": {"name": "test_robot", "type": "simple"},
-        },
-    }
-    manager.trigger("launch_world", data=event_data)
+    event_data = {"world": invalid_world_cfg, "robot": valid_robot_cfg}
+
+    with pytest.raises(ValueError):
+        manager.trigger("launch_world", data=event_data)
     # Assert that world_launcher is created but has no useful config
     assert manager.world_launcher is not None
     assert (
@@ -91,17 +97,10 @@ def fake_validate(cfg):
         "manager.libs.launch_world_model.ConfigurationManager.validate", fake_validate
     )
 
-    valid_world_cfg = {
-        "world": "test_world",
-        "launch_file_path": "/path/to/launch_file.launch",
-    }
     invalid_robot_cfg = {"name": "", "type": ""}  # Invalid robot config
     event_data = {
         "world": valid_world_cfg,
-        "robot": {
-            "world": valid_world_cfg,
-            "robot_config": invalid_robot_cfg,
-        },
+        "robot": invalid_robot_cfg,
     }
 
     with pytest.raises(ValueError):
@@ -121,17 +120,11 @@ def test_launch_world_with_no_world_config(manager, monkeypatch):
     # Initial state should be 'connected'
     setup_manager_to_connected(manager, monkeypatch)
 
-    # Use ConfigurationModel for valid robot config
-    from manager.libs.launch_world_model import ConfigurationModel
-
-    valid_robot_cfg = ConfigurationModel(
-        world="test_world",  # No world specified
-        launch_file_path="/path/to/robot_launch_file.launch",
-    ).model_dump()
     event_data = {
         "world": {
             "world": None,  # No world specified
             "launch_file_path": None,  # No launch file specified
+            "type": None,
         },  # No world specified
         "robot": valid_robot_cfg,
     }
@@ -148,16 +141,13 @@ def test_launch_world_with_no_robot_config(manager, monkeypatch):
     # Initial state should be 'connected'
     setup_manager_to_connected(manager, monkeypatch)
 
-    # Use ConfigurationModel for valid world config
-    from manager.libs.launch_world_model import ConfigurationModel
-
-    valid_world_cfg = ConfigurationModel(
-        world="test_world", launch_file_path="/path/to/launch_file.launch"
-    ).model_dump()
-
     event_data = {
         "world": valid_world_cfg,
-        "robot": {"world": None, "robot_config": None},  # No robot specified
+        "robot": {
+            "world": None,
+            "robot_config": None,
+            "type": None,
+        },  # No robot specified
     }
     manager.trigger("launch_world", data=event_data)
 

test/test_resume_and_pause_transitions.py

@@ -3,7 +3,7 @@
 import pytest
 from transitions import MachineError
 from test_utils import setup_manager_to_application_running
-from test_utils import setup_manager_to_visualization_ready
+from test_utils import setup_manager_to_tools_ready
 
 
 class DummyProc:
@@ -38,7 +38,7 @@ def test_pause_transition_valid(manager, monkeypatch):
 def test_pause_transition_invalid_machine_error(manager, monkeypatch):
     """Test the invalid pause transition in the Manager."""
     # Ensure the manager is in a state where it can pause
-    setup_manager_to_visualization_ready(manager, monkeypatch)
+    setup_manager_to_tools_ready(manager, monkeypatch)
 
     # Mock needed methods and attributes
     monkeypatch.setattr("psutil.Process", lambda pid: DummyProc())
@@ -47,7 +47,7 @@ def test_pause_transition_invalid_machine_error(manager, monkeypatch):
     with pytest.raises(MachineError):
         manager.trigger("pause")
     # Check that the state has changed to 'paused'
-    assert manager.state == "visualization_ready"
+    assert manager.state == "tools_ready"
 
 
 def test_resume_transition_valid(manager, monkeypatch):

test/test_terminate_transitions.py

@@ -5,7 +5,7 @@
 from conftest import DummyServer
 from test_utils import setup_manager_to_application_running
 from test_utils import setup_manager_to_world_ready
-from test_utils import setup_manager_to_visualization_ready
+from test_utils import setup_manager_to_tools_ready
 
 
 class DummyProc:
@@ -55,7 +55,7 @@ def dummy_stop_process_and_children(proc):
     # Trigger the terminate transition
     manager.trigger("terminate_application")
     # Check that the state has changed to 'visualization_ready'
-    assert manager.state == "visualization_ready"
+    assert manager.state == "tools_ready"
 
 
 def test_terminate_application_invalid_machine_error(manager, monkeypatch):
@@ -85,21 +85,21 @@ def dummy_stop_process_and_children(proc):
     assert manager.state == "world_ready"
 
 
-def test_terminate_visualization_valid(manager, monkeypatch):
+def test_terminate_tools_valid(manager, monkeypatch):
     """Test the valid terminate visualization transition in the Manager."""
     # Ensure the manager is in a state where it can stop
-    setup_manager_to_visualization_ready(manager, monkeypatch)
+    setup_manager_to_tools_ready(manager, monkeypatch)
     # Mock needed methods and attributes
     manager.visualization_launcher = DummyVisualizationLauncher()
     manager.terminate_harmonic_processes = lambda: None
 
     # Trigger the stop transition
-    manager.trigger("terminate_visualization")
+    manager.trigger("terminate_tools")
     # Check that the state has changed to 'world_ready'
     assert manager.state == "world_ready"
 
 
-def test_terminate_visualization_invalid_machine_error(manager, monkeypatch):
+def test_terminate_tools_invalid_machine_error(manager, monkeypatch):
     """
     Test the invalid terminate visualization transition in the Manager.
 
@@ -113,7 +113,7 @@ def test_terminate_visualization_invalid_machine_error(manager, monkeypatch):
 
     # Trigger the stop transition
     with pytest.raises(MachineError):
-        manager.trigger("terminate_visualization")
+        manager.trigger("terminate_tools")
     # Check that the state has not changed
     assert manager.state == "application_running"
 

test/test_visualization_ready_to_application_running.py renamed to test/test_tools_ready_to_application_running.py

@@ -3,16 +3,22 @@
 import io
 import pytest
 import builtins
-from test_utils import setup_manager_to_visualization_ready
+from test_utils import setup_manager_to_tools_ready
 
+valid_app_data = {
+    "entrypoint": "main.py",
+    "linter": "pylint",
+    "code": "data:base64,ZmFrZV9jb2Rl",
+}
 
-def test_visualization_ready_to_application_running_valid(manager, monkeypatch):
+
+def test_tools_ready_to_application_running_valid(manager, monkeypatch):
     """
-    Test transitioning from 'visualization_ready' to 'application_running' state.
+    Test transitioning from 'tools_ready' to 'application_running' state.
 
     This test verifies the state transitions in case of valid values.
     """
-    setup_manager_to_visualization_ready(manager, monkeypatch)
+    setup_manager_to_tools_ready(manager, monkeypatch)
 
     class DummyProc:
         def __init__(self):
@@ -59,15 +65,15 @@ def fake_open(file, mode="r", *args, **kwargs):
     # Trigger application running state
     manager.trigger(
         "run_application",
-        data={"type": "robotics-academy", "code": "data:base64,ZmFrZV9jb2Rl"},
+        data=valid_app_data,
     )
     # Assert state is now application_running
     assert manager.state == "application_running"
 
 
 def test_on_run_application_missing_code(manager, monkeypatch):
     """Test running application with missing code file."""
-    setup_manager_to_visualization_ready(manager, monkeypatch)
+    setup_manager_to_tools_ready(manager, monkeypatch)
 
     # Mock file system so code file is missing
     monkeypatch.setattr("os.path.isfile", lambda path: False)
@@ -103,18 +109,18 @@ def fake_open(file, mode="r", *args, **kwargs):
     # Mock linter to return no errors
     manager.linter.evaluate_code = lambda code, ros_version: ""
     # Prep data
-    data = {"type": "robotics-academy", "code": "data:base64,ZmFrZV9jb2Rl"}
+    data = valid_app_data
     # Trigger run_application with missing code
     with pytest.raises(Exception, match="User code not found"):
         manager.trigger("run_application", data=data)
     assert manager.application_process is None
-    # Ensure state is still visualization_ready
-    assert manager.state == "visualization_ready"
+    # Ensure state is still tools_ready
+    assert manager.state == "tools_ready"
 
 
 def test_on_run_application_corrupt_zip(manager, monkeypatch):
     """Test running application with corrupt zip/base64."""
-    setup_manager_to_visualization_ready(manager, monkeypatch)
+    setup_manager_to_tools_ready(manager, monkeypatch)
 
     # Mock file system so code dir exists
     monkeypatch.setattr("os.path.isfile", lambda path: True)
@@ -150,8 +156,8 @@ def fake_open(file, mode="r", *args, **kwargs):
         "manager.manager.manager.Manager.unpause_sim", lambda self: None
     )
     manager.linter.evaluate_code = lambda code, ros_version: ""
-    data = {"type": "robotics-academy", "code": "data:base64,ZmFrZV9jb2Rl"}
-    with pytest.raises(Exception, match="Corrupt base64"):
+    data = valid_app_data
+    with pytest.raises(Exception):
         manager.trigger("run_application", data=data)
     assert manager.application_process is None
-    assert manager.state == "visualization_ready"
+    assert manager.state == "tools_ready"