Vom PRD zur Testschleife: Ein vollständiger Agenten-Workflow mit Apidog CLI

Dies ist eine 10-teilige Serie, die beschreibt, wie Apidog Apidog CLI, ein Befehlszeilentool für API-Tests und API-Lebenszyklusmanagement, entwickelt hat. Lesen Sie der Reihe nach oder springen Sie zu einem beliebigen Beitrag, der Sie interessiert:

Gehen wir ein echtes Beispiel durch: Ein Team hat eine PRD und Codebasis für eine Auftragsrückerstattung. Sehen Sie, wie ein Agent Apidog CLI + SKILL verwendet, um OpenAPI zu generieren, Tests zu erstellen, zu validieren und zu verifizieren – End-to-End.

Das Szenario

Lassen Sie uns alles mit einem realen Workflow konkret machen.

Kontext:

Ein Team hat gerade eine "Auftragsrückerstattungs"-PRD fertiggestellt. Die Codebasis verfügt bereits über entsprechende Routen und Controller.

Benutzeranfrage an den Agenten:

"Generieren Sie API-Tests für die Rückerstattungsfunktionalität basierend auf der PRD und der Codebasis und führen Sie dann die Verifizierung durch."

Das Problem des alten Ansatzes

Mit MCP-Tools steht der Agent vor einer Reihe von Dilemmata:

Der Agent wendet viel Aufwand nur für die Entscheidung des Pfades auf – nicht für die Ausführung der Aufgabe.

Der CLI + SKILL Pfad

CLI + SKILL erfüllt echte F&E-Abläufe mit einer klaren Reihenfolge:

OpenAPI aus PRD & Codebasis generieren
        ↓
In Apidog importieren
        ↓
Einzel-Endpunkt-Testfälle hinzufügen
        ↓
Vor dem Schreiben validieren
        ↓
Testszenario für den Geschäftsablauf generieren
        ↓
Vor dem Schreiben validieren
        ↓
Automatisierte Tests durchführen

Gehen wir jeden Schritt durch.

Schritt 1: OpenAPI generieren & importieren

Der Agent liest die PRD und die Codebasis und generiert dann die OpenAPI-Spezifikation.

PRD-Auszug:

API zur Auftragsrückerstattung

POST /api/orders/{orderId}/refund
- Anfragekörper: { "reason": string, "amount": number }
- Antwort: { "refundId": string, "status": string, "processedAt": datetime }

GET /api/orders/{orderId}/refund/{refundId}
- Antwort: { "refundId": string, "status": string, "amount": number }

Agent generiert OpenAPI:

{
  "openapi": "3.0.0",
  "paths": {
    "/api/orders/{orderId}/refund": {
      "post": {
        "summary": "Rückerstattungsanfrage erstellen",
        "parameters": [...],
        "requestBody": {...},
        "responses": {...}
      }
    },
    "/api/orders/{orderId}/refund/{refundId}": {
      "get": {
        "summary": "Rückerstattungsstatus abrufen",
        ...
      }
    }
  }
}

In Apidog importieren:

apidog import --project <projectId> --format openapi --file ./openapi.json

CLI-Ausgabe:

{
  "success": true,
  "data": {
    "importedEndpoints": ["POST /refund", "GET /refund/{refundId}"],
    "endpointIds": ["ep-001", "ep-002"]
  },
  "agentHints": {
    "summary": "OpenAPI erfolgreich importiert. 2 Endpunkte erstellt.",
    "nextSteps": [
      "Die importierten Endpunkte auflisten, um die Struktur zu bestätigen.",
      "Testfälle für jeden Endpunkt hinzufügen.",
      "Ein Testszenario für den vollständigen Rückerstattungsablauf erstellen."
    ]
  }
}

Schritt 2: Einzel-Endpunkt-Testfälle

Der Agent konzentriert sich zuerst auf den "Rückerstattungs-Endpunkt".

Agent liest Endpunkt:

apidog endpoint get ep-001 --project <projectId>

CLI gibt Endpunktstruktur zurück:

{
  "id": "ep-001",
  "method": "POST",
  "path": "/api/orders/{orderId}/refund",
  "requestBody": {
    "schema": {
      "type": "object",
      "properties": {
        "reason": { "type": "string" },
        "amount": { "type": "number" }
      },
      "required": ["reason", "amount"]
    }
  },
  "responses": {
    "200": {...}
  }
}

Agent generiert Testfall:

{
  "name": "Rückerstattung erstellen - Erfolg",
  "endpointId": "ep-001",
  "request": {
    "path": "/api/orders/order-123/refund",
    "body": {
      "reason": "Kundenanfrage",
      "amount": 99.99
    }
  },
  "assertions": [
    {
      "subject": "responseJson.status",
      "comparator": "equal",
      "target": "processed"
    }
  ]
}

Vor dem Schreiben validieren:

apidog cli-schema validate test-case-create --file ./test-case-create.json

CLI-Validierungsergebnis:

{
  "success": true,
  "agentHints": {
    "summary": "Testfallstruktur ist gültig.",
    "nextSteps": [
      "Den Testfall in Apidog erstellen.",
      "Den erstellten Testfall zurücklesen, um ihn zu bestätigen.",
      "Bei Bedarf weitere Assertions hinzufügen."
    ]
  }
}

Testfall erstellen:

apidog test-case create --project <projectId> --file ./test-case-create.json

CLI-Ausgabe:

{
  "success": true,
  "data": {
    "id": "tc-001",
    "name": "Rückerstattung erstellen - Erfolg"
  },
  "agentHints": {
    "summary": "Testfall erfolgreich erstellt.",
    "nextSteps": [
      "Testfall tc-001 zurücklesen, um Assertions zu bestätigen.",
      "Testfall für GET /refund/{refundId} erstellen.",
      "Testszenario für den vollständigen Rückerstattungsablauf erstellen."
    ]
  }
}

Schritt 3: Testszenario für den vollständigen Ablauf

Basierend auf der PRD ist der vollständige Geschäftsablauf:

Bestellung erstellen → Bezahlen → Rückerstattung → Rückerstattungsstatus abfragen

Agent generiert Szenario:

{
  "name": "Vollständiger Ablauf der Auftragsrückerstattung",
  "steps": [
    { "type": "case", "caseId": "tc-create-order" },
    { "type": "case", "caseId": "tc-pay" },
    { "type": "case", "caseId": "tc-001" },
    { "type": "case", "caseId": "tc-get-refund" }
  ]
}

Vor dem Schreiben validieren:

apidog cli-schema validate test-scenario-update --file ./scenario-update.json

Szenario erstellen:

apidog test-scenario create --project <projectId> --file ./scenario-update.json

Schritt 4: Verifizierung durchführen

Nachdem Testfälle und Szenarien bereit sind:

apidog run --project <projectId> \
  --test-scenario scenario-001 \
  --environment env-production \
  -r "cli,html,junit" \
  --out-dir ./apidog-reports

CLI-Ausgabe:

{
  "success": true,
  "stats": {
    "total": 4,
    "passed": 4,
    "failed": 0
  },
  "reportFiles": {
    "cli": "./apidog-reports/cli-report.txt",
    "html": "./apidog-reports/report.html",
    "junit": "./apidog-reports/junit.xml"
  },
  "agentHints": {
    "summary": "Alle Tests bestanden. 4 Schritte erfolgreich ausgeführt.",
    "nextSteps": [
      "Den HTML-Bericht für detaillierte Ergebnisse überprüfen.",
      "Bei Fehlern mithilfe der CLI-Fehlerdetails debuggen.",
      "Diesen Test in die CI-Pipeline integrieren."
    ]
  }
}

Die vollständige Kette

Alle Elemente sind nun verbunden:

Alles ist verifizierbar und nachvollziehbar.

agentHints im Ablauf

Beachten Sie, wie agentHints jeden Übergang leitet:

Der Agent muss nie erraten, was als Nächstes zu tun ist.

Vergleich: MCP vs. CLI + SKILL für diese Aufgabe

Was kommt als Nächstes

Dieses praktische Beispiel zeigt, wie CLI + SKILL in einem realen Workflow funktioniert.

Doch unter all dem liegt ein Fundament: CI/CD-Kompatibilität.

In Teil 8, Warum CI/CD-Kompatibilität für Agent Tools unerlässlich ist, werden wir untersuchen, warum apidog run sowohl CI-Pipelines als auch KI-Agenten dient – und warum dieser doppelte Zweck für ein nachhaltiges Tool-Design wichtig ist.

Wichtige Erkenntnisse

• Kompletter Workflow: PRD → OpenAPI → Import → Testfälle → Szenario → Verifizieren
• Jeder Schritt hat CLI-Befehl + Validierung + agentHints
• Schritte importieren + zurücklesen ist sicherer als Szenarien manuell zu schreiben
• --with-case-detail bietet eine echte Struktur für Updates
• agentHints leitet jeden Übergang
• Alles ist verifizierbar und nachvollziehbar

Laden Sie Apidog herunter, um APIs in einem einzigen Arbeitsbereich zu entwerfen, zu mocken, zu testen und zu dokumentieren. Erfahren Sie mehr über Apidog CLI für API-Tests über die Befehlszeile, CI-Automatisierung und KI-Agenten-Workflows.