Control de pruebas unitarias con unittest.skip en Python

Me ayudé un poco de ChatGPT para hacer la solicitud de la API, porque nunca había consumido una. Estuve buscando API's que dieran el tipo de cambio y me encontré con que el Banco de México tiene una. Con base en ella realicé la prueba. Se generó una función para conseguir el tipo de cambio y otra para definir si la API está disponible. ```python # ----- Código de las funciones ----- import requests #Permite hacer solicitudes HTTP # Se utiliza la API del Banco de México para hacer el cambio de moneda. # Con la siguiente función se obtiene desde la API de Banxico el tipo de cambio: def get_exchange_rate(api): url = f'https://www.banxico.org.mx/SieAPIRest/service/v1/series/SF63528/datos/oportuno?token={api}' response = requests.get(url) if response.status_code == 200: data = response.json() return float(data['bmx']['series'][0]['datos'][0]['dato']) else: print('Error to obtain exchange rate:', response.status_code) return None # Con la siguiente función se verifica si la API está dispoible: def is_api_available(api): url = f'https://www.banxico.org.mx/SieAPIRest/service/v1/series/SF63528/datos/oportuno?token={api}' response = requests.get(url) return response.status_code == 200 # Aquí comienza el código para solucionar los retos de la clase class BankAccount: def __init__(self, balance=0, log_file=None): self.balance = balance self.log_file = log_file self._log_transaction('Cuenta creada') def _log_transaction(self, message): if self.log_file: with open(self.log_file, "a") as f: f.write(f"{message}\n") def deposit(self, amount): if amount > 0: self.balance += amount self._log_transaction(f"Deposited {amount}. New balance: {self.balance}.") return self.balance def withdraw(self, amount): if amount > 0: self.balance -= amount self._log_transaction(f"Withdrew {amount}. New balance: {self.balance}.") return self.balance def get_balance(self): self._log_transaction(f"Checked balance. Current balance {self.balance}.") return self.balance def transfer(self, amount): if self.balance >= amount: self.balance = self.balance - amount self._log_transaction(f"Transfered {amount}. New balance: {self.balance}.") else: self._log_transaction(f"Not transfered {amount}. Insufficient founds: {self.balance}") print("Fondos insuficientes.") return self.balance # Adicional a lo trabajado en las clases anteriores, con la siguiente función podremos convertir a USD: def convert_to_usd(self, api): exchange_rate = get_exchange_rate(api) if exchange_rate: return self.balance / exchange_rate else: return None # ----- Código de las pruebas ----- import unittest import os from src.bank_account import BankAccount from src.bank_account import is_api_available # Se importa función que se agregó fuera de la clse from unittest.mock import patch class BankAccountTests(unittest.TestCase): # Con setUp lo que se hace es definir desde el inicio los valores que tendrán las funciones. # Es una manera de evitar escribir los valores iniciales desde el inicio, en este caso,todas las variables iniciarán con $1,000 # def setUp(self) -> None: self.account = BankAccount(balance=1000, log_file="transaction_log.txt") # Aquí se define la API key: self.api = 'e3980208bf01ec653aba9aee3c2d6f70f6ae8b066d2545e379b9e0ef92e9de25' def tearDown(self) -> None: if os.path.exists(self.account.log_file): os.remove(self.account.log_file) def _count_lines(self, filename): with open(filename, "r") as f: return len(f.readlines()) def test_deposit(self): new_balance = self.account.deposit(500) self.assertEqual(new_balance, 1500, "El balance no es igual") def test_withdraw(self): new_balance = self.account.withdraw(200) self.assertEqual(new_balance, 800, "El balance no es igual") def test_get_balance(self): self.assertEqual(self.account.get_balance(), 1000, "El balance no es igual") def test_transfer(self): new_balance = self.account.transfer(200) self.assertEqual(new_balance, 800, "El balance no es igual") def test_transaction_log(self): new_balance = self.account.deposit(500) self.assertTrue(os.path.exists("transaction_log.txt")) def test_count_transactions(self): assert self._count_lines(self.account.log_file) == 1 self.account.deposit(500) assert self._count_lines(self.account.log_file) == 2 # Se agrega conversión a USD, condicionada a disponibilidad de API # Se utiliza skipUnless en caso de que la API no esté disponible. @unittest.skipUnless(is_api_available('e3980208bf01ec653aba9aee3c2d6f70f6ae8b066d2545e379b9e0ef92e9de25'), 'API no disponible') @patch('src.bank_account.get_exchange_rate') def test_convert_to_usd(self, mock_get_exchange_rate): mock_get_exchange_rate.return_value = 20 # Ejemplo de tipo de cambio usd_balance = self.account.convert_to_usd(self.api) assert usd_balance == 50 # 1000/20 = 50 ```


El reto: Lo que hice fue instalar decouple y usar config, cree un archivo .env para evitar que la secret key termine en el repo remoto y use el request de toda la vida con un get. Además de lo anterior use una variable available que cambia a True si la api esta disponible junto con skipUnless con el mensaje "La API no está disponible para pruebas". skipUnless = <https://www.pythontutorial.net/python-unit-testing/python-unittest-skip-test/> @unittest.skipUnless(condition, reason) ```python import unittest from decouple import config import requests SERVER = "server_b" API_KEY = config('SECRET_KEY') URL = f'https://v6.exchangerate-api.com/v6/{API_KEY}/latest/USD' response = requests.get(URL) available = False if response.status_code == 200: data = response.json() print(data) available = True else: print(f'Error {response.status_code}: {response.text}') class AllAssertsTest(unittest.TestCase): def test_assert_equal(self): self.assertEqual(10, 10) self.assertEqual("Hola", "Hola") def test_assert_true_or_false(self): self.assertTrue(True) self.assertTrue(True) def test_assert_raises(self): with self.assertRaises(ValueError): int("no soy un número") def test_assert_in(self): self.assertIn(10, [2, 4, 5, 10]) self.assertNotIn(5, [2, 4, 10]) def test_assert_dicts(self): user = {"name": "jesus", "last_name": "vergara"} self.assertDictEqual( {"name": "jesus", "last_name": "vergara"}, user ) self.assertSetEqual( {1, 2, 3}, {1, 2, 3} ) @unittest.skip("Trabajo en progreso, se habilitará nuevamente!") def test_skip(self): self.assertEqual("hola", "chao") @unittest.skipIf(SERVER == "server_b", "Saltado porque no estamos en el servidor a") def test_skip_if(self): self.assertEqual(100, 100) @unittest.expectedFailure def test_expected_failure(self): self.assertEqual(100, 150) @unittest.skipUnless(available, "La API no está disponible para pruebas") def test_api_response(self): self.assertTrue(available, "La API debería estar disponible") if available: print("La API está disponible.") ```import unittestfrom decouple import configimport requests SERVER = "server\_b"API\_KEY = config('SECRET\_KEY') URL = f'https://v6.exchangerate-api.com/v6/{API\_KEY}/latest/USD' response = requests.get(URL)available = Falseif response.status\_code == 200: data = response.json() print(data) available = Trueelse: print(f'Error {response.status\_code}: {response.text}') class AllAssertsTest(unittest.TestCase): def test\_assert\_equal(self): self.assertEqual(10, 10) self.assertEqual("Hola", "Hola") def test\_assert\_true\_or\_false(self): self.assertTrue(True) self.assertTrue(True) def test\_assert\_raises(self): with self.assertRaises(ValueError): int("no soy un número") def test\_assert\_in(self): self.assertIn(10, \[2, 4, 5, 10]) self.assertNotIn(5, \[2, 4, 10]) def test\_assert\_dicts(self): user = {"name": "jesus", "last\_name": "vergara"} self.assertDictEqual( {"name": "jesus", "last\_name": "vergara"}, user ) self.assertSetEqual( {1, 2, 3}, {1, 2, 3} ) @unittest.skip("Trabajo en progreso, se habilitará nuevamente!") def test\_skip(self): self.assertEqual("hola", "chao") @unittest.skipIf(SERVER == "server\_b", "Saltado porque no estamos en el servidor a") def test\_skip\_if(self): self.assertEqual(100, 100) @unittest.expectedFailure def test\_expected\_failure(self): self.assertEqual(100, 150) @unittest.skipUnless(available, "La API no está disponible para pruebas") def test\_api\_response(self): self.assertTrue(available, "La API debería estar disponible") if available: print("La API está disponible.")

Yo intenté solucionar el reto de la manera más simple posible. 1. Cree una API alojada en el local host con un diccionario que contiene un currency del dólar fijo, llamada currency\_web.py: 2. Luego, creé otro archivo dentro del módulo de 'src', llamado 'get\_currency.py', en el cual intento extraer el valor del currency 'USD' de la API creada anteriormente. Sin embargo, he usado las sentencias 'try' y 'except' para capturar el error de forma adecuada en caso de que la API no esté corriendo(por razones de seguridad no he puesto mi ip loca, cada quien debe tener la suya) 3. Finalmente usé el decorador 'skipUnless' en el módulo de 'test\_all\_asserts.py'. PRimero establecí la variable USD como el valor que me retorna la función del módulo de 'get\_currency', y dentro de los parámetros de 'skipUnless' simplemente coloqué debe hacerse la excepción a menos que USD sea un número, es decir, que la API esté corriendo de forma exitosa.

Solución al reto: Ya que era requerido llamar un API, encontré qué [APILayer - Best API Marketplace | Reliable, Scalable APIs | APILayer](https://apilayer.com/marketplace/) tiene un gran repertorio de APIs entre las cuales están para obtener diferentes currencies. Entonces, después del registro me dieron una *api key* que guardé en un archivo <u>.env</u>, para luego inicializarla en la clase  Luego, implementé un método que me permitiera conocer si la *API* está funcionando.  Para que entonces, podamos llamar el método en nuestros tests que requieran las funcionalidades de la *API*. Por lo tanto, usando el decorador **skipUnless** podemos validar que si la *API* está funcionando, entonces ejecute la prueba, de lo contrario, que muestre el mensaje de error.  Si algún aspecto de la explicación no quedó claro, lo pueden dejar saber : D

Sigo haciendo la comparativa usando `pytest`: ```python # saltar pruebas @pytest.mark.skip def test_deposit_skip(): # Esta prueba será omitida result = 1000 + 250 assert result == 1250 import sys @pytest.mark.skipif(sys.platform == "win32", reason="No se ejecuta en Windows") def test_withdra_skip(): # Esta prueba solo se ejecutará en plataformas que no sean Windows result = 1000 - 250 assert result == 750 ```