| |
| """Dependency-light tests for VRBench SPAgent training environments.""" |
|
|
| from __future__ import annotations |
|
|
| import importlib.util |
| import os |
| import sys |
| import tempfile |
| import types |
| from pathlib import Path |
|
|
| from PIL import Image |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT)) |
|
|
| from spagent.frozenlake_v3_protocol import count_explicit_images |
| from spagent.vrbench_navigation_protocol import ( |
| EMPTY, |
| GOAL, |
| MAZE_TASK, |
| PATHFINDER_TASK, |
| TRAP, |
| TRAPFIELD_SOLVABLE_SEEDS, |
| TRAPFIELD_TASK, |
| WALL, |
| build_system_prompt, |
| build_user_prompt, |
| canonical_state, |
| encode_initial_state, |
| render_state, |
| replay_actions, |
| shortest_path, |
| state_text, |
| step_state, |
| ) |
|
|
| _builder_spec = importlib.util.spec_from_file_location( |
| "build_vrbench_navigation_training_data", |
| ROOT / "train" / "build_vrbench_navigation_training_data.py", |
| ) |
| builder = importlib.util.module_from_spec(_builder_spec) |
| assert _builder_spec.loader is not None |
| _builder_spec.loader.exec_module(builder) |
|
|
|
|
| def simple_state() -> dict: |
| return canonical_state( |
| grid=[ |
| [WALL, WALL, WALL, WALL, WALL], |
| [WALL, EMPTY, EMPTY, EMPTY, WALL], |
| [WALL, WALL, WALL, EMPTY, WALL], |
| [WALL, EMPTY, EMPTY, GOAL, WALL], |
| [WALL, WALL, WALL, WALL, WALL], |
| ], |
| start=(1, 1), |
| goal=(3, 3), |
| ) |
|
|
|
|
| def trap_state() -> dict: |
| return canonical_state( |
| grid=[ |
| [WALL, WALL, WALL, WALL, WALL], |
| [WALL, EMPTY, TRAP, EMPTY, WALL], |
| [WALL, EMPTY, EMPTY, EMPTY, WALL], |
| [WALL, EMPTY, EMPTY, GOAL, WALL], |
| [WALL, WALL, WALL, WALL, WALL], |
| ], |
| start=(1, 1), |
| goal=(3, 3), |
| ) |
|
|
|
|
| def test_protocol_and_replay() -> None: |
| state = simple_state() |
| solution = ["Right", "Right", "Down", "Down"] |
| assert shortest_path(state) == solution |
| assert replay_actions(MAZE_TASK, encode_initial_state(state), solution) |
| assert not replay_actions( |
| MAZE_TASK, |
| encode_initial_state(state), |
| ["Down"], |
| ) |
|
|
|
|
| def test_blocked_wall_and_trap() -> None: |
| state = simple_state() |
| wall = step_state(PATHFINDER_TASK, state, "Down") |
| assert not wall.changed |
| assert wall.tool_result["error"] == "wall" |
| trapped = step_state(TRAPFIELD_TASK, trap_state(), "Right") |
| assert not trapped.changed |
| assert trapped.tool_result["error"] == "trap" |
|
|
|
|
| def test_text_render_and_prompt(tmp: Path) -> None: |
| state = simple_state() |
| image_path = tmp / "maze.png" |
| render_state(MAZE_TASK, state, image_path) |
| assert state_text(state, initial=True).splitlines()[1] == "#SFF#" |
| prompt = build_user_prompt(MAZE_TASK, state, image_path) |
| assert count_explicit_images(prompt) == 1 |
| assert "# Initial Grid (text view, 5x5)" in prompt |
| assert '"name": "move"' in build_system_prompt(MAZE_TASK, state) |
| with Image.open(image_path) as image: |
| assert image.mode == "RGB" |
| assert image.size == (240, 240) |
|
|
|
|
| def load_plugin_with_stubs(): |
| class FakeRolloutInferRequest: |
| def __init__(self, **kwargs): |
| self.__dict__.update(kwargs) |
|
|
| class FakeScheduler: |
| def __init__(self, max_turns=20, *args, **kwargs): |
| self.max_turns = max_turns |
|
|
| def check_finished(self, infer_request, response_choice, current_turn): |
| return current_turn >= self.max_turns |
|
|
| class FakeORM: |
| pass |
|
|
| class FakeLogger: |
| def warning(self, *args, **kwargs): |
| pass |
|
|
| swift = types.ModuleType("swift") |
| swift_llm = types.ModuleType("swift.llm") |
| swift_llm.RolloutInferRequest = FakeRolloutInferRequest |
| swift_infer = types.ModuleType("swift.llm.infer") |
| swift_protocol = types.ModuleType("swift.llm.infer.protocol") |
| swift_protocol.ChatCompletionResponseChoice = object |
| swift_plugin = types.ModuleType("swift.plugin") |
| swift_plugin.ORM = FakeORM |
| swift_plugin.orms = {} |
| swift_multi = types.ModuleType("swift.plugin.multi_turn") |
| swift_multi.MultiTurnScheduler = FakeScheduler |
| swift_multi.multi_turns = {} |
| swift_utils = types.ModuleType("swift.utils") |
| swift_utils.get_logger = lambda: FakeLogger() |
| trainer = types.ModuleType("grpo_filtered_trainer") |
|
|
| modules = { |
| "swift": swift, |
| "swift.llm": swift_llm, |
| "swift.llm.infer": swift_infer, |
| "swift.llm.infer.protocol": swift_protocol, |
| "swift.plugin": swift_plugin, |
| "swift.plugin.multi_turn": swift_multi, |
| "swift.utils": swift_utils, |
| "grpo_filtered_trainer": trainer, |
| } |
| previous = {name: sys.modules.get(name) for name in modules} |
| sys.modules.update(modules) |
| try: |
| spec = importlib.util.spec_from_file_location( |
| "vrbench_navigation_plugin_under_test", |
| ROOT / "train" / "vrbench_navigation_plugin.py", |
| ) |
| module = importlib.util.module_from_spec(spec) |
| assert spec.loader is not None |
| spec.loader.exec_module(module) |
| return module, FakeRolloutInferRequest |
| finally: |
| for name, old in previous.items(): |
| if old is None: |
| sys.modules.pop(name, None) |
| else: |
| sys.modules[name] = old |
|
|
|
|
| def test_reward_and_scheduler(tmp: Path) -> None: |
| plugin, request_type = load_plugin_with_stubs() |
| state = simple_state() |
| encoded = encode_initial_state(state) |
| solution = "Right Right Down Down" |
| completion = f"<think>Plan.</think><answer>{solution}</answer>" |
| assert plugin.VRBenchNavigationReward()( |
| [completion], |
| [MAZE_TASK], |
| [encoded], |
| ) == [1.0] |
| assert plugin.VRBenchNavigationFormatReward()([completion]) == [0.5] |
|
|
| initial_image = tmp / "initial.png" |
| render_state(MAZE_TASK, state, initial_image) |
| old_dir = os.environ.get("VRBENCH_NAV_IMG_DIR") |
| os.environ["VRBENCH_NAV_IMG_DIR"] = str(tmp / "rollout") |
| try: |
| scheduler = plugin.VRBenchNavigationScheduler(max_turns=10) |
| request = request_type( |
| messages=[ |
| {"role": "system", "content": "system"}, |
| {"role": "user", "content": "user"}, |
| ], |
| images=[str(initial_image)], |
| audios=None, |
| videos=None, |
| tools=None, |
| objects=None, |
| data_dict={ |
| "task_id": MAZE_TASK, |
| "initial_state": encoded, |
| }, |
| ) |
| choice = types.SimpleNamespace( |
| message=types.SimpleNamespace( |
| content=( |
| "<think>Move right.</think>" |
| '<tool_call>{"name":"move","arguments":' |
| '{"direction":"Right"}}</tool_call>' |
| ) |
| ) |
| ) |
| result = scheduler.step(request, choice, 1) |
| next_request = result["infer_request"] |
| assert next_request.data_dict["_vrbench_navigation"]["actions"] == [ |
| "Right" |
| ] |
| assert len(next_request.images) == 2 |
| assert Path(next_request.images[-1]).is_file() |
| assert count_explicit_images( |
| next_request.messages[-1]["content"] |
| ) == 1 |
|
|
| blocked_choice = types.SimpleNamespace( |
| message=types.SimpleNamespace( |
| content=( |
| "<think>Try down.</think>" |
| '<tool_call>{"name":"move","arguments":' |
| '{"direction":"Down"}}</tool_call>' |
| ) |
| ) |
| ) |
| blocked = scheduler.step(next_request, blocked_choice, 2) |
| blocked_request = blocked["infer_request"] |
| assert len(blocked_request.images) == 2 |
| assert count_explicit_images( |
| blocked_request.messages[-1]["content"] |
| ) == 1 |
| finally: |
| if old_dir is None: |
| os.environ.pop("VRBENCH_NAV_IMG_DIR", None) |
| else: |
| os.environ["VRBENCH_NAV_IMG_DIR"] = old_dir |
|
|
|
|
| def test_trapfield_seed_contract() -> None: |
| assert len(TRAPFIELD_SOLVABLE_SEEDS) == 30 |
| assert len(set(TRAPFIELD_SOLVABLE_SEEDS)) == 30 |
|
|
|
|
| def main() -> None: |
| with tempfile.TemporaryDirectory() as directory: |
| tmp = Path(directory) |
| test_protocol_and_replay() |
| test_blocked_wall_and_trap() |
| test_text_render_and_prompt(tmp) |
| test_reward_and_scheduler(tmp) |
| test_trapfield_seed_contract() |
| print("VRBench navigation training tests passed") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
