QA-8162 testcases added for login tabs

.github/workflows/sa-workflows-extended.yml

@@ -85,7 +85,7 @@ jobs:
             --dashboard --html=presetup_extendedtests-report-${{ matrix.environment }}.html  --maxfail=1
           pytest -v -m extendedtests \
             --browser=chrome --headless --headless2 \
-            --reruns 1 -n 3 --dist=loadscope\
+            --reruns 1 -n 4 --dist=loadscope\
             --dashboard --html=extendedtests-report-${{ matrix.environment }}.html
 
       - name: Parse test counts
@@ -293,7 +293,7 @@ jobs:
           script: |
             const { promises: fs } = require('fs')
             const {JOB_STATUS, NOW, CC_ENV, GITHUB_HEAD_REF} = process.env
-            const prefix = `[${CC_ENV}] SureAdhere Tests - ${JOB_STATUS.toUpperCase()} - Run #${context.runNumber}`
+            const prefix = `[${CC_ENV}] SureAdhere Extended Tests - ${JOB_STATUS.toUpperCase()} - Run #${context.runNumber}`
             const suffix = `at ${NOW}`
             let subject = `${prefix} on branch "${GITHUB_HEAD_REF}" ${suffix}`
 
@@ -303,7 +303,7 @@ jobs:
             }
 
             let actionRunLink = context.payload.repository.html_url + `/actions/runs/${context.runId}`
-            let testSuite = 'SureAdhere Tests'
+            let testSuite = 'SureAdhere Extended Tests'
             let bodyContent = await fs.readFile(bodyFile, 'utf8')
             bodyContent = bodyContent.replace(/{{actionRunLink}}/g, actionRunLink)
                 .replace(/{{runNumber}}/g, context.runNumber)
@@ -335,4 +335,3 @@ jobs:
           convert_markdown: true
           attachments: sbase-extendedtests-artifacts-${{ matrix.environment }}.zip
           in_reply_to: ${{ fromJSON(steps.configure_email.outputs.result).reference }}
-

.github/workflows/sa-workflows.yml

@@ -87,6 +87,7 @@ jobs:
           DIMAGIQA_ADMIN_PASSWORD: ${{ secrets.DIMAGIQA_ADMIN_PASSWORD }}
           DIMAGIQA_BS_USER: ${{ secrets.DIMAGIQA_BS_USER }}
           DIMAGIQA_BS_KEY: ${{ secrets.DIMAGIQA_BS_KEY }}
+          DIMAGIQA_SA_IMAP_PASSWORD: ${{ secrets.DIMAGIQA_SA_IMAP_PASSWORD }}
 
         run: |
           echo "client_payload: ${{ toJson(github.event.client_payload) }}"

common_utilities/base_page.py

@@ -6,7 +6,7 @@
 from typing import Dict, Any, Iterable, List, Tuple, Optional
 import platform
 from selenium.webdriver.common.keys import Keys
-from selenium.common.exceptions import StaleElementReferenceException, TimeoutException
+from selenium.common.exceptions import StaleElementReferenceException, TimeoutException, NoSuchFrameException
 from selenium.common.exceptions import ElementClickInterceptedException
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
@@ -24,7 +24,7 @@
 # ---- Tunables ---------------------------------------------------------------
 
 PRIMARY_TIMEOUT = 6         # seconds for fast checks
-CLICK_TIMEOUT = 15          # seconds for user actions
+CLICK_TIMEOUT = 30          # seconds for user actions
 VISIBLE_REQUIRED = True     # only accept visible elements
 SIM_THRESHOLD = 0.62        # fuzzy match threshold for text-ish attrs
 MIN_STABLE_PREFIX = 3       # for dynamic-id starts-with heuristics
@@ -312,7 +312,7 @@ def _candidate_matches_entry(self, el, entry: dict) -> bool:
         if col is not None:
             if (el.get_attribute("aria-colindex") or "").strip() != str(col):
                 return False
-        # class tokens guard (token-based, not substring)
+        # class tokens guard – ONLY for table-ish cells where we really care
         cls = entry.get("class") or ""
         if cls and not self._class_has_tokens(el, cls):
             return False
@@ -372,7 +372,7 @@ def _candidates_for(self, entry: Dict[str, Any]) -> List[str]:
         # 4) Attribute combos (equals)
         # inside your candidate builder, add aria-colindex to equality attributes
         combo_attrs = [
-            "id", "name", "type", "placeholder", "aria-label", "role",
+            "id", "name", "type", "placeholder", "aria-label", "title", "role",
             "data-testid", "data-id", "data-value", "aria-colindex"  # <--- add this
             ]
 
@@ -445,7 +445,7 @@ def _score_element(self, el, entry: Dict[str, Any]) -> float:
             tag = (el.tag_name or "").lower()
             if entry.get("tag") and tag == (entry["tag"] or "").lower():
                 score += 0.35
-            for a in ["type", "placeholder", "aria-label", "name", "id", "class"]:
+            for a in ["type", "placeholder", "aria-label", "name", "id", "class", "title", "role"]:
                 want = entry.get(a)
                 if not want:
                     continue
@@ -554,6 +554,13 @@ def wait_for_element(self, logical_name: str, timeout: int = CLICK_TIMEOUT, stri
         sel = self.resolve_strict(logical_name) if strict else self.resolve(logical_name)
         self.sb.wait_for_element(sel, timeout=timeout)
 
+    def wait_for_text(self, text: str, logical_name: str, timeout: int = CLICK_TIMEOUT, strict: bool = False):
+        sel = self.resolve_strict(logical_name) if strict else self.resolve(logical_name)
+        text = text.strip()
+        self.sb.wait_for_element_present(sel, timeout=timeout)
+        self.sb.wait_for_element_visible(sel, timeout=timeout)
+        self.sb.wait_for_text(text, sel, timeout=timeout)
+
     def find_elements(self, logical_name: str, timeout: int = CLICK_TIMEOUT):
         sel = self.resolve_strict(logical_name)
         print(sel)
@@ -566,6 +573,30 @@ def find_elements(self, logical_name: str, timeout: int = CLICK_TIMEOUT):
         # Return all currently matching elements
         return self.sb.find_elements(sel)
 
+    def find_elements_raw(self, selector: str, by: str = "xpath", timeout: int = 10):
+        by = by.lower()
+        if by == "xpath":
+            by_type = By.XPATH
+        elif by == "css":
+            by_type = By.CSS_SELECTOR
+        elif by == "id":
+            by_type = By.ID
+        elif by == "name":
+            by_type = By.NAME
+        else:
+            raise ValueError(f"Unsupported selector type: {by}")
+
+        print(f"[RAW FIND] {by_type} -> {selector}")
+
+        try:
+            WebDriverWait(self.driver, timeout).until(
+                lambda d: d.find_elements(by_type, selector)
+                )
+        except TimeoutException:
+            return []
+
+        return self.driver.find_elements(by_type, selector)
+
     def go_back(self):
         """Go back one page in browser history."""
         self.sb.go_back()
@@ -590,6 +621,11 @@ def type(self, logical_name: str, value: str, timeout: int = CLICK_TIMEOUT):
         # self.sb.highlight(sel)
         self.sb.type(sel, value)
 
+    def idle_wait(self, idle_time=300):
+        print(f"⏳ Simulating {idle_time / 60} minutes of inactivity...")
+        for i in range(idle_time // 60):
+            time.sleep(60)
+            print(f"   ... {i + 1} minute(s) passed")
 
     def type_and_trigger(self, logical_name: str, text: str, *,
                          timeout: int = 15, blur: bool = True, clear_first: bool = True):
@@ -3413,4 +3449,249 @@ def round_to_nearest_minute(self, dt: datetime) -> datetime:
         return (dt.replace(second=0, microsecond=0)
                 + timedelta(minutes=1) if dt.second >= 30 else dt.replace(second=0, microsecond=0))
 
+    def get_current_url(self):
+        return self.sb.get_current_url()
+
+    def normalize_values(self, values):
+        """Convert values into appropriate comparable formats.
+
+        - Numeric strings → floats
+        - Phone numbers (10 digits) → keep as strings
+        - Everything else stays as string (date detection happens later)
+        """
+        cleaned = [v for v in values if v is not None]
+
+        if not cleaned:
+            return cleaned
+
+        # Phone number pattern: 10 digits
+        if all(v.isdigit() and len(v) == 10 for v in cleaned):
+            return cleaned  # keep as strings
+
+        # Try converting to floats
+        numeric_converted = []
+        for v in cleaned:
+            s = str(v)
+            try:
+                numeric_converted.append(float(s.replace(",", "")))
+            except ValueError:
+                return cleaned  # at least one is not numeric → fallback to strings
+
+        return numeric_converted
+
+    def try_parse_datetime(self, value):
+        """Try parsing strings like 'Dec 10 19:53:15'. Return datetime or None."""
+        formats = [
+            "%b %d %H:%M:%S",  # Dec 10 19:53:15
+            "%b %d %Y %H:%M:%S"  # Dec 10 2023 19:53:15 (if year added later)
+            ]
+
+        for fmt in formats:
+            try:
+                return datetime.strptime(value, fmt)
+            except ValueError:
+                pass
+
+        return None
+
+    def is_sorted(self, final_values, sorted_as):
+        """Automatically detect type: datetime, number, or string."""
+
+        if not final_values:
+            return
+
+        reverse = (sorted_as == "descending")
+
+        # 1️⃣ Check if values are datetime strings
+        parsed_dates = []
+        date_mode = True
+
+        for v in final_values:
+            dt = self.try_parse_datetime(str(v))
+            if dt is None:
+                date_mode = False
+                break
+            parsed_dates.append(dt)
+
+        if date_mode:
+            expected = sorted(parsed_dates, reverse=reverse)
+            if parsed_dates != expected:
+                print("ACTUAL datetimes :", parsed_dates)
+                print("EXPECTED datetimes:", expected)
+                raise AssertionError(f"Date column NOT sorted {sorted_as}")
+            return
+
+        # 2️⃣ Numeric?
+        if isinstance(final_values[0], (int, float)):
+            expected = sorted(final_values, reverse=reverse)
+        else:
+            # 3️⃣ Default: case-insensitive string
+            expected = sorted(final_values, key=lambda s: str(s).casefold(), reverse=reverse)
+
+        if final_values != expected:
+            print("ACTUAL :", final_values)
+            print("EXPECTED:", expected)
+            raise AssertionError(f"Column NOT sorted {sorted_as}")
+
+    def _get_column_values(self, col_index: int):
+        rows = self.find_elements_raw("//*[contains(@class,'k-table-row')]", by="xpath")
+        print(f"DEBUG: found {len(rows)} rows for column {col_index}")
+
+        values = []
+        for i, row in enumerate(rows, start=1):
+            cells = row.find_elements(By.XPATH, ".//*[contains(@class,'k-table-td')]")
+            print(f"  Row {i}: {len(cells)} cells")
+            if len(cells) < col_index:
+                continue
+            txt = (cells[col_index - 1].text or "").strip()
+            if txt:
+                values.append(txt)
+
+        return self.normalize_values(values) if values else []
+
+    def kendo_multiselect_clear_all(self, input_logical_name: str, timeout: int = 10) -> None:
+        """
+        Clear all selected values from a Kendo MultiSelect.
+
+        Pass the SAME logical name you use for kendo_select's input, e.g.:
+            self.kendo_multiselect_clear_all("k-input_Patient_Manager")
+        """
+
+        sel = self.resolve(input_logical_name)
+        inp = self._get_webelement(sel, timeout=timeout)
+
+        # Put focus inside the control so Kendo is "awake"
+        try:
+            inp.click()
+        except Exception:
+            pass
+
+        # Use your MultiSelect root helper
+        root = self._ms_root(inp)
+        wait = WebDriverWait(self.driver, timeout)
+
+        def chips():
+            # All selected tags inside this multiselect
+            return root.find_elements(
+                By.CSS_SELECTOR,
+                ".k-chip-list .k-chip"
+                )
+
+        def remove_buttons():
+            # All possible "x" icons / remove actions inside chips
+            return root.find_elements(
+                By.CSS_SELECTOR,
+                (
+                    ".k-chip-remove-action, "  # ✅ your class
+                    ".k-chip-remove, "
+                    ".k-chip .k-icon.k-i-close, "
+                    ".k-chip .k-button-icon, "
+                    ".k-chip .k-select"
+                )
+                )
+
+        # --- Try a global clear icon on the widget, if present ---
+        clear_btns = root.find_elements(
+            By.CSS_SELECTOR,
+            ".k-clear-value, .k-multiselect-clearable .k-clear-value"
+            )
+        if clear_btns:
+            try:
+                clear_btns[0].click()
+                try:
+                    wait.until(lambda d: len(chips()) == 0)
+                    return
+                except TimeoutException:
+                    # If still not empty, fall back to per-chip removal
+                    pass
+            except Exception:
+                pass
+
+        # --- Fallback: click each chip's remove action one by one ---
+        end = time.time() + timeout
+        while time.time() < end:
+            btns = remove_buttons()
+            if not btns:
+                break
+
+            btn = btns[0]
+            try:
+                # optional: visual debug
+                try:
+                    self.sb.highlight(btn)
+                except Exception:
+                    pass
+
+                btn.click()
+            except StaleElementReferenceException:
+                # DOM changed between find & click; retry in next loop
+                continue
+            except Exception:
+                # JS click fallback
+                try:
+                    self.driver.execute_script("arguments[0].click();", btn)
+                except Exception:
+                    break
+
+            time.sleep(0.1)  # let DOM update
+
+        # Final soft wait; don't hard-fail the test here
+        try:
+            wait.until(lambda d: len(chips()) == 0)
+        except TimeoutException:
+            print(
+                f"⚠ kendo_multiselect_clear_all('{input_logical_name}'): "
+                f"some chips may still remain ({len(chips())} left)"
+                )
+
+    def get_li_items(self, ul_logical_name: str, timeout: int = 10) -> list[str]:
+        """
+        Given a locator for a <ul>, return text of all <li> elements under it.
+        """
+
+        sel = self.resolve(ul_logical_name)
+        try:
+            ul = self._get_webelement(sel, timeout=timeout)
+        except TimeoutException:
+            return []
+
+        lis = ul.find_elements(By.TAG_NAME, "li")
+        values = [li.text.strip() for li in lis if li.text.strip()]
+
+        print(f"[UL → LI VALUES] {values}")
+        return values
+
+    def assert_list_contains_only(self, actual: list, expected: list):
+        """
+        Assert that actual list contains ONLY expected values (order-independent).
+        """
+        actual_set = set(actual)
+        expected_set = set(expected)
+
+        missing = expected_set - actual_set
+        extra = actual_set - expected_set
+
+        assert not missing and not extra, (
+            f"List contents mismatch.\n"
+            f"Missing: {sorted(missing)}\n"
+            f"Extra  : {sorted(extra)}\n"
+            f"Actual : {actual}"
+        )
+
+    def get_elements_texts(self, logical_name: str, timeout: int = 10) -> list[str]:
+        """
+        Given a logical locator that matches multiple elements,
+        return text of all matching elements.
+        """
+
+        sel = self.resolve(logical_name)
+
+        try:
+            elements = self.find_elements(logical_name, timeout=timeout)
+        except TimeoutException:
+            return []
+
+        values = [el.text.strip() for el in elements if el.text and el.text.strip()]
 
+        print(f"[ELEMENT TEXTS → {logical_name}] {values}")
+        return values