test: Enhance US03 tests with alert verification for percentage sum > 100%

Author: 02loveslollipop

tests/us3.py

@@ -17,7 +17,10 @@ class US03Tests(unittest.TestCase):
     PERCENTAGE_INPUT_SELECTOR = "input.home__input[placeholder='0'][type='number']"
     ADD_GRADE_BUTTON_SELECTOR = "button.home__add-button"
     GRADES_LIST_ITEM_SELECTOR = "div.home__grades-container > div.home__grade-row"
-    REMAINING_PERCENTAGE_DISPLAY_SELECTOR = "div.home__results-card p.home__card-text span"
+    CALCULATE_BUTTON_SELECTOR = "button.home__calculate-button"  # Added
+    ALERT_TITLE_SELECTOR = "div.alert__title"  # Added
+    ALERT_MESSAGE_SELECTOR = "div.alert__message" # Added
+    ALERT_CONFIRM_BUTTON_SELECTOR = "div.alert__actions button.alert__button" # General confirm, can be more specific if needed
 
     FIRST_TIME_ALERT_BUTTON_SELECTOR = ".alert__button.alert__button--single"
     ALERT_OVERLAY_SELECTOR = "div.alert__overlay"
@@ -126,16 +129,38 @@ def _add_grade_and_percentage(self, grade, percentage):
             self.fail("Driver not available.")
             return
 
+        # Find all grade input rows. The last one is the one we want to fill.
+        # If it's the first grade, it's the only row.
+        # If we've added one, a new empty row is typically added by the app, so we target that.
+        
+        # Click "Agregar nota" first to ensure a new empty row is available if needed,
+        # or to use the existing one if it's the first entry.
+        # This logic might need adjustment based on how `handleAddGrade` in home.jsx works.
+        # For now, assume we always fill the *last* available input row.
+        
+        # If it's not the first grade being added in the test sequence, click "Agregar nota"
+        # to generate a new row for this entry.
+        # This assumes that _add_grade_and_percentage is called for each new grade entry
+        # and the app adds a new row template upon clicking "Agregar nota" *after* filling the previous.
+        
+        # Let's refine: The "Agregar nota" button adds a new *blank* row.
+        # We should fill the *current last* row's inputs, then click "Agregar nota"
+        # if we intend to add *another* one after this.
+        # The current _add_grade_and_percentage is designed to fill inputs and then click "Agregar nota".
+        # This implies "Agregar nota" serves dual purpose: commit current and prepare next.
+        # This seems to be the behavior from US01/US02.
+
         grade_rows = self.driver.find_elements(By.CSS_SELECTOR, self.GRADES_LIST_ITEM_SELECTOR)
         if not grade_rows:
             logger.error("No grade rows found to add grade and percentage.")
             self._take_screenshot("no_grade_rows_found")
             self.fail("No grade rows found.")
             return
 
-        last_row = grade_rows[-1]
+        last_row = grade_rows[-1] # Target the last row for input
         logger.info(f"Targeting the last of {len(grade_rows)} grade rows for input.")
 
+
         try:
             grade_input_element = last_row.find_element(By.CSS_SELECTOR, self.GRADE_INPUT_SELECTOR)
             percentage_input_element = last_row.find_element(By.CSS_SELECTOR, self.PERCENTAGE_INPUT_SELECTOR)
@@ -146,109 +171,92 @@ def _add_grade_and_percentage(self, grade, percentage):
             self.fail("Input elements not found in the last row.")
             return
 
+        # The "Agregar nota" button is outside the rows, so it's found globally.
         add_button = self.wait_long.until(EC.element_to_be_clickable((By.CSS_SELECTOR, self.ADD_GRADE_BUTTON_SELECTOR)))
 
         grade_input_element.clear()
         grade_input_element.send_keys(str(grade))
         percentage_input_element.clear()
         percentage_input_element.send_keys(str(percentage))
 
+        # Click "Agregar nota" AFTER filling the inputs.
+        # This should add the current grade and potentially prepare a new row.
         add_button.click() 
-        logger.info(f"Clicked 'Agregar nota' after attempting to add grade: {grade}, percentage: {percentage} to the last row.")
-        # Wait for UI to update, especially if new rows are added dynamically.
+        logger.info(f"Clicked \'Agregar nota\' after filling grade: {grade}, percentage: {percentage} into the last available row.")
+        
+        # Wait for UI to update, e.g., for a new row to be added if that's the behavior.
         # A more robust wait would be for the number of rows to change or for a specific element to appear.
         time.sleep(0.5) # Small delay for React state updates
 
-    def _get_remaining_percentage(self):
-        cleaned_text = "" # Initialize cleaned_text
-        try:
-            # Wait for the element to be present and contain some text
-            percentage_element = self.wait_long.until(
-                EC.presence_of_element_located((By.CSS_SELECTOR, self.REMAINING_PERCENTAGE_DISPLAY_SELECTOR))
-            )
-            # Add a small delay or check for text to be non-empty if necessary
-            time.sleep(0.2) # give a brief moment for text to update
-            
-            # Attempt to get text, retry if it's empty initially due to rendering delays
-            text_value = percentage_element.text.strip()
-            attempts = 0
-            while text_value == "" and attempts < 5: # Retry if empty
-                time.sleep(0.3)
-                text_value = percentage_element.text.strip()
-                attempts += 1
-            
-            logger.info(f"Raw remaining percentage text: '{text_value}'")
-            if not text_value: # If still empty after retries
-                logger.warning("Remaining percentage text is empty after retries.")
-                self._take_screenshot("empty_remaining_percentage")
-                return "Error: Empty Value" # Or raise an error
-
-            # Assuming the text is like "XX %" or "XX%", we remove "%" and convert to float
-            # If it's just "XX", this will also work.
-            cleaned_text = text_value.replace('%', '').strip()
-            return float(cleaned_text)
-        except TimeoutException:
-            logger.error(f"Timeout waiting for remaining percentage display element: {self.REMAINING_PERCENTAGE_DISPLAY_SELECTOR}")
-            self._take_screenshot("remaining_percentage_timeout")
-            return "Error: Timeout" # Or raise an error
-        except ValueError:
-            logger.error(f"Could not convert remaining percentage text '{cleaned_text}' to float.") # cleaned_text is now defined
-            self._take_screenshot("remaining_percentage_value_error")
-            return "Error: Conversion" # Or raise an error
-        except Exception as e:
-            logger.error(f"Error getting remaining percentage: {e}")
-            self._take_screenshot("get_remaining_percentage_error")
-            return "Error: General" # Or raise an error
-
-    # US03: Calculo del porcentaje faltante
-    def test_us03_verify_calculation_of_remaining_percentage(self):
+    # US03: Verify alert for percentage sum > 100%
+    def test_us03_verify_percentage_sum_alert(self):
         test_name = self._testMethodName
         logger.info(f"Running test: {test_name}")
 
         try:
-            # 1. Initial state: Verify remaining percentage is 100%
-            logger.info("Verifying initial remaining percentage.")
-            initial_remaining = self._get_remaining_percentage()
-            self.assertEqual(initial_remaining, 100.0, 
-                             f"Initial remaining percentage expected 100.0, but got {initial_remaining}")
-            logger.info(f"Initial remaining percentage is correct: {initial_remaining}%")
+            # 1. Add grades with percentages summing > 100%
+            logger.info("Adding first grade (70%).")
+            self._add_grade_and_percentage("3.0", "70")
+            
+            # The previous _add_grade_and_percentage clicks "Agregar nota",
+            # which should make a new row available for the next grade.
+            logger.info("Adding second grade (40%). Total percentage should be 110%.")
+            self._add_grade_and_percentage("4.0", "40")
+            # After this, we should have two rows with data, and possibly a third empty template row.
+
+            # 2. Click "Calcular" button
+            logger.info(f"Clicking \'Calcular\' button with selector: {self.CALCULATE_BUTTON_SELECTOR}")
+            calculate_button = self.wait_long.until(
+                EC.element_to_be_clickable((By.CSS_SELECTOR, self.CALCULATE_BUTTON_SELECTOR))
+            )
+            calculate_button.click()
+            logger.info("\'Calcular\' button clicked.")
+
+            # 3. Verify the alert is displayed with correct title and message
+            logger.info("Verifying alert for percentage sum > 100%.")
+            
+            alert_title_element = self.wait_long.until(
+                EC.visibility_of_element_located((By.CSS_SELECTOR, self.ALERT_TITLE_SELECTOR))
+            )
+            alert_title_text = alert_title_element.text
+            expected_title = "La suma de los porcentajes es mayor al 100%"
+            self.assertEqual(alert_title_text, expected_title,
+                             f"Alert title expected \'{expected_title}\', but got \'{alert_title_text}\'")
+            logger.info(f"Alert title is correct: \'{alert_title_text}\'")
 
-            # 2. Add one grade and verify
-            logger.info("Adding first grade (20%).")
-            self._add_grade_and_percentage("3.0", "20")
-            # It might take a moment for the calculation to update
-            time.sleep(0.5) # Wait for calculation update
-            remaining_after_first_grade = self._get_remaining_percentage()
-            self.assertEqual(remaining_after_first_grade, 80.0,
-                             f"Remaining percentage after 1st grade (20%) expected 80.0, but got {remaining_after_first_grade}")
-            logger.info(f"Remaining percentage after 1st grade (20%) is correct: {remaining_after_first_grade}%")
+            alert_message_element = self.wait_long.until(
+                EC.visibility_of_element_located((By.CSS_SELECTOR, self.ALERT_MESSAGE_SELECTOR))
+            )
+            alert_message_text = alert_message_element.text
+            expected_message = "Por favor verifica los porcentajes de las notas ingresadas, para que la suma sea menor o igual a 100%."
+            self.assertEqual(alert_message_text, expected_message,
+                             f"Alert message expected \'{expected_message}\', but got \'{alert_message_text}\'")
+            logger.info(f"Alert message is correct: \'{alert_message_text}\'")
 
-            # 3. Add a second grade and verify
-            logger.info("Adding second grade (30%). Total 50%.")
-            self._add_grade_and_percentage("4.0", "30")
-            time.sleep(0.5) # Wait for calculation update
-            remaining_after_second_grade = self._get_remaining_percentage()
-            self.assertEqual(remaining_after_second_grade, 50.0,
-                             f"Remaining percentage after 2nd grade (total 50%) expected 50.0, but got {remaining_after_second_grade}")
-            logger.info(f"Remaining percentage after 2nd grade (total 50%) is correct: {remaining_after_second_grade}%")
+            # 4. Close the alert
+            alert_confirm_button = self.wait_long.until(
+                EC.element_to_be_clickable((By.CSS_SELECTOR, self.ALERT_CONFIRM_BUTTON_SELECTOR))
+            )
+            # Based on alert.jsx, if showCancel is false (which it is for this alert),
+            # the confirm button will have 'alert__button--single'
+            # We can use a more general selector for the button within alert__actions
+            alert_confirm_button.click()
+            logger.info("Alert confirm button clicked.")
 
-            # 4. Add a third grade to make total 100% and verify
-            logger.info("Adding third grade (50%). Total 100%.")
-            self._add_grade_and_percentage("5.0", "50")
-            time.sleep(0.5) # Wait for calculation update
-            remaining_after_third_grade = self._get_remaining_percentage()
-            self.assertEqual(remaining_after_third_grade, 0.0,
-                             f"Remaining percentage after 3rd grade (total 100%) expected 0.0, but got {remaining_after_third_grade}")
-            logger.info(f"Remaining percentage after 3rd grade (total 100%) is correct: {remaining_after_third_grade}%")
+            # Verify alert is closed
+            WebDriverWait(self.driver, 5).until(
+                EC.invisibility_of_element_located((By.CSS_SELECTOR, self.ALERT_OVERLAY_SELECTOR))
+            )
+            logger.info("Alert successfully closed.")
 
         except AssertionError as e:
             logger.error(f"AssertionError in {test_name}: {e}")
             self._take_screenshot(f"{test_name}_assertion_failure")
-            raise  # Re-raise the assertion error to fail the test
+            raise
         except Exception as e:
             logger.error(f"An unexpected error occurred in {test_name}: {e}")
             self._take_screenshot(f"{test_name}_unexpected_error")
-            raise # Re-raise to fail the test
+            raise
 
         logger.info(f"Test {test_name} completed successfully.")