Pruebas Móviles Multiplataforma: Estrategias para el Éxito Multi-Dispositivo

import boto3

# Inicializar cliente de Device Farm
client = boto3.client('devicefarm', region_name='us-west-2')

# Crear una ejecución de prueba
response = client.schedule_run(
    projectArn='arn:aws:devicefarm:us-west-2:111222333:project:xxxxx',
    appArn='arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx',
    devicePoolArn='arn:aws:devicefarm:us-west-2:111222333:devicepool:xxxxx',
    test={
        'type': 'APPIUM_PYTHON',
        'testPackageArn': 'arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx'
    },
    configuration={
        'extraDataPackageArn': 'arn:aws:devicefarm:us-west-2:111222333:upload:xxxxx',
        'locale': 'en_US',
        'location': {
            'latitude': 37.422,
            'longitude': -122.084
        }
    }
)

print(f"ARN de ejecución de prueba: {response['run']['arn']}")

// Configuración de BrowserStack para Appium
const capabilities = {
  'browserstack.user': process.env.BROWSERSTACK_USERNAME,
  'browserstack.key': process.env.BROWSERSTACK_ACCESS_KEY,
  'app': 'bs://c700ce60cf13ae8ed97705a55b8e022f13c5827c',
  'device': 'Samsung Galaxy S23',
  'os_version': '13.0',
  'project': 'Suite de Pruebas Multiplataforma',
  'build': 'Android Build 1.0',
  'name': 'Prueba de Flujo de Pago',
  'browserstack.debug': true,
  'browserstack.networkLogs': true
};

const driver = await new webdriver.Builder()
  .usingServer('http://hub-cloud.browserstack.com/wd/hub')
  .withCapabilities(capabilities)
  .build();

@Test
public void testCrossPlatformLogin() {
    DesiredCapabilities caps = new DesiredCapabilities();
    caps.setCapability("platformName", "Android");
    caps.setCapability("platformVersion", "13");
    caps.setCapability("deviceName", "Google Pixel 7");
    caps.setCapability("app", "sauce-storage:MyApp.apk");
    caps.setCapability("automationName", "UiAutomator2");
    caps.setCapability("name", "Prueba de Login - Android 13");

    String sauceUrl = "https://ondemand.us-west-1.saucelabs.com:443/wd/hub";
    AppiumDriver driver = new AppiumDriver(new URL(sauceUrl), caps);

    // Lógica de prueba aquí
    driver.quit();
}

# compatibility-matrix.yml
platforms:
  ios:
    priority_devices:
      - { model: "iPhone 15 Pro", os: "17.0", priority: 1 }
      - { model: "iPhone 14", os: "16.0", priority: 1 }
      - { model: "iPhone 13", os: "15.0", priority: 2 }
      - { model: "iPad Pro 12.9", os: "17.0", priority: 2 }

    os_coverage:
      - version: "17.0"  # Última
      - version: "16.0"  # N-1
      - version: "15.0"  # N-2

  android:
    priority_devices:
      - { model: "Samsung Galaxy S23", os: "13.0", priority: 1 }
      - { model: "Google Pixel 7", os: "13.0", priority: 1 }
      - { model: "OnePlus 11", os: "13.0", priority: 2 }
      - { model: "Samsung Galaxy A54", os: "13.0", priority: 2 }
      - { model: "Samsung Galaxy S21", os: "12.0", priority: 2 }

    os_coverage:
      - version: "13.0"  # Última
      - version: "12.0"  # N-1
      - version: "11.0"  # N-2
      - version: "10.0"  # Soporte a largo plazo

    screen_categories:
      - small: "< 5 pulgadas"
      - medium: "5-6 pulgadas"
      - large: "> 6 pulgadas"
      - tablet: "> 7 pulgadas"

test_coverage:
  p1_devices: "Suite de pruebas 100%"
  p2_devices: "Flujos principales + pruebas de humo"
  p3_devices: "Solo pruebas de humo"

from appium import webdriver
from appium.options.android import UiAutomator2Options
from appium.options.ios import XCUITestOptions

class CrossPlatformTest:
    def __init__(self, platform):
        self.platform = platform
        self.driver = self._initialize_driver()

    def _initialize_driver(self):
        if self.platform == 'android':
            options = UiAutomator2Options()
            options.platform_name = 'Android'
            options.device_name = 'Android Emulator'
            options.app = '/path/to/app.apk'
            options.automation_name = 'UiAutomator2'
        else:  # iOS
            options = XCUITestOptions()
            options.platform_name = 'iOS'
            options.device_name = 'iPhone 14 Simulator'
            options.app = '/path/to/app.app'
            options.automation_name = 'XCUITest'

        return webdriver.Remote('http://localhost:4723', options=options)

    def test_login_flow(self):
        # Localización de elementos independiente de plataforma
        username_field = self.driver.find_element(
            by='accessibility id',
            value='username_input'
        )
        password_field = self.driver.find_element(
            by='accessibility id',
            value='password_input'
        )
        login_button = self.driver.find_element(
            by='accessibility id',
            value='login_button'
        )

        username_field.send_keys('testuser@example.com')
        password_field.send_keys('SecurePass123!')
        login_button.click()

        # Verificar login exitoso
        assert self.driver.find_element(
            by='accessibility id',
            value='home_screen'
        ).is_displayed()

    def teardown(self):
        self.driver.quit()

# Ejecutar en ambas plataformas
android_test = CrossPlatformTest('android')
android_test.test_login_flow()
android_test.teardown()

ios_test = CrossPlatformTest('ios')
ios_test.test_login_flow()
ios_test.teardown()

// detox.config.js - Configuración de Detox multiplataforma
module.exports = {
  testRunner: 'jest',
  runnerConfig: 'e2e/config.json',
  apps: {
    'ios.debug': {
      type: 'ios.app',
      binaryPath: 'ios/build/Build/Products/Debug-iphonesimulator/MyApp.app',
      build: 'xcodebuild -workspace ios/MyApp.xcworkspace -scheme MyApp -configuration Debug -sdk iphonesimulator -derivedDataPath ios/build'
    },
    'android.debug': {
      type: 'android.apk',
      binaryPath: 'android/app/build/outputs/apk/debug/app-debug.apk',
      build: 'cd android && ./gradlew assembleDebug assembleAndroidTest -DtestBuildType=debug'
    }
  },
  devices: {
    simulator: {
      type: 'ios.simulator',
      device: { type: 'iPhone 14' }
    },
    emulator: {
      type: 'android.emulator',
      device: { avdName: 'Pixel_7_API_33' }
    }
  },
  configurations: {
    'ios.sim.debug': {
      device: 'simulator',
      app: 'ios.debug'
    },
    'android.emu.debug': {
      device: 'emulator',
      app: 'android.debug'
    }
  }
};

// integration_test/cross_platform_test.dart
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:my_app/main.dart' as app;
import 'dart:io' show Platform;

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  group('Prueba de Login Multiplataforma', () {
    testWidgets('debería iniciar sesión exitosamente en ambas plataformas',
      (WidgetTester tester) async {
      app.main();
      await tester.pumpAndSettle();

      // Ajustes específicos de plataforma
      if (Platform.isIOS) {
        // Comportamiento específico de iOS
        await tester.tap(find.text('Continuar con Apple'));
      } else {
        // Comportamiento específico de Android
        await tester.tap(find.text('Continuar con Google'));
      }
      await tester.pumpAndSettle();

      // Pasos de prueba comunes
      await tester.enterText(
        find.byKey(Key('email_field')),
        'test@example.com'
      );
      await tester.enterText(
        find.byKey(Key('password_field')),
        'password123'
      );
      await tester.tap(find.byKey(Key('login_button')));
      await tester.pumpAndSettle();

      expect(find.text('Bienvenido de Nuevo'), findsOneWidget);
    });
  });
}

class PlatformHandler:
    def __init__(self, driver, platform):
        self.driver = driver
        self.platform = platform

    def handle_permissions(self, permission_type):
        if self.platform == 'iOS':
            # Diálogo de permisos iOS
            if permission_type == 'location':
                self.driver.find_element(
                    by='xpath',
                    value='//XCUIElementTypeButton[@name="Allow While Using App"]'
                ).click()
        else:  # Android
            # Diálogo de permisos Android
            if permission_type == 'location':
                self.driver.find_element(
                    by='id',
                    value='com.android.permissioncontroller:id/permission_allow_foreground_only_button'
                ).click()

    def enable_biometric(self):
        if self.platform == 'iOS':
            # Simular Face ID
            self.driver.execute_script('mobile: enrollBiometric', {
                'isEnabled': True
            })
        else:  # Android
            # Simular huella digital
            self.driver.finger_print(1)

# Suite de pruebas de configuración de pantalla
SCREEN_CONFIGS = [
    {'name': 'Teléfono Pequeño', 'width': 375, 'height': 667, 'dpi': 326},   # iPhone SE
    {'name': 'Teléfono Mediano', 'width': 390, 'height': 844, 'dpi': 460},   # iPhone 14
    {'name': 'Teléfono Grande', 'width': 430, 'height': 932, 'dpi': 460},    # iPhone 14 Pro Max
    {'name': 'Tableta', 'width': 1024, 'height': 1366, 'dpi': 264},          # iPad Pro
    {'name': 'Android Pequeño', 'width': 360, 'height': 640, 'dpi': 320},
    {'name': 'Android Mediano', 'width': 412, 'height': 915, 'dpi': 420},
    {'name': 'Android Grande', 'width': 384, 'height': 854, 'dpi': 440},
]

def test_responsive_layout(driver, config):
    """Probar que el diseño se adapta correctamente a diferentes tamaños de pantalla"""
    # Establecer tamaño de pantalla (emulador/simulador)
    driver.set_window_size(config['width'], config['height'])

    # Verificar que elementos críticos son visibles y tienen tamaño apropiado
    header = driver.find_element(by='id', value='header')
    assert header.is_displayed()

    # Verificar que el texto no se desborda
    product_title = driver.find_element(by='id', value='product_title')
    assert product_title.size['width'] <= config['width']

    # Verificar que las imágenes escalan apropiadamente
    product_image = driver.find_element(by='id', value='product_image')
    assert product_image.size['width'] <= config['width'] * 0.9

    # Captura de pantalla para regresión visual
    driver.save_screenshot(f"layout_{config['name']}.png")

# version-compatibility-strategy.yml
minimum_supported_versions:
  ios: "15.0"    # Soportar últimas 3 versiones principales
  android: "10"  # Nivel de API 29

testing_strategy:
  new_features:
    # Probar nuevas características de OS en versiones más recientes
    - ios_17_features:
        - interactive_widgets
        - contact_posters
    - android_13_features:
        - themed_icons
        - per_app_language

  deprecated_apis:
    # Probar fallbacks para funcionalidad obsoleta
    - monitor_deprecation_warnings
    - implement_alternative_apis
    - gradual_migration_plan

  backward_compatibility:
    # Asegurar degradación elegante
    - feature_flags_for_new_apis
    - runtime_os_version_checks
    - fallback_implementations

test_matrix:
  regression_testing:
    - current_version  # iOS 17, Android 13
    - n_minus_1        # iOS 16, Android 12
    - n_minus_2        # iOS 15, Android 11

  edge_testing:
    - minimum_supported  # iOS 15, Android 10
    - beta_versions      # iOS 18 beta, Android 14 beta

// Verificación de versión iOS
if #available(iOS 16.0, *) {
    // Usar características de iOS 16+
    configureActivityKit()
} else {
    // Fallback para versiones antiguas
    configureLocalNotifications()
}

// Verificación de versión Android
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    // Permisos de notificación Android 13+
    requestNotificationPermission()
} else {
    // Permiso automático en versiones antiguas
    setupNotifications()
}

# analytics_based_selection.py
import pandas as pd

# Cargar análisis de usuarios reales
device_analytics = pd.read_csv('user_devices.csv')

# Seleccionar dispositivos cubriendo 90% de la base de usuarios
top_devices = device_analytics.nlargest(10, 'user_percentage')

print("Dispositivos prioritarios (cobertura 90%):")
for idx, device in top_devices.iterrows():
    print(f"{device['model']} - {device['user_percentage']}% usuarios")

// Jenkinsfile - Configuración de ejecución paralela
pipeline {
    agent any
    stages {
        stage('Pruebas Móviles Paralelas') {
            parallel {
                stage('Suite iOS') {
                    steps {
                        script {
                            // Ejecutar en 3 dispositivos iOS concurrentes
                            sh './run_ios_tests.sh --parallel 3'
                        }
                    }
                }
                stage('Suite Android') {
                    steps {
                        script {
                            // Ejecutar en 5 dispositivos Android concurrentes
                            sh './run_android_tests.sh --parallel 5'
                        }
                    }
                }
            }
        }
    }
}

#!/bin/bash
# Usar emuladores para retroalimentación rápida, dispositivos reales para flujos críticos

# Pruebas de humo rápidas en emuladores (5 minutos)
./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.app.SmokeTests

# Flujos críticos en dispositivos reales (20 minutos)
./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.class=com.app.CriticalFlows \
  -Pandroid.device.cloud=browserstack

# pytest_parallel_config.py
import pytest
from concurrent.futures import ThreadPoolExecutor
from appium import webdriver

DEVICE_CONFIGS = [
    {'platform': 'iOS', 'device': 'iPhone 14', 'version': '16.0'},
    {'platform': 'iOS', 'device': 'iPhone 13', 'version': '15.0'},
    {'platform': 'Android', 'device': 'Pixel 7', 'version': '13.0'},
    {'platform': 'Android', 'device': 'Galaxy S23', 'version': '13.0'},
]

def run_test_on_device(config):
    """Ejecutar suite de pruebas en una configuración de dispositivo específica"""
    driver = initialize_driver(config)
    try:
        # Ejecutar suite de pruebas
        run_login_tests(driver)
        run_checkout_tests(driver)
        run_profile_tests(driver)
        return {'config': config, 'status': 'PASSED'}
    except Exception as e:
        return {'config': config, 'status': 'FAILED', 'error': str(e)}
    finally:
        driver.quit()

def parallel_test_execution():
    """Ejecutar pruebas en paralelo en múltiples dispositivos"""
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(run_test_on_device, DEVICE_CONFIGS))

    # Agregar resultados
    passed = sum(1 for r in results if r['status'] == 'PASSED')
    failed = sum(1 for r in results if r['status'] == 'FAILED')

    print(f"Resultados: {passed} aprobados, {failed} fallidos")
    return all(r['status'] == 'PASSED' for r in results)

if __name__ == '__main__':
    success = parallel_test_execution()
    exit(0 if success else 1)

# test-execution-strategy.yml
test_stages:
  development:
    environment: "local_emulators"
    frequency: "every_commit"
    coverage: "unit_tests + smoke_tests"
    cost: "$0"

  continuous_integration:
    environment: "cloud_emulators"
    frequency: "every_pull_request"
    coverage: "regression_suite"
    cost: "$50/month"

  nightly:
    environment: "cloud_real_devices (top_5)"
    frequency: "daily"
    coverage: "full_regression"
    cost: "$200/month"

  release_candidate:
    environment: "cloud_real_devices (full_matrix)"
    frequency: "pre_release"
    coverage: "comprehensive_testing"
    cost: "$500/release"

# .github/workflows/mobile-testing.yml
name: Pruebas Móviles Multiplataforma

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  android_emulator_tests:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Configurar JDK 17
        uses: actions/setup-java@v3
        with:
          java-version: '17'
          distribution: 'temurin'

      - name: Ejecutar Pruebas de Emulador Android
        uses: reactivecircus/android-emulator-runner@v2
        with:
          api-level: 33
          target: google_apis
          arch: x86_64
          script: ./gradlew connectedAndroidTest

      - name: Subir Reportes de Pruebas
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: android-test-reports
          path: app/build/reports/androidTests/

  ios_simulator_tests:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Seleccionar Xcode
        run: sudo xcode-select -s /Applications/Xcode_15.0.app

      - name: Ejecutar Pruebas iOS
        run: |
          xcodebuild test \
            -workspace MyApp.xcworkspace \
            -scheme MyApp \
            -destination 'platform=iOS Simulator,name=iPhone 14,OS=17.0'

      - name: Subir Resultados de Pruebas
        uses: actions/upload-artifact@v3
        if: always()
        with:
          name: ios-test-results
          path: build/test-results/

  browserstack_real_devices:
    runs-on: ubuntu-latest
    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v3

      - name: Configurar Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Instalar dependencias
        run: npm ci

      - name: Ejecutar Pruebas BrowserStack
        env:
          BROWSERSTACK_USERNAME: ${{ secrets.BROWSERSTACK_USERNAME }}
          BROWSERSTACK_ACCESS_KEY: ${{ secrets.BROWSERSTACK_ACCESS_KEY }}
        run: |
          npm run test:browserstack:parallel

      - name: Generar Reporte de Pruebas
        run: npm run generate-report

      - name: Subir Resultados BrowserStack
        uses: actions/upload-artifact@v3
        with:
          name: browserstack-results
          path: test-results/

  test_report:
    needs: [android_emulator_tests, ios_simulator_tests, browserstack_real_devices]
    runs-on: ubuntu-latest
    if: always()
    steps:
      - name: Descargar todos los artefactos
        uses: actions/download-artifact@v3

      - name: Fusionar y publicar resultados de pruebas
        run: |
          # Agregar resultados de todas las plataformas
          python scripts/merge_test_results.py

      - name: Comentar PR con resultados
        uses: actions/github-script@v6
        if: github.event_name == 'pull_request'
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('test-summary.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });