Beim Entwerfen automatisierter Test-Workflows in Apidog verwenden Sie verschiedene Arten von Testschritten – wie z.B. API-Anfragen, Datenbankabfragen, For-Schleifen, ForEach-Schleifen, Skripte und mehr.
Oft müssen die in einem Schritt erzeugten Daten in einem späteren Schritt verwendet werden. Dies schafft einen logischen Fluss, bei dem Daten den Prozess steuern und Schritte miteinander verknüpft sind.
Sie könnten zum Beispiel:
- In einem früheren Schritt ein Benutzer-Token abrufen oder eine Datenbankabfrage ausführen, um einen bestimmten Datensatz zu erhalten
- Diese Ergebnisse dann in einer Endpunktanfrage im nächsten Schritt verwenden.
Dies wirft eine wichtige Frage auf:
Wie können Sie die Daten aus früheren (vorgelagerten) Schritten in den nachfolgenden (nachgelagerten) Schritten korrekt referenzieren?
Zwei Mechanismen zur Datenübergabe in Apidog
In Apidogs automatisiertem Test gibt es zwei Hauptmethoden zur Datenübergabe zwischen verschiedenen Testschritten:
1. Vorherige Schrittdaten über "Dynamische Werte" abrufen
Sie können die Ausgabe eines vorherigen (vorgelagerten) Schritts in einem späteren (nachgelagerten) Schritt direkt referenzieren, indem Sie die Funktion "Dynamischer Wert" verwenden. Dadurch können Sie Daten spontan abrufen, ohne sie zu speichern.
2. Variablen speichern und wiederverwenden
Sie können wichtige Daten aus einem vorgelagerten Schritt extrahieren und als Variable speichern. Diese Variablen können dann in jedem nachfolgenden Schritt wiederverwendet werden.
Die Beherrschung dieser beiden Methoden zur Datenübergabe ist entscheidend für den Aufbau effizienter, datengesteuerter automatisierter Workflows in Apidog.
Dieser Artikel erklärt, wie Daten in verschiedenen Arten von Testschritten aus zwei Blickwinkeln gehandhabt werden: wie man Daten extrahiert und wie man sie verwendet. Wenn Sie beides verstehen, können Sie flexiblere und besser vernetzte Test-Workflows erstellen.
Extrahieren und Verwenden von Endpunkt-Antwortdaten
Verstehen von Endpunkt-Antwortdaten
In automatisierten Tests geben API-Anfragen normalerweise strukturierte JSON-Antworten zurück, die oft als Eingabe für spätere Testschritte dienen.
Im Gegensatz zu anderen Schritttypen sind Endpunkt-Antworten tendenziell komplexer – sie enthalten häufig verschachtelte Objekte und Arrays.
Wie man Daten aus Endpunkt-Antworten extrahiert
Es gibt zwei Hauptmethoden, um Endpunkt-Antwortdaten zwischen Testschritten zu extrahieren und zu übergeben:
Methode Eins: Dynamische Wertreferenz
Verwenden Sie "Dynamische Werte", um Daten aus vorherigen Schritten direkt zu referenzieren:
- Klicken Sie in einem beliebigen Eingabefeld eines nachgelagerten Schritts auf das Zauberstab-Symbol.
- Wählen Sie "Vorherige Schrittdaten abrufen"
- Apidog fügt den korrekten Ausdruck automatisch ein – kein manuelles Schreiben erforderlich.
Methode Zwei: Daten als Variablen extrahieren
Sie können auch die Funktion "Variablen extrahieren" in Endpunkt-Postprozessoren verwenden, um bestimmte Felder aus der Antwort als Variablen zu extrahieren.
Um beispielsweise die `id` der Produkte in einer Antwort zu extrahieren:
- Legen Sie den Variablennamen als `products_id` fest
- Verwenden Sie den JSONPath: `$.products[0].id`
In späteren Schritten referenzieren Sie sie einfach mit `{{products_id}}`.
Wie man aus Endpunkt-Antworten extrahierte Daten verwendet
Sobald Sie Daten aus einer API-Antwort extrahiert haben – entweder mit "Dynamischen Werten" oder "Extrahierten Variablen" – können Sie diese Daten in nachgelagerten Schritten auf verschiedene Weisen verwenden:
1. Daten in Endpunktanfragen verwenden
- Über Dynamischen Wert: Wie zuvor klicken Sie auf das Zauberstab-Symbol im Eingabefeld, wählen "Vorherige Schrittdaten abrufen", und Apidog fügt den korrekten Ausdruck automatisch ein.
- Über Extrahierte Variable: Wenn Sie zuvor einen Wert als Variable (z.B. `products_id`) gespeichert haben, verwenden Sie einfach `{{products_id}}` als Parameter in der API-Anfrage.
2. Daten in Datenbankoperationen verwenden
Sie können die API-Antwort als Eingabe in einer Datenbankabfrage verwenden. Beide Methoden funktionieren:
- Methode Dynamischer Wert
SELECT * FROM products WHERE id = '{{$.1.response.body.products[0].id}}'
Verwenden Sie dynamische Werte, um die API-Antwortdaten direkt in der SQL-Abfrage zu referenzieren:
- Methode Extrahierte Variable: Wenn Sie die Produkt-ID als Variable namens `products_id` extrahiert haben, verwenden Sie:
SELECT * FROM products WHERE id = '{{products_id}}'3. Daten in `For-Schleifen` verwenden
Um Schritte basierend auf der Länge eines Arrays aus einer API-Antwort zu wiederholen:
- Verwenden Sie dynamische Werte, um die Array-Länge zu erhalten, zum Beispiel:
{{$.1.response.body.products.length}}Dies legt die Anzahl der Schleifeniterationen fest.
4. Daten in `ForEach-Schleifen` verwenden
Wenn Sie jedes Element in einem von einem Endpunkt zurückgegebenen Array durchlaufen möchten:
- Methode Dynamischer Wert: Extrahieren Sie direkt das gesamte Array, zum Beispiel `{{$.1.response.body.products}}`
- Methode Variable extrahieren: Angenommen, das gesamte Array wurde als Variable `products` extrahiert, dann fügen Sie `{{products}}` direkt in die Schleife ein.
5. Daten in Skripten verwenden
Um Daten aus vorherigen Schritten innerhalb eines Skripts zu verwenden, nutzen Sie die Methode `pm.variables.get()`. So geht's:
- Methode Dynamischer Wert: Lesen Sie die Daten direkt aus einem vorherigen Schritt:
const products = pm.variables.get("$.1.response.body.products")
- Methode Variable extrahieren: Wenn Sie das Array oder den Wert als Variable gespeichert haben, verwenden Sie das folgende Skript, um die Daten abzurufen:
Den Wert einer temporären Variablen abrufen:
const products = pm.variables.get("products") Den Wert einer Umgebungsvariablen abrufen:
const products = pm.environment.get("products")
Den Wert einer globalen Variablen abrufen:
const products = pm.globals.get("products"){{products}} nicht direkt verwenden. Stattdessen müssen Sie Variablenwerte mit den oben genannten geeigneten Methoden abrufen.Extrahieren und Verwenden von Datenbankabfrageergebnissen
Verstehen von Datenbankdaten
Wenn ein Datenbankabfrageschritt ausgeführt wird, gibt er strukturierte Daten in Form eines Arrays von Objekten zurück. Selbst wenn nur ein Datensatz zurückgegeben wird, ist er immer noch in ein Array eingeschlossen. Zum Beispiel:
Im Gegensatz zu Endpunkt-Antworten können Daten aus Datenbankschritten nicht direkt mit dynamischen Variablen abgerufen werden. Sie müssen die Werte zuerst in Variablen extrahieren.
Wie man Daten aus der Datenbank extrahiert
Nach dem Ausführen der SQL-Abfrage in einem Datenbankschritt parst Apidog die Antwort automatisch in strukturierte Daten, wie folgt:
[
{
"id": "1000",
"title": "Title 1",
"description": "Description for Title 1"
}
]
Sie können dann JSONPath verwenden, um bestimmte Felder zu extrahieren und als Variablen zu speichern.
Zum Beispiel:
- Variablenname: `products_id`
- JSONPath: `$[0].id` (um die ID des ersten Elements zu extrahieren). Wenn Sie den gesamten Ergebnissatz extrahieren möchten, verwenden Sie: `$` .
- Nachgelagerte Schritte referenzieren Variablen über `{{ }}`, zum Beispiel: `{{products_id}}`
Wie man aus einer Datenbank extrahierte Daten verwendet
1. Daten in Endpunktanfragen verwenden
Wenn Ihre Datenbankabfrage eine ID zurückgibt und Sie diese als Variable (`products_id`) gespeichert haben, können Sie sie direkt in einer nachgelagerten Endpunktanfrage verwenden:
2. Daten in ForEach-Schleifen verwenden
Wenn Ihre Abfrage eine Liste von Datensätzen zurückgibt und Sie jeden einzeln verarbeiten möchten, können Sie das gesamte Array als Quelle für eine `ForEach`-Schleife verwenden:
Die Voraussetzung ist, dass Sie das gesamte Array speichern, wenn Sie Variablen in Datenbankoperationen extrahieren, zum Beispiel:
- Variablenname: `products`
- JSONPath: `$`
3. Daten in Skripten verwenden
Um extrahierte Datenbankvariablen in einem Skript zu verwenden, verwenden Sie dieselbe Methode wie bei anderen Variablen.
Den Wert einer temporären Variablen abrufen:
const products = pm.variables.get("products")Den Wert einer Umgebungsvariablen abrufen:
const products = pm.environment.get("products")Den Wert einer globalen Variablen abrufen:
const products = pm.globals.get("products")
Extrahieren und Verwenden von Daten aus `For-Schleifen`
Wie `For-Schleifen` funktionieren?
Eine **`For-Schleife`** wird verwendet, um eine bestimmte Reihe von Aktionen mehrmals zu wiederholen. Sie läuft basierend auf einer definierten Anzahl von Iterationen.
Sie können entweder eine feste Anzahl von Schleifendurchläufen festlegen oder einen dynamischen Wert wie die Länge eines Arrays `.length` verwenden, der von einem vorherigen Schritt zurückgegeben wurde. Zum Beispiel: `{{$.1.response.body.products.length}}`:
Hinweis: Im Gegensatz zu anderen Schritten, die Daten ausgeben, gibt eine `For-Schleife` selbst keine Daten direkt zurück. Sie liefert lediglich einen Indexwert (beginnend bei 0), um anzuzeigen, wie oft die Schleife ausgeführt wurde.
Wie man Daten aus `For-Schleifen` extrahiert
Während des Ausführungsprozesses können Sie auf den aktuellen Schleifenindex über die dynamische Variablensyntax zugreifen: {{$.9.index}}
- Die Zahl `9` bezieht sich auf die ID des `For-Schleifen`-Schritts.
- Jeder Schritt hat eine eindeutige ID.
- Der Index beginnt bei 0 für die erste Schleife, 1 für die zweite und so weiter.
Wie man aus `For-Schleifen` extrahierte Daten verwendet
1. Daten in Skripten verwenden
Wenn Sie schleifenbezogene Informationen in Ihrem Testskript verwenden möchten, können Sie `pm.variables.get()` verwenden, um den aktuellen Index abzurufen:
// Den aktuellen Schleifenindex abrufen
const index = pm.variables.get("$.7.index");
2. Daten mit anderen Datenquellen verwenden
Ein häufiger Anwendungsfall für eine `For-Schleife` ist die Verarbeitung von Daten aus früheren Schritten – wie das Durchlaufen eines Arrays und die Bearbeitung jedes Elements:
// Das Array aus einem vorherigen Schritt abrufen
const products = pm.variables.get("$.1.response.body.products");
// Den aktuellen Schleifenindex abrufen
const index = pm.variables.get("$.7.index");
// Auf das aktuelle Element im Array über den Index zugreifen
console.log(products[index]);
Dies ermöglicht es Ihnen, Batch-Operationen für jedes Element im Array während jeder Schleifeniteration durchzuführen.
Extrahieren und Verwenden von Daten aus `ForEach-Schleifen`
Wie die `ForEach-Schleife` funktioniert?
Die ForEach-Schleife ist speziell für Array-Daten konzipiert. Sie iteriert automatisch durch jedes Element im Array und führt dieselben Operationen aus.
Der Hauptunterschied zwischen einer `ForEach-Schleife` und einer `For-Schleife` besteht darin, dass die `ForEach-Schleife` in jeder Iteration automatisch die vollständigen Daten des aktuellen Array-Elements extrahiert, wodurch sie in ihren Kindschritten direkt zugänglich sind.
Zugriff auf Daten in einer `ForEach-Schleife`
Innerhalb einer `ForEach-Schleife` erstellt das System automatisch zwei spezielle Variablen:
- Aktuelle Schleifenelemente: Enthält die vollständigen Daten des aktuell verarbeiteten Array-Elements. Zum Beispiel: `{{$.4.element}}`. Wenn das Array Objekte enthält, können Sie direkt auf deren Eigenschaften zugreifen, wie z.B.: `{{$.4.element.id}}`, `{{$.4.element.title}}`, etc.
- Aktueller Schleifenindex: Repräsentiert die aktuelle Iterationsanzahl (beginnend bei 0), z.B. `{{$.4.index}}`.
Hinweis: Die Zahl `4` bezieht sich auf die ID des `ForEach-Schleifen`-Schritts. Ersetzen Sie diese in Ihrem tatsächlichen Workflow durch die korrekte Schritt-ID aus Ihrem Prozess.
Häufige Anwendungsfälle für `ForEach-Schleifen`-Daten
1. Daten in Endpunktanfragen verwenden
ForEach-Schleifen eignen sich perfekt für die Verarbeitung von Batch-Daten. Wenn Sie beispielsweise ein Array von Elementen haben, können Sie automatisch eine Endpunktanfrage für jedes Element im Array senden. Während jeder Schleife wird dieselbe Anforderungsvorlage wiederverwendet, aber mit unterschiedlichen Daten gefüllt, wie z.B. `{{$.4.element.id}}`.
2. Daten in Datenbankoperationen verwenden
Sie können Daten aus dem aktuellen Schleifenelement verwenden, um Datenbankabfragen auszuführen oder mehrere Zeilen einzufügen.
Beispiel: Abfragen der Datenbank unter Verwendung des Feldes des aktuellen Elements
SELECT * FROM products WHERE id = '{{$.4.element.id}}'
Der Ausdruck `{{$.4.element.id}}` kann mit der Funktion für dynamische Werte aufgerufen werden.
Einfügen mehrerer Felder aus dem aktuellen Element in eine Tabelle:
INSERT INTO products (id, title) VALUES ('{{$.4.element.id}}', '{{$.4.element.title}}')
3. Daten in Skripten verwenden
Wenn Sie Daten aus der Schleife in einem benutzerdefinierten Skript weiterverarbeiten müssen, können Sie die Methode `pm.variables.get()` verwenden, um die Werte abzurufen:
// Das aktuelle Element abrufen
const item = pm.variables.get("$.4.element");
// Den aktuellen Index abrufen
const index = pm.variables.get("$.4.index");Extrahieren und Verwenden von Daten aus Skripten
Wie Skriptdaten funktionieren
Im Gegensatz zu anderen Schritten in einem Workflow generieren Skripte keine automatische Ausgabe, die direkt in den folgenden Schritten verwendet werden kann. Wenn Sie Daten von einem Skript an spätere Schritte übergeben möchten, müssen Sie diese manuell in einer Variablen speichern.
Wie man Daten aus einem Skript extrahiert
Sie können Werte wie folgt in verschiedene Variablentypen speichern:
// JSON-Antwortdaten abrufen
// 1. Aus der aktuellen Endpunktantwort
// const currentData = pm.response.json();
// 2. Oder aus einem vorherigen Schritt mit einem dynamischen Wert abrufen
const preData = pm.variables.get("$.1.response.body");
// In Umgebungsvariablen speichern
pm.environment.set('products', preData.products);
pm.environment.set('products_id', preData.products[0].id);
// In globalen Variablen speichern
pm.globals.set('products', preData.products);
// In temporären Variablen speichern (nur während dieser Ausführung gültig)
pm.variables.set('products', preData.products);Sobald die Variablen extrahiert und gesetzt sind, können Sie sie in späteren Schritten mit der Syntax `{{variableName}}` referenzieren.
Wie man aus Skripten extrahierte Daten verwendet
1. Daten in Endpunktanfragen verwenden
In einem Skript gesetzte Variablen können direkt als Parameter in nachgelagerten Endpunktanfragen verwendet werden. Wenn Sie beispielsweise `products_id` im Skript speichern, können Sie es in einer späteren Anfrage wie folgt referenzieren: `{{products_id}}`.
2. Daten in Datenbankoperationen verwenden
Skriptvariablen können auch verwendet werden, um dynamische SQL-Anweisungen zu erstellen. Zum Beispiel:
SELECT * FROM products WHERE id = '{{products_id}}'3. Daten in `For-Schleifen` verwenden
Sie können ein Skript verwenden, um die Schleifenanzahl oder andere Zwischenwerte zu generieren, diese als "temporäre Variablen" zu speichern und sie an den **`For-Schleifen`**-Schritt zu übergeben:
pm.variables.set("loopCount", 5); Verwenden Sie dann in den Schleifeneinstellungen `{{loopCount}}` als Anzahl der Iterationen.
4. Daten in `ForEach-Schleifen` verwenden
Sie können ein gesamtes Array in einer Variablen speichern und es als Datenquelle für eine `ForEach-Schleife` verwenden.
Beispiel:
// Optional: Array aus einem vorherigen Schritt mit dynamischen Werten abrufen
// const preData = pm.variables.get("$.1.response.body.products")
const preData = [{id: 1}, {id: 2}, {id: 3}];
// In Umgebungsvariable speichern
pm.environment.set('products', preData);
Stellen Sie dann in der `ForEach-Schleife` die Datenquelle auf `{{products}}` ein.
Fazit
Um einen effizienten automatisierten Test-Workflow zu erstellen, ist es unerlässlich zu verstehen, wie Daten aus verschiedenen Arten von Schritten extrahiert und verwendet werden:
- Endpunkt- und Datenbankschritte generieren geschäftsbezogene Daten.
- Schleifenschritte steuern den Logikfluss.
- Skriptschritte werden verwendet, um Daten zu verarbeiten und zu transformieren.
Durch die Kombination von dynamischer Wertreferenzierung mit Variablenextraktion können Sie einen flexiblen und leistungsstarken datengesteuerten Testprozess entwerfen.
Best Practices für die Datenübergabe:
- Verwenden Sie die dynamische Wertreferenzierung für einfache Daten, die nur einmal oder gelegentlich verwendet werden.
- Verwenden Sie die Variablenextraktion für Daten, die über mehrere Schritte hinweg wiederverwendet oder in Skripten verarbeitet werden müssen.
Die Wahl der richtigen Methode, basierend auf Datenkomplexität und Nutzungshäufigkeit, macht Ihren Workflow wartbarer und effizienter.