Pruebas de Juegos Móviles: Guía Completa de QA para Aplicaciones de Gaming

using UnityEngine;
using UnityEngine.Profiling;

public class FPSMonitor : MonoBehaviour
{
    private float deltaTime = 0.0f;
    private int frameCount = 0;
    private float fpsSum = 0.0f;

    void Update()
    {
        deltaTime += (Time.unscaledDeltaTime - deltaTime) * 0.1f;
        float fps = 1.0f / deltaTime;

        frameCount++;
        fpsSum += fps;

        // Registrar métricas cada 60 frames
        if (frameCount >= 60)
        {
            float avgFPS = fpsSum / frameCount;
            LogPerformanceMetric("AvgFPS", avgFPS);
            LogPerformanceMetric("MemoryUsage", Profiler.GetTotalAllocatedMemoryLong() / 1048576f);

            frameCount = 0;
            fpsSum = 0.0f;
        }
    }

    void LogPerformanceMetric(string metricName, float value)
    {
        Debug.Log($"[Performance] {metricName}: {value:F2}");
        // Enviar a servicio de analytics
    }
}

# Monitorear FPS en tiempo real en dispositivo Android
adb shell dumpsys gfxinfo com.tujuego.paquete framestats

# Extraer datos de timing de frames
adb shell dumpsys gfxinfo com.tujuego.paquete | grep "50th\|90th\|95th\|99th"

# Monitoreo continuo de FPS con timestamp
while true; do
  echo "$(date +%H:%M:%S) - $(adb shell dumpsys gfxinfo com.tujuego.paquete | grep 'Total frames rendered')"
  sleep 5
done

using UnityEngine;
using System;

public class MemoryTracker : MonoBehaviour
{
    private long lastMemoryUsage = 0;

    public void TrackMemoryUsage(string sceneName)
    {
        // Forzar recolección de basura para medición precisa
        GC.Collect();
        System.Threading.Thread.Sleep(100);

        long totalMemory = GC.GetTotalMemory(false);
        long nativeMemory = UnityEngine.Profiling.Profiler.GetTotalAllocatedMemoryLong();

        Debug.Log($"[Memory] Scene: {sceneName}");
        Debug.Log($"  Managed Heap: {totalMemory / 1048576f:F2} MB");
        Debug.Log($"  Native Memory: {nativeMemory / 1048576f:F2} MB");
        Debug.Log($"  Delta: {(nativeMemory - lastMemoryUsage) / 1048576f:F2} MB");

        lastMemoryUsage = nativeMemory;

        // Alertar si la memoria excede umbrales
        if (nativeMemory > 1024 * 1048576) // 1GB
        {
            Debug.LogWarning("Uso de memoria excede 1GB - riesgo potencial de crash en dispositivos de gama baja");
        }
    }
}

# Resetear estadísticas de batería
adb shell dumpsys batterystats --reset

# Jugar juego durante duración de prueba (ej., 30 minutos)

# Extraer datos de consumo de batería
adb shell dumpsys batterystats com.tujuego.paquete

# Obtener uso específico de batería de la app
adb shell dumpsys batterystats | grep -A 20 "com.tujuego.paquete"

using UnityEngine;
using System.Net.NetworkInformation;
using System.Diagnostics;

public class NetworkMonitor : MonoBehaviour
{
    private Ping ping;
    private Stopwatch stopwatch;

    public void MeasureLatency(string serverAddress)
    {
        ping = new Ping();
        stopwatch = Stopwatch.StartNew();

        ping.SendAsync(serverAddress, 1000, null);
        ping.PingCompleted += PingCompletedCallback;
    }

    private void PingCompletedCallback(object sender, PingCompletedEventArgs e)
    {
        if (e.Reply != null && e.Reply.Status == IPStatus.Success)
        {
            long latency = e.Reply.RoundtripTime;
            LogLatencyMetric(latency);

            if (latency > 150)
                UnityEngine.Debug.LogWarning($"Alta latencia detectada: {latency}ms");
        }
    }

    private void LogLatencyMetric(long latency)
    {
        UnityEngine.Debug.Log($"[Network] Latency: {latency}ms");
        // Categorizar experiencia
        string quality = latency < 50 ? "Excelente" :
                        latency < 100 ? "Buena" :
                        latency < 150 ? "Regular" : "Pobre";
        UnityEngine.Debug.Log($"[Network] Calidad de Conexión: {quality}");
    }
}

using UnityEngine;
using UnityEngine.TestTools;
using NUnit.Framework;
using System.Collections;

public class GameplayTests
{
    [UnityTest]
    public IEnumerator PlayerTakesDamageCorrectly()
    {
        // Arrange: Cargar escena de juego
        UnityEngine.SceneManagement.SceneManager.LoadScene("GameScene");
        yield return null; // Esperar un frame para carga de escena

        var player = GameObject.FindObjectOfType<PlayerController>();
        int initialHealth = player.Health;

        // Act: Aplicar daño
        player.TakeDamage(25);
        yield return new WaitForSeconds(0.1f);

        // Assert: Verificar que la salud disminuyó
        Assert.AreEqual(initialHealth - 25, player.Health);
        Assert.IsTrue(player.IsAlive);
    }

    [UnityTest]
    public IEnumerator GameMaintains60FPSUnderLoad()
    {
        // Arrange: Generar 100 enemigos
        var enemyPrefab = Resources.Load<GameObject>("Enemy");
        for (int i = 0; i < 100; i++)
        {
            GameObject.Instantiate(enemyPrefab, Random.insideUnitSphere * 50, Quaternion.identity);
        }

        yield return null;

        // Act: Monitorear FPS por 5 segundos
        float testDuration = 5.0f;
        float elapsed = 0;
        int frameCount = 0;
        float totalFPS = 0;

        while (elapsed < testDuration)
        {
            totalFPS += 1.0f / Time.unscaledDeltaTime;
            frameCount++;
            elapsed += Time.unscaledDeltaTime;
            yield return null;
        }

        float avgFPS = totalFPS / frameCount;

        // Assert: FPS promedio debe estar sobre 55 (permitiendo margen de 5 FPS)
        Assert.Greater(avgFPS, 55f, $"FPS promedio fue {avgFPS:F1}, esperado >55");
    }
}

using NUnit.Framework;

public class InventorySystemTests
{
    private InventorySystem inventory;

    [SetUp]
    public void Setup()
    {
        inventory = new InventorySystem(maxSlots: 20);
    }

    [Test]
    public void AddItem_IncreasesItemCount()
    {
        // Arrange
        var item = new Item("Health Potion", ItemType.Consumable);

        // Act
        bool added = inventory.AddItem(item);

        // Assert
        Assert.IsTrue(added);
        Assert.AreEqual(1, inventory.ItemCount);
    }

    [Test]
    public void AddItem_ExceedingMaxSlots_ReturnsFalse()
    {
        // Arrange
        for (int i = 0; i < 20; i++)
        {
            inventory.AddItem(new Item($"Item{i}", ItemType.Material));
        }

        // Act
        bool added = inventory.AddItem(new Item("ExtraItem", ItemType.Material));

        // Assert
        Assert.IsFalse(added);
        Assert.AreEqual(20, inventory.ItemCount);
    }
}

#include "Tests/AutomationCommon.h"
#include "Misc/AutomationTest.h"

IMPLEMENT_SIMPLE_AUTOMATION_TEST(
    FPlayerMovementTest,
    "Game.Player.Movement",
    EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter
)

bool FPlayerMovementTest::RunTest(const FString& Parameters)
{
    // Arrange: Obtener personaje del jugador
    APlayerCharacter* Player = GetWorld()->SpawnActor<APlayerCharacter>();
    FVector InitialLocation = Player->GetActorLocation();

    // Act: Simular movimiento hacia adelante por 1 segundo
    Player->MoveForward(1.0f);
    GetWorld()->Tick(LEVELTICK_All, 1.0f);

    // Assert: El jugador debería haberse movido hacia adelante
    FVector FinalLocation = Player->GetActorLocation();
    TestTrue("Player moved forward", FinalLocation.X > InitialLocation.X);

    // Cleanup
    Player->Destroy();

    return true;
}

class FGamePerformanceTest : public FAutomationTestBase
{
public:
    bool RunPerfTest()
    {
        // Lanzar juego con mapa específico
        LaunchGame("TestMap_Combat");

        // Esperar inicialización del juego
        WaitForGameReady();

        // Generar escenario de prueba (100 enemigos AI)
        SpawnEnemies(100);

        // Monitorear rendimiento por 60 segundos
        bool PassedFPSTest = MonitorFPS(60.0f, MinFPS: 30.0f);
        bool PassedMemoryTest = MonitorMemory(60.0f, MaxMB: 2048);

        return PassedFPSTest && PassedMemoryTest;
    }
};

# test_matrix.yaml
platforms:
  - name: Android
    devices:
      - model: flame  # Pixel 4
        version: 29
        orientation: portrait
      - model: starqlteue  # Galaxy S9+
        version: 28
        orientation: landscape
      - model: OnePlus7
        version: 30
        orientation: portrait

test-targets:
  - game-launch-test
  - tutorial-completion-test
  - 30min-gameplay-test

using UnityEngine;
using UnityEngine.Purchasing;

public class IAPTestValidator
{
    public void ValidatePurchaseFlow(Product product)
    {
        // Escenarios de prueba:
        // 1. Compra exitosa
        Assert.True(ProcessPurchase(product.transactionID));
        Assert.True(VerifyReceipt(product.receipt));
        Assert.True(GrantVirtualGoods(product.definition.id));

        // 2. Cancelación de compra
        CancelPurchase(product);
        Assert.False(WasVirtualGoodsGranted(product.definition.id));

        // 3. Restauración de compra
        RestorePurchases();
        Assert.True(NonConsumablesRestored());

        // 4. Fallo de red durante compra
        SimulateNetworkFailure();
        Assert.True(PurchaseQueuedForRetry(product));
    }
}

using UnityEngine;

public class ProgressionAnalytics
{
    public void TrackLevelCompletion(int levelID, float completionTime, int attempts)
    {
        // Calcular métricas de dificultad
        float avgCompletionTime = GetAverageCompletionTime(levelID);
        float completionRate = GetCompletionRate(levelID);

        // Señalar problemas de balance
        if (completionRate < 0.4f)
        {
            Debug.LogWarning($"Nivel {levelID} tiene baja tasa de completación: {completionRate:P0}");
        }

        if (completionTime > avgCompletionTime * 2)
        {
            Debug.Log($"Jugador luchó con nivel {levelID} - tomó {completionTime:F1}s vs promedio {avgCompletionTime:F1}s");
        }

        // Seguir ritmo de progresión
        LogMetric("level_completion", new {
            level = levelID,
            duration = completionTime,
            attempts = attempts,
            player_level = GetPlayerLevel(),
            equipment_power = GetEquipmentPower()
        });
    }
}

import asyncio
import aiohttp
import time

class GameServerLoadTest:
    def __init__(self, server_url, concurrent_users):
        self.server_url = server_url
        self.concurrent_users = concurrent_users
        self.results = []

    async def simulate_player(self, player_id):
        async with aiohttp.ClientSession() as session:
            # Conectar a servidor
            start_time = time.time()

            async with session.ws_connect(f"{self.server_url}/game") as ws:
                # Autenticar
                await ws.send_json({
                    "action": "authenticate",
                    "player_id": player_id
                })

                # Unirse a matchmaking
                await ws.send_json({
                    "action": "join_matchmaking",
                    "game_mode": "ranked"
                })

                # Esperar partida
                match_found = False
                while not match_found:
                    msg = await ws.receive_json()
                    if msg["type"] == "match_found":
                        match_time = time.time() - start_time
                        self.results.append({
                            "player_id": player_id,
                            "match_time": match_time
                        })
                        match_found = True

    async def run_test(self):
        tasks = [
            self.simulate_player(f"player_{i}")
            for i in range(self.concurrent_users)
        ]
        await asyncio.gather(*tasks)

        # Analizar resultados
        avg_match_time = sum(r["match_time"] for r in self.results) / len(self.results)
        print(f"Tiempo promedio de matchmaking: {avg_match_time:.2f}s")
        print(f"Partidas exitosas: {len(self.results)}/{self.concurrent_users}")

# Ejecutar prueba con 1000 jugadores concurrentes
test = GameServerLoadTest("wss://game-server.example.com", 1000)
asyncio.run(test.run_test())

using UnityEngine;

public class QualityPresetTester : MonoBehaviour
{
    [System.Serializable]
    public class QualityBenchmark
    {
        public string qualityLevel;
        public float minFPS;
        public float maxMemoryMB;
        public float testDuration;
    }

    public QualityBenchmark[] benchmarks = new QualityBenchmark[]
    {
        new QualityBenchmark { qualityLevel = "Low", minFPS = 30, maxMemoryMB = 512, testDuration = 60 },
        new QualityBenchmark { qualityLevel = "Medium", minFPS = 45, maxMemoryMB = 768, testDuration = 60 },
        new QualityBenchmark { qualityLevel = "High", minFPS = 60, maxMemoryMB = 1024, testDuration = 60 }
    };

    public void RunQualityTests()
    {
        foreach (var benchmark in benchmarks)
        {
            QualitySettings.SetQualityLevel(GetQualityLevelIndex(benchmark.qualityLevel));

            float avgFPS = MeasureAverageFPS(benchmark.testDuration);
            float peakMemory = MeasurePeakMemory(benchmark.testDuration);

            bool fpsPass = avgFPS >= benchmark.minFPS;
            bool memoryPass = peakMemory <= benchmark.maxMemoryMB;

            Debug.Log($"Calidad: {benchmark.qualityLevel} - FPS: {avgFPS:F1} (objetivo: {benchmark.minFPS}) - Memoria: {peakMemory:F0}MB (máx: {benchmark.maxMemoryMB}MB)");
            Debug.Log($"Resultado: {(fpsPass && memoryPass ? "PASS" : "FAIL")}");
        }
    }
}

using UnityEngine;

public class HapticsValidator : MonoBehaviour
{
    public void TestHapticFeedback()
    {
        // Probar háptico ligero
        Handheld.Vibrate();  // Impacto ligero iOS

        // Validar disparadores hápticos:
        // - Presión de botón: Háptico ligero
        // - Recolección de ítem: Háptico medio
        // - Daño al jugador: Háptico fuerte
        // - Game over: Vibración en patrón

        // Verificar que háptico respeta:
        // - Modo silencioso del dispositivo (iOS)
        // - Configuración de preferencia del usuario
        // - Modo ahorro de batería
    }
}

# unity-cloud-build.yaml
targets:
  android-production (como se discute en [Cross-Platform Mobile Testing: Strategies for Multi-Device Success](/blog/cross-platform-mobile-testing)):
    platform: android
    scriptingBackend: il2cpp
    buildSettings:
      development: false
      compressionMethod: lz4
    pre-build-script: Scripts/PreBuild.sh
    post-build-script: Scripts/PostBuild.sh

  ios-production:
    platform: ios
    scriptingBackend: il2cpp
    xcodeVersion: latest
    buildSettings:
      development: false

test-suites:
  unit-tests:
    platform: editmode
    testCategories: [Unit, Integration]

  playmode-tests:
    platform: playmode
    testCategories: [Functional, Performance]
    minPassRate: 95%

name: Game Build and Test

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

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - uses: game-ci/unity-test-runner@v2
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          testMode: all
          artifactsPath: test-results

      - name: Upload test results
        uses: actions/upload-artifact@v3
        with:
          name: Test results
          path: test-results

  build:
    needs: test
    runs-on: ubuntu-latest
    strategy:
      matrix:
        platform: [Android, iOS]
    steps:
      - uses: game-ci/unity-builder@v2
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
        with:
          targetPlatform: ${{ matrix.platform }}

      - name: Deploy to TestFlight/Play Console
        run: ./deploy-scripts/${{ matrix.platform }}.sh