totelegram 0.1.0__py3-none-any.whl

tests_real/base.py

@@ -0,0 +1,311 @@
+import hashlib
+import json
+import logging
+import os
+import shutil
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from typing import cast
+
+import peewee
+from pyrogram.client import Client
+from pyrogram.errors import RPCError
+from pyrogram.types import Chat, Message, User
+from rich.panel import Panel
+
+from totelegram.cli.ui import console
+from totelegram.concurrency import LOCK_ROOT_TAG, ConcurrencyCoordinator
+from totelegram.database import DatabaseSession
+from totelegram.discovery import DiscoveryService
+from totelegram.engine.events import UploadObserver
+from totelegram.identity import Settings, SettingsManager
+from totelegram.models import TelegramChat, TelegramUser
+from totelegram.telegram.client import TelegramSession
+from totelegram.types import UploadSession
+
+logger = logging.getLogger(__name__)
+
+TEST_WORKSPACE = Path.home() / ".config" / "toTelegram_test"
+TEST_PROFILE_NAME = "test_runner"
+
+
+class RealTelegramTestCase(unittest.TestCase):
+    """
+    TestCase base que encapsula la sesión real de Telegram y la base de datos de prueba.
+    """
+
+    manager: SettingsManager
+    settings: Settings
+    client: Client
+    db_session: DatabaseSession
+    db: peewee.Database
+    tg_chat: Chat
+    owner: TelegramUser
+    test_chat_id: int
+
+    @classmethod
+    def _skip_with_panel(cls, reason: str, details: str, command: str | None = None):
+        """Muestra un panel visual explicativo antes de registrar el SkipTest en unittest."""
+        lines = [f"[yellow]{reason}[/yellow]\n", f"[dim]{details}[/dim]"]
+        if command:
+            lines.append("\nEjecuta el siguiente comando para aprovisionar el entorno:")
+            lines.append(f"  [bold cyan]> {command}[/bold cyan]")
+
+        panel = Panel(
+            "\n".join(lines),
+            title="[bold yellow]TESTS REALES OMITIDOS (ENTORNO PENDIENTE)[/bold yellow]",
+            border_style="yellow",
+            padding=(1, 2),
+        )
+        console.print()
+        console.print(panel)
+        console.print()
+        raise unittest.SkipTest(reason)
+
+    @classmethod
+    def setUpClass(cls):
+        """Inicializa la sesión real de Telegram y la base de datos aislada."""
+        # Comprobar si el workspace existe
+        if not TEST_WORKSPACE.exists():
+            cls._skip_with_panel(
+                reason=f"Entorno de pruebas no configurado en: {TEST_WORKSPACE}",
+                details="Estos tests realizan transferencias reales y requieren una sesión y canal dedicados.",
+                command="python3 tests_real/setup_test_env.py",
+            )
+
+        cls.manager = SettingsManager(TEST_WORKSPACE)
+        profile = cls.manager.get_profile(TEST_PROFILE_NAME)
+
+        # Comprobar si el perfil está completo
+        if not profile or not profile.is_trinity:
+            cls._skip_with_panel(
+                reason=f"El perfil '{TEST_PROFILE_NAME}' no existe o está incompleto en {TEST_WORKSPACE}.",
+                details="Falta el archivo de sesión .session o la configuración .json.",
+                command="python3 tests_real/setup_test_env.py",
+            )
+
+        cls.settings = cls.manager.get_settings(TEST_PROFILE_NAME)
+
+        # Iniciar cliente Pyrogram
+        try:
+            cls._tg_session_ctx = TelegramSession(
+                session_name=TEST_PROFILE_NAME,
+                api_id=cls.settings.api_id,
+                api_hash=cls.settings.api_hash,
+                profiles_dir=cls.manager.profiles_dir,
+            )
+            cls.client = cls._tg_session_ctx.__enter__()
+        except Exception as e:
+            cls._skip_with_panel(
+                reason=f"No se pudo conectar a Telegram: {e}",
+                details="Verifica tu conexión a Internet o que la sesión no haya sido revocada.",
+                command="python3 tests_real/setup_test_env.py",
+            )
+
+        # Iniciar sesión de base de datos aislada
+        cls.db_session = DatabaseSession(
+            cls.manager.database_path, auto_init_schema=True
+        )
+        cls.db = cls.db_session.__enter__()
+
+        # Resolver chat de pruebas en orden de prioridad:
+        # 1. Archivo dedicado test_chat.json
+        # 2. Variable de entorno TOTELEGRAM_TEST_CHAT_ID o TOTELEGRAM_TARGET
+        # 3. Registro previo en la tabla TelegramChat de SQLite
+        test_chat_id = None
+        target_file = TEST_WORKSPACE / "test_chat.json"
+        if target_file.exists():
+            try:
+                data = json.loads(target_file.read_text(encoding="utf-8"))
+                test_chat_id = data.get("chat_id")
+            except Exception as e:
+                logger.debug(f"Aviso leyendo test_chat.json: {e}")
+
+        if not test_chat_id:
+            env_target = os.environ.get("TOTELEGRAM_TEST_CHAT_ID") or os.environ.get(
+                "TOTELEGRAM_TARGET"
+            )
+            if env_target:
+                try:
+                    test_chat_id = int(env_target)
+                except ValueError:
+                    pass
+
+        if not test_chat_id:
+            try:
+                assert TelegramChat.last_verified is not None
+                cached_chat = (
+                    TelegramChat.select()
+                    .where((TelegramChat.type == "channel") & (TelegramChat.id != 0))
+                    .order_by(TelegramChat.last_verified.desc())
+                    .first()
+                )
+                if cached_chat:
+                    test_chat_id = cached_chat.id
+            except Exception as e:
+                logger.debug(f"Aviso buscando chat en DB de pruebas: {e}")
+
+        if not test_chat_id:
+            cls.tearDownClass()
+            cls._skip_with_panel(
+                reason="No hay un chat_id de pruebas configurado.",
+                details="Se necesita un canal dedicado para verificar subidas.",
+                command="python3 tests_real/setup_test_env.py",
+            )
+
+        # Obtener información del usuario y del chat de pruebas
+        try:
+            cls.test_chat_id = int(test_chat_id)
+            cls.tg_chat = cast(Chat, cls.client.get_chat(cls.test_chat_id))
+            time.sleep(1)
+            me = cast(User, cls.client.get_me())
+            cls.owner = TelegramUser.get_or_create_from_tg(me)
+        except RPCError as e:
+            cls.tearDownClass()
+            cls._skip_with_panel(
+                reason=f"Error validando el chat o cuenta de pruebas en Telegram: {e}",
+                details="Asegúrate de que la cuenta tenga acceso al chat configurado.",
+                command="python3 tests_real/setup_test_env.py",
+            )
+
+    @classmethod
+    def tearDownClass(cls):
+        """Cierra de forma segura el cliente de Telegram y la base de datos."""
+        if hasattr(cls, "db_session"):
+            try:
+                cls.db_session.__exit__(None, None, None)
+            except Exception as e:
+                logger.debug(f"Aviso cerrando DB de test: {e}")
+
+        if hasattr(cls, "_tg_session_ctx"):
+            try:
+                cls._tg_session_ctx.__exit__(None, None, None)
+            except Exception as e:
+                logger.debug(f"Aviso cerrando cliente Telegram: {e}")
+
+    def setUp(self):
+        """Preparación antes de cada método de test."""
+        self.created_message_ids: list[int] = []
+        self._temp_dirs_to_clean: list[Path] = []
+
+        # Auto-sanación: Limpiar posibles locks residuales en 'me' de tests previos abortados
+        self._heal_dangling_account_locks()
+
+    def tearDown(self):
+        """
+        Limpieza post-test: Garantiza la política de 'Basura Cero'
+        eliminando todos los mensajes creados en Telegram y carpetas temporales.
+        """
+        # Eliminar mensajes subidos a Telegram
+        if self.created_message_ids:
+            try:
+                unique_ids = list(set(self.created_message_ids))
+                for i in range(0, len(unique_ids), 100):
+                    batch = unique_ids[i : i + 100]
+                    self.client.delete_messages(
+                        chat_id=self.test_chat_id,
+                        message_ids=batch,
+                    )
+                logger.debug(
+                    f"Eliminados {len(unique_ids)} mensajes de test en chat {self.test_chat_id}"
+                )
+            except Exception as e:
+                logger.warning(f"Aviso limpiando mensajes en tearDown: {e}")
+
+        # Limpiar directorios temporales en disco
+        for temp_dir in self._temp_dirs_to_clean:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+    # HELPERS DE RECOLECCIÓN Y GESTIÓN
+
+    def track_message(self, message_or_id: Message | int | None):
+        """Registra un mensaje para su eliminación automática en tearDown."""
+        if message_or_id is None:
+            return
+        if isinstance(message_or_id, int):
+            self.created_message_ids.append(message_or_id)
+        elif hasattr(message_or_id, "id"):
+            self.created_message_ids.append(message_or_id.id)
+
+    def track_messages(self, messages_or_ids: list[Message | int]):
+        """Registra una lista de mensajes para eliminación automática."""
+        for m in messages_or_ids:
+            self.track_message(m)
+
+    def _heal_dangling_account_locks(self):
+        """Elimina locks residuales en 'Mensajes Guardados' (me) para evitar falsos AccountBusyError."""
+        try:
+            query = f"{LOCK_ROOT_TAG} #acc_{self.owner.id}"
+            locks = list(self.client.search_messages("me", query=query, limit=5))
+            lock_ids = [m.id for m in locks if m and not getattr(m, "empty", False)]
+            if lock_ids:
+                self.client.delete_messages("me", lock_ids)
+                logger.debug(f"Auto-sanados {len(lock_ids)} locks residuales en 'me'.")
+        except Exception as e:
+            logger.debug(f"Aviso durante auto-sanación de locks: {e}")
+
+    # FACTORÍAS DE DATOS Y ENTORNO
+
+    def create_temp_dir(self) -> Path:
+        """Crea un directorio temporal que se auto-eliminará en tearDown."""
+        temp_dir = Path(tempfile.mkdtemp(prefix="totelegram_test_"))
+        self._temp_dirs_to_clean.append(temp_dir)
+        return temp_dir
+
+    def create_dummy_file(
+        self,
+        filename: str,
+        size_bytes: int,
+        parent_dir: Path | None = None,
+    ) -> Path:
+        """
+        Crea un archivo binario con contenido pseudoaleatorio determinista y tamaño exacto.
+        """
+        target_dir = parent_dir or self.create_temp_dir()
+        file_path = target_dir / filename
+
+        chunk_size = 64 * 1024
+        written = 0
+        with open(file_path, "wb") as f:
+            while written < size_bytes:
+                to_write = min(chunk_size, size_bytes - written)
+                f.write(os.urandom(to_write))
+                written += to_write
+
+        return file_path
+
+    @staticmethod
+    def calculate_md5(file_path: Path) -> str:
+        """Calcula el hash MD5 exacto de un archivo en disco."""
+        hasher = hashlib.md5()
+        with open(file_path, "rb") as f:
+            while chunk := f.read(64 * 1024):
+                hasher.update(chunk)
+        return hasher.hexdigest()
+
+    def build_upload_session(
+        self,
+        observer: UploadObserver | None = None,
+    ) -> UploadSession:
+        """Construye una instancia de UploadSession conectada al arnés de testing."""
+        coordinator = ConcurrencyCoordinator(
+            db=self.db,
+            node_id="test_runner_node",
+            client=self.client,
+        )
+        discovery = DiscoveryService(
+            client=self.client,
+            db=self.db,
+        )
+
+        return UploadSession(
+            client=self.client,
+            db=self.db,
+            tg_chat=self.tg_chat,
+            owner=self.owner,
+            settings=self.settings,
+            coordinator=coordinator,
+            discovery=discovery,
+        )

tests_real/setup_test_env.py

@@ -0,0 +1,337 @@
+"""
+Script para aprovisionar, actualizar el canal o limpiar el entorno de pruebas reales.
+Guarda la sesión y ajustes en: ~/.config/toTelegram_test/
+"""
+
+import argparse
+import json
+import shutil
+import sys
+import tempfile
+import uuid
+from pathlib import Path
+
+# Asegurar que el paquete totelegram sea importable desde la raíz del repositorio
+repo_root = Path(__file__).resolve().parent.parent.parent
+if str(repo_root) not in sys.path:
+    sys.path.insert(0, repo_root)
+
+from pyrogram.errors import RPCError
+
+from totelegram.cli.ui import UI, console
+from totelegram.database import DatabaseSession
+from totelegram.identity import (
+    DEFAULT_TG_API_HASH,
+    DEFAULT_TG_API_ID,
+    Settings,
+    SettingsManager,
+)
+from totelegram.telegram.access import ChatAccessService
+from totelegram.telegram.auth import AuthLogic
+from totelegram.telegram.client import TelegramSession
+from totelegram.telegram.resolver import TargetResolver
+from totelegram.telegram.types import TargetResolutionStatus
+
+TEST_WORKSPACE = Path.home() / ".config" / "toTelegram_test"
+TEST_PROFILE_NAME = "test_runner"
+TEST_TARGET_FILE = TEST_WORKSPACE / "test_chat.json"
+
+
+def clean_test_env():
+    """Cierra la sesión remotamente en los servidores de Telegram y elimina el workspace."""
+    console.print(
+        "\n[bold cyan]====================================================[/]"
+    )
+    console.print("[bold cyan]       Limpieza del Entorno de Pruebas              [/]")
+    console.print(
+        "[bold cyan]====================================================[/]\n"
+    )
+
+    if not TEST_WORKSPACE.exists():
+        console.print(
+            "[yellow]No existe un entorno de pruebas configurado en disco.[/]"
+        )
+        return
+
+    manager = SettingsManager(TEST_WORKSPACE)
+    profile = manager.get_profile(TEST_PROFILE_NAME)
+
+    if profile and profile.has_session:
+        with UI.loading("Revocando sesión remota en los servidores de Telegram..."):
+            try:
+                settings = manager.get_settings(TEST_PROFILE_NAME)
+                with TelegramSession(
+                    session_name=TEST_PROFILE_NAME,
+                    api_id=settings.api_id,
+                    api_hash=settings.api_hash,
+                    profiles_dir=manager.profiles_dir,
+                ) as client:
+                    client.log_out()
+                UI.success("Sesión remota invalidada exitosamente en Telegram.")
+            except RPCError as e:
+                console.print(f"[dim]Aviso al revocar sesión en Telegram: {e}[/dim]")
+            except Exception as e:
+                console.print(
+                    f"[dim]No se pudo revocar la sesión remota ({e}), procediendo con limpieza local...[/dim]"
+                )
+
+    with UI.loading(f"Eliminando workspace local en {TEST_WORKSPACE}..."):
+        shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)
+
+    UI.success("Entorno de pruebas eliminado por completo.\n")
+
+
+def update_test_channel(query: str | None = None):
+    """
+    Actualiza exclusivamente el canal de pruebas utilizando la sesión autenticada existente,
+    sin requerir volver a ingresar teléfono ni código OTP.
+    """
+    console.print(
+        "\n[bold cyan]====================================================[/]"
+    )
+    console.print("[bold cyan]    Actualización del Canal de Pruebas              [/]")
+    console.print(
+        "[bold cyan]====================================================[/]\n"
+    )
+
+    if not TEST_WORKSPACE.exists():
+        UI.error(
+            f"No existe un entorno de pruebas en '{TEST_WORKSPACE}'. "
+            "Debes realizar la configuración inicial primero."
+        )
+        sys.exit(1)
+
+    manager = SettingsManager(TEST_WORKSPACE)
+    profile = manager.get_profile(TEST_PROFILE_NAME)
+    if not profile or not profile.is_trinity:
+        UI.error(
+            "El perfil de pruebas no está autenticado. "
+            "Ejecuta 'python tests_real/setup_test_env.py' para iniciar sesión."
+        )
+        sys.exit(1)
+
+    settings = manager.get_settings(TEST_PROFILE_NAME)
+
+    with (
+        TelegramSession(
+            session_name=TEST_PROFILE_NAME,
+            api_id=settings.api_id,
+            api_hash=settings.api_hash,
+            profiles_dir=manager.profiles_dir,
+        ) as client,
+        DatabaseSession(manager.database_path, auto_init_schema=True) as db,
+    ):
+        resolver = TargetResolver(client, db)
+        access_service = ChatAccessService(client)
+
+        target_query = query
+        while True:
+            if not target_query:
+                target_query = console.input(
+                    "Nombre, @username o ID del nuevo canal de pruebas: "
+                ).strip()
+
+            if not target_query:
+                console.print("[red]Debes especificar un canal válido.[/]")
+                continue
+
+            with UI.loading(f"Verificando canal '{target_query}'..."):
+                resolution = resolver.resolve(target_query)
+
+            if (
+                resolution.status != TargetResolutionStatus.RESOLVED
+                or not resolution.chat_id
+            ):
+                UI.error(resolution.error_message or "No se pudo encontrar el canal.")
+                if resolution.hint:
+                    console.print(f"[dim]{resolution.hint}[/dim]")
+                target_query = None
+                continue
+
+            chat_id = resolution.chat_id
+
+            # Validar permisos de administrador y borrado (requerido para limpieza)
+            with UI.loading("Validando permisos de administrador..."):
+                access_report = access_service.verify_access(chat_id)
+
+            if not access_report.is_ready:
+                UI.error(f"Problema de acceso: {access_report.reason}")
+                if access_report.hint:
+                    console.print(f"[dim]{access_report.hint}[/dim]")
+                target_query = None
+                continue
+
+            can_delete = access_service.can_delete_messages(chat_id)
+            if not can_delete:
+                UI.warn(
+                    f"La cuenta tiene acceso a '{resolution.title}', pero [bold red]carece del permiso "
+                    f"'Eliminar mensajes' (can_delete_messages)[/].\n"
+                    "Otorga permisos de administrador a la cuenta en los ajustes del canal y presiona Enter para reintentar."
+                )
+                console.input("\nPresiona Enter tras otorgar los permisos de admin...")
+                target_query = None
+                continue
+
+            # Persistir canal en test_chat.json
+            TEST_TARGET_FILE.parent.mkdir(parents=True, exist_ok=True)
+            TEST_TARGET_FILE.write_text(
+                json.dumps(
+                    {
+                        "chat_id": chat_id,
+                        "title": resolution.title,
+                    },
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+
+            UI.separator()
+            UI.success(
+                f"Canal de pruebas actualizado a: [bold cyan]{resolution.title}[/] [dim]({chat_id})[/]"
+            )
+            console.print(f"[dim]Guardado en: {TEST_TARGET_FILE}[/dim]\n")
+            console.print("Ya puedes ejecutar las pruebas:")
+            console.print(
+                '  [bold yellow]python3 -m unittest discover -s tests_real -p "test_real_*.py" -v[/]\n'
+            )
+            break
+
+
+def setup_test_env():
+    """Flujo interactivo de aprovisionamiento de cuenta y canal de pruebas."""
+    console.print(
+        "\n[bold cyan]====================================================[/]"
+    )
+    console.print(
+        "[bold cyan]   Configuración del Entorno de Pruebas de toTelegram [/]"
+    )
+    console.print(
+        "[bold cyan]====================================================[/]\n"
+    )
+
+    console.print(
+        f"Este asistente configurará una sesión aislada en:\n"
+        f"[bold yellow]{TEST_WORKSPACE}[/]\n"
+    )
+
+    manager = SettingsManager(TEST_WORKSPACE)
+    existing_profile = manager.get_profile(TEST_PROFILE_NAME)
+
+    # Si ya existía una sesión válida, ofrecer cambiar solo el canal
+    if existing_profile and existing_profile.is_trinity:
+        console.print("[green]✔ Se detectó una sesión activa válida para pruebas.[/]")
+        console.print("\n¿Qué deseas hacer?")
+        console.print(
+            "  [1] [bold cyan]Actualizar solo el canal de pruebas[/] (Recomendado)"
+        )
+        console.print("  [2] Reconfigurar cuenta completa (nuevo login OTP)")
+        console.print("  [0] Salir")
+
+        opcion = console.input("\nElige una opción [1]: ").strip()
+        if opcion in ("", "1"):
+            update_test_channel()
+            return
+        elif opcion == "0":
+            console.print("[yellow]Operación cancelada.[/]")
+            return
+
+    # Credenciales de API
+    console.print("\n[bold green]1. Credenciales de Telegram[/]")
+    console.print(
+        "[dim]Presiona Enter para usar las credenciales compartidas por defecto.[/dim]"
+    )
+
+    api_id_raw = console.input(f"API ID [{DEFAULT_TG_API_ID}]: ").strip()
+    api_id = int(api_id_raw) if api_id_raw else DEFAULT_TG_API_ID
+
+    api_hash_raw = console.input("API HASH [default]: ").strip()
+    api_hash = api_hash_raw if api_hash_raw else DEFAULT_TG_API_HASH
+
+    has_custom_app = (api_id != DEFAULT_TG_API_ID) or (api_hash != DEFAULT_TG_API_HASH)
+
+    # Login Pyrogram (OTP)
+    console.print("\n[bold green]2. Autenticación con Telegram[/]")
+    console.print(
+        "[dim]Se solicitará tu número de teléfono y el código que recibirás en Telegram.[/dim]\n"
+    )
+
+    temp_session_name = f"temp_setup_{uuid.uuid4().hex[:8]}"
+    with tempfile.TemporaryDirectory() as temp_dir:
+        auth = AuthLogic(
+            session_name=temp_session_name,
+            api_id=api_id,
+            api_hash=api_hash,
+            workdir=Path(temp_dir),
+        )
+        try:
+            temp_session_path, account_id, first_name = auth.run_auth_flow()
+        except Exception as e:
+            UI.error(f"Fallo durante la autenticación: {e}")
+            sys.exit(1)
+
+        manager.profiles_dir.mkdir(parents=True, exist_ok=True)
+        final_session_path = manager.get_session_path(TEST_PROFILE_NAME)
+
+        if final_session_path.exists():
+            final_session_path.unlink()
+
+        temp_session_path.rename(final_session_path)
+
+    UI.success(
+        f"Sesión autenticada con éxito como: [bold]{first_name}[/] (ID: {account_id})"
+    )
+
+    # Guardar configuración base para testing
+    test_settings = Settings(
+        profile_name=TEST_PROFILE_NAME,
+        telegram_account_id=account_id,
+        api_id=api_id,
+        api_hash=api_hash,
+        has_custom_app=has_custom_app,
+        tg_max_size_normal=2 * 1024 * 1024,  # 2 MB simulados para pruebas rápidas
+        tg_max_size_premium=2 * 1024 * 1024,
+        upload_pause_range=[0, 0],
+        upload_limit_rate_kbps=0,
+        auto_truncate=True,
+    )
+    manager.save_settings(TEST_PROFILE_NAME, test_settings)
+    manager.set_profile_name_as_active(TEST_PROFILE_NAME)
+
+    # Paso 3: Selección de canal
+    update_test_channel()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Aprovisionamiento del entorno de pruebas reales de toTelegram"
+    )
+    parser.add_argument(
+        "-t",
+        "--target",
+        "--channel",
+        dest="target",
+        nargs="?",
+        const="",
+        help="Actualiza únicamente el canal de pruebas sin requerir login ni OTP.",
+    )
+    parser.add_argument(
+        "-c",
+        "--clean",
+        "--reset",
+        action="store_true",
+        help="Revoca la sesión remota y elimina el workspace de pruebas.",
+    )
+
+    args = parser.parse_args()
+
+    if args.clean:
+        clean_test_env()
+    elif args.target is not None:
+        target_value = args.target.strip() if args.target else None
+        update_test_channel(target_value)
+    else:
+        setup_test_env()
+
+
+if __name__ == "__main__":
+    main()