burtenshaw HF Staff
Publish procedural SQL investigation tasks and reproducible environment source
2ce79be verified | """Independent checks of reward, SQL boundaries, and episode isolation.""" | |
| import json | |
| import time | |
| import pytest | |
| from pydantic import ValidationError | |
| from sql_investigation.environment import SQLInvestigationEnvironment, rows_match | |
| from sql_investigation.models import SQLAction | |
| from sql_investigation.tasks import TASK_IDS, build_task | |
| def environment(): | |
| env = SQLInvestigationEnvironment() | |
| env.reset(task_id=TASK_IDS[0], seed=42) | |
| try: | |
| yield env | |
| finally: | |
| env.close() | |
| def test_oracle_submission_is_terminal_and_rewarded(task_id, seed): | |
| task = build_task(task_id, seed) | |
| env = SQLInvestigationEnvironment() | |
| try: | |
| reset = env.reset(task_id=task_id, seed=seed) | |
| assert not reset.done | |
| assert reset.reward == 0.0 | |
| assert task.oracle_sql not in json.dumps(reset.model_dump()) | |
| assert reset.metadata == {} | |
| observation = env.step(SQLAction(op="submit", sql=task.oracle_sql)) | |
| assert observation.done | |
| assert observation.reward == 1.0 | |
| assert observation.metadata == {} | |
| assert observation.rows == [] | |
| assert observation.columns == [] | |
| finally: | |
| task.connection.close() | |
| env.close() | |
| def test_wrong_answer_and_finish_receive_zero(task_id): | |
| env = SQLInvestigationEnvironment() | |
| try: | |
| for action in ( | |
| SQLAction(op="submit", sql="SELECT '__incorrect_answer__'"), | |
| SQLAction(op="finish"), | |
| ): | |
| env.reset(task_id=task_id, seed=42) | |
| observation = env.step(action) | |
| assert observation.done | |
| assert observation.reward == 0.0 | |
| assert observation.metadata == {} | |
| finally: | |
| env.close() | |
| def test_example_sequence_and_action_budget(environment): | |
| first = environment.step(SQLAction(op="query", sql="SELECT 1 AS ready")) | |
| assert first.columns == ["ready"] | |
| assert first.rows == [[1]] | |
| assert first.reward == 0.0 | |
| assert not first.done | |
| assert first.remaining_steps == 11 | |
| assert first.metadata == {} | |
| final = environment.step(SQLAction(op="finish")) | |
| assert final.done and final.reward == 0.0 | |
| environment.reset(task_id=TASK_IDS[0], seed=42) | |
| for step in range(12): | |
| result = environment.step(SQLAction(op="query", sql="SELECT 1")) | |
| assert result.done == (step == 11) | |
| assert result.remaining_steps == 11 - step | |
| assert result.reward == 0.0 | |
| state_steps = environment.state.step_count | |
| assert environment.step(SQLAction(op="finish")).model_dump() == result.model_dump() | |
| assert environment.state.step_count == state_steps | |
| def test_unsafe_sql_is_rejected_and_session_recovers(environment, sql): | |
| result = environment.step(SQLAction(op="query", sql=sql)) | |
| assert "SQL error:" in result.message | |
| assert result.reward == 0.0 | |
| assert result.rows == [] | |
| assert not result.done | |
| recovered = environment.step(SQLAction(op="query", sql="SELECT 1 AS intact")) | |
| assert recovered.rows == [[1]] | |
| def test_file_creation_is_rejected(environment, tmp_path): | |
| destination = tmp_path / "forbidden.sqlite" | |
| result = environment.step(SQLAction(op="query", sql=f"VACUUM INTO '{destination}'")) | |
| assert "SQL error:" in result.message | |
| assert not destination.exists() | |
| def test_mutation_does_not_change_existing_data(environment): | |
| table = environment.step( | |
| SQLAction( | |
| op="query", | |
| sql="SELECT name FROM sqlite_master WHERE type='table' ORDER BY name LIMIT 1", | |
| ) | |
| ).rows[0][0] | |
| quoted_table = '"' + table.replace('"', '""') + '"' | |
| before = environment.step(SQLAction(op="query", sql=f"SELECT * FROM {quoted_table}")) | |
| rejected = environment.step(SQLAction(op="query", sql=f"DELETE FROM {quoted_table}")) | |
| assert "SQL error:" in rejected.message | |
| after = environment.step(SQLAction(op="query", sql=f"SELECT * FROM {quoted_table}")) | |
| assert after.columns == before.columns | |
| assert after.rows == before.rows | |
| def test_recursive_query_is_bounded_and_session_recovers(environment): | |
| started = time.monotonic() | |
| interrupted = environment.step( | |
| SQLAction( | |
| op="query", | |
| sql=( | |
| "WITH RECURSIVE loop(x) AS (VALUES(1) UNION ALL " | |
| "SELECT x+1 FROM loop) SELECT sum(x) FROM loop" | |
| ), | |
| ) | |
| ) | |
| assert time.monotonic() - started < 5.0 | |
| assert "SQL error:" in interrupted.message | |
| assert interrupted.reward == 0.0 | |
| assert environment.step(SQLAction(op="query", sql="SELECT 2")).rows == [[2]] | |
| def test_large_results_are_bounded(environment): | |
| result = environment.step( | |
| SQLAction( | |
| op="query", | |
| sql=( | |
| "WITH RECURSIVE series(x) AS (VALUES(1) UNION ALL " | |
| "SELECT x+1 FROM series WHERE x<200) SELECT x FROM series" | |
| ), | |
| ) | |
| ) | |
| assert len(result.rows) == 40 | |
| assert "truncated" in result.message | |
| assert not result.done | |
| def test_invalid_result_values_and_empty_sql_are_rejected(environment, sql): | |
| result = environment.step(SQLAction(op="submit", sql=sql)) | |
| assert result.done | |
| assert result.reward == 0.0 | |
| assert "SQL error:" in result.message | |
| def test_reset_reproduces_task_and_resets_episode_state(environment): | |
| initial = environment.reset(task_id=TASK_IDS[0], seed=42, episode_id="first") | |
| query = "SELECT * FROM sqlite_master ORDER BY name" | |
| first = environment.step(SQLAction(op="query", sql=query)) | |
| reset = environment.reset(task_id=TASK_IDS[0], seed=42, episode_id="second") | |
| assert reset.model_dump() == initial.model_dump() | |
| assert environment.state.episode_id == "second" | |
| assert environment.state.step_count == 0 | |
| second = environment.step(SQLAction(op="query", sql=query)) | |
| assert second.rows == first.rows | |
| assert second.columns == first.columns | |
| def test_parallel_instances_have_independent_state(environment): | |
| other = SQLInvestigationEnvironment() | |
| try: | |
| other.reset(task_id=TASK_IDS[-1], seed=123) | |
| first_episode = environment.state.episode_id | |
| environment.step(SQLAction(op="query", sql="SELECT 1")) | |
| assert other.state.step_count == 0 | |
| other.step(SQLAction(op="finish")) | |
| assert environment.state.episode_id == first_episode | |
| assert environment.state.step_count == 1 | |
| assert not environment.step(SQLAction(op="query", sql="SELECT 2")).done | |
| finally: | |
| other.close() | |
| def test_unknown_task_fails_explicitly(environment): | |
| with pytest.raises(ValueError, match="Unknown task_id"): | |
| environment.reset(task_id="does-not-exist", seed=42) | |
| def test_action_schema_rejects_unknown_fields_and_reserved_shapes(): | |
| for value in ( | |
| {"finish": True}, | |
| {"op": "finish", "unexpected": True}, | |
| {"op": "bad"}, | |
| ): | |
| with pytest.raises(ValidationError): | |
| SQLAction.model_validate(value) | |
| def test_reward_matches_multisets_without_coercing_text_or_null(): | |
| assert rows_match([["a", 1], ["b", 2], ["a", 1]], [["b", 2], ["a", 1], ["a", 1]]) | |
| assert not rows_match([["a", 1], ["b", 2]], [["a", 1], ["a", 1]]) | |
| assert not rows_match([[1, "a"]], [["a", 1]]) | |
| assert not rows_match([["1"]], [[1]]) | |
| assert not rows_match([[None]], [[0]]) | |
| assert rows_match([[None]], [[None]]) | |
| def test_reward_numeric_tolerance_is_absolute_and_finite(): | |
| assert rows_match([[1.00005]], [[1]]) | |
| assert not rows_match([[1.001]], [[1]]) | |
| assert not rows_match([[1_000_000.5]], [[1_000_000]]) | |
| assert not rows_match([[float("inf")]], [[float("inf")]]) | |
| assert not rows_match([[float("nan")]], [[float("nan")]]) | |