> ## Documentation Index
> Fetch the complete documentation index at: https://docs.localmind.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Testing

> Konkrete Testmethoden für Automate-Workflows - Praktische Anleitung zum Testen und Interpretieren von Ergebnissen

Bevor Sie einen Workflow aktivieren, testen Sie ihn — erst Node für Node, dann als Ganzes. Diese Seite zeigt, wie Sie dabei vorgehen und wie Sie Ergebnisse und Fehler richtig interpretieren.

## Einzelne Nodes testen

Testen Sie jeden Node einzeln, bevor Sie den gesamten Workflow ausführen: Node öffnen, Parameter und Credentials prüfen, dann **Execute Node** klicken (oder F2). Grüner Status heißt erfolgreich ausgeführt — prüfen Sie anschließend, ob der Output vollständig ist und dem erwarteten Format entspricht. Roter Status heißt fehlgeschlagen — lesen Sie die Error-Message und prüfen Sie Input-Daten und Credentials.

Im Node-Detail sehen Sie drei Dinge: den **Input** (was hineingegangen ist), den **Output** (was herauskommt) und die **Execution Time** (wie lange es gedauert hat).

Verwenden Sie realistische Test-Daten — und testen Sie nicht nur den Happy Path:

<CodeGroup>
  ```json Standard Test-Daten theme={null}
  {
    "email": "test@example.com",
    "name": "Max Mustermann",
    "message": "Test-Nachricht für Workflow-Testing"
  }
  ```

  ```json Edge Case Test-Daten theme={null}
  {
    "email": "",
    "name": null,
    "message": "Sehr lange Nachricht " + "x".repeat(10000)
  }
  ```
</CodeGroup>

Validieren Sie den Output gezielt gegen Ihre Erwartungen:

```javascript Output prüfen (Beispiel HTTP Request) theme={null}
// 1. Status Code prüfen
{{ $json.statusCode }} === 200

// 2. Erwartete Felder vorhanden?
{{ $json.body.id }} !== undefined

// 3. Datentyp korrekt?
typeof {{ $json.body.id }} === 'number'
```

## Outputs pinnen

Führen Sie den Workflow einmal komplett aus, um echte Daten zu erhalten, und pinnen Sie dann den Node-Output über das **Pin-Icon**. Nachgelagerte Nodes verwenden ab jetzt die gepinnten Daten — ohne erneute API-Calls oder Agent-Aufrufe, also ohne zusätzlichen Credit-Verbrauch. Gepinnte Daten können Sie manuell bearbeiten, um fehlende Felder, geänderte Werte oder Fehlerzustände zu simulieren.

<Warning>
  **Credits sparen:** Jeder Test eines Agent-Aufrufs ohne Pinning verbraucht Credits — bei 50 Tests summiert sich das schnell. Pinnen Sie nach dem ersten erfolgreichen Test.
</Warning>

## Den gesamten Workflow testen

Fügen Sie einen **Manual Trigger** am Anfang hinzu und starten Sie den Workflow mit **Execute Workflow**. Beobachten Sie während der Ausführung den Status jedes Nodes (grün/rot) und klicken Sie auf einzelne Nodes, um Zwischenergebnisse zu sehen. Prüfen Sie am Ende das Gesamtergebnis: Sind alle erwarteten Outputs vorhanden und korrekt formatiert?

## Execution Logs lesen

Sie erreichen die Logs über den **Executions**-Tab: Execution auswählen, dann **Open in Editor** klicken.

| Status         | Bedeutung                          | Was prüfen                                                                           |
| -------------- | ---------------------------------- | ------------------------------------------------------------------------------------ |
| Grün (Success) | Workflow erfolgreich abgeschlossen | Output-Daten vorhanden? Execution-Zeit akzeptabel?                                   |
| Rot (Error)    | Workflow fehlgeschlagen            | Welcher Node ist rot? Error-Message und Input-Daten des Nodes lesen                  |
| Gelb (Waiting) | Workflow wartet                    | Webhook wartet auf Request, Schedule-Trigger auf Zeitpunkt, oder Rate Limit erreicht |

Bei einzelnen Nodes lohnt der Blick auf drei Dinge:

* **Input-Daten:** Sind alle erwarteten Felder vorhanden, im richtigen Format, ohne null/undefined?
* **Output-Daten:** Entspricht der Output den Erwartungen — alle benötigten Felder, korrektes Format?
* **Execution-Zeit:** unter 1 Sekunde sehr schnell, 1–5 Sekunden normal, 5–30 Sekunden langsam aber akzeptabel, über 30 Sekunden zu langsam — optimieren.

## Fehler interpretieren

### HTTP-Fehler

| Code                      | Ursache                          | Lösung                                 |
| ------------------------- | -------------------------------- | -------------------------------------- |
| 400 Bad Request           | Ungültige Anfrage-Parameter      | Request-Body und Headers prüfen        |
| 401 Unauthorized          | Authentifizierung fehlgeschlagen | Credentials überprüfen                 |
| 404 Not Found             | Endpoint nicht gefunden          | URL überprüfen                         |
| 429 Too Many Requests     | Rate Limit erreicht              | Retry-Logik implementieren oder warten |
| 500 Internal Server Error | Server-Fehler                    | Retry-Logik oder Support kontaktieren  |

### Datenformat-Fehler

Meldungen wie „Cannot read property 'x' of undefined", „Expected string but got number" oder „Invalid JSON format" deuten auf Format-Probleme zwischen Nodes hin. Prüfen Sie die Input-Daten des Nodes, die Expression-Syntax (`{{ $json.fieldName }}`) und die Datenformate zwischen den Nodes — bei Bedarf transformieren Sie mit einem Set-Node:

```javascript Null-Check in Expressions theme={null}
// FALSCH:
{{ $json.user.name }}

// RICHTIG (mit Null-Check):
{{ $json.user?.name || 'Unknown' }}
```

### Timeout-Fehler

Bei „Execution timeout exceeded" (Node bleibt lange gelb, dann rot) haben Sie drei Hebel: den Timeout in den Node-Einstellungen erhöhen (Standard 30 Sekunden → 60 Sekunden), den API-Call verschlanken (Request-Größe reduzieren, Pagination nutzen) oder automatische Retries mit Exponential Backoff — siehe [Retry Logic](/automate/Retry-Logic).

### Credential-Fehler

Bei „Authentication failed", „Invalid credentials" oder „API key not found": Credentials in den Node-Einstellungen überprüfen, das Credential-Format validieren (Bearer Token, API Key) und den Call isoliert testen — zum Beispiel in Postman:

```bash theme={null}
# Testen Sie Credentials zuerst in Postman
curl -X GET "https://api.example.com/endpoint" \
  -H "Authorization: Bearer YOUR_API_KEY"
```

## Test-Szenarien

### API-Call testen

Testen Sie externe APIs zuerst außerhalb von Automate: cURL aus der API-Dokumentation in Postman importieren, mit echten Parametern testen, Response-Format verifizieren. Übertragen Sie dann Method, URL, Headers und Body in einen HTTP Request Node und führen Sie **Execute Node** aus. Prüfen Sie im Output `$json.statusCode === 200` und ob die erwarteten Felder im Response-Body vorhanden sind.

### Agent-Aufruf testen

Localmind-Agenten rufen Sie über einen HTTP Request Node gegen `/v1/chat/completions` auf — die vollständige Anleitung steht unter [Localmind Agent in n8n einbinden](/automate/Localmind-Agent).

<Steps>
  <Step title="HTTP Request Node konfigurieren">
    1. Methode **POST**, URL: `https://<deine-instanz>-api.localmind.ai/v1/chat/completions`
    2. Authentication: Header-Auth-Credential mit `Authorization: Bearer <LOCALMIND_API_KEY>`
    3. Body (JSON) — `model` trägt die Agent-UUID aus `GET /v1/models`:

    ```json theme={null}
    {
      "model": "<agent_uuid>",
      "messages": [
        { "role": "user", "content": "{{ $json.text }}" }
      ],
      "stream": false
    }
    ```
  </Step>

  <Step title="Execute Node und Output prüfen">
    Die Antwort kann 5–30 Sekunden dauern. Der Output folgt dem Chat-Completions-Schema:

    ```json theme={null}
    {
      "choices": [
        {
          "message": {
            "role": "assistant",
            "content": "Diese E-Mail ist dringend und sollte priorisiert werden."
          },
          "finish_reason": "stop"
        }
      ],
      "usage": {
        "prompt_tokens": 25,
        "completion_tokens": 20,
        "total_tokens": 45
      }
    }
    ```

    Prüfen Sie: `$json.choices[0].message.content` ist vorhanden und nicht leer, `$json.usage.total_tokens` liegt im erwarteten Rahmen.
  </Step>

  <Step title="Output pinnen und Verbrauch überwachen">
    Agent-Aufrufe werden in Credits abgerechnet — behalten Sie `usage.total_tokens` pro Test im Blick und pinnen Sie den Output nach dem ersten erfolgreichen Test.
  </Step>
</Steps>

### Bedingte Logik testen (IF/Switch)

Testen Sie beide Branches mit passenden Daten — und zusätzlich die Edge Cases:

```javascript IF-Bedingung theme={null}
{{ $json.userType === 'premium' && $json.subscriptionActive === true }}
```

<CodeGroup>
  ```json True-Branch theme={null}
  {
    "userType": "premium",
    "subscriptionActive": true,
    "balance": 100
  }
  ```

  ```json False-Branch theme={null}
  {
    "userType": "free",
    "subscriptionActive": false,
    "balance": 0
  }
  ```

  ```json Edge Case theme={null}
  {
    "userType": null,
    "subscriptionActive": undefined,
    "balance": null
  }
  ```
</CodeGroup>

Erwartung: Der jeweils passende Branch wird ausgeführt, der andere übersprungen. Bei den Null/Undefined-Fällen prüfen Sie, wie sich der Node verhält, ob Fehler geworfen werden und ob Ihr Error-Handling greift.

### Daten-Transformation testen (Set/Code)

Definieren Sie Input-Daten, konfigurieren Sie die Transformation und vergleichen Sie den Output mit dem erwarteten Ergebnis. Beispiel für einen Set-Node mit den Feldern `fullName`: `{{ $json.firstName }} {{ $json.lastName }}`, `greeting`: `Hallo {{ $json.firstName }}!` und `email`: `{{ $json.email }}`:

<CodeGroup>
  ```json Input theme={null}
  {
    "firstName": "Max",
    "lastName": "Mustermann",
    "email": "max@example.com"
  }
  ```

  ```json Erwarteter Output theme={null}
  {
    "fullName": "Max Mustermann",
    "greeting": "Hallo Max!",
    "email": "max@example.com"
  }
  ```
</CodeGroup>

## Best Practices

* **Früh testen:** jeden Node sofort nach Erstellung, nicht erst am Ende der Entwicklung.
* **Outputs pinnen:** spart Zeit und Credits bei Downstream-Tests.
* **Realistische Test-Daten:** Daten verwenden, die echten Szenarien entsprechen — plus Edge Cases (null-Werte, leere Strings, sehr lange Texte).
* **Tests dokumentieren:** Szenarien und erwartete Outputs für zukünftige Referenz notieren.
* **Tests isolieren:** jeder Test funktioniert unabhängig von anderen.

## Checkliste vor dem Aktivieren

<Check>
  * [ ] Alle Nodes wurden einzeln getestet und liefern grünen Status
  * [ ] Output-Daten wurden validiert: erwartete Felder vorhanden, Formate korrekt, keine null/undefined-Werte in kritischen Feldern
  * [ ] Der Workflow wurde vollständig durchlaufen
  * [ ] Alle Branches wurden getestet (IF/Switch), Edge Cases eingeschlossen
  * [ ] Error-Handling und Retry-Logik wurden getestet, Timeouts sind angemessen
  * [ ] Execution-Zeit ist akzeptabel (unter 30 Sekunden)
  * [ ] Execution Logs wurden überprüft
  * [ ] Credit-Verbrauch wurde kalkuliert (bei KI-Nodes)
</Check>

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Debugging" icon="bug" href="/automate/debugging">
    Erfahren Sie mehr über fortgeschrittene Debugging-Techniken.
  </Card>

  <Card title="Performance" icon="gauge" href="/automate/performance">
    Optimieren Sie die Performance Ihrer Workflows.
  </Card>

  <Card title="Best Practices" icon="star" href="/automate/basics#best-practices">
    Lernen Sie weitere Best Practices für professionelle Workflows.
  </Card>

  <Card title="Sicherheit" icon="shield" href="/automate/security">
    Erfahren Sie mehr über sichere Workflow-Implementierung.
  </Card>
</CardGroup>

Bei Fragen zum Testing Ihrer Workflows hilft unser Support-Team unter [support@localmind.ai](mailto:support@localmind.ai).
