From 047bb0201e44126f4afed9b76ea2db6143dffcb0 Mon Sep 17 00:00:00 2001 From: Juan Manuel Date: Tue, 4 Jun 2024 17:28:54 -0300 Subject: [PATCH 1/4] =?UTF-8?q?Documente=20los=20metodos=20p=C3=BAblicos?= =?UTF-8?q?=20de=20models.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/models.py | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/app/models.py b/app/models.py index 6877fdd3..533c3003 100644 --- a/app/models.py +++ b/app/models.py @@ -4,6 +4,9 @@ def validate_client(data): + """ + Esta función valida los datos del cliente. + """ errors = {} name = data.get("name", "") @@ -31,10 +34,16 @@ class Client(models.Model): address = models.CharField(max_length=100, blank=True) def __str__(self): + """ + Devuelve la representación de cadena de cliente. + """ return self.name @classmethod def save_client(cls, client_data): + """ + Esta función guarda el cliente. + """ errors = validate_client(client_data) if len(errors.keys()) > 0: @@ -50,6 +59,9 @@ def save_client(cls, client_data): return True, None def update_client(self, client_data): + """ + Esta función actualiza el cliente. + """ self.name = client_data.get("name", "") or self.name self.email = client_data.get("email", "") or self.email self.phone = client_data.get("phone", "") or self.phone @@ -58,6 +70,9 @@ def update_client(self, client_data): self.save() def validate_provider(data): + """ + Esta función valida los datos del proovedor. + """ errors = {} name = data.get("name", "") @@ -84,10 +99,16 @@ class Provider(models.Model): address = models.CharField(max_length=100) def __str__(self): + """ + Devuelve la representación de cadena de proovedor. + """ return self.name @classmethod def save_provider(cls, provider_data): + """ + Esta función guarda el proveedor en la base de datos. + """ errors = validate_provider(provider_data) if len(errors.keys()) > 0: @@ -102,6 +123,9 @@ def save_provider(cls, provider_data): return True, None def update_provider(self, provider_data): + """ + Esta función actualiza el proveedor. + """ errors = validate_provider(provider_data) if len(errors) > 0: @@ -117,6 +141,9 @@ def update_provider(self, provider_data): def validate_product(data): + """ + Esta función valida los datos del producto. + """ errors = {} name = data.get("name", "") @@ -149,10 +176,16 @@ class Product(models.Model): price = models.DecimalField(max_digits=10, decimal_places=2) def __str__(self): + """ + Devuelve la representación de cadena de producto. + """ return self.name @classmethod def save_product(cls, product_data): + """ + Esta función guarda el producto en la base de datos. + """ errors = validate_product(product_data) if len(errors.keys()) > 0: @@ -168,6 +201,9 @@ def save_product(cls, product_data): def update_product(self, product_data): + """ + Esta función actualiza el producto. + """ errors = validate_product(product_data) @@ -182,6 +218,9 @@ def update_product(self, product_data): return True, None def validate_pet(data): + """ + Esta función valida los datos de mascota. + """ errors = {} name = data.get("name", "") @@ -225,10 +264,16 @@ class Pet(models.Model): weight = models.FloatField() def __str__(self): + """ + Devuelve la representación de cadena de mascota. + """ return self.name @classmethod def save_pet(cls, pet_data): + """ + Esta función guarda la mascota en la base de datos. + """ errors = validate_pet(pet_data) if len(errors.keys()) > 0: @@ -244,6 +289,9 @@ def save_pet(cls, pet_data): return True, None def update_pet(self, pet_data): + """ + Esta función actualiza los datos de mascota. + """ errors = validate_pet(pet_data) if len(errors.keys()) > 0: print("Retorno false") @@ -263,6 +311,9 @@ def update_pet(self, pet_data): return True, None def validate_veterinary(data): + """ + Esta función valida los datos del veterinario. + """ errors = {} name = data.get("name", "") @@ -291,10 +342,16 @@ class Veterinary(models.Model): def __str__(self): + """ + Devuelve la representación de cadena de veterinario. + """ return self.name @classmethod def save_veterinary(cls, veterinary_data): + """ + Esta función guarda los datos de veterinario. + """ errors = validate_veterinary(veterinary_data) if len(errors.keys()) > 0: @@ -310,6 +367,9 @@ def save_veterinary(cls, veterinary_data): return True, None def update_veterinary(self, veterinary_data): + """ + Esta función actualiza los datos de veterinario. + """ self.name = veterinary_data.get("name", "") or self.name self.email = veterinary_data.get("email", "") or self.email self.phone = veterinary_data.get("phone", "") or self.phone @@ -318,6 +378,9 @@ def update_veterinary(self, veterinary_data): def validate_medicine(data): + """ + Esta función valida los datos de medicina. + """ errors = {} name = data.get("name", "") @@ -346,10 +409,16 @@ class Medicine(models.Model): dose = models.IntegerField() def __str__(self): + """ + Devuelve la representación de cadena de medicina. + """ return self.name @classmethod def save_medicine(cls, medicine_data): + """ + Esta función guarda los datos de medicina. + """ errors = validate_medicine(medicine_data) if len(errors.keys()) > 0: @@ -363,6 +432,9 @@ def save_medicine(cls, medicine_data): return True, None def update_medicine(self, medicine_data): + """ + Esta función actualiza los datos de medicina. + """ errors = validate_medicine(medicine_data) if len(errors) > 0: From 399915fdcf8cd1f5cba57c5791b837b5b9347c94 Mon Sep 17 00:00:00 2001 From: Juan Manuel Date: Tue, 4 Jun 2024 17:29:32 -0300 Subject: [PATCH 2/4] =?UTF-8?q?Documente=20los=20metodos=20p=C3=BAblicos?= =?UTF-8?q?=20del=20test=20de=20integraci=C3=B3n.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/tests_integration.py | 82 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) diff --git a/app/tests_integration.py b/app/tests_integration.py index a15ce08b..b5acc761 100644 --- a/app/tests_integration.py +++ b/app/tests_integration.py @@ -9,24 +9,44 @@ class HomePageTest(TestCase): def test_use_home_template(self): + """ + Esta funcion testea que el template del home funcione. + """ response = self.client.get(reverse("home")) self.assertTemplateUsed(response, "home.html") - + """ + Esta función compara que el response y el home sean iguales. + """ class ClientsTest(TestCase): def test_repo_use_repo_template(self): + """ + Esta función testea que el template del repo funcione. + """ response = self.client.get(reverse("clients_repo")) self.assertTemplateUsed(response, "clients/repository.html") + """ + Esta función compara que el response y el repo sean iguales. + """ def test_repo_display_all_clients(self): + """ + Esta función muestra todos los clientes del repo. + """ response = self.client.get(reverse("clients_repo")) self.assertTemplateUsed(response, "clients/repository.html") def test_form_use_form_template(self): + """ + Esta función testea el formulario que utiliza una plantilla específica. + """ response = self.client.get(reverse("clients_form")) self.assertTemplateUsed(response, "clients/form.html") def test_can_create_client(self): + """ + Esta función verifica si se puede crear un cliente correctamente. + """ response = self.client.post( reverse("clients_form"), data={ @@ -47,6 +67,9 @@ def test_can_create_client(self): self.assertRedirects(response, reverse("clients_repo")) def test_validation_errors_create_client(self): + """ + Esta función testea la validacion de errores creados en cliente. + """ response = self.client.post( reverse("clients_form"), data={}, @@ -57,10 +80,16 @@ def test_validation_errors_create_client(self): self.assertContains(response, "Por favor ingrese un email") def test_should_response_with_404_status_if_client_doesnt_exists(self): + """ + Esta función testea que si el cliente no existe, se genera un error 404. + """ response = self.client.get(reverse("clients_edit", kwargs={"id": 100})) self.assertEqual(response.status_code, 404) def test_validation_invalid_email(self): + """ + Esta función testea la validación de emails invalidos. + """ response = self.client.post( reverse("clients_form"), data={ @@ -74,6 +103,9 @@ def test_validation_invalid_email(self): self.assertContains(response, "Por favor ingrese un email valido") def test_edit_user_with_valid_data(self): + """ + Esta función testea que se pueda editar el usuario datos validos. + """ client = Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -100,6 +132,9 @@ def test_edit_user_with_valid_data(self): class MedicineIntegrationTest(TestCase): def test_can_create_medicine(self): + """ + Esta función testea si pudo crear una medicina. + """ response = self.client.post( reverse("medicine_form"), data={ @@ -118,6 +153,9 @@ def test_can_create_medicine(self): self.assertRedirects(response, reverse("medicine_repo")) def test_validation_errors_create_medicine(self): + """ + Esta función testea la validacion de errores de medicinas creadas. + """ response = self.client.post( reverse("medicine_form"), data={}, @@ -128,6 +166,9 @@ def test_validation_errors_create_medicine(self): self.assertContains(response, "Por favor ingrese una dosis") def test_validation_valid_dose(self): + """ + Esta función testea la validación de dosis validas. + """ response = self.client.post( reverse("medicine_form"), data={ @@ -139,6 +180,9 @@ def test_validation_valid_dose(self): self.assertEqual(response.status_code, 302) # verificamos medicina creada tras la redireccion def test_validation_invalid_dose_is_greater_than_10(self): + """ + Esta función testea la validación de una dosis que debe ser menor o igual a 10. + """ response = self.client.post( reverse("medicine_form"), data={ @@ -150,6 +194,9 @@ def test_validation_invalid_dose_is_greater_than_10(self): self.assertContains(response, "La dosis debe estar en un rango de 1 a 10") def test_validation_invalid_dose_is_less_than_1(self): + """ + Esta función testea la validación de una dosis que debe ser mayor o igual a 1. + """ response = self.client.post( reverse("medicine_form"), data={ @@ -161,10 +208,16 @@ def test_validation_invalid_dose_is_less_than_1(self): self.assertContains(response, "La dosis debe estar en un rango de 1 a 10") class ProviderTest(TestCase): def test_repo_use_repo_template(self): + """ + Esta función verifica que un repositorio está utilizando una plantilla de repositorio específica. + """ response = self.client.get(reverse("provider_repo")) self.assertTemplateUsed(response, "providers/repository.html") def test_can_create_provider(self): + """ + Esta función prueba la creación de un proveedor en una aplicación. + """ response = self.client.post( reverse("provider_form"), data={ @@ -183,6 +236,9 @@ def test_can_create_provider(self): self.assertRedirects(response, reverse("provider_repo")) def test_validation_invalid_email(self): #Agrego una función ajena a la funcionalidad agregada para mayor calidad. + """ + Esta función verifica que el sistema maneje adecuadamente la validación de correos electrónicos inválidos. + """ response = self.client.post( reverse("provider_form"), data={ @@ -196,6 +252,9 @@ def test_validation_invalid_email(self): #Agrego una función ajena a la funcion def test_validation_address_null(self): #Agrego una función especifica del issue #La modificacion es que la direccion es obligatoria. Comprueba que al poner una direccion vacia devuelva el mensaje de error + """ + Esta función verifica que el sistema maneje adecuadamente la validación de direcciones nulas. + """ response = self.client.post( reverse("provider_form"), data={ @@ -213,6 +272,9 @@ def test_validation_address_null(self): #Agrego una función especifica del issu class PetsTest(TestCase): def test_create_pet_with_valid_weight(self): + """ + Esta función verifica que un sistema permita la creación de una mascota con un peso válido. + """ # Crear un mascota con peso válido response = self.client.post( reverse("pet_form"), @@ -239,6 +301,9 @@ def test_create_pet_with_valid_weight(self): def test_create_product_with_invalid_weight(self): # Intentar crear una mascota con precio negativo + """ + Esta función testea la creación de una mascota con un precio invalido. + """ response = self.client.post( reverse("pet_form"), data={ @@ -259,6 +324,9 @@ def test_create_product_with_invalid_weight(self): def test_create_pet_with_valid_birthday(self): # Crear una mascota con fecha de nacimiento válida + """ + Esta función testea la creación de una mascota con una fecha de nacimiento valido. + """ response = self.client.post( reverse("pet_form"), data={ @@ -284,6 +352,9 @@ def test_create_pet_with_valid_birthday(self): def test_create_pet_with_invalid_birthday(self): # Intentar crear una mascota con fecha de nacimiento en el futuro + """ + Esta función testea la creación de una mascota con una fecha de nacimiento invalida. + """ future_date = datetime.now().date() + timezone.timedelta(days=1) response = self.client.post( reverse("pet_form"), @@ -306,6 +377,9 @@ def test_create_pet_with_invalid_birthday(self): class ProductsTest(TestCase): def test_create_product_with_valid_price(self): # Crear un producto con precio válido + """ + Esta función verifica la creación de un producto con un precio valido. + """ response = self.client.post( reverse("product_form"), data={ @@ -329,6 +403,9 @@ def test_create_product_with_valid_price(self): def test_create_product_with_invalid_price(self): # Intentar crear un producto con precio negativo + """ + Esta función verifica la creación de un producto con un precio invalido + """ response = self.client.post( reverse("product_form"), data={ @@ -347,6 +424,9 @@ def test_create_product_with_invalid_price(self): def test_create_product_with_non_numeric_price(self): # Intentar crear un producto con precio no numérico + """ + Esta función testea la creación de un producto con precio no numérico. + """ response = self.client.post( reverse("product_form"), data={ From 62a03ae3e3040b6414d14fca155e4af65abf2428 Mon Sep 17 00:00:00 2001 From: Juan Manuel Date: Tue, 4 Jun 2024 17:29:57 -0300 Subject: [PATCH 3/4] =?UTF-8?q?Documente=20los=20metodos=20p=C3=BAblicos?= =?UTF-8?q?=20del=20test=20unitario.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- app/tests_unit.py | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/app/tests_unit.py b/app/tests_unit.py index b8a32327..d3c0a2de 100644 --- a/app/tests_unit.py +++ b/app/tests_unit.py @@ -4,6 +4,9 @@ class ClientModelTest(TestCase): def test_can_create_and_get_client(self): + """ + Esta función verifica que el sistema permita la creación de un cliente y que se pueda recuperar correctamente desde la base de datos. + """ Client.save_client( { "name": "Juan Sebastian Veron", @@ -21,6 +24,9 @@ def test_can_create_and_get_client(self): self.assertEqual(clients[0].email, "brujita75@hotmail.com") def test_can_update_client(self): + """ + Esta función testea si se puede actualizar el cliente. + """ Client.save_client( { "name": "Juan Sebastian Veron", @@ -40,6 +46,9 @@ def test_can_update_client(self): self.assertEqual(client_updated.phone, "221555233") def test_update_client_with_error(self): + """ + Esta función testea que el sistema maneje adecuadamente los errores al intentar actualizar un cliente. + """ Client.save_client( { "name": "Juan Sebastian Veron", @@ -61,6 +70,9 @@ def test_update_client_with_error(self): class MedicineModelTest(TestCase): def test_can_create_medicine_with_valid_dose(self): + """ + Esta función testea que el sistema permita la creación de un medicamento con una dosis válida. + """ success, errors = Medicine.save_medicine( { "name": "Ibuprofeno", @@ -74,6 +86,9 @@ def test_can_create_medicine_with_valid_dose(self): self.assertEqual(len(medicines), 1) def test_cannot_create_medicine_with_invalid_dose(self): + """ + Esta función verifica que el sistema no permita la creación de un medicamento con una dosis inválida. + """ success, errors = Medicine.save_medicine( { "name": "Ibuprofeno", @@ -88,6 +103,9 @@ def test_cannot_create_medicine_with_invalid_dose(self): self.assertEqual(len(medicines), 0) def test_update_medicine_with_invalid_dose(self): + """ + Esta función verifica que el sistema maneje adecuadamente los intentos de actualización de un medicamento con una dosis inválida. + """ Medicine.save_medicine( { "name": "Paracetamol", @@ -109,6 +127,9 @@ def test_update_medicine_with_invalid_dose(self): class ProviderModelTest(TestCase): def test_can_create_and_get_provider(self): + """ + Esta función asegura de que se pueda crear un proveedor con datos válidos y luego recuperarlo correctamente de la base de datos. + """ Provider.save_provider( { "name": "Juan Roman Riquelme", @@ -125,6 +146,10 @@ def test_can_create_and_get_provider(self): #Agrego test unitario especifico de la issue de provider def test_provider_address(self): + """ + Esta función verifica que el sistema maneje correctamente tanto los proveedores con dirección como los que no tienen dirección. + Garantizando que los datos se almacenen y recuperen correctamente de la base de datos. + """ addres = "calle 13 y 44" Provider.save_provider( { @@ -139,6 +164,9 @@ def test_provider_address(self): class PetModelTest(TestCase): def test_validate_pet_birthday(self): # Probamos la validación de fecha de nacimiento para una mascota + """ + Esta función testea la validación de fecha de nacimiento para una mascota. + """ valid_data = { "name": "Frida", "breed": "negrita", @@ -161,6 +189,9 @@ def test_validate_pet_birthday(self): # Validacion de peso mascota def test_create_pet_with_valid_weight(self): + """ + Esta función valida la creación de una mascota con peso valido. + """ success, message_or_errors = Pet.save_pet({ "name": "Frida", "breed": "negrita", @@ -172,6 +203,9 @@ def test_create_pet_with_valid_weight(self): self.assertEqual(message_or_errors, None) def test_create_pet_with_invalid_weight_negative(self): + """ + Esta función verifica el comportamiento del sistema al intentar crear una mascota con un peso negativo. + """ success, message_or_errors = Pet.save_pet({ "name": "Frida", "breed": "negrita", @@ -185,6 +219,9 @@ def test_create_pet_with_invalid_weight_negative(self): class ProductModelTest(TestCase): def test_create_product_with_valid_price(self): + """ + Esta función verifica que el sistema permita la creación de un producto con un precio válido. + """ success, message_or_errors = Product.save_product({ "name": "Test Product", "product_type": "Test Type", @@ -195,6 +232,9 @@ def test_create_product_with_valid_price(self): self.assertEqual(message_or_errors, "Producto creado exitosamente") def test_create_product_with_invalid_price_zero(self): + """ + Esta función verifica cómo el sistema maneja la creación de un producto con un precio igual a cero. + """ success, message_or_errors = Product.save_product({ "name": "Test Product", "product_type": "Test Type", @@ -206,6 +246,9 @@ def test_create_product_with_invalid_price_zero(self): self.assertEqual(message_or_errors["price"], "El precio debe ser mayor que cero") def test_create_product_with_invalid_price_negative(self): + """ + Esta función verifica cómo el sistema maneja la creación de un producto con un precio negativo. + """ success, message_or_errors = Product.save_product({ "name": "Test Product", "product_type": "Test Type", From c828c23662b9ed0f173c8727e6eb877a946e9148 Mon Sep 17 00:00:00 2001 From: Juan Manuel Date: Tue, 4 Jun 2024 17:30:57 -0300 Subject: [PATCH 4/4] =?UTF-8?q?Documente=20los=20metodos=20p=C3=BAblicos?= =?UTF-8?q?=20del=20test=20e2e.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- functional_tests/tests.py | 98 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) diff --git a/functional_tests/tests.py b/functional_tests/tests.py index 4dbce8ad..4f6e4021 100644 --- a/functional_tests/tests.py +++ b/functional_tests/tests.py @@ -18,6 +18,9 @@ class PlaywrightTestCase(StaticLiveServerTestCase): @classmethod def setUpClass(cls): + """ + Esta función prepara el entorno necesario para la ejecución de un conjunto de pruebas dentro de una clase de pruebas. + """ super().setUpClass() cls.browser: Browser = playwright.chromium.launch( headless=headless, slow_mo=int(slow_mo) @@ -25,20 +28,32 @@ def setUpClass(cls): @classmethod def tearDownClass(cls): + """ + Esta función limpia y libera los recursos compartidos después de que todas las pruebas en la clase hayan sido ejecutadas. + """ super().tearDownClass() cls.browser.close() def setUp(self): + """ + Esta función prepara el entorno necesario antes de ejecutar cada prueba individual. + """ super().setUp() self.page = self.browser.new_page() def tearDown(self): + """ + Esta función limpia y libera los recursos después de que cada prueba individual haya sido ejecutada. + """ super().tearDown() self.page.close() class HomeTestCase(PlaywrightTestCase): def test_should_have_navbar_with_links(self): + """ + Esta función verifica que una página web tenga una barra de navegación (navbar) con enlaces (links) a otras páginas o secciones del sitio. + """ self.page.goto(self.live_server_url) navbar_home_link = self.page.get_by_test_id("navbar-Inicio") @@ -56,6 +71,9 @@ def test_should_have_navbar_with_links(self): expect(navbar_clients_link).to_have_attribute("href", reverse("clients_repo")) def test_should_have_home_cards_with_links(self): + """ + Esta función verifica que una página de inicio tenga tarjetas (cards) con enlaces (links) a otras partes del sitio. + """ self.page.goto(self.live_server_url) home_clients_link = self.page.get_by_test_id("home-Clientes") @@ -67,11 +85,17 @@ def test_should_have_home_cards_with_links(self): class ClientsRepoTestCase(PlaywrightTestCase): def test_should_show_message_if_table_is_empty(self): + """ + Esta función verifica que un mensaje se muestre correctamente cuando una tabla está vacía en una aplicación web. + """ self.page.goto(f"{self.live_server_url}{reverse('clients_repo')}") expect(self.page.get_by_text("No existen clientes")).to_be_visible() def test_should_show_clients_data(self): + """ + Esta función verifica que los datos de los clientes se muestren correctamente en una determinada página de la aplicación web. + """ Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -101,6 +125,9 @@ def test_should_show_clients_data(self): expect(self.page.get_by_text("goleador@gmail.com")).to_be_visible() def test_should_show_add_client_action(self): + """ + Esta función verifica que la página de la lista de clientes incluya una acción para agregar un nuevo cliente. + """ self.page.goto(f"{self.live_server_url}{reverse('clients_repo')}") add_client_action = self.page.get_by_role( @@ -109,6 +136,9 @@ def test_should_show_add_client_action(self): expect(add_client_action).to_have_attribute("href", reverse("clients_form")) def test_should_show_client_edit_action(self): + """ + Esta función verifica que la página de detalle de cliente incluya una acción para editar el cliente. + """ client = Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -124,6 +154,9 @@ def test_should_show_client_edit_action(self): ) def test_should_show_client_delete_action(self): + """ + Esta función verifica que la página de detalle de cliente incluya una acción para eliminar el cliente. + """ client = Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -145,6 +178,9 @@ def test_should_show_client_delete_action(self): expect(edit_form.get_by_role("button", name="Eliminar")).to_be_visible() def test_should_can_be_able_to_delete_a_client(self): + """ + Esta función verifica que un cliente pueda ser eliminado correctamente a través de una solicitud POST al servidor. + """ Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -157,6 +193,9 @@ def test_should_can_be_able_to_delete_a_client(self): expect(self.page.get_by_text("Juan Sebastián Veron")).to_be_visible() def is_delete_response(response): + """ + Esta función verifica si una respuesta HTTP es una respuesta de eliminación (código de estado 204 No Content). + """ return response.url.find(reverse("clients_delete")) # verificamos que el envio del formulario fue exitoso @@ -171,6 +210,9 @@ def is_delete_response(response): class ClientCreateEditTestCase(PlaywrightTestCase): def test_should_be_able_to_create_a_new_client(self): + """ + Esta función verifica que se pueda crear un nuevo cliente correctamente a través de una solicitud POST al servidor. + """ self.page.goto(f"{self.live_server_url}{reverse('clients_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -188,6 +230,10 @@ def test_should_be_able_to_create_a_new_client(self): expect(self.page.get_by_text("13 y 44")).to_be_visible() def test_should_view_errors_if_form_is_invalid(self): + """ + Esta función verifica que se muestren los errores de validación en el + formulario si se envían datos inválidos al intentar crear un nuevo cliente. + """ self.page.goto(f"{self.live_server_url}{reverse('clients_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -215,6 +261,9 @@ def test_should_view_errors_if_form_is_invalid(self): ).to_be_visible() def test_should_be_able_to_edit_a_client(self): + """ + Esta función verifica que se pueda editar un cliente existente correctamente a través de una solicitud POST al servidor. + """ client = Client.objects.create( name="Juan Sebastián Veron", address="13 y 44", @@ -250,6 +299,10 @@ def test_should_be_able_to_edit_a_client(self): class MedicineCreateEditTestCase(PlaywrightTestCase): def test_should_show_error_for_dose_greater_than_10(self): + """ + Esta función verifica que se muestre un mensaje de error cuando se intenta + crear o editar un medicamento con una dosis mayor que 10. + """ self.page.goto(f"{self.live_server_url}{reverse('medicine_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -263,6 +316,10 @@ def test_should_show_error_for_dose_greater_than_10(self): expect(self.page.get_by_text("La dosis debe estar en un rango de 1 a 10")).to_be_visible() def test_should_show_error_for_dose_less_than_1(self): + """ + Esta función verifica que se muestre un mensaje de error cuando se intenta crear o + editar un medicamento con una dosis menor que 1. + """ self.page.goto(f"{self.live_server_url}{reverse('medicine_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -277,11 +334,17 @@ def test_should_show_error_for_dose_less_than_1(self): class ProvidersRepoTestCase(PlaywrightTestCase): def test_should_show_message_if_table_is_empty(self): + """ + Esta función verifica que se muestre un mensaje adecuado si una tabla en la interfaz de usuario está vacía. + """ self.page.goto(f"{self.live_server_url}{reverse('provider_repo')}") expect(self.page.get_by_text("No existen proveedores")).to_be_visible() def test_should_show_providers_data(self): + """ + Esta función verifica que se muestren los datos de los proveedores en la interfaz de usuario. + """ Provider.objects.create( name="Juan Roman Riquelme", email="senor10@hotmail.com", @@ -289,6 +352,9 @@ def test_should_show_providers_data(self): ) def test_should_show_add_provider_action(self): + """ + Esta función verifica que en la interfaz de usuario se muestre una acción para agregar un nuevo proveedor. + """ self.page.goto(f"{self.live_server_url}{reverse('provider_repo')}") add_provider_action = self.page.get_by_role( @@ -298,6 +364,10 @@ def test_should_show_add_provider_action(self): #Agrego e2e que utilicen el atributo address def test_should_view_errors_if_form_is_invalid(self): + """ + Esta función verifica que se muestren los errores de validación en un + formulario si se envían datos inválidos al servidor. + """ self.page.goto(f"{self.live_server_url}{reverse('provider_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -325,6 +395,10 @@ def test_should_view_errors_if_form_is_invalid(self): ).to_be_visible() def test_should_be_able_to_edit_a_provider(self): + """ + Esta función verifica que se pueda editar un proveedor existente correctamente + a través de una solicitud POST al servidor. + """ provider = Provider.objects.create( name="Juan Roman Riquelme", email="senor10@hotmail.com", @@ -357,6 +431,10 @@ def test_should_be_able_to_edit_a_provider(self): class PetFormCreateValidationTestCase(PlaywrightTestCase): def test_should_show_error_for_future_birth_date(self): + """ + Esta función verifica que se muestre un mensaje de error cuando se intenta + ingresar una fecha de nacimiento en el futuro al crear o editar un cliente. + """ self.page.goto(f"{self.live_server_url}{reverse('pet_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -375,6 +453,10 @@ def test_should_show_error_for_future_birth_date(self): expect(self.page.get_by_text("La fecha de nacimiento debe ser menor a la fecha actual")).to_be_visible() def test_should_show_error_for_present_birth_date(self): + """ + Esta función verifica que se muestre un mensaje de error cuando se intenta ingresar una fecha de nacimiento + que corresponde al día actual (o una fecha anterior al día actual) al crear o editar un cliente. + """ self.page.goto(f"{self.live_server_url}{reverse('pet_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -396,6 +478,10 @@ def test_should_show_error_for_present_birth_date(self): # Pruebas para peso de la mascota def test_should_be_able_to_create_a_new_pet(self): + """ + Esta función verifica que se pueda crear una nueva mascota correctamente + a través de una solicitud POST al servidor. + """ self.page.goto(f"{self.live_server_url}{reverse('pet_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -416,6 +502,10 @@ def test_should_be_able_to_create_a_new_pet(self): # Prueba para verificar si se muestran errores cuando el formulario es inválido con un peso menor que cero def test_should_view_errors_if_form_is_invalid_with_weight_less_than_zero(self): + """ + Esta función verifica que se muestren errores cuando se intenta + enviar un formulario con un peso de mascota menor que cero. + """ self.page.goto(f"{self.live_server_url}{reverse('pet_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -445,6 +535,10 @@ def test_should_view_errors_if_form_is_invalid_with_weight_less_than_zero(self): class ProductCreatePriceGreaterThanZeroTestCase(PlaywrightTestCase): def test_should_be_able_to_create_a_new_product(self): + """ + Esta función verifica que se pueda crear un nuevo producto correctamente + a través de una solicitud POST al servidor. + """ self.page.goto(f"{self.live_server_url}{reverse('product_form')}") expect(self.page.get_by_role("form")).to_be_visible() @@ -463,6 +557,10 @@ def test_should_be_able_to_create_a_new_product(self): # Prueba para verificar si se muestran errores cuando el formulario es inválido con un precio menor que cero def test_should_view_errors_if_form_is_invalid_with_price_less_than_zero(self): + """ + Esta función verifica que se muestren errores cuando se intenta enviar + un formulario con un precio de producto menor que cero. + """ self.page.goto(f"{self.live_server_url}{reverse('product_form')}") expect(self.page.get_by_role("form")).to_be_visible()