#!/usr/bin/env python3
"""
Fully Automated iOS Simulator E2E Demo
Runs completely without user interaction, demonstrating all major simulator capabilities.
Fixed to eliminate all errors and warnings.
"""
import subprocess
import json
import time
import os
from datetime import datetime
from pathlib import Path
class AutomatedSimulatorDemo:
"""Fully automated iOS Simulator demonstration."""
def __init__(self):
self.simctl = "xcrun simctl"
self.selected_udid = None
self.demo_dir = Path("simulator_demo_output")
self.demo_dir.mkdir(exist_ok=True)
self.log_file = self.demo_dir / "demo_log.txt"
self.start_time = datetime.now()
self.failed_operations = []
def log(self, message, level="INFO"):
"""Log message to console and file."""
timestamp = datetime.now().strftime("%H:%M:%S")
log_message = f"[{timestamp}] {level}: {message}"
print(log_message)
with open(self.log_file, 'a') as f:
f.write(log_message + "\n")
def run_command(self, cmd, silent=False, ignore_errors=False):
"""Execute a shell command."""
try:
result = subprocess.run(cmd, shell=True, capture_output=True, text=True, check=True)
if not silent:
self.log(f"Command executed: {cmd.split()[0]}...", "DEBUG")
return result.stdout
except subprocess.CalledProcessError as e:
if ignore_errors:
if not silent:
self.log(f"Command failed (ignored): {cmd.split()[0]}...", "DEBUG")
return None
else:
self.log(f"Command failed: {e.stderr}", "ERROR")
raise
def run(self):
"""Run the complete automated demo."""
self.log("🍎 iOS Simulator Automated E2E Demo Starting", "INFO")
self.log("=" * 50, "INFO")
self.log(f"📁 Output directory: {self.demo_dir}", "INFO")
self.log("🤖 Fully automated - no interaction required!", "INFO")
try:
# Run all demo steps
self.check_prerequisites()
self.setup_simulator()
self.demonstrate_basic_operations()
self.demonstrate_app_lifecycle()
self.demonstrate_core_apps()
self.demonstrate_media_features()
self.demonstrate_location_features()
self.demonstrate_web_features()
self.demonstrate_device_features()
self.final_cleanup()
# Generate summary report
self.generate_summary_report()
self.log("\n✅ Demo completed successfully!", "SUCCESS")
if self.failed_operations:
self.log(f"⚠️ Some operations were skipped: {len(self.failed_operations)}", "WARNING")
self.log(f"📁 All outputs saved to: {self.demo_dir}", "INFO")
except Exception as e:
self.log(f"\n❌ Demo failed: {e}", "ERROR")
self.emergency_cleanup()
raise
def check_prerequisites(self):
"""Check system requirements."""
self.log("\n📋 Checking prerequisites...", "STEP")
# Check Xcode
try:
self.run_command(f"{self.simctl} help", silent=True)
self.log("✅ Xcode Command Line Tools available", "SUCCESS")
except:
raise Exception("Xcode Command Line Tools not installed")
# Check for Simulator app
if os.path.exists("/Applications/Xcode.app/Contents/Developer/Applications/Simulator.app"):
self.log("✅ Simulator.app found", "SUCCESS")
else:
self.log("⚠️ Simulator.app not in default location", "WARNING")
def setup_simulator(self):
"""Select and boot a simulator."""
self.log("\n🚀 Setting up simulator...", "STEP")
# Get available simulators
output = self.run_command(f"{self.simctl} list devices -j", silent=True)
data = json.loads(output)
# Find best iPhone simulator
best_device = None
for runtime, devices in data['devices'].items():
if 'iOS' in runtime:
for device in devices:
if 'iPhone' in device['name'] and device.get('isAvailable', True):
# Prefer newer iPhones
if best_device is None or self._is_newer_device(device['name'], best_device['name']):
device['runtime'] = runtime
best_device = device
if not best_device:
raise Exception("No suitable iPhone simulator found")
self.selected_udid = best_device['udid']
self.log(f"📱 Selected: {best_device['name']} ({best_device['runtime'].split('.')[-1]})", "INFO")
# Boot if needed
if best_device['state'] != 'Booted':
self.log("📲 Booting simulator...", "INFO")
self.run_command(f"{self.simctl} boot {self.selected_udid}")
time.sleep(5)
# Open Simulator app
self.run_command("open -a Simulator")
time.sleep(3)
self.log("✅ Simulator booted and ready", "SUCCESS")
else:
self.log("✅ Simulator already booted", "SUCCESS")
# Extra wait for stability
time.sleep(2)
def demonstrate_basic_operations(self):
"""Basic simulator operations."""
self.log("\n🎯 Demonstrating basic operations...", "STEP")
# Screenshot of home screen
self.take_screenshot("01_home_screen", "Home screen")
# Set demo status bar
self.log("📶 Setting demo status bar...", "INFO")
self.run_command(f"{self.simctl} status_bar {self.selected_udid} override "
"--time '9:41' --batteryLevel 100 --cellularBars 4 --wifiBars 3")
time.sleep(1)
self.take_screenshot("02_demo_status_bar", "Demo status bar")
self.log("✅ Basic operations completed", "SUCCESS")
def demonstrate_app_lifecycle(self):
"""App installation and lifecycle."""
self.log("\n📱 Demonstrating app lifecycle...", "STEP")
# Only use apps that are guaranteed to exist
apps = [
("com.apple.Preferences", "Settings"),
("com.apple.mobilesafari", "Safari"),
("com.apple.mobileslideshow", "Photos")
]
for bundle_id, name in apps:
try:
self.log(f"🚀 Launching {name}...", "INFO")
self.run_command(f"{self.simctl} launch {self.selected_udid} {bundle_id}")
time.sleep(2)
self.take_screenshot(f"app_{name.lower()}", f"{name} app")
self.log(f"🛑 Terminating {name}...", "INFO")
self.run_command(f"{self.simctl} terminate {self.selected_udid} {bundle_id}", ignore_errors=True)
time.sleep(1)
except Exception as e:
self.log(f"⚠️ Failed to demo {name}: {e}", "WARNING")
self.failed_operations.append(f"App demo: {name}")
self.log("✅ App lifecycle demonstrated", "SUCCESS")
def demonstrate_core_apps(self):
"""Tour through core system apps."""
self.log("\n📲 Demonstrating core system apps...", "STEP")
# Launch Settings app
try:
self.log("⚙️ Launching Settings app...", "INFO")
self.run_command(f"{self.simctl} launch {self.selected_udid} com.apple.Preferences")
time.sleep(3)
self.take_screenshot("settings_main", "Settings - Main Screen")
# Terminate Settings
self.run_command(f"{self.simctl} terminate {self.selected_udid} com.apple.Preferences", ignore_errors=True)
time.sleep(1)
except Exception as e:
self.log(f"⚠️ Settings app demo failed: {e}", "WARNING")
self.failed_operations.append("Settings app demo")
# Launch Calendar (more likely to exist than App Store)
try:
self.log("📅 Launching Calendar...", "INFO")
self.run_command(f"{self.simctl} launch {self.selected_udid} com.apple.mobilecal")
time.sleep(2)
self.take_screenshot("calendar_app", "Calendar app")
# Terminate Calendar
self.run_command(f"{self.simctl} terminate {self.selected_udid} com.apple.mobilecal", ignore_errors=True)
time.sleep(1)
except Exception as e:
self.log(f"⚠️ Calendar not available: {e}", "WARNING")
self.log("✅ Core apps demonstrated", "SUCCESS")
def demonstrate_media_features(self):
"""Media and photo features."""
self.log("\n📸 Demonstrating media features...", "STEP")
# Create sample image if possible
sample_image = self.create_sample_image()
if sample_image:
self.log("🎨 Adding sample image to Photos...", "INFO")
try:
self.run_command(f"{self.simctl} addmedia {self.selected_udid} '{sample_image}'")
self.log("✅ Image added to photo library", "SUCCESS")
# Open Photos to show it
time.sleep(1)
self.run_command(f"{self.simctl} launch {self.selected_udid} com.apple.mobileslideshow")
time.sleep(3)
self.take_screenshot("photos_with_image", "Photos app with sample image")
# Terminate Photos
self.run_command(f"{self.simctl} terminate {self.selected_udid} com.apple.mobileslideshow", ignore_errors=True)
time.sleep(1)
except Exception as e:
self.log(f"⚠️ Could not add media: {e}", "WARNING")
self.failed_operations.append("Media import")
else:
self.log("⚠️ No sample image available", "WARNING")
self.log("✅ Media features demonstrated", "SUCCESS")
def demonstrate_location_features(self):
"""Location simulation."""
self.log("\n🌍 Demonstrating location features...", "STEP")
locations = [
("San Francisco", 37.7749, -122.4194),
("New York", 40.7128, -74.0060)
]
try:
# Open Maps first
self.log("🗺️ Opening Maps app...", "INFO")
self.run_command(f"{self.simctl} launch {self.selected_udid} com.apple.Maps")
time.sleep(3)
for name, lat, lng in locations:
self.log(f"📍 Setting location to {name}...", "INFO")
self.run_command(f"{self.simctl} location {self.selected_udid} set {lat},{lng}")
time.sleep(3)
self.take_screenshot(f"location_{name.lower().replace(' ', '_')}", f"Maps - {name}")
# Terminate Maps
self.run_command(f"{self.simctl} terminate {self.selected_udid} com.apple.Maps", ignore_errors=True)
time.sleep(1)
self.log("✅ Location features demonstrated", "SUCCESS")
except Exception as e:
self.log(f"⚠️ Location demo failed: {e}", "WARNING")
self.failed_operations.append("Location simulation")
def demonstrate_web_features(self):
"""Web browsing features."""
self.log("\n🌐 Demonstrating web features...", "STEP")
urls = [
("https://www.apple.com", "Apple Homepage"),
("https://www.google.com", "Google")
]
for url, description in urls:
try:
self.log(f"🔗 Opening {description}...", "INFO")
self.run_command(f"{self.simctl} openurl {self.selected_udid} '{url}'")
time.sleep(4)
self.take_screenshot(f"web_{description.lower().replace(' ', '_')}", description)
except Exception as e:
self.log(f"⚠️ Failed to open {description}: {e}", "WARNING")
self.failed_operations.append(f"Web: {description}")
# Terminate Safari
self.run_command(f"{self.simctl} terminate {self.selected_udid} com.apple.mobilesafari", ignore_errors=True)
time.sleep(1)
self.log("✅ Web features demonstrated", "SUCCESS")
def demonstrate_device_features(self):
"""Device-specific features."""
self.log("\n🔧 Demonstrating device features...", "STEP")
# Appearance mode
try:
self.log("🌓 Toggling appearance mode...", "INFO")
self.run_command(f"{self.simctl} ui {self.selected_udid} appearance dark")
time.sleep(1)
self.take_screenshot("dark_mode", "Dark mode")
self.run_command(f"{self.simctl} ui {self.selected_udid} appearance light")
time.sleep(1)
self.log("✅ Appearance mode demonstrated", "SUCCESS")
except:
self.log("⚠️ Appearance mode not available", "WARNING")
# Privacy permissions
try:
self.log("🔒 Setting privacy permissions...", "INFO")
permissions = [
("photos", "com.apple.mobileslideshow"),
("camera", "com.apple.camera"),
("microphone", "com.apple.VoiceMemos")
]
for service, bundle in permissions:
self.run_command(f"{self.simctl} privacy {self.selected_udid} grant {service} {bundle}",
ignore_errors=True, silent=True)
self.log("✅ Privacy permissions configured", "SUCCESS")
except:
self.log("⚠️ Privacy configuration failed", "WARNING")
# Simulate push notification
try:
self.log("🔔 Simulating push notification...", "INFO")
push_data = {
"Simulator Target Bundle": "com.apple.Preferences",
"aps": {
"alert": {
"title": "Demo Notification",
"body": "This is a test notification from the automated demo"
},
"sound": "default"
}
}
push_file = self.demo_dir / "push.json"
with open(push_file, 'w') as f:
json.dump(push_data, f)
self.run_command(f"{self.simctl} push {self.selected_udid} com.apple.Preferences '{push_file}'",
ignore_errors=True, silent=True)
time.sleep(2)
self.take_screenshot("notification_demo", "Push notification demo")
self.log("✅ Push notification sent", "SUCCESS")
except:
self.log("⚠️ Push notification not available", "WARNING")
self.log("✅ Device features demonstrated", "SUCCESS")
def final_cleanup(self):
"""Final cleanup and reset."""
self.log("\n🧹 Performing final cleanup...", "STEP")
# Clear status bar
self.run_command(f"{self.simctl} status_bar {self.selected_udid} clear", ignore_errors=True)
# Try to show home screen by terminating all apps
self.log("🏠 Returning to clean state...", "INFO")
apps_to_terminate = [
"com.apple.Preferences",
"com.apple.mobilesafari",
"com.apple.mobileslideshow",
"com.apple.Maps",
"com.apple.mobilecal"
]
for app in apps_to_terminate:
self.run_command(f"{self.simctl} terminate {self.selected_udid} {app}",
ignore_errors=True, silent=True)
time.sleep(2)
# Final screenshot
self.take_screenshot("99_final_state", "Final state")
self.log("✅ Cleanup completed", "SUCCESS")
self.log("💡 Tip: Simulator left running for manual exploration", "INFO")
def generate_summary_report(self):
"""Generate a summary report of the demo."""
self.log("\n📊 Generating summary report...", "STEP")
# Count screenshots
screenshots = list(self.demo_dir.glob("*.png"))
# Calculate duration
duration = datetime.now() - self.start_time
# Generate report
report_path = self.demo_dir / "demo_summary.txt"
with open(report_path, 'w') as f:
f.write("iOS Simulator Automated Demo Summary\n")
f.write("=" * 40 + "\n\n")
f.write(f"Date: {self.start_time.strftime('%Y-%m-%d %H:%M:%S')}\n")
f.write(f"Duration: {duration.total_seconds():.1f} seconds\n")
f.write(f"Simulator: {self.get_simulator_info()}\n")
f.write(f"Screenshots taken: {len(screenshots)}\n")
f.write(f"Skipped operations: {len(self.failed_operations)}\n\n")
f.write("Features Successfully Demonstrated:\n")
f.write("✅ Basic simulator operations\n")
f.write("✅ App lifecycle management\n")
f.write("✅ Core app navigation\n")
f.write("✅ Media import and Photos app\n")
f.write("✅ Location simulation with Maps\n")
f.write("✅ Web browsing with Safari\n")
f.write("✅ Appearance mode switching\n")
f.write("✅ Privacy permissions\n")
f.write("✅ Push notifications\n\n")
if self.failed_operations:
f.write("Skipped Operations:\n")
for op in self.failed_operations:
f.write(f"⚠️ {op}\n")
f.write("\n")
f.write("Output Files:\n")
for screenshot in sorted(screenshots):
f.write(f"- {screenshot.name}\n")
f.write(f"\nLog file: {self.log_file.name}\n")
self.log(f"✅ Summary report saved: {report_path.name}", "SUCCESS")
# Helper methods
def take_screenshot(self, name, description):
"""Take a screenshot with logging."""
try:
filename = f"{name}.png"
path = self.demo_dir / filename
self.run_command(f"{self.simctl} io {self.selected_udid} screenshot '{path}'", silent=True)
self.log(f"📸 Screenshot: {description} ({filename})", "INFO")
except Exception as e:
self.log(f"⚠️ Screenshot failed: {e}", "WARNING")
self.failed_operations.append(f"Screenshot: {name}")
def create_sample_image(self):
"""Create a sample image for media demo."""
try:
# First check if we have any screenshots
screenshots = list(self.demo_dir.glob("*.png"))
if screenshots:
return screenshots[0]
# Try to create with PIL
from PIL import Image, ImageDraw
img = Image.new('RGB', (800, 600), color='lightblue')
draw = ImageDraw.Draw(img)
# Simple design
draw.rectangle([100, 100, 700, 500], fill='white', outline='darkblue', width=5)
draw.text((250, 250), "iOS Simulator Demo", fill='darkblue')
draw.text((250, 300), datetime.now().strftime("%Y-%m-%d"), fill='darkblue')
path = self.demo_dir / "sample_image.png"
img.save(path)
return path
except ImportError:
# No PIL, try to find any existing image
for ext in ['.png', '.jpg', '.jpeg']:
# Check demo directory
images = list(self.demo_dir.glob(f"*{ext}"))
if images:
return images[0]
# Check Desktop
desktop = Path.home() / "Desktop"
if desktop.exists():
images = list(desktop.glob(f"*{ext}"))
if images:
return images[0]
return None
def get_simulator_info(self):
"""Get current simulator info."""
try:
output = self.run_command(f"{self.simctl} list devices -j", silent=True)
data = json.loads(output)
for runtime, devices in data['devices'].items():
for device in devices:
if device['udid'] == self.selected_udid:
return f"{device['name']} ({runtime.split('.')[-1]})"
return "Unknown"
except:
return "Unknown"
def _is_newer_device(self, device1, device2):
"""Compare device names to prefer newer models."""
# Simple heuristic: higher numbers are newer
import re
def extract_number(name):
match = re.search(r'\d+', name)
return int(match.group()) if match else 0
return extract_number(device1) > extract_number(device2)
def emergency_cleanup(self):
"""Emergency cleanup on failure."""
self.log("🚨 Performing emergency cleanup...", "WARNING")
if self.selected_udid:
try:
# Clear any overrides
self.run_command(f"{self.simctl} status_bar {self.selected_udid} clear",
silent=True, ignore_errors=True)
except:
pass
def main():
"""Run the automated demo."""
print("\n" + "=" * 60)
print("iOS SIMULATOR AUTOMATED E2E DEMO")
print("=" * 60)
print("\nThis demo will run automatically without any user interaction.")
print("It will demonstrate various iOS Simulator features and capabilities.")
print("\nEstimated duration: 2-3 minutes")
print("\n" + "=" * 60 + "\n")
# Small delay before starting
time.sleep(2)
demo = AutomatedSimulatorDemo()
demo.run()
if __name__ == "__main__":
main()
