xlavm-lib 1.1.1__tar.gz

xlavm_lib-1.1.1/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: xlavm-lib
+Version: 1.1.1
+Summary: Visual Testing and Get Ids utilities for Selenium & Appium
+Author-email: Luis Angel Vanegas Martinez <angelvamart@hotmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pillow
+Requires-Dist: opencv-python
+Requires-Dist: easyocr
+Requires-Dist: jinja2
+Requires-Dist: numpy
+Requires-Dist: lxml
+Requires-Dist: imageio-ffmpeg
+Requires-Dist: allure-pytest
+
+# xlavm-lib
+
+Librería orientada a pruebas automatizadas de Python (Pytest) con Selenium y Appium. 
+
+Esta libreria se enfoca en 3 partes fundamentales:
+
+- Pruebas Visuales
+- Obtencion de accessibility id o xpath (Sin necesidad de inspeccionar elementos)
+- Reportes en Allure (Local y en Browserstack)
+
+## Instalación
+
+```bash
+pip install xlavm-lib
+```
+
+## Visual Testing
+
+1. En conftest.py:
+
+    ```PY
+    @pytest.fixture
+    def driver():
+        driver.quit()
+        from xlavm_lib import VisualTestReport
+        VisualTestReport().exec()
+    ```
+
+2. En cualquier parte donde se quiera realizar una prueba visual:
+
+    ```PY
+    from xlavm_lib import VisualTest
+    VisualTest(self.driver, 'nombre_pagina').exec()
+    ```
+
+## Get Ids
+
+1. En cualquier parte donde se quiera obtener los elements ids de una pagina:
+
+```PY
+from xlavm_lib import GetIds
+GetIds(self.driver, 'nombre_pagina').exec()
+```
+
+## Allure Reports
+
+1. En conftest.py:
+
+    ```PY
+    @pytest.fixture
+    def driver(request):
+        request.node.report = AllureReport(driver)
+        yield driver
+    
+    from xlavm_lib import AllureReport
+    # HOOKS
+    def pytest_runtest_call(item):
+        report = getattr(item, "report", None)
+        if report:
+            report.start_record_video()
+                
+    def pytest_runtest_teardown(item):
+        report = getattr(item, "report", None)
+        if report:
+            report.stop_record_video()
+    ```
+
+2. En env.py:
+
+    ```PY
+    import os
+    os.environ["BROWSERSTACK_USERNAME"] = "tu_username"
+    os.environ["BROWSERSTACK_ACCESS_KEY"] = "tu_access_key"
+    ```
+
+3. En cualquier parte donde se quiera usar el reporte:
+
+    ```PY
+    from xlavm_lib import AllureReport
+    AllureReport(driver).step("1. Ingreso credenciales validas", request.node.name) #toma pantallazo por cada paso
+    AllureReport(driver).info("este es un mensaje infomativo")
+    AllureReport(driver).error("este es un mensaje de error")
+    ```

xlavm_lib-1.1.1/README.md

@@ -0,0 +1,83 @@
+# xlavm-lib
+
+Librería orientada a pruebas automatizadas de Python (Pytest) con Selenium y Appium. 
+
+Esta libreria se enfoca en 3 partes fundamentales:
+
+- Pruebas Visuales
+- Obtencion de accessibility id o xpath (Sin necesidad de inspeccionar elementos)
+- Reportes en Allure (Local y en Browserstack)
+
+## Instalación
+
+```bash
+pip install xlavm-lib
+```
+
+## Visual Testing
+
+1. En conftest.py:
+
+    ```PY
+    @pytest.fixture
+    def driver():
+        driver.quit()
+        from xlavm_lib import VisualTestReport
+        VisualTestReport().exec()
+    ```
+
+2. En cualquier parte donde se quiera realizar una prueba visual:
+
+    ```PY
+    from xlavm_lib import VisualTest
+    VisualTest(self.driver, 'nombre_pagina').exec()
+    ```
+
+## Get Ids
+
+1. En cualquier parte donde se quiera obtener los elements ids de una pagina:
+
+```PY
+from xlavm_lib import GetIds
+GetIds(self.driver, 'nombre_pagina').exec()
+```
+
+## Allure Reports
+
+1. En conftest.py:
+
+    ```PY
+    @pytest.fixture
+    def driver(request):
+        request.node.report = AllureReport(driver)
+        yield driver
+    
+    from xlavm_lib import AllureReport
+    # HOOKS
+    def pytest_runtest_call(item):
+        report = getattr(item, "report", None)
+        if report:
+            report.start_record_video()
+                
+    def pytest_runtest_teardown(item):
+        report = getattr(item, "report", None)
+        if report:
+            report.stop_record_video()
+    ```
+
+2. En env.py:
+
+    ```PY
+    import os
+    os.environ["BROWSERSTACK_USERNAME"] = "tu_username"
+    os.environ["BROWSERSTACK_ACCESS_KEY"] = "tu_access_key"
+    ```
+
+3. En cualquier parte donde se quiera usar el reporte:
+
+    ```PY
+    from xlavm_lib import AllureReport
+    AllureReport(driver).step("1. Ingreso credenciales validas", request.node.name) #toma pantallazo por cada paso
+    AllureReport(driver).info("este es un mensaje infomativo")
+    AllureReport(driver).error("este es un mensaje de error")
+    ```

xlavm_lib-1.1.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xlavm-lib"
+version = "1.1.1"
+description = "Visual Testing and Get Ids utilities for Selenium & Appium"
+readme = "README.md"
+requires-python = ">=3.9"
+authors = [
+  { name="Luis Angel Vanegas Martinez", email="angelvamart@hotmail.com" }
+]
+license = { text = "MIT" }
+dependencies = [
+  "pillow",
+  "opencv-python",
+  "easyocr",
+  "jinja2",
+  "numpy",
+  "lxml",
+  "imageio-ffmpeg",
+  "allure-pytest"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

xlavm_lib-1.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xlavm_lib-1.1.1/src/xlavm_lib/__init__.py

@@ -0,0 +1,13 @@
+from xlavm_lib.visual_test.visual_test import VisualTest
+from xlavm_lib.visual_test.visual_test_report import VisualTestReport
+from xlavm_lib.get_ids.get_ids import GetIds
+from xlavm_lib.allure_report.allure_report import AllureReport
+
+__all__ = [
+    "VisualTest",
+    "VisualTestReport",
+    "GetIds",
+    "AllureReport"
+]
+
+# Asi el usuario usa: from xlavm_lib import VisualTest, VisualTestReport, GetIds, AllureReport

xlavm_lib-1.1.1/src/xlavm_lib/allure_report/allure_report.py

@@ -0,0 +1,153 @@
+import os
+import allure
+import requests
+from xlavm_lib.allure_report.browserstack import Browserstack
+from xlavm_lib.allure_report.video_recorder_mobile import VideoRecorderMobile
+from xlavm_lib.allure_report.video_recorder_web import VideoRecorderWeb
+import env
+import random
+
+class AllureReport():
+    """
+    Crea un reporte en Allure ya sea para ejecuciones locales o de Browserstack
+    
+    Prerrequisitos:
+        En el conftest.py se crean estos hooks:
+        from xlavm_lib import AllureReport
+        # HOOKS
+        def pytest_runtest_call(item):
+            report = getattr(item, "report", None)
+            if report:
+                report.start_record_video()
+                
+        def pytest_runtest_teardown(item):
+            report = getattr(item, "report", None)
+            if report:
+                report.stop_record_video()
+        
+        En el conftest.py dentro de la funcion driver(request) y y antes del yield driver, se
+        debe ubicar:
+        request.node.report = AllureReport(driver)
+        
+        Se debe crear el archivo env.py en la raiz del proyecto con los siguientes valores (si no usas Browserstack, dejalos vacio)
+        import os
+        os.environ["BROWSERSTACK_USERNAME"] = "tu_username"
+        os.environ["BROWSERSTACK_ACCESS_KEY"] = "tu_access_key"
+        
+    Uso:
+        from xlavm_lib import AllureReport
+        AllureReport(driver).step("1. Ingreso credenciales validas", request.node.name) #toma pantallazo por cada paso
+        AllureReport(driver).info("este es un mensaje infomativo")
+        AllureReport(driver).error("este es un mensaje de error")
+        
+    Args:
+        driver (driver): Driver web o mobile
+    """
+    
+    video_path_web = f"videos/evidencia.mp4"
+    web_recorder = VideoRecorderWeb(video_path_web)
+    
+    def __init__(self, driver):
+        self.driver = driver
+        self.mobile_recorder = None
+        # BrowserStack credentials (desde ENV)
+        self.BS_username = os.getenv("BROWSERSTACK_USERNAME")
+        self.BS_access_key = os.getenv("BROWSERSTACK_ACCESS_KEY")
+        self.BS_session_id = None
+        if not self.BS_username or not self.BS_access_key:
+            raise EnvironmentError("Variables de entorno BROWSERSTACK_USERNAME / BROWSERSTACK_ACCESS_KEY no definidas")
+        
+    def info(self, description):
+        with allure.step(description):
+            pass
+        if not self.is_local_execution():
+            browserstack = Browserstack(self.driver)
+            browserstack.log_debug(description)
+            
+    def error(self, description):
+        if not self.is_local_execution():
+            browserstack = Browserstack(self.driver)
+            browserstack.log_error(description)
+        with allure.step(description):
+            assert False, description
+
+    def step(self, description, TC):
+        """
+        - Use:
+        report.step(description, request.node.name)
+        """
+        SC_PATH = f'screenshots/evidences/{TC}/{description}.png'
+        with allure.step(description):
+            with allure.step("Evidencia"):
+                os.makedirs(os.path.dirname(SC_PATH), exist_ok=True)  
+                self.driver.save_screenshot(SC_PATH)
+                with open(SC_PATH, "rb") as image_file:
+                    allure.attach(image_file.read(), name="Evidencia", attachment_type=allure.attachment_type.PNG)
+     
+    """
+    Metodo que se ejecuta antes del 'yield driver' para grabar evidencias
+    """
+    def start_record_video(self):
+        if self.is_local_execution():
+            if self.driver.platform in ["android", "ios"]:
+                self.mobile_recorder = VideoRecorderMobile(self.driver)
+                self.mobile_recorder.start()
+            else:
+                self.web_recorder.start()
+        else:
+            """Uso BS, entonces guardo el session id para obtener el video"""
+            self.BS_session_id = self.driver.session_id
+    
+    """
+    Metodo que se ejecuta despues del 'driver.quit' para detener la grabacion y guardar evidencias
+    """
+    def stop_record_video(self):
+        if self.is_local_execution():
+            if self.driver.platform in ["android", "ios"]:
+                if self.mobile_recorder:
+                    self.mobile_recorder.stop()
+            else:
+                self.web_recorder.stop()
+                if os.path.exists(self.video_path_web):
+                    with open(self.video_path_web, "rb") as video:
+                        allure.attach(
+                            video.read(),
+                            name="Video Evidencia de la Prueba",
+                            attachment_type=allure.attachment_type.MP4
+                        )
+        else:
+            video_url = self.get_browserstack_video_url(self.BS_session_id, self.BS_username, self.BS_access_key)
+            if video_url:
+                allure.attach(
+                    video_url,
+                    name="Video Evidencia de la Prueba en BrowserStack",
+                    attachment_type=allure.attachment_type.URI_LIST
+                )
+        # tomo pantallazo despues de la grabacion
+        SC_PATH = f'screenshots/evidences/post_record/post-{random.random()}.png'
+        os.makedirs(os.path.dirname(SC_PATH), exist_ok=True)
+        self.driver.save_screenshot(SC_PATH)
+        with open(SC_PATH, "rb") as image_file:
+            allure.attach(
+                image_file.read(),
+                name="Screenshot Final",
+                attachment_type=allure.attachment_type.PNG
+            )
+
+    """
+    Este metodo verifica si la ejecucion es local o desde Browserstack
+    """
+    def is_local_execution(self):
+        return "hub-use.browserstack.com" not in str(self.driver.capabilities)
+    
+    """
+    Este metodo obtiene la url del video que se graba en Browserstack
+    """
+    def get_browserstack_video_url(self, session_id, user, key):
+        if self.driver.platform in ["android", "ios"]:
+            url = f"https://api.browserstack.com/app-automate/sessions/{session_id}.json" # para mobile
+        else:
+            url = f"https://api.browserstack.com/automate/sessions/{session_id}.json" # para web
+        response = requests.get(url, auth=(user, key))
+        response.raise_for_status()
+        return response.json()["automation_session"]["video_url"]

xlavm_lib-1.1.1/src/xlavm_lib/allure_report/browserstack.py

@@ -0,0 +1,25 @@
+class Browserstack():
+
+    def __init__(self, driver):
+        self.driver = driver
+        
+    def log_debug(self, message):
+        self.driver.execute_script('browserstack_executor: {"action": "annotate", "arguments": {"data":"'+ message +'", "level": "debug"}}')
+        
+    def log_error(self, message):
+        self.driver.execute_script('browserstack_executor: {"action": "annotate", "arguments": {"data":"'+ message +'", "level": "error"}}')
+    
+    def log_info(self, message):
+        self.driver.execute_script('browserstack_executor: {"action": "annotate", "arguments": {"data":"'+ message +'", "level": "info"}}')
+
+    def network_offline(self):
+        self.driver.execute_script('browserstack_executor: {"action": "setNetworkProfile", "arguments": {"profile": "offline"}}')
+
+    def network_online(self):
+        self.driver.execute_script('browserstack_executor: {"action": "setNetworkProfile", "arguments": {"profile": "full"}}')
+        
+    def mark_failed(self, message): 
+        self.driver.execute_script('browserstack_executor: {"action": "setSessionStatus", "arguments": {"status": "failed", "reason": "'+ message +'"}}')
+    
+    def mark_passed(self, message): 
+        self.driver.execute_script('browserstack_executor: {"action": "setSessionStatus", "arguments": {"status": "passed", "reason": "'+ message +'"}}')

xlavm_lib-1.1.1/src/xlavm_lib/allure_report/video_recorder_mobile.py

@@ -0,0 +1,55 @@
+import time
+import base64
+import threading
+import allure
+
+class VideoRecorderMobile:
+    """
+    170 porque el recording_screen del driver para mobiles graba solo 3 minutos, entonces
+    cuando este en 170, haga otra grabacion parte 2
+    """
+    def __init__(self, driver, max_seconds=170, check_interval=5):
+        self.driver = driver
+        self.max_seconds = max_seconds
+        self.check_interval = check_interval
+        self.segment = 1
+        self.last_start = None
+        self.running = False
+        self.thread = None
+
+    def start(self):
+        self.driver.start_recording_screen()
+        self.last_start = time.time()
+        self.running = True
+
+        self.thread = threading.Thread(
+            target=self._watchdog,
+            daemon=True
+        )
+        self.thread.start()
+
+    def _watchdog(self):
+        while self.running:
+            time.sleep(self.check_interval)
+            self.rotate_if_needed()
+
+    def rotate_if_needed(self):
+        elapsed = time.time() - self.last_start
+        if elapsed >= self.max_seconds:
+            self._stop_and_attach()
+            self.driver.start_recording_screen()
+            self.last_start = time.time()
+            self.segment += 1
+
+    def stop(self):
+        self.running = False
+        time.sleep(0.2)  # deja cerrar el hilo
+        self._stop_and_attach()
+
+    def _stop_and_attach(self):
+        video = self.driver.stop_recording_screen()
+        allure.attach(
+            base64.b64decode(video),
+            name=f"Video Evidencia Parte {self.segment}",
+            attachment_type=allure.attachment_type.MP4
+        )

xlavm_lib-1.1.1/src/xlavm_lib/allure_report/video_recorder_web.py

@@ -0,0 +1,44 @@
+import subprocess
+import os
+import time
+import imageio_ffmpeg
+
+class VideoRecorderWeb:
+    def __init__(self, output_path):
+        self.output_path = output_path
+        self.process = None
+        self.ffmpeg = imageio_ffmpeg.get_ffmpeg_exe()
+
+    def start(self):
+        os.makedirs(os.path.dirname(self.output_path), exist_ok=True)
+        self.process = subprocess.Popen(
+            [
+                self.ffmpeg,
+                "-y",
+                "-f", "gdigrab",
+                "-framerate", "30",
+                "-video_size", "1920x1080",
+                "-i", "desktop",
+                "-vcodec", "libx264",
+                "-preset", "ultrafast",
+                "-pix_fmt", "yuv420p",
+                self.output_path
+            ],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            creationflags=subprocess.CREATE_NO_WINDOW
+        )
+        time.sleep(1) # deja que FFmpeg escriba headers
+
+    def stop(self):
+        if not self.process:
+            return
+        try:
+            # CIERRE CORRECTO
+            self.process.stdin.write(b"q\n")
+            self.process.stdin.flush()
+            self.process.wait(timeout=3) # esperar máximo 3s
+        except Exception:
+            # fallback si ffmpeg no responde
+            self.process.kill()