# Tests automatisés d'applications iOS

Combinez le système de mémoire de Synapse avec l'API Computer Control pour construire
des tests d'applications iOS pilotés par LLM. Le LLM se souvient des scénarios de
test, apprend des échecs passés et s'adapte aux changements d'interface.

## Architecture

```
┌──────────────┐    commands    ┌──────────────┐    screenshots    ┌──────────────┐
│  LLM Agent   │ ─────────────▶│  Synapse     │ ────────────────▶ │  iOS Sim     │
│  (Claude)    │               │  Computer    │ ◀──────────────── │  (via agent) │
└──────────────┘               │  Control     │    results        └──────────────┘
       │                       └──────────────┘
       │ store/recall
       ▼
┌──────────────┐
│  Memories    │ (test scenarios, past failures, UI patterns)
└──────────────┘
```

## Prérequis

- Compte Synapse + Mind Key
- Serveur MCP Synapse configuré dans Claude Desktop
- iOS Simulator avec `screen-remote-agent` installé
- Ordinateur enregistré dans Synapse (voir [API Computer Control](/docs/api/computers))

## Étape 1 : enregistrer l'ordinateur Simulator

Sur le Mac exécutant iOS Simulator :

```bash
# Obtenir le code d'installation de Synapse
curl -X POST https://synapse.schaefer.zone/computers/install-code \
  -H "Authorization: Bearer YOUR_MIND_KEY" \
  -d '{"computer_name":"ios-sim"}'
# → { "install_code": "ic_..." }

# Exécuter screen-remote-agent sur le Mac
# (utilise le code d'installation pour s'enregistrer)
```

## Étape 2 : stocker les scénarios de test en mémoire

Stockez les scénarios de test réutilisables en tant que mémoires :

```python
import requests

def store_test_scenario(name, steps, app):
    requests.post(f"{URL}/memory",
        headers={"Authorization": f"Bearer {MIND_KEY}"},
        json={
            "category": "skill",
            "key": f"test_scenario_{name}",
            "content": f"App: {app}\nSteps:\n" + "\n".join(steps),
            "tags": ["test", "ios", app],
            "priority": "high"
        })

store_test_scenario("login_flow", [
    "Launch app",
    "Tap email field",
    "Type test@example.com",
    "Tap password field",
    "Type password123",
    "Tap Login button",
    "Verify home screen appears"
], "MyApp")
```

## Étape 3 : exécution de test pilotée par LLM

Dans Claude Desktop (avec MCP Synapse configuré) :

```
Run the login_flow test scenario on the iOS Simulator.
Take a screenshot after each step and verify the expected UI.
If any step fails, store the failure as a memory so we can
avoid it next time.
```

Claude va :

1. Appeler `memory_search` pour trouver la mémoire `test_scenario_login_flow`
2. Appeler `computer_screenshot` pour voir l'état actuel
3. Exécuter chaque étape via `computer_command_queue` (clic, saisie)
4. Vérifier les résultats via captures d'écran
5. Stocker tout échec en tant que mémoires `mistake`

## Étape 4 : tests auto-réparables

Quand un test échoue, stockez l'échec et la récupération :

```python
def store_test_failure(scenario, step, error, recovery):
    requests.post(f"{URL}/memory",
        headers={"Authorization": f"Bearer {MIND_KEY}"},
        json={
            "category": "mistake",
            "key": f"failure_{scenario}_{step}",
            "content": f"Scenario: {scenario}\nStep: {step}\nError: {error}\nRecovery: {recovery}",
            "tags": ["test", "failure", "ios", scenario],
            "priority": "high"
        })

# Exemple
store_test_failure("login_flow", "tap_login",
    "Login button not found at expected coordinates",
    "Button moved due to new logo. Search by accessibility label instead.")
```

La prochaine fois que le LLM exécute le test, il rappelle l'échec et applique la
récupération automatiquement.

## Étape 5 : suivi des résultats de test

Suivez les exécutions de test en tant que tâches :

```python
def track_test_run(scenario, status, duration):
    requests.post(f"{URL}/mind/task",
        headers={"Authorization": f"Bearer {MIND_KEY}",
                 "Content-Type": "application/json"},
        json={
            "title": f"Test: {scenario}",
            "description": f"Status: {status}, Duration: {duration}s",
            "priority": "normal"
        })
```

## Commandes courantes

| Action | Commande |
|--------|---------|
| Lancer Simulator | `xcrun simctl launch booted com.example.app` |
| Capture d'écran | `computer_screenshot` (via MCP Synapse) |
| Taper à (x,y) | `computer_command_queue {type:"click", payload:{x,y}}` |
| Saisir du texte | `computer_command_queue {type:"type", payload:{text:"..."}}` |
| Appuyer sur Home | `computer_command_queue {type:"key", payload:{keys:["Cmd","Shift","H"]}}` |

## Bonnes pratiques

> [!TIP]
> - **Stockez les coordonnées UI en mémoire** — l'UI change, mais le LLM peut réapprendre
> - **Utilisez les labels d'accessibilité** — plus stables que les coordonnées
> - **Stockez les données de test séparément** — utilisez des variables pour les noms d'utilisateur, mots de passe
> - **Exécutez les tests dans un état propre** — réinitialisez Simulator entre les exécutions
> - **Journalisez les captures d'écran pour les échecs** — utiles pour le débogage

## Prochaines étapes

- [Tests auto-réparables](/docs/guides/self-healing-tests)
- [API Computer Control](/docs/api/computers)
- [Bonnes pratiques mémoire](/docs/guides/memory-best-practices)