File size: 7,565 Bytes
8ccac0b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
"""Tests del modelo determinΓ­stico (TA-003).

Demuestran el requisito cientΓ­fico RN-004: mismo input β†’ mismo output, y que
cada patrΓ³n estratΓ©gico se dispara con la secuencia esperada.

Corre con pytest (`pytest backend/tests/`) o directo (`python test_deterministic.py`).
"""
import copy
import os
import sys

# Permite importar `modules.*` corriendo desde cualquier carpeta.
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))

from modules.deterministic import comentar
from modules.deterministic.estado import construir
from modules.deterministic.reglas import detectar_patron
from modules.deterministic import tablero
from modules.analysis.classifier import classify


def _move(color: str, number: int, dif: int) -> dict:
    """Construye un dict de jugada con la forma que devuelve Stockfish."""
    return {
        "color": color, "number": number, "diferencia_cp": dif,
        "move": "Xx", "eval_antes_cp": 0, "eval_despues_cp": 0,
        "mejor_jugada": "Yy", "mejor_eval_cp": 0,
    }


def _jugadas(difs, numero_base=1):
    """Lista de (dif, clasificacion, numero) a partir de una lista de diferencia_cp."""
    return [(d, classify(d), numero_base + i) for i, d in enumerate(difs)]


# ─── Replicabilidad (RN-004) ─────────────────────────────────────────────────

def test_replicabilidad_mismo_input_mismo_output():
    history = [_move("white", i + 1, d) for i, d in enumerate([-5, -20, -40, -60])]
    move = _move("white", 5, -90)
    salidas = [comentar(move, "Error", history) for _ in range(100)]
    assert all(s == salidas[0] for s in salidas), "El modelo NO es determinΓ­stico"


def test_no_muta_la_entrada():
    history = [_move("white", 1, -10)]
    move = _move("white", 2, -90)
    h_copia, m_copia = copy.deepcopy(history), copy.deepcopy(move)
    comentar(move, "Error", history)
    assert history == h_copia and move == m_copia, "comentar() mutΓ³ sus argumentos"


# ─── Estructura de salida ────────────────────────────────────────────────────

def test_estructura_salida():
    out = comentar(_move("black", 3, -90), "Error", [])
    assert set(out) == {"corto", "expandido"}
    assert isinstance(out["corto"], str) and len(out["corto"]) > 0


# ─── DetecciΓ³n de patrones (sobre features, no sobre cp puntual) ─────────────

def test_deterioro_sostenido():
    # Serie que empeora progresivamente: pendiente negativa + racha bajo la media.
    estado = construir(_jugadas([-5, -20, -50, -80]))
    assert detectar_patron(estado, "Error") == "deterioro_sostenido"


def test_caida_brusca():
    # 4 jugadas buenas y luego 4 malas β†’ cambio de rΓ©gimen fuerte.
    estado = construir(_jugadas([-5, -3, -8, -2, -50, -60, -70, -90]))
    assert detectar_patron(estado, "Error") == "caida_brusca"


def test_error_en_final():
    # Jugada mala aislada pero en fase final (nΓΊmero > 30).
    estado = construir([(-50, "ImprecisiΓ³n", 35)])
    assert detectar_patron(estado, "ImprecisiΓ³n") == "error_en_final"


def test_hallazgo():
    estado = construir([(200, "Brillante", 10)])
    assert detectar_patron(estado, "Brillante") == "hallazgo"


def test_solidez():
    estado = construir(_jugadas([-2, -3, -1, -4]))
    assert detectar_patron(estado, "Buena") == "solidez"


def test_misma_jugada_distinto_historial_distinto_comentario():
    """El nΓΊcleo del aporte: mismo cp actual, comentario distinto segΓΊn la secuencia."""
    move = _move("white", 9, -80)
    hist_deterioro = [_move("white", i + 1, d) for i, d in enumerate([-5, -20, -50])]
    hist_estable = [_move("white", i + 1, d) for i, d in enumerate([-2, -3, -1])]
    c1 = comentar(move, "Error", hist_deterioro)
    c2 = comentar(move, "Error", hist_estable)
    assert c1["corto"] != c2["corto"], "El historial no influye en el comentario"


# ─── Capa de tablero (python-chess) ──────────────────────────────────────────

def test_tablero_estructura():
    sans = ["e4", "c5", "Nf3", "d6", "d4", "cxd4", "Nxd4", "Nf6"]
    f = tablero.features_tablero(sans, "white", 4)
    assert f is not None
    assert {"desarrollo", "enrocado", "rey_centro", "control_centro", "numero"} <= set(f)
    assert isinstance(f["desarrollo"], int)


def test_tablero_san_invalido_devuelve_none():
    assert tablero.features_tablero(["e4", "zz99"], "black", 1) is None


def test_tablero_enroque_detectado():
    sans = ["e4", "e5", "Nf3", "Nc6", "Bc4", "Bc5", "O-O"]   # enrocan las blancas
    f = tablero.features_tablero(sans, "white", 4)
    assert f["enrocado"] is True
    assert f["rey_centro"] is False


def test_tablero_rey_en_centro():
    sans = ["e4", "e5", "Bc4", "Bc5", "Qe2", "Qe7"]          # nadie enroca
    f = tablero.features_tablero(sans, "white", 3)
    assert f["enrocado"] is False
    assert f["rey_centro"] is True


def test_patron_posicional_rey_sin_enrocar():
    estado = construir([(-50, "ImprecisiΓ³n", 8)])
    feats = {"desarrollo": 3, "enrocado": False, "rey_centro": True,
             "control_centro": 2, "numero": 8}
    assert detectar_patron(estado, "ImprecisiΓ³n", feats) == "rey_sin_enrocar"


def test_patron_posicional_sin_desarrollo():
    estado = construir([(-50, "Error", 7)])
    feats = {"desarrollo": 0, "enrocado": True, "rey_centro": False,
             "control_centro": 3, "numero": 7}
    assert detectar_patron(estado, "Error", feats) == "sin_desarrollo"


def test_patron_avance_enroque():
    # Negro enroca corto y luego empuja g5 delante de su propio rey.
    sans = ["e4", "e5", "Nf3", "Nc6", "Bc4", "Bc5", "d3", "Nf6", "Nc3", "O-O", "h3", "h6", "a3", "g5"]
    f = tablero.features_tablero(sans, "black", 7)
    assert f is not None
    assert f["avance_enroque"] is True


def test_patron_caballo_borde():
    f = tablero.features_tablero(["e4", "Nh6"], "black", 1)
    assert f["caballo_borde"] is True


def test_patron_dama_temprano():
    f = tablero.features_tablero(["e4", "e5", "Qh5"], "white", 2)
    assert f["dama_fuera"] is True


def test_fallback_varia_por_tipo_de_jugada():
    # Una mala sin patrΓ³n fuerte debe dar comentarios DISTINTOS segΓΊn el SAN.
    base = lambda san: {
        "color": "white", "number": 12, "move": san, "diferencia_cp": -50,
        "mejor_jugada": "Xx",
    }
    captura = comentar(base("Rxe5"), "ImprecisiΓ³n", [])
    peon    = comentar(base("a3"),   "ImprecisiΓ³n", [])
    assert captura["corto"] != peon["corto"]


def test_patron_cp_sin_tablero_sigue_andando():
    # Sin features de tablero, debe caer a los patrones de cp (compatibilidad).
    estado = construir(_jugadas([-5, -20, -50, -80]))
    assert detectar_patron(estado, "Error") == "deterioro_sostenido"


# ─── Runner sin pytest ───────────────────────────────────────────────────────

if __name__ == "__main__":
    funcs = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
    fallos = 0
    for f in funcs:
        try:
            f()
            print(f"  OK   {f.__name__}")
        except AssertionError as e:
            fallos += 1
            print(f"  FAIL {f.__name__}: {e}")
    print(f"\n{len(funcs) - fallos}/{len(funcs)} tests pasaron.")
    sys.exit(1 if fallos else 0)