Spaces:
Configuration error
Configuration error
Download test_rocketenv.py from sarahzephyr/Rocket_env: direct link, hf CLI and curl.
- Browser
- Download file 9.38 kB
-
https://huggingface.co/spaces/sarahzephyr/Rocket_env/resolve/main/test_rocketenv.py
- Command line
-
hf download hf://spaces/sarahzephyr/Rocket_env/test_rocketenv.py
-
curl -L -o test_rocketenv.py https://huggingface.co/spaces/sarahzephyr/Rocket_env/resolve/main/test_rocketenv.py
9.38 kB
| """ | |
| RocketEnv Tests β validates all OpenEnv spec requirements | |
| """ | |
| import pytest | |
| from rocket_env import ( | |
| RocketEnv, RocketAction, RocketObservation, | |
| ActionType, LaunchPhase, SubsystemStatus, TASK_CONFIGS | |
| ) | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # Reset tests | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def test_reset_returns_observation(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| obs = env.reset() | |
| assert isinstance(obs, RocketObservation) | |
| def test_reset_produces_clean_state(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| obs = env.reset() | |
| assert obs.step_number == 0 | |
| assert obs.phase == LaunchPhase.PRE_CHECKS | |
| assert obs.abort_risk == 0.0 | |
| assert len(obs.subsystems) == 6 | |
| def test_reset_deterministic_with_seed(): | |
| env = RocketEnv(task="nominal_launch", seed=123) | |
| obs1 = env.reset() | |
| env2 = RocketEnv(task="nominal_launch", seed=123) | |
| obs2 = env2.reset() | |
| assert obs1.subsystems == obs2.subsystems | |
| assert obs1.weather_window == obs2.weather_window | |
| def test_reset_all_tasks(): | |
| for task in TASK_CONFIGS: | |
| env = RocketEnv(task=task, seed=0) | |
| obs = env.reset() | |
| assert obs is not None | |
| assert obs.t_minus == TASK_CONFIGS[task]["t_minus_start"] | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # Step tests | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def test_step_returns_correct_types(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| result = env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| assert isinstance(result.reward, float) | |
| assert isinstance(result.done, bool) | |
| assert isinstance(result.observation, RocketObservation) | |
| assert isinstance(result.info, dict) | |
| def test_step_reward_in_range(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| for _ in range(10): | |
| if env._done: | |
| break | |
| result = env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| assert -1.0 <= result.reward <= 1.0 | |
| def test_step_after_done_raises(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| # Force done state | |
| env._done = True | |
| with pytest.raises(RuntimeError): | |
| env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| def test_diagnose_action(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| # Find a faulted subsystem | |
| faulted = None | |
| for name, sub in env._state["subsystems"].items(): | |
| if sub.status != SubsystemStatus.NOMINAL: | |
| faulted = name | |
| break | |
| if faulted: | |
| result = env.step(RocketAction(action_type=ActionType.DIAGNOSE, target=faulted)) | |
| assert result.reward > 0 # should reward fault discovery | |
| def test_run_diagnostic_gives_positive_reward(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| result = env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| assert result.reward >= 0.0 # diagnostic always gives small positive reward | |
| def test_override_penalized(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| result = env.step(RocketAction(action_type=ActionType.OVERRIDE, target="propulsion")) | |
| assert result.reward < 0 # override should always penalize | |
| def test_invalid_target_penalized(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| result = env.step(RocketAction(action_type=ActionType.DIAGNOSE, target="nonexistent")) | |
| assert result.reward < 0 | |
| def test_step_increments_step_count(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| result = env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| assert result.observation.step_number == 1 | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # State tests | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def test_state_returns_dict(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| s = env.state() | |
| assert isinstance(s, dict) | |
| assert "phase" in s | |
| assert "subsystems" in s | |
| assert "t_minus" in s | |
| def test_state_before_reset(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| s = env.state() | |
| assert s["status"] == "not_initialized" | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # Grader tests | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def test_grader_returns_float_in_range(): | |
| for task in TASK_CONFIGS: | |
| env = RocketEnv(task=task, seed=42) | |
| env.reset() | |
| # Run a few steps | |
| for _ in range(5): | |
| if env._done: | |
| break | |
| env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| score = env.grade() | |
| assert isinstance(score, float), f"grade() must return float for task {task}" | |
| assert 0.0 <= score <= 1.0, f"score out of range for task {task}: {score}" | |
| def test_grader_higher_for_authorized_launch(): | |
| env = RocketEnv(task="nominal_launch", seed=42) | |
| env.reset() | |
| # Manually repair all faults | |
| for name, sub in env._state["subsystems"].items(): | |
| sub.status = SubsystemStatus.NOMINAL | |
| sub.fault_code = None | |
| # Authorize | |
| env.step(RocketAction(action_type=ActionType.AUTHORIZE)) | |
| score_good = env.grade() | |
| env2 = RocketEnv(task="nominal_launch", seed=42) | |
| env2.reset() | |
| # Just abort immediately | |
| env2.step(RocketAction(action_type=ActionType.ABORT)) | |
| score_bad = env2.grade() | |
| assert score_good > score_bad | |
| def test_grader_deterministic(): | |
| """Same episode, same score.""" | |
| def run_episode(seed): | |
| env = RocketEnv(task="multi_fault_recovery", seed=seed) | |
| env.reset() | |
| for _ in range(5): | |
| if env._done: | |
| break | |
| env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| return env.grade() | |
| score1 = run_episode(99) | |
| score2 = run_episode(99) | |
| assert score1 == score2 | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| # Full episode tests | |
| # βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def test_full_episode_nominal_launch(): | |
| """Simulate a smart agent on nominal_launch.""" | |
| env = RocketEnv(task="nominal_launch", seed=7) | |
| obs = env.reset() | |
| rewards = [] | |
| for step in range(20): | |
| if env._done: | |
| break | |
| # Smart strategy: diagnose faults, repair them, then authorize | |
| faulted = None | |
| for name, sub in env._state["subsystems"].items(): | |
| if sub.status != SubsystemStatus.NOMINAL: | |
| faulted = name | |
| break | |
| if faulted and obs.step_number < 2: | |
| action = RocketAction(action_type=ActionType.DIAGNOSE, target=faulted) | |
| elif faulted: | |
| action = RocketAction(action_type=ActionType.REPAIR, target=faulted) | |
| else: | |
| action = RocketAction(action_type=ActionType.AUTHORIZE) | |
| result = env.step(action) | |
| rewards.append(result.reward) | |
| obs = result.observation | |
| score = env.grade() | |
| assert 0.0 <= score <= 1.0 | |
| assert len(rewards) > 0 | |
| def test_all_tasks_complete_without_error(): | |
| for task in TASK_CONFIGS: | |
| env = RocketEnv(task=task, seed=42) | |
| env.reset() | |
| for _ in range(TASK_CONFIGS[task]["max_steps"]): | |
| if env._done: | |
| break | |
| env.step(RocketAction(action_type=ActionType.RUN_DIAGNOSTIC)) | |
| score = env.grade() | |
| assert 0.0 <= score <= 1.0 | |
| if __name__ == "__main__": | |
| pytest.main([__file__, "-v"]) | |