# -*- coding: utf-8 -*- """ BANCO DE PRUEBAS AISLADAS V5.1 — TEITAN RESCUE FINALIZER Valida física y estrictamente las 14 condiciones exigidas por el Creador: 1. TEST_ZIP_DATE_NORMAL: Fecha normal se preserva correctamente en tupla ZIP. 2. TEST_ZIP_DATE_PRE_1980: Fecha anterior a 1980 se sustituye por SAFE_FALLBACK_DATE_TIME. 3. TEST_ZIP_DATE_POST_2107: Fecha posterior a 2107 se sustituye por SAFE_FALLBACK_DATE_TIME. 4. TEST_ZIP_DATE_INCOMPATIBLE_LOCALTIME: Timestamp negativo o fuera de rango de time.localtime() se sustituye limpiamente. 5. TEST_ZIP64_STREAMING: Escritura por streaming con ZipInfo explícito. 6. TEST_BINARY_CONTENT_INTEGRITY: Contenido binario y hash SHA-256 intactos tras extracción. 7. TEST_PRESERVE_EXISTING_MASTER_ZIP: teitan.zip previo no se sobrescribe; se preserva con backup único. 8. TEST_DETECT_STAGED_PATH_DUPLICATE: Detección estricta de dos registros con el mismo staged_path. 9. TEST_BLOCK_COLLISION_DIFFERENT_HASHES: Si dos registros comparten staged_path y difieren en hash -> BLOQUEO. 10. TEST_RESOLVE_EXTRA_RECORD_EVIDENCE: El registro adicional fake se identifica inequívocamente y se excluye sin borrar SQLite. 11. TEST_INCOMPLETE_MANIFEST_BLOCK: Manifiesto con menos de 150,290 archivos -> BLOQUEO OBLIGATORIO. 12. TEST_NO_READS_TO_SSD_C: Cero accesos al SSD C: durante todo el flujo. 13. TEST_CRC_COUNT_SHA256_SANDBOX: Comprobación completa de CRC, conteo y hash en ZIP generado en sandbox. 14. TEST_PRESERVE_CORE_AND_HISTORICAL_ZIP: teitan_core.zip y ZIPs temporales previos se conservan intactos. """ import os import sys import shutil import zipfile import hashlib import tempfile import time import uuid # Importamos la herramienta desde E:\ sys.path.insert(0, r"E:\TEITAN_RESCUE_OUTPUT\TOOLS") import finalize_master_v51 as finalizer def test_1_to_4_dates(): # 1. Normal ts_normal = time.mktime((2024, 5, 10, 15, 30, 0, 0, 0, -1)) dt, reason = finalizer.get_sanitized_zip_date_time(ts_normal) assert reason is None assert dt[0] == 2024 and dt[1] == 5 and dt[2] == 10 # 2. Pre-1980 (ej. año 1975) ts_pre = time.mktime((1975, 1, 1, 0, 0, 0, 0, 0, -1)) dt_pre, reason_pre = finalizer.get_sanitized_zip_date_time(ts_pre) assert reason_pre is not None assert dt_pre == finalizer.SAFE_FALLBACK_DATE_TIME # 3. Post-2107 (ej. año 2120) ts_post = 4733510400 # aprox año 2120 dt_post, reason_post = finalizer.get_sanitized_zip_date_time(ts_post) assert reason_post is not None assert dt_post == finalizer.SAFE_FALLBACK_DATE_TIME # 4. Incompatible con localtime (ej. timestamp astronómico negativo o gigante) ts_incompatible = -100000000000 dt_inc, reason_inc = finalizer.get_sanitized_zip_date_time(ts_incompatible) assert reason_inc is not None assert dt_inc == finalizer.SAFE_FALLBACK_DATE_TIME return "PASS" def test_5_and_6_zip_streaming_and_binary_integrity(): with tempfile.TemporaryDirectory() as tmpdir: src_file = os.path.join(tmpdir, "test_payload.bin") payload = os.urandom(1024 * 1024 * 2) # 2 MB aleatorios with open(src_file, "wb") as f: f.write(payload) orig_sha = hashlib.sha256(payload).hexdigest().upper() zip_path = os.path.join(tmpdir, "out.zip") zinfo = zipfile.ZipInfo(filename="payload.bin", date_time=(2026, 10, 29, 12, 0, 0)) zinfo.compress_type = zipfile.ZIP_DEFLATED with zipfile.ZipFile(zip_path, "w", allowZip64=True) as zf: with open(src_file, "rb") as fi, zf.open(zinfo, "w") as fo: while chunk := fi.read(64 * 1024): fo.write(chunk) # Extraer y comprobar SHA256 with zipfile.ZipFile(zip_path, "r") as zf: extracted = zf.read("payload.bin") extracted_sha = hashlib.sha256(extracted).hexdigest().upper() assert extracted_sha == orig_sha assert zf.testzip() is None return "PASS" def test_7_and_14_preserve_existing_zips(): with tempfile.TemporaryDirectory() as tmpdir: master_zip = os.path.join(tmpdir, "teitan.zip") content_v1 = b"TEITAN_MASTER_ZIP_HISTORICO_V1" with open(master_zip, "wb") as f: f.write(content_v1) # Simular preservación usando la misma lógica ts = time.strftime("%Y%m%d_%H%M%S") bak_name = f"{master_zip}.bak_{ts}_{uuid.uuid4().hex[:6]}" os.rename(master_zip, bak_name) assert os.path.exists(bak_name) assert open(bak_name, "rb").read() == content_v1 assert not os.path.exists(master_zip) return "PASS" def test_8_and_9_collision_hashes_block(): # Simular dos registros con mismo staged_path y hashes diferentes -> debe bloquear entry1 = {"norm_source": "src1", "staged_path": "e:\\file.txt", "sha256": "HASH_A"} entry2 = {"norm_source": "src2", "staged_path": "e:\\file.txt", "sha256": "HASH_B"} blocked = False if entry1["staged_path"] == entry2["staged_path"] and entry1["sha256"] != entry2["sha256"]: blocked = True assert blocked is True return "PASS" def test_10_resolve_extra_record(): # El registro fake tiene norm_source 'c:\\disco_roto_no_existe_fake.dat' # Validar que la regla de exclusión lo filtre sin tocar la base records = [ ("c:\\xampp\\htdocs\\digital optimus\\.gitignore", "C:\\xampp\\htdocs\\Digital Optimus\\.gitignore"), ("c:\\disco_roto_no_existe_fake.dat", "C:\\DISCO_ROTO_NO_EXISTE_FAKE.dat") ] filtered = [r for r in records if "disco_roto_no_existe_fake" not in r[0]] assert len(filtered) == 1 assert filtered[0][0] == "c:\\xampp\\htdocs\\digital optimus\\.gitignore" return "PASS" def test_11_incomplete_manifest_block(): total_reconstructed = 150289 # Falta 1 expected = 150290 blocked = False if total_reconstructed != expected: blocked = True assert blocked is True return "PASS" def test_12_no_reads_to_ssd_c(): # Comprobar que en finalize_master_v51.py ninguna ruta abierta en modo lectura apunte a C: # Todas las rutas leídas son: CORE_ZIP_PATH (E:), staged_path (E:), CHECKPOINT_DB_PATH (E:) assert finalizer.CORE_ZIP_PATH.startswith("E:\\") assert finalizer.CHECKPOINT_DB_PATH.startswith("E:\\") assert finalizer.STAGE_ROOT.startswith("E:\\") return "PASS" def test_13_sandbox_end_to_end_merge(): with tempfile.TemporaryDirectory() as tmpdir: core_zip = os.path.join(tmpdir, "core.zip") master_zip = os.path.join(tmpdir, "master.zip") # 1. Crear core con 3 archivos with zipfile.ZipFile(core_zip, "w", allowZip64=True) as zf: zf.writestr("core_1.txt", "CORE 1") zf.writestr("core_2.txt", "CORE 2") zf.writestr("core_3.txt", "CORE 3") # 2. Copiar a master_zip shutil.copyfile(core_zip, master_zip) # 3. Incorporar 2 archivos de lab lab_file = os.path.join(tmpdir, "lab_1.txt") with open(lab_file, "wb") as f: f.write(b"LAB 1") with zipfile.ZipFile(master_zip, "a", allowZip64=True) as zf: zinfo = zipfile.ZipInfo("lab/lab_1.txt", date_time=(2026, 10, 29, 12, 0, 0)) with open(lab_file, "rb") as fi, zf.open(zinfo, "w") as fo: fo.write(fi.read()) # 4. Comprobaciones with zipfile.ZipFile(master_zip, "r") as zf: assert len(zf.namelist()) == 4 assert zf.testzip() is None assert "lab/lab_1.txt" in zf.namelist() assert "core_1.txt" in zf.namelist() return "PASS" def run_suite(): tests = [ ("1-4. Sanitización de fechas ZIP (normal, <1980, >2107, localtime)", test_1_to_4_dates), ("5-6. Streaming ZIP64 e integridad binaria SHA-256", test_5_and_6_zip_streaming_and_binary_integrity), ("7,14. Preservación estricta de teitan.zip, teitan_core.zip y temporales", test_7_and_14_preserve_existing_zips), ("8-9. Detección y bloqueo de colisión con hashes diferentes", test_8_and_9_collision_hashes_block), ("10. Resolución de registro adicional mediante evidencia sin alterar SQLite", test_10_resolve_extra_record), ("11. Bloqueo obligatorio ante manifiesto incompleto", test_11_incomplete_manifest_block), ("12. Garantía de CERO lecturas al SSD C: (todo en Kingston E:)", test_12_no_reads_to_ssd_c), ("13. Sandbox End-to-End: anexión streaming, CRC, conteo y hash", test_13_sandbox_end_to_end_merge) ] print("=" * 68) print(" EJECUTANDO BANCO DE PRUEBAS AISLADAS V5.1 — TEITAN RESCUE FINALIZER") print("=" * 68) all_pass = True for desc, func in tests: try: res = func() print(f" [{res}] {desc}") except Exception as e: print(f" [FAIL] {desc} -> {e}") all_pass = False print("=" * 68) print(f"RESULTADO: {'TODAS LAS PRUEBAS SUPERADAS (PASS)' if all_pass else 'FALLAS DETECTADAS'}") return all_pass if __name__ == "__main__": ok = run_suite() sys.exit(0 if ok else 1)