Warum dedizierte Hardware für Tests?
UI-Tests auf gemeinsam genutzten oder lokalen Maschinen führen zu Instabilität, Inkonsistenz und Engpässen. Ein dedizierter Mac mini M4 Build Server löst diese Probleme.
Konsistente Ergebnisse
Keine anderen Prozesse konkurrieren um CPU oder RAM. Tests laufen jedes Mal in einer sauberen, kontrollierten Umgebung ab, wodurch instabile Testfehler durch Ressourcenkonkurrenz vermieden werden.
Parallele Ausführung
Führen Sie Tests über mehrere iOS-Simulator-Instanzen gleichzeitig aus. Ein Mac mini M4 Pro (12-Kern-CPU, 24 GB) bewältigt 4-6 parallele Simulator-Instanzen ohne Leistungseinbußen.
Verfügbarkeit rund um die Uhr
Tests laufen jederzeit: nächtliche Regressions-Suites, Validierung nach dem Merge oder auf Abruf. Der Server ist immer bereit, kein Entwickler-Laptop erforderlich.
XCTest auf einem dedizierten Mac
XCTest ist Apples integriertes Test-Framework, das mit Xcode geliefert wird. XCUITest erweitert es für UI-Tests. Beide laufen nativ und erfordern keine zusätzliche Einrichtung über Xcode hinaus.
XCTest über die Befehlszeile ausführen
# Use any device listed by: xcrun simctl list devices available
# Run all unit tests
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
-resultBundlePath ./TestResults/UnitTests.xcresult
# Run only UI tests
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyAppUITests \
-destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
-resultBundlePath ./TestResults/UITests.xcresult
# Run a specific test class
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-only-testing:MyAppTests/LoginTests
# Run a specific test method
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-only-testing:MyAppTests/LoginTests/testSuccessfulLogin
Tests auf mehreren Zielen
# Test on multiple iPhone models simultaneously
# (each name must exist in: xcrun simctl list devices available;
# create a missing one with: xcrun simctl create "iPhone 17e" "iPhone 17e")
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-destination 'platform=iOS Simulator,name=iPhone 18 Pro Max' \
-destination 'platform=iOS Simulator,name=iPhone 17e' \
-destination 'platform=iOS Simulator,name=iPad Pro 13-inch (M5)' \
-resultBundlePath ./TestResults/MultiDevice.xcresult
# List all available destinations
xcodebuild -showdestinations \
-workspace MyApp.xcworkspace \
-scheme MyApp
Ergebnis-Bundles und Screenshots
# Test results summary as JSON (Xcode 16 and later)
xcrun xcresulttool get test-results summary \
--path ./TestResults/UITests.xcresult
# Every test with its result
xcrun xcresulttool get test-results tests \
--path ./TestResults/UITests.xcresult
# Export test attachments (screenshots, videos)
xcrun xcresulttool export attachments \
--path ./TestResults/UITests.xcresult \
--output-path ./TestArtifacts
Appium-Einrichtung für iOS
Appium ist ein Open-Source-Automatisierungs-Framework, mit dem Sie Tests in jeder Sprache (Python, JavaScript, Java usw.) schreiben und gegen iOS-Apps auf Simulatoren oder Geräten ausführen können. Es nutzt Apples XCUITest-Treiber im Hintergrund.
Appium auf Ihrem Mac-Server installieren
# Install Node.js via Homebrew
brew install node
# Install Appium globally (npm installs the latest release)
npm install -g appium
# Install the XCUITest driver for iOS
appium driver install xcuitest
# Verify installation
appium --version
appium driver list --installed
# Check the driver's requirements (Xcode, WebDriverAgent, etc.)
appium driver doctor xcuitest
# Start Appium server
appium server --address 127.0.0.1 --port 4723
Desired Capabilities konfigurieren
# Example capabilities (JSON format, Appium 2 and later)
# The Simulator is picked by name; add "appium:platformVersion"
# to pin a specific iOS version
{
"platformName": "iOS",
"appium:automationName": "XCUITest",
"appium:deviceName": "iPhone 17",
"appium:app": "/path/to/MyApp.app",
"appium:noReset": false,
"appium:wdaStartupRetries": 3,
"appium:wdaStartupRetryInterval": 20000,
"appium:simulatorStartupTimeout": 120000
}
Beispiel für einen Appium-Test (Python)
# Install Appium Python client
# pip install Appium-Python-Client
from appium import webdriver
from appium.options.ios import XCUITestOptions
from appium.webdriver.common.appiumby import AppiumBy
# Configure options
options = XCUITestOptions()
options.platform_name = "iOS"
options.device_name = "iPhone 17"
# Optional: options.platform_version pins a specific iOS version
options.app = "/path/to/MyApp.app"
# Connect to Appium server
driver = webdriver.Remote(
command_executor="http://127.0.0.1:4723",
options=options
)
try:
# Wait for app to load
driver.implicitly_wait(10)
# Find and tap login button
login_button = driver.find_element(
AppiumBy.ACCESSIBILITY_ID, "loginButton"
)
login_button.click()
# Enter username
username_field = driver.find_element(
AppiumBy.ACCESSIBILITY_ID, "usernameField"
)
username_field.send_keys("testuser@example.com")
# Enter password
password_field = driver.find_element(
AppiumBy.ACCESSIBILITY_ID, "passwordField"
)
password_field.send_keys("password123")
# Submit login
submit_button = driver.find_element(
AppiumBy.ACCESSIBILITY_ID, "submitButton"
)
submit_button.click()
# Verify welcome screen
welcome_label = driver.find_element(
AppiumBy.ACCESSIBILITY_ID, "welcomeLabel"
)
assert "Welcome" in welcome_label.text
print("Test PASSED: Login successful")
finally:
driver.quit()
Beispiel für einen Appium-Test (JavaScript)
// npm install webdriverio @wdio/cli
const { remote } = require('webdriverio');
async function runTest() {
const driver = await remote({
protocol: 'http',
hostname: '127.0.0.1',
port: 4723,
path: '/',
capabilities: {
platformName: 'iOS',
'appium:automationName': 'XCUITest',
'appium:deviceName': 'iPhone 17',
'appium:app': '/path/to/MyApp.app'
}
});
try {
// Tap login button
const loginBtn = await driver.$('~loginButton');
await loginBtn.click();
// Enter credentials
const username = await driver.$('~usernameField');
await username.setValue('testuser@example.com');
const password = await driver.$('~passwordField');
await password.setValue('password123');
// Submit
const submit = await driver.$('~submitButton');
await submit.click();
// Verify
const welcome = await driver.$('~welcomeLabel');
const text = await welcome.getText();
console.assert(text.includes('Welcome'), 'Login test failed');
console.log('Test PASSED: Login successful');
} finally {
await driver.deleteSession();
}
}
runTest();
Selenium für Safari
macOS enthält Safari und safaridriver von Haus aus. Es sind keine zusätzlichen Browser-Treiber-Downloads erforderlich, anders als bei Chrome oder Firefox auf anderen Plattformen.
safaridriver aktivieren
# Enable the Safari WebDriver (one-time setup)
safaridriver --enable
# Verify safaridriver is working
safaridriver --version
# For headless-like automation, enable "Allow Remote Automation"
# in Safari > Settings > Advanced > Show Develop menu
# Then: Develop > Allow Remote Automation
# Or via command line:
defaults write com.apple.Safari AllowRemoteAutomation 1
Selenium-Safari-Test (Python)
# pip install selenium
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
# Create Safari driver
driver = webdriver.Safari()
try:
# Navigate to your web app
driver.get("https://your-webapp.com")
# Wait for page to load
wait = WebDriverWait(driver, 10)
# Find and click a button
login_link = wait.until(
EC.element_to_be_clickable((By.CSS_SELECTOR, "a.login-btn"))
)
login_link.click()
# Fill in form
email_input = wait.until(
EC.presence_of_element_located((By.ID, "email"))
)
email_input.send_keys("test@example.com")
password_input = driver.find_element(By.ID, "password")
password_input.send_keys("testpassword")
# Submit form
submit_btn = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
submit_btn.click()
# Verify redirect to dashboard
wait.until(EC.url_contains("/dashboard"))
assert "/dashboard" in driver.current_url
print("Test PASSED: Safari login flow works correctly")
finally:
driver.quit()
Selenium-Safari-Test (JavaScript)
// npm install selenium-webdriver
const { Builder, By, until } = require('selenium-webdriver');
async function safariTest() {
const driver = await new Builder()
.forBrowser('safari')
.build();
try {
await driver.get('https://your-webapp.com');
// Click login
const loginBtn = await driver.findElement(By.css('a.login-btn'));
await loginBtn.click();
// Fill form
const email = await driver.findElement(By.id('email'));
await email.sendKeys('test@example.com');
const password = await driver.findElement(By.id('password'));
await password.sendKeys('testpassword');
// Submit
const submit = await driver.findElement(
By.css("button[type='submit']")
);
await submit.click();
// Verify
await driver.wait(until.urlContains('/dashboard'), 10000);
const url = await driver.getCurrentUrl();
console.assert(url.includes('/dashboard'));
console.log('Test PASSED: Safari login flow works');
} finally {
await driver.quit();
}
}
safariTest();
Parallele Testausführung
Das parallele Ausführen von Tests verkürzt die Gesamtausführungszeit Ihrer Test-Suite drastisch. Der Mac Mini M4 Pro kann bequem 4-6 Simulator-Instanzen gleichzeitig ausführen.
Parallele XCTest-Tests
# Enable parallel testing with xcodebuild
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-parallel-testing-enabled YES \
-parallel-testing-worker-count 4 \
-resultBundlePath ./TestResults/Parallel.xcresult
# Parallel testing across multiple device types
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-destination 'platform=iOS Simulator,name=iPhone 17e' \
-destination 'platform=iOS Simulator,name=iPad Pro 13-inch (M5)' \
-parallel-testing-enabled YES \
-resultBundlePath ./TestResults/MultiDeviceParallel.xcresult
Verwaltung von Simulator-Instanzen
# List all available simulators
xcrun simctl list devices available
# Create custom simulator instances for testing
# (without a runtime argument, simctl uses the newest iOS runtime)
xcrun simctl create "Test-iPhone-1" "iPhone 17"
xcrun simctl create "Test-iPhone-2" "iPhone 17"
xcrun simctl create "Test-iPhone-3" "iPhone 17"
xcrun simctl create "Test-iPhone-4" "iPhone 17"
# Boot multiple simulators
xcrun simctl boot "Test-iPhone-1"
xcrun simctl boot "Test-iPhone-2"
xcrun simctl boot "Test-iPhone-3"
xcrun simctl boot "Test-iPhone-4"
# Check booted simulators
xcrun simctl list devices booted
# Shut down all simulators
xcrun simctl shutdown all
# Delete all test simulators
xcrun simctl delete "Test-iPhone-1"
xcrun simctl delete "Test-iPhone-2"
xcrun simctl delete "Test-iPhone-3"
xcrun simctl delete "Test-iPhone-4"
Leistung bei parallelen Tests
| Konfiguration | Dauer von 200 UI-Tests | Geschwindigkeitsverbesserung |
|---|---|---|
| 1 Simulator (sequenziell) | 45 Minuten | Referenzwert |
| 2 Simulatoren (parallel) | 24 Minuten | 1,9x schneller |
| 4 Simulatoren (parallel) | 13 Minuten | 3,5x schneller |
| 6 Simulatoren (parallel) | 10 Minuten | 4,5x schneller |
Hinweis: Ergebnisse gemessen auf einem Mac Mini M4 Pro (14 Kerne, 24 GB RAM). Die optimale Anzahl paralleler Simulatoren hängt von der Komplexität Ihrer Tests und den Speicheranforderungen ab. Für die meisten UI-Test-Suites bieten 4 parallele Worker das beste Gleichgewicht zwischen Geschwindigkeit und Stabilität.
CI/CD-Integration
Integrieren Sie Ihre automatisierten Tests in Ihre CI/CD-Pipeline für eine automatisierte Testausführung bei jedem Push, jeder Pull-Request oder in geplanten Intervallen.
GitHub-Actions-Workflow für automatisierte Tests
# .github/workflows/ios-tests.yml
name: iOS Automated Tests
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
schedule:
# Nightly regression tests at 2 AM UTC
- cron: '0 2 * * *'
env:
# Xcode for every job, no sudo needed
# (preinstalled Xcode; for another version, use the path from xcodes installed)
DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer
jobs:
unit-tests:
name: Unit Tests
runs-on: self-hosted
timeout-minutes: 30
steps:
- uses: actions/checkout@v7
- name: Resolve dependencies
run: |
xcodebuild -resolvePackageDependencies \
-workspace MyApp.xcworkspace \
-scheme MyApp
- name: Run unit tests
run: |
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17,OS=latest' \
-parallel-testing-enabled YES \
-resultBundlePath ${{ runner.temp }}/UnitTests.xcresult
- name: Upload test results
if: always()
uses: actions/upload-artifact@v7
with:
name: unit-test-results
path: ${{ runner.temp }}/UnitTests.xcresult
ui-tests:
name: UI Tests
runs-on: self-hosted
timeout-minutes: 60
needs: unit-tests
steps:
- uses: actions/checkout@v7
- name: Boot simulators for parallel testing
run: |
xcrun simctl boot "iPhone 17" || true
xcrun simctl boot "iPhone 17e" || true
- name: Run UI tests in parallel
run: |
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyAppUITests \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-destination 'platform=iOS Simulator,name=iPhone 17e' \
-parallel-testing-enabled YES \
-parallel-testing-worker-count 4 \
-resultBundlePath ${{ runner.temp }}/UITests.xcresult
- name: Upload test results
if: always()
uses: actions/upload-artifact@v7
with:
name: ui-test-results
path: ${{ runner.temp }}/UITests.xcresult
- name: Cleanup simulators
if: always()
run: xcrun simctl shutdown all
Appium-Tests in CI ausführen
# Add to your GitHub Actions workflow
- name: Start Appium server
run: |
appium server --address 127.0.0.1 --port 4723 &
sleep 5
curl http://127.0.0.1:4723/status
- name: Build app for testing
run: |
xcodebuild build-for-testing \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'generic/platform=iOS Simulator'
- name: Run Appium tests
run: |
cd tests/appium
pip install -r requirements.txt
pytest test_login.py test_checkout.py \
--junitxml=results.xml -v
- name: Stop Appium server
if: always()
run: pkill -f appium || true
Testberichte
Erstellen und verarbeiten Sie Testberichte, um Qualitätstrends zu verfolgen und fehlgeschlagene Tests schnell zu identifizieren.
Arbeiten mit xcresult-Bundles
# Test results summary as JSON (Xcode 16 and later)
xcrun xcresulttool get test-results summary \
--path ./TestResults.xcresult
# Results of every test, then the details of one of them
# (TEST_ID: an identifier printed by the tests command)
xcrun xcresulttool get test-results tests \
--path ./TestResults.xcresult
xcrun xcresulttool get test-results test-details \
--test-id "TEST_ID" \
--path ./TestResults.xcresult
# Export all attachments (screenshots, logs)
xcrun xcresulttool export attachments \
--path ./TestResults.xcresult \
--output-path ./artifacts
# Merge multiple xcresult bundles
xcrun xcresulttool merge \
./UnitTests.xcresult \
./UITests.xcresult \
--output-path ./MergedResults.xcresult
In JUnit XML konvertieren
JUnit XML ist das universelle Format, das von CI/CD-Plattformen, Slack-Integrationen und Test-Dashboards unterstützt wird.
# Option 1: write JUnit XML while the tests run (xcbeautify)
brew install xcbeautify
set -o pipefail && xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyApp \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-resultBundlePath ./TestResults/Tests.xcresult \
| xcbeautify --report junit --report-path ./reports
# Writes ./reports/junit.xml
# Option 2: convert existing .xcresult bundles with fastlane's
# trainer action (path: the folder that holds them)
fastlane run trainer path:"./TestResults" output_directory:"./reports"
# The generated JUnit XML works with:
# - GitHub Actions test summaries
# - Jenkins Test Result plugin
# - GitLab CI test reporting
# - Slack notifications via CI integrations
Screenshot bei Fehlschlag
// In your XCUITest, add screenshot capture on failure:
// XCTestCase+Screenshots.swift
import XCTest
extension XCTestCase {
override func tearDown() {
if testRun?.hasSucceeded == false {
let screenshot = XCUIScreen.main.screenshot()
let attachment = XCTAttachment(screenshot: screenshot)
attachment.name = "Failure-\(name)"
attachment.lifetime = .keepAlways
add(attachment)
}
super.tearDown()
}
}
Bewährte Methoden
Test-Isolation
Jeder Test sollte unabhängig sein und nicht auf dem Zustand vorheriger Tests beruhen. Setzen Sie den App-Zustand vor jedem Test zurück.
// In your XCUITest setUp() method:
override func setUp() {
super.setUp()
continueAfterFailure = false
let app = XCUIApplication()
app.launchArguments = ["--uitesting", "--reset-state"]
app.launchEnvironment = [
"DISABLE_ANIMATIONS": "1",
"UI_TEST_MODE": "true"
]
app.launch()
}
Simulator-Verwaltung
Bereinigen Sie Simulatoren zwischen Testläufen, um Zustandslecks und Speicherplatzprobleme zu vermeiden.
#!/bin/bash
# cleanup-simulators.sh - Run before and after test suites
# Shutdown all running simulators
xcrun simctl shutdown all
# Erase all simulator content and settings
xcrun simctl erase all
# Delete unavailable simulators
xcrun simctl delete unavailable
# Clear DerivedData
rm -rf ~/Library/Developer/Xcode/DerivedData/*
# Clear simulator logs
rm -rf ~/Library/Logs/CoreSimulator/*
echo "Simulator cleanup complete"
Animationen für mehr Geschwindigkeit deaktivieren
Deaktivieren Sie Animationen in Ihrer App während der UI-Tests, um die Testausführungszeit und Instabilität zu reduzieren.
// In your AppDelegate or App struct:
#if DEBUG
if CommandLine.arguments.contains("--uitesting") {
UIView.setAnimationsEnabled(false)
}
#endif
Instabile Tests wiederholen
Nutzen Sie Xcodes integrierten Mechanismus zur Testwiederholung, um gelegentlich instabile UI-Tests zu handhaben.
# Run each failing test up to 3 times in total
xcodebuild test \
-workspace MyApp.xcworkspace \
-scheme MyAppUITests \
-destination 'platform=iOS Simulator,name=iPhone 17' \
-retry-tests-on-failure \
-test-iterations 3 \
-resultBundlePath ./TestResults.xcresult
Speicherplatz überwachen
Simulatoren und Test-Artefakte verbrauchen erheblichen Speicherplatz. Richten Sie eine automatisierte Bereinigung ein.
# Add to crontab for daily cleanup at midnight
# crontab -e
0 0 * * * /usr/local/bin/cleanup-test-artifacts.sh
# cleanup-test-artifacts.sh
#!/bin/bash
# Remove test results older than 7 days
find ~/TestResults -name "*.xcresult" -mtime +7 -delete
# Remove DerivedData older than 3 days
find ~/Library/Developer/Xcode/DerivedData \
-maxdepth 1 -mtime +3 -exec rm -rf {} +
# Remove old simulator logs
find ~/Library/Logs/CoreSimulator -mtime +3 -delete
# Check remaining disk space
df -h / | tail -1
Häufig gestellte Fragen
Wie viele parallele Simulatoren kann ein Mac Mini M4 Pro bewältigen?
Kann ich Tests headless ohne VNC ausführen?
xcodebuild ohne Anzeigesitzung gestartet wird. Sie benötigen während der Testausführung kein verbundenes VNC. VNC ist nur nützlich, um fehlgeschlagene Tests visuell zu debuggen.Wie gehe ich mit instabilen UI-Tests um?
sleep(). Nutzen Sie Xcodes Flag -retry-tests-on-failure, um fehlgeschlagene Tests automatisch zu wiederholen. Auf einem dedizierten macOS-Server wird Instabilität durch Ressourcenkonkurrenz eliminiert, was die häufigste Ursache für instabile Tests auf gemeinsam genutzten CI-Maschinen ist.Kann ich auf echten iOS-Geräten von einem entfernten Mac aus testen?
Wie sieht es mit Tests auf verschiedenen iOS-Versionen aus?
xcodebuild -downloadPlatform iOS für die neueste Version oder laden Sie ältere Runtimes über Xcode > Settings > Components herunter. Geben Sie dann die OS-Version in Ihrem Testziel an: -destination 'platform=iOS Simulator,name=iPhone 17,OS=26.0'.