test(e2e_appium): utils

Author: glitchminer

test/e2e_appium/conftest.py

@@ -7,11 +7,12 @@
 from .config.logging_config import get_logger
 from .core import EnvironmentSwitcher
 from .utils.lambdatest_reporter import LambdaTestReporter
+from .utils.screenshot import save_screenshot, save_page_source
 
 
 # Expose fixture modules without star imports
 pytest_plugins = [
-    "fixtures.onboarding_fixture",
+    # "fixtures.onboarding_fixture",  # Disabled - using BaseAppReadyTest instead
 ]
 
 
@@ -161,6 +162,51 @@ def pytest_runtest_makereport(item, call):
             logger = get_logger("session")
             logger.error(f"Failed to report test result to LambdaTest: {e}")
 
+    # Get screenshot and page source artifacts
+    try:
+        if getattr(rep, "failed", False) and not getattr(item, "_failure_artifacts_saved", False):
+            driver = None
+            try:
+                if hasattr(item, "instance") and hasattr(item.instance, "driver"):
+                    driver = item.instance.driver
+            except Exception:
+                driver = None
+
+            if driver:
+                # Resolve screenshots directory from environment config; fallback to 'screenshots'
+                try:
+                    env_name = os.getenv("CURRENT_TEST_ENVIRONMENT", "lambdatest")
+                    switcher = EnvironmentSwitcher()
+                    env_config = switcher.switch_to(env_name)
+                    screenshots_dir = env_config.directories.get("screenshots", "screenshots")
+                except Exception:
+                    screenshots_dir = "screenshots"
+
+                test_id = getattr(item, "name", "test") + (f"__{rep.when}" if getattr(rep, "when", None) else "")
+
+                s_path = None
+                x_path = None
+                try:
+                    s_path = save_screenshot(driver, str(screenshots_dir), f"FAILED_{test_id}")
+                except Exception:
+                    pass
+                try:
+                    x_path = save_page_source(driver, str(screenshots_dir), f"FAILED_{test_id}")
+                except Exception:
+                    pass
+
+                log = get_logger("conftest")
+                if s_path:
+                    log.info(f"Saved failure screenshot: {s_path}")
+                if x_path:
+                    log.info(f"Saved failure page source: {x_path}")
+
+                setattr(item, "_failure_artifacts_saved", True)
+    except Exception as e:
+        log = get_logger("conftest")
+        log.warning(f"Artifact capture failed: {e}")
+
+
 def pytest_terminal_summary(terminalreporter, exitstatus, config):
     if not _logging_setup:
         return

test/e2e_appium/services/__init__.py

@@ -0,0 +1,9 @@
+from .user_profile_service import UserProfileService
+from .app_state_manager import AppStateManager
+from .app_initialization_manager import AppInitializationManager
+
+__all__ = [
+    "UserProfileService",
+    "AppStateManager",
+    "AppInitializationManager",
+]

test/e2e_appium/services/app_initialization_manager.py

@@ -0,0 +1,144 @@
+import time
+
+from config.logging_config import get_logger
+from utils.gestures import Gestures
+
+
+class AppInitializationManager:
+
+    def __init__(self, driver):
+        self.driver = driver
+        self.gestures = Gestures(driver)
+        self.logger = get_logger("app_initialization")
+
+    def perform_initial_activation(
+        self, timeout: float = 15.0, interval: float = 2.0
+    ) -> bool:
+        """Perform initial app activation until UI appears or timeout is reached."""
+        self.logger.debug("🚀 Starting app initialization sequence")
+
+        self._wait_for_session_ready()
+
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            if not self._should_perform_activation_tap():
+                self.logger.debug("↷ UI already present - skipping activation")
+                return True
+
+            if self._perform_activation_tap():
+                if self._wait_for_ui_response(timeout=interval):
+                    self.logger.info("✓ App UI surfaced after activation")
+                    return True
+
+        self.logger.warning("⚠ App activation timeout - UI may not be ready")
+        return False
+
+    def _wait_for_session_ready(
+        self, timeout: float = 2.0, poll_interval: float = 0.2
+    ) -> None:
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                _ = self.driver.get_window_size()
+                try:
+                    _ = self.driver.page_source
+                except Exception:
+                    pass
+                break
+            except Exception:
+                time.sleep(poll_interval)
+
+    def _should_perform_activation_tap(self) -> bool:
+        ui_checks = [
+            self._is_home_container_visible,
+            self._is_welcome_back_visible,
+            self._is_welcome_visible,
+            self._is_ui_content_present,
+        ]
+
+        for check in ui_checks:
+            try:
+                if check():
+                    return False
+            except Exception:
+                continue
+
+        return True
+
+    def _is_home_container_visible(self) -> bool:
+        try:
+            from pages.onboarding import HomePage
+
+            main_app = HomePage(self.driver)
+            return main_app.is_element_visible(
+                main_app.locators.HOME_CONTAINER, timeout=1
+            )
+        except Exception:
+            return False
+
+    def _is_welcome_back_visible(self) -> bool:
+        try:
+            from pages.onboarding import WelcomeBackPage
+
+            welcome_back = WelcomeBackPage(self.driver)
+            return welcome_back.is_welcome_back_screen_displayed(timeout=1)
+        except Exception:
+            return False
+
+    def _is_welcome_visible(self) -> bool:
+        try:
+            from pages.onboarding import WelcomePage
+
+            welcome = WelcomePage(self.driver)
+            return welcome.is_screen_displayed(timeout=1)
+        except Exception:
+            return False
+
+    def _is_ui_content_present(self) -> bool:
+        try:
+            src = self.driver.page_source
+            ui_markers = [
+                "startupOnboardingLayout",
+                "homeContainer.homeDock",
+                "Welcome to Status",
+            ]
+            return any(marker in src for marker in ui_markers)
+        except Exception:
+            return False
+
+    def _perform_activation_tap(self) -> bool:
+        try:
+            coords = self._get_safe_tap_coordinates()
+            if self.gestures.double_tap(coords[0], coords[1]):
+                self.logger.debug("✓ Activation double-tap performed")
+                return True
+            elif self.gestures.tap(coords[0], coords[1]):
+                self.logger.debug("✓ Activation tap performed")
+                return True
+            else:
+                self.logger.debug("⚠ Activation tap failed")
+                return False
+        except Exception as e:
+            self.logger.debug(f"⚠ Activation tap error: {e}")
+            return False
+
+    def _get_safe_tap_coordinates(self) -> tuple:
+        try:
+            size = self.driver.get_window_size()
+            return (size["width"] // 2, size["height"] // 2)
+        except Exception:
+            self.logger.warning("⚠ Could not get window size; using fallback coords")
+            return (500, 300)
+
+    def _wait_for_ui_response(
+        self, timeout: int = 5, poll_interval: float = 0.5
+    ) -> bool:
+        deadline = time.time() + timeout
+
+        while time.time() < deadline:
+            if not self._should_perform_activation_tap():
+                return True
+            time.sleep(poll_interval)
+
+        return False

test/e2e_appium/services/app_state_manager.py

@@ -0,0 +1,126 @@
+import time
+
+from config.logging_config import get_logger
+from core.models import TestAppState
+
+
+class AppStateManager:
+
+    def __init__(self, driver):
+        self.driver = driver
+        self.logger = get_logger("app_state_manager")
+        self.state = TestAppState()
+
+    def detect_current_state(self) -> TestAppState:
+        self.logger.debug("🔍 Detecting app state...")
+
+        if self._is_welcome_screen_displayed():
+            self._set_welcome_state()
+        elif self._is_welcome_back_displayed():
+            self._set_welcome_back_state()
+        elif self._is_app_section_loaded():
+            self._set_app_section_state()
+        elif self._is_home_loaded():
+            self._set_home_state()
+        else:
+            self._set_unknown_state()
+
+        return self.state
+
+    def wait_for_app_ready(self, timeout: int = 30, poll_interval: float = 0.5) -> bool:
+        deadline = time.time() + timeout
+        while time.time() < deadline:
+            try:
+                self.detect_current_state()
+                if self.state.is_home_loaded or self.state.requires_authentication:
+                    return True
+            except Exception:
+                pass
+            time.sleep(poll_interval)
+        return False
+
+    def _is_welcome_screen_displayed(self) -> bool:
+        try:
+            from pages.onboarding import WelcomePage
+
+            welcome = WelcomePage(self.driver)
+            return welcome.is_screen_displayed(timeout=3)
+        except Exception:
+            return False
+
+    def _is_welcome_back_displayed(self) -> bool:
+        try:
+            from pages.onboarding import WelcomeBackPage
+
+            welcome_back = WelcomeBackPage(self.driver)
+            return welcome_back.is_welcome_back_screen_displayed(timeout=5)
+        except Exception:
+            return False
+
+    def _is_app_section_loaded(self) -> bool:
+        try:
+            from pages.app import App
+
+            app = App(self.driver)
+            section = app.active_section()
+            return section in (
+                "home",
+                "messaging",
+                "wallet",
+                "communities",
+                "market",
+                "settings",
+            )
+        except Exception:
+            return False
+
+    def _is_home_loaded(self) -> bool:
+        try:
+            from pages.onboarding import HomePage
+
+            main_app = HomePage(self.driver)
+            return main_app.is_home_loaded()
+        except Exception:
+            return False
+
+    def _set_welcome_state(self):
+        self.state.is_home_loaded = False
+        self.state.current_screen = "welcome"
+        self.state.requires_authentication = False
+        self.state.has_existing_profiles = False
+        self.logger.debug("✓ Welcome screen detected")
+
+    def _set_welcome_back_state(self):
+        self.state.has_existing_profiles = True
+        self.state.current_screen = "welcome_back"
+        self.state.requires_authentication = True
+        self.logger.debug("✓ Welcome back screen detected")
+
+    def _set_app_section_state(self):
+        try:
+            from pages.app import App
+
+            app = App(self.driver)
+            section = app.active_section()
+            if section == "home":
+                self.state.is_home_loaded = True
+                self.state.current_screen = "home"
+                self.state.requires_authentication = False
+                self.logger.debug("✓ Home detected (container)")
+            else:
+                self.state.is_home_loaded = False
+                self.state.current_screen = section
+                self.state.requires_authentication = False
+                self.logger.debug(f"✓ Section detected: {section}")
+        except Exception:
+            self._set_unknown_state()
+
+    def _set_home_state(self):
+        self.state.is_home_loaded = True
+        self.state.current_screen = "home"
+        self.state.requires_authentication = False
+        self.logger.debug("✓ Home detected (fallback)")
+
+    def _set_unknown_state(self):
+        self.state.current_screen = "unknown"
+        self.logger.debug("? Unknown app state detected")