Spaces:
Paused
Paused
Download tests/test_deterministic.py from SamilG2/BACKEND-CheckScan: direct link, hf CLI and curl.
- Browser
- Download file 7.57 kB
-
https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/tests/test_deterministic.py
- Command line
-
hf download hf://spaces/SamilG2/BACKEND-CheckScan/tests/test_deterministic.py
-
curl -L -o test_deterministic.py https://huggingface.co/spaces/SamilG2/BACKEND-CheckScan/resolve/main/tests/test_deterministic.py
7.57 kB
| """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) | |