File size: 7,377 Bytes
22bc83d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
"""v3 software families: render 1, oracle script 1, nothing/empty/one-value-perturbed 0, on three seeds per level,
plus the trap each level adds: the common mistake, replayed through the oracle script, scores 0."""

import json
import os
import sys
import tempfile

import pytest

if "TERMINAL_DESK_ROOTS" not in os.environ:
    _base = tempfile.mkdtemp(prefix="td-test-")
    os.chmod(_base, 0o755)  # nobody traverses it when the suite runs as root
    os.environ["TERMINAL_DESK_ROOTS"] = _base
sys.path.insert(0, os.path.dirname(__file__))

from terminal_desk.core.grading import render_artifact  # noqa: E402
from terminal_desk.families import FAMILIES  # noqa: E402
from terminal_desk.models import Tbench2Action  # noqa: E402
from terminal_desk.oracles import oracle_source, run_oracle  # noqa: E402
from terminal_desk.server.environment import TerminalDeskEnvironment  # noqa: E402
from test_episodes import _evaluate, _sh, _write_oracle  # noqa: E402

FAMS = ("sw3_fix_module", "sw3_rate_limit", "sw3_dep_lock")
IDS = [f"{f}-L{lv}" for f in FAMS for lv in (1, 2, 3)]
SEEDS = (1, 2, 3)


def _env(task_id, seed):
    env = TerminalDeskEnvironment(allow_seed=True)
    env.reset(task_id=task_id, seed=seed)
    return env, env._ep["built"]


def _write(env, path, content):
    obs = env.step(Tbench2Action(action_type="write_file", file_path=path, content=content))
    assert obs.success, obs.error


def _perturb(task_id, built) -> str:
    """The rendered answer with one value changed."""
    good = render_artifact(built.artifact)
    if task_id.startswith("sw3_rate_limit"):
        ids = json.loads(good)
        return json.dumps(ids[:-1] + [ids[-1] + 1])  # last rejected id swapped for its neighbour
    if task_id.startswith("sw3_dep_lock"):
        lines = good.split("\n")
        name, ver = lines[0].split("==")
        major, minor = ver.split(".")
        lines[0] = f"{name}=={major}.{int(minor) + 1}"
        return "\n".join(lines)
    # fix_module: the first buggy function keeps its planted bug, every other function is fixed
    name, bad = built.notes["buggy"][0], built.files[built.artifact.path]
    return good.replace(_block(good, name), _block(bad, name))


def _block(text: str, name: str) -> str:
    start = text.index(f"def {name}(")
    end = text.find("\n\n\ndef ", start)
    return text[start:] if end < 0 else text[start:end]


@pytest.mark.parametrize("task_id", IDS)
@pytest.mark.parametrize("seed", SEEDS)
def test_render_and_oracle_score_one(task_id, seed):
    env, built = _env(task_id, seed)
    assert 600 <= len(built.instruction) <= 1000 and f"{built.root}/{built.artifact.path}" in built.instruction
    _write_oracle(env)
    obs = _evaluate(env)
    assert obs.reward == 1.0, obs.output
    env.reset(task_id=task_id, seed=seed)
    out, obs = run_oracle(env, oracle_source(task_id.rpartition("-L")[0]))
    assert obs.reward == 1.0, (out, obs.output)


@pytest.mark.parametrize("task_id", IDS)
@pytest.mark.parametrize("seed", SEEDS)
def test_nothing_empty_and_perturbed_score_zero(task_id, seed):
    env, built = _env(task_id, seed)
    obs = _evaluate(env)  # fix_module's artifact is the unfixed input module; the others have no file yet
    assert obs.reward == 0.0 and "FAILED tests/test_outputs.py::test_" in obs.output
    env.reset(task_id=task_id, seed=seed)
    _write(env, built.artifact.path, "")
    assert _evaluate(env).reward == 0.0
    env.reset(task_id=task_id, seed=seed)
    _write(env, built.artifact.path, _perturb(task_id, built))
    obs = _evaluate(env)
    assert obs.reward == 0.0 and obs.info["assertions_passed"] >= 1, obs.output


@pytest.mark.parametrize("seed", SEEDS)
def test_rate_limit_traps_score_zero(seed):
    src = oracle_source("sw3_rate_limit")
    traps = {
        2: [src.replace('reqs.sort(key=lambda r: (float(r["ts"]), int(r["id"])))', ""),  # file order
            src.replace('exempt = set(cfg.get("exempt_keys", []))', "exempt = set()")],
        3: [src.replace('if os.path.exists("CHANGE_NOTICE.md"):', "if False:")],
    }
    for level in (1, 2, 3):
        variants = [src.replace("tokens = min(cap, tokens + (ts - last) * rate)",
                                "tokens = min(cap, tokens + int(ts - last) * rate)")]  # whole-second refill
        variants += [v for lv, vs in traps.items() if lv <= level for v in vs]
        for variant in variants:
            assert variant != src
            env, _ = _env(f"sw3_rate_limit-L{level}", seed)
            out, obs = run_oracle(env, variant)
            assert obs.reward == 0.0, (level, out)


@pytest.mark.parametrize("seed", SEEDS)
def test_dep_lock_traps_score_zero(seed):
    src = oracle_source("sw3_dep_lock")
    string_compare = src.replace('return tuple(int(x) for x in v.split("."))', 'return tuple(v.split("."))')
    ignore_yanked = src.replace('if os.path.exists("yanked.txt"):', "if False:")
    newest_each = src.replace("best = None", "best = None\nfor p in pkgs:\n    releases[p] = "
                              "{max(releases[p], key=vkey): releases[p][max(releases[p], key=vkey)]}")
    for level, variants in ((1, [newest_each]), (2, [string_compare, newest_each]),
                            (3, [string_compare, ignore_yanked, newest_each])):
        for variant in variants:
            assert variant != src
            env, _ = _env(f"sw3_dep_lock-L{level}", seed)
            out, obs = run_oracle(env, variant)
            assert obs.reward == 0.0, (level, out)


@pytest.mark.parametrize("seed", SEEDS)
def test_fix_module_docstring_only_fix_fails_when_changelog_revises(seed):
    src = oracle_source("sw3_fix_module")
    src = src.replace(r'REV = sorted(set(re.findall(r"### Changed\n- `(\w+)`", log)))', "REV = []")
    assert "REV = []\n" in src
    for level in (2, 3):
        env, built = _env(f"sw3_fix_module-L{level}", seed)
        assert built.notes["revised"] and "CHANGELOG.md" in built.files
        out, obs = run_oracle(env, src)
        assert obs.reward == 0.0, out
        assert f"FAILED tests/test_outputs.py::test_{built.notes['revised']}" in obs.output


@pytest.mark.parametrize("level", (1, 2, 3))
def test_fix_module_visible_tests_fail_before_and_pass_after(level):
    env, built = _env(f"sw3_fix_module-L{level}", 5)
    before = _sh(env, "python3 -m unittest discover -s tests 2>&1 | tail -n 3")
    assert "FAILED (failures=1)" in before, before
    assert "FAIL: test_" in built.files["ci/nightly.log"]
    _write_oracle(env)
    after = _sh(env, "python3 -m unittest discover -s tests 2>&1 | tail -n 3")
    assert after.endswith("OK"), after
    if level == 3:
        assert built.notes["revised"] in built.notes["buggy"]
    if level == 2:
        assert built.notes["revised"] not in built.notes["buggy"]


def test_fix_module_reads_a_planted_symlink_as_missing():
    env, built = _env("sw3_fix_module-L1", 2)
    _sh(env, f"rm {built.artifact.path} && ln -s /etc/passwd {built.artifact.path}")
    obs = _evaluate(env)
    assert obs.reward == 0.0 and "FAILED tests/test_outputs.py::test_file_exists" in obs.output


def test_fresh_instances_per_reset():
    env = TerminalDeskEnvironment()
    for fam in FAMS:
        a = env.reset(task_id=f"{fam}-L2").instruction, dict(env._ep["built"].files)
        b = env.reset(task_id=f"{fam}-L2").instruction, dict(env._ep["built"].files)
        assert a != b
        assert FAMILIES[fam].v3