Programación Orientada a Objetos

# =====================================================
# excepciones.py
# Excepciones personalizadas para el sistema bancario
# =====================================================


class ErrorBancario(Exception):
    """
    Clase base para todas las excepciones del sistema bancario.
    Hereda de Exception (la clase base de todas las excepciones de Python).
    """
    pass


class SaldoInsuficienteError(ErrorBancario):
    """Se lanza cuando se intenta retirar más dinero del disponible."""

    def __init__(self, saldo_actual: float, monto_retirar: float):
        self.saldo_actual   = saldo_actual
        self.monto_retirar  = monto_retirar
        self.faltante       = monto_retirar - saldo_actual
        mensaje = (
            f"Saldo insuficiente: tienes ${saldo_actual:,.2f}, "
            f"intentas retirar ${monto_retirar:,.2f}. "
            f"Faltan ${self.faltante:,.2f}."
        )
        # Llama al constructor de Exception con el mensaje
        super().__init__(mensaje)


class MontoInvalidoError(ErrorBancario):
    """Se lanza cuando el monto es 0 o negativo."""

    def __init__(self, monto: float):
        mensaje = f"Monto inválido: ${monto:,.2f}. Debe ser mayor a 0."
        super().__init__(mensaje)


class CuentaCerradaError(ErrorBancario):
    """Se lanza cuando se opera sobre una cuenta cerrada."""

    def __init__(self, numero_cuenta: str):
        mensaje = f"La cuenta {numero_cuenta} está cerrada. No se pueden realizar operaciones."
        super().__init__(mensaje)

# =====================================================
# cuenta_bancaria.py
# Clase CuentaBancaria con manejo de excepciones
# =====================================================

from excepciones import (SaldoInsuficienteError,
                           MontoInvalidoError,
                           CuentaCerradaError)


class CuentaBancaria:
    """Cuenta bancaria con manejo robusto de errores."""

    def __init__(self, numero: str, titular: str, saldo_inicial: float = 0.0):
        if saldo_inicial < 0:
            # Lanzamos MontoInvalidoError si el saldo inicial es negativo
            raise MontoInvalidoError(saldo_inicial)

        self.__numero  = numero
        self.__titular = titular
        self.__saldo   = saldo_inicial
        self.__abierta = True
        self.__movimientos = []   # historial de movimientos

    # ─── Properties ───
    @property
    def saldo(self): return self.__saldo

    @property
    def numero(self): return self.__numero

    @property
    def titular(self): return self.__titular

    @property
    def esta_abierta(self): return self.__abierta

    # ─── Método de validación interna ───
    def _validar_cuenta_abierta(self):
        """Verifica si la cuenta está abierta. Si no, lanza excepción."""
        if not self.__abierta:
            raise CuentaCerradaError(self.__numero)

    def _validar_monto(self, monto: float):
        """Verifica que el monto sea positivo."""
        if monto <= 0:
            raise MontoInvalidoError(monto)

    # ─── Operaciones ───
    def depositar(self, monto: float) -> float:
        """
        Deposita dinero en la cuenta.
        Lanza MontoInvalidoError si el monto es <= 0.
        Lanza CuentaCerradaError si la cuenta está cerrada.
        Retorna el nuevo saldo.
        """
        self._validar_cuenta_abierta()
        self._validar_monto(monto)

        self.__saldo += monto
        self.__movimientos.append(f"+${monto:,.2f} (Depósito)")
        return self.__saldo

    def retirar(self, monto: float) -> float:
        """
        Retira dinero de la cuenta.
        Lanza MontoInvalidoError, CuentaCerradaError o SaldoInsuficienteError.
        Retorna el nuevo saldo.
        """
        self._validar_cuenta_abierta()
        self._validar_monto(monto)

        if monto > self.__saldo:
            raise SaldoInsuficienteError(self.__saldo, monto)

        self.__saldo -= monto
        self.__movimientos.append(f"-${monto:,.2f} (Retiro)")
        return self.__saldo

    def transferir(self, destino: 'CuentaBancaria', monto: float):
        """
        Transfiere dinero a otra cuenta.
        Usa try/except para capturar errores de retirar/depositar.
        """
        try:
            self.retirar(monto)       # puede lanzar excepción
            destino.depositar(monto)  # puede lanzar excepción
            self.__movimientos.append(f"→ Transferencia a {destino.numero}: ${monto:,.2f}")
            print(f"✅ Transferencia de ${monto:,.2f} realizada a cuenta {destino.numero}.")
        except SaldoInsuficienteError as e:
            print(f"❌ Transferencia fallida: {e}")
        except CuentaCerradaError as e:
            print(f"❌ Cuenta cerrada: {e}")

    def cerrar_cuenta(self):
        """Cierra la cuenta. Solo se puede hacer si el saldo es 0."""
        if self.__saldo != 0:
            raise ValueError(
                f"No se puede cerrar la cuenta con saldo ${self.__saldo:,.2f}. "
                "Retire todo el dinero primero."
            )
        self.__abierta = False
        print(f"🔒 Cuenta {self.__numero} cerrada.")

    def ver_estado(self):
        """Imprime el estado actual de la cuenta."""
        estado = "🟢 Abierta" if self.__abierta else "🔴 Cerrada"
        print(f"\n{'='*45}")
        print(f"  Cuenta:  {self.__numero}")
        print(f"  Titular: {self.__titular}")
        print(f"  Saldo:   ${self.__saldo:,.2f}")
        print(f"  Estado:  {estado}")
        print(f"  Últimos movimientos:")
        for mov in self.__movimientos[-5:]:
            print(f"    {mov}")
        print(f"{'='*45}")

from cuenta_bancaria import CuentaBancaria
from excepciones import SaldoInsuficienteError, MontoInvalidoError, CuentaCerradaError

if __name__ == "__main__":
    print("\n🏦 UTH BANK — Demostración de Excepciones")
    print("=" * 50)

    # Crear cuentas
    cuenta1 = CuentaBancaria("UTH-001", "Ana López", 5000.0)
    cuenta2 = CuentaBancaria("UTH-002", "Carlos Mendoza", 1200.0)

    # ── Depósito exitoso ──
    print("\n1. Depósito exitoso:")
    try:
        nuevo_saldo = cuenta1.depositar(2000.0)
        print(f"   ✅ Depósito exitoso. Saldo: ${nuevo_saldo:,.2f}")
    except MontoInvalidoError as e:
        print(f"   ❌ {e}")

    # ── Retiro con saldo insuficiente ──
    print("\n2. Retiro con saldo insuficiente:")
    try:
        cuenta2.retirar(5000.0)   # intenta retirar más de lo disponible
    except SaldoInsuficienteError as e:
        print(f"   ❌ {e}")
        print(f"   ℹ️ Faltan: ${e.faltante:,.2f}")

    # ── Monto inválido (negativo) ──
    print("\n3. Monto inválido:")
    try:
        cuenta1.depositar(-100)   # monto negativo
    except MontoInvalidoError as e:
        print(f"   ❌ {e}")

    # ── Transferencia ──
    print("\n4. Transferencia entre cuentas:")
    cuenta1.transferir(cuenta2, 1500.0)

    # ── Estado de las cuentas ──
    cuenta1.ver_estado()
    cuenta2.ver_estado()

# =====================================================
# test_cuenta.py
# Pruebas unitarias para CuentaBancaria
# =====================================================

import unittest
from cuenta_bancaria import CuentaBancaria
from excepciones import (SaldoInsuficienteError,
                           MontoInvalidoError,
                           CuentaCerradaError)


class TestCuentaBancaria(unittest.TestCase):
    """
    Clase de pruebas para CuentaBancaria.
    Hereda de unittest.TestCase para acceder a los métodos de aserción.
    """

    def setUp(self):
        """
        Se ejecuta automáticamente ANTES de cada prueba.
        Aquí preparamos el estado inicial para cada test.
        """
        self.cuenta_ana    = CuentaBancaria("UTH-001", "Ana López", 5000.0)
        self.cuenta_carlos = CuentaBancaria("UTH-002", "Carlos Mendoza", 1200.0)

    # ────── PRUEBAS DE DEPÓSITO ──────

    def test_deposito_exitoso(self):
        """Verifica que un depósito válido aumenta el saldo correctamente."""
        nuevo_saldo = self.cuenta_ana.depositar(1000.0)
        self.assertEqual(nuevo_saldo, 6000.0)   # saldo esperado = 5000 + 1000
        self.assertEqual(self.cuenta_ana.saldo, 6000.0)

    def test_deposito_monto_cero_lanza_error(self):
        """Depositar 0 debe lanzar MontoInvalidoError."""
        with self.assertRaises(MontoInvalidoError):
            self.cuenta_ana.depositar(0)

    def test_deposito_monto_negativo_lanza_error(self):
        """Depositar un monto negativo debe lanzar MontoInvalidoError."""
        with self.assertRaises(MontoInvalidoError):
            self.cuenta_ana.depositar(-500)

    # ────── PRUEBAS DE RETIRO ──────

    def test_retiro_exitoso(self):
        """Verifica que un retiro válido reduce el saldo correctamente."""
        nuevo_saldo = self.cuenta_ana.retirar(2000.0)
        self.assertEqual(nuevo_saldo, 3000.0)   # 5000 - 2000 = 3000

    def test_retiro_saldo_insuficiente(self):
        """Intentar retirar más del saldo debe lanzar SaldoInsuficienteError."""
        with self.assertRaises(SaldoInsuficienteError):
            self.cuenta_carlos.retirar(5000.0)  # Carlos tiene 1200, intenta 5000

    def test_retiro_exacto_del_saldo(self):
        """Retirar exactamente el saldo disponible debe funcionar."""
        nuevo_saldo = self.cuenta_carlos.retirar(1200.0)
        self.assertEqual(nuevo_saldo, 0.0)

    def test_saldo_insuficiente_datos_correctos(self):
        """Verifica que SaldoInsuficienteError contiene los datos correctos."""
        try:
            self.cuenta_carlos.retirar(2000.0)
            self.fail("Debería haber lanzado SaldoInsuficienteError")
        except SaldoInsuficienteError as e:
            self.assertEqual(e.saldo_actual, 1200.0)
            self.assertEqual(e.monto_retirar, 2000.0)
            self.assertEqual(e.faltante, 800.0)

    # ────── PRUEBAS DE CUENTA CERRADA ──────

    def test_operaciones_en_cuenta_cerrada(self):
        """Las operaciones en cuenta cerrada deben lanzar CuentaCerradaError."""
        # Primero retiramos todo para poder cerrar
        self.cuenta_carlos.retirar(1200.0)
        self.cuenta_carlos.cerrar_cuenta()

        with self.assertRaises(CuentaCerradaError):
            self.cuenta_carlos.depositar(100)

        with self.assertRaises(CuentaCerradaError):
            self.cuenta_carlos.retirar(50)

    def test_cerrar_cuenta_con_saldo_falla(self):
        """Cerrar una cuenta con saldo debe lanzar ValueError."""
        with assertRaises(ValueError):
            self.cuenta_ana.cerrar_cuenta()  # Ana tiene 5000, no puede cerrar

    # ────── PRUEBAS DE TRANSFERENCIA ──────

    def test_transferencia_exitosa(self):
        """Verifica que una transferencia válida mueve el dinero correctamente."""
        self.cuenta_ana.transferir(self.cuenta_carlos, 500.0)
        self.assertEqual(self.cuenta_ana.saldo, 4500.0)    # 5000 - 500
        self.assertEqual(self.cuenta_carlos.saldo, 1700.0)  # 1200 + 500

    # ────── OTRAS ASERCIONES ÚTILES ──────

    def test_cuenta_creada_con_datos_correctos(self):
        """Verifica los datos iniciales de la cuenta."""
        self.assertEqual(self.cuenta_ana.numero, "UTH-001")
        self.assertEqual(self.cuenta_ana.titular, "Ana López")
        self.assertEqual(self.cuenta_ana.saldo, 5000.0)
        self.assertTrue(self.cuenta_ana.esta_abierta)   # debe ser True

    def test_creacion_con_saldo_negativo_falla(self):
        """Crear cuenta con saldo negativo debe lanzar MontoInvalidoError."""
        with self.assertRaises(MontoInvalidoError):
            CuentaBancaria("UTH-999", "Error", -1000.0)


# Punto de entrada: ejecuta todas las pruebas
if __name__ == "__main__":
    unittest.main(verbosity=2)   # verbosity=2 muestra nombre de cada prueba

python -m unittest test_cuenta.py -v

# Archivos de Python compilados (caché)
__pycache__/
*.pyc
*.pyo

# Entorno virtual de Python
venv/
.venv/
env/

# Archivos de VS Code
.vscode/settings.json

# Archivos con contraseñas o configuración local
configuracion_local.py
*.env

# 1. Agrega GitHub como servidor remoto
git remote add origin https://github.com/TU_USUARIO/poo-uth-2026.git

# 2. Renombra la rama principal a 'main'
git branch -M main

# 3. Sube el código a GitHub
git push -u origin main

# Revisar el estado de tus archivos
git status

# Agregar todos los cambios al staging
git add .

# Crear un commit con descripción clara
git commit -m "feat: agregar pruebas para transferencia"

# Subir a GitHub
git push

# --- Otros comandos útiles ---

# Ver historial de commits
git log --oneline

# Deshacer cambios no guardados en un archivo
git restore nombre_archivo.py

# Ver diferencias entre versión actual y último commit
git diff

# 1. Crear carpeta y abrir en VS Code
mkdir Unidad4
cd Unidad4

# 2. Inicializar repositorio Git
git init
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"

# 3. Crea los archivos: excepciones.py, cuenta_bancaria.py,
#    demo_banco.py, test_cuenta.py, .gitignore
# (escribir el código de cada archivo)

# 4. Probar la demo
python demo_banco.py

# 5. Ejecutar las pruebas unitarias
python -m unittest test_cuenta.py -v

# 6. Si todas pasan, hacer commit
git add .
git commit -m "feat: sistema bancario con excepciones y pruebas unitarias"

# 7. Subir a GitHub
git remote add origin https://github.com/TU_USUARIO/poo-uth-2026.git
git branch -M main
git push -u origin main