Top Game QA Automation Tools in 2026

from appium import webdriver
from appium.options import UiAutomator2Options

options = UiAutomator2Options()
options.app_package = "com.studio.mygame"
driver = webdriver.Remote("http://localhost:4723", options=options)

# GameDriver Python client
from gdio.unity_api import UnityApiClient

client = UnityApiClient()
client.launch(game_path="MyGame.exe")
client.connect()

# Move player to a specific position
client.navAgentMoveToPoint("Player", Vector3(10, 0, 20))

# Interact with in-game UI
client.click(object_name="StartGameButton")

# Query game state
health = client.getObjectField("Player", "CurrentHealth")
assert health > 0, "Player should be alive"

// k6 script for game server load test (WebSocket-based)
import ws from 'k6/ws';
import { check, sleep } from 'k6';

export const options = {
  stages: [
    { duration: '2m', target: 100 },    // Ramp to 100 concurrent players
    { duration: '10m', target: 1000 },  // Hold at 1000 players
    { duration: '2m', target: 0 },      // Ramp down
  ],
};

export default function () {
  const response = ws.connect('wss://gameserver.example.com/ws', {}, function(socket) {
    socket.on('open', () => {
      socket.send(JSON.stringify({ type: 'join_lobby', player_id: `player-${__VU}` }));
    });
    
    socket.on('message', (msg) => {
      const data = JSON.parse(msg);
      check(data, {
        'join confirmed': (d) => d.type === 'join_confirmed',
      });
    });
    
    socket.setTimeout(() => socket.close(), 30000);  // Play for 30 seconds
  });
  
  check(response, { 'status is 101': (r) => r && r.status === 101 });
}

# Simple bot agent for an action game
class GameplayBot:
    def __init__(self, game_client, behavior: str = "random"):
        self.client = game_client
        self.behavior = behavior
    
    def run_session(self, duration_minutes: int = 10):
        """Run a gameplay session for the specified duration."""
        start = time.time()
        actions_taken = 0
        errors = []
        
        while time.time() - start < duration_minutes * 60:
            try:
                action = self._choose_action()
                self.client.execute_action(action)
                actions_taken += 1
                time.sleep(random.uniform(0.5, 2.0))  # Random think time
            except GameException as e:
                errors.append({"action": action, "error": str(e), 
                               "timestamp": time.time()})
        
        return {
            "session_duration_minutes": (time.time() - start) / 60,
            "actions_taken": actions_taken,
            "errors": errors,
            "crash_detected": self.client.game_has_crashed()
        }
    
    def _choose_action(self):
        if self.behavior == "random":
            return random.choice(self.client.get_available_actions())
        elif self.behavior == "aggressive":
            return random.choice(["attack", "attack", "attack", "dodge", "use_ability"])
        elif self.behavior == "explorer":
            return random.choice(["move_forward", "move_right", "move_left", 
                                  "interact", "open_menu"])

def test_no_crashes_in_1000_random_actions():
    """Fuzz testing with a random bot — should not crash."""
    bot = GameplayBot(game_client=GameClient(), behavior="random")
    result = bot.run_session(duration_minutes=10)
    
    assert not result["crash_detected"], "Game crashed during bot session"
    assert len(result["errors"]) == 0, \
        f"Errors during bot session: {result['errors'][:5]}"

# .github/workflows/game-qa.yml
name: Game QA Pipeline

on: [push, pull_request]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: game-ci/unity-test-runner@v4
        with:
          testMode: editmode
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
  
  build:
    needs: unit-tests
    runs-on: ubuntu-latest
    steps:
      - uses: game-ci/unity-builder@v4
        with:
          targetPlatform: Android
        env:
          UNITY_LICENSE: ${{ secrets.UNITY_LICENSE }}
  
  device-tests:
    needs: build
    runs-on: ubuntu-latest
    steps:
      - name: Upload to Firebase Test Lab
        run: |
          gcloud firebase test android run \
            --type robo \
            --app build/MyGame.apk \
            --device model=Pixel6,version=33 \
            --device model=samsungA53x,version=33 \
            --robo-directives click:startButton=1
  
  performance-tests:
    needs: build
    runs-on: [self-hosted, android-device]
    steps:
      - name: Run performance benchmarks
        run: pytest tests/performance/ -v --device-udid=$DEVICE_UDID