API-Tests: Postman/Newman

1) Warum Postman/Newman

• wiederholbare Regressionen und schnelle Smokes;
• Parametrierung von Umgebungen/Geheimnissen;
• Qualitätsmetriken und maschinenlesbare Berichte.

2) Basismodell

Sammlung - Eine Abfrage- und Ordnerstruktur mit freigegebenen Skripten.
Environments - set'{{vars}} 'für dev/stage/prod (URL, Schlüssel).
Pre-request script - Vorbereitung: Signaturen, Token, Datenkorrelation.
Tests - Genehmigen und Speichern von Variablen/Artefakten.
Data-files - CSV/JSON für einen datengetriebenen Lauf.
Mock/Monitor - Stapel und regelmäßige Kontrollen.

<API v1>
├─ _bootstrap (auth, health, seeds)
├─ Public
├─ Authenticated
│  ├─ Accounts
│  ├─ Payments
│  └─ Reports
└─ _teardown (cleanup)

3) Variablen und Geheimnisse

Benennen Sie die Variablen mit einem expliziten Präfix: 'baseUrl', 'tenant', 'clientId'.
Halten Sie Geheimnisse (Passwörter, client_secret, HMAC-Schlüssel) in CI-Umgebungsvariablen, nicht in das Repository.
Verwenden Sie scope: local → collection → environment → globals.

json
{
"name": "stage-eu",
"values": [
{"key":"baseUrl","value":"https://api. stage. example. com","type":"text","enabled":true},
{"key":"tenant","value":"eu-1","type":"text","enabled":true}
]
}

4) Authentifizierung: Vorlagen

4. 1 OAuth2/OIDC (Client Credentials)

js if (!pm.environment. get("access_token")          Date. now() > pm. environment. get("token_exp")) {
pm. sendRequest({
url: pm. environment. get("authUrl"),
method: 'POST',
header: {'Content-Type':'application/x-www-form-urlencoded'},
body: { mode:'urlencoded', urlencoded:[
{key:'grant_type',value:'client_credentials'},
{key:'client_id',value:pm. environment. get('clientId')},
{key:'client_secret',value:pm. environment. get('clientSecret')},
{key:'scope',value:'payments:read payments:write'}
]}
}, (err, res) => {
pm. environment. set("access_token", res. json(). access_token);
pm. environment. set("token_exp", Date. now()+ (res. json(). expires_in-30)1000);
});
}

In der Abfrage: 'Authorization: Bearer {{access _ token}}'.

4. 2 HMAC (Webhooks/Partner)

js const body = pm. request. body? pm. request. body. raw          '': '';
const ts = Math. floor(Date. now()/1000);
const msg = `${ts}.${body}`;
const sig = CryptoJS. HmacSHA256(msg, pm. environment. get('hmacSecret')). toString();
pm. variables. set('ts', ts);
pm. variables. set('sig', sig);

Überschriften: „X-Timestamp: {{ts}}“, „X-Signature: {{sig}}“.

5) Tests: Zulassungen und Korrelation

Benutze' pm. expect(...)` и `pm. test("...", fn)`.
Speichern Sie die IDs für die nächsten Schritte durch 'pm. collectionVariables. set`.

js pm. test("HTTP 200", () => pm. response. to. have. status(200));
pm. test ("Scheme is valid," () => {
const schema = pm. collectionVariables. get("schema_wallet");
pm. expect(tv4. validate(pm. response. json(), JSON. parse(schema))). to. be. true;
});
pm. test ("Contains id," () => {
const id = pm. response. json(). id;
pm. expect(id). to. be. a('string');
pm. collectionVariables. set("wallet_id", id);
});

6) Schema-Validierung (OpenAPI/JSON Schema)

Speichern Sie JSON Schema in Sammlungsvariablen oder in einer separaten Datei.
Für OpenAPI: Verwenden Sie die fertigen Blätter in pre-request/test (ajv, tv4) - via 'pm. sendRequest ™ an eine raw-Datei oder eine JSON-Inline.

js pm. collectionVariables. set("schema_wallet", JSON. stringify({
"type":"object",
"required":["id","currency","balance"],
"properties":{
"id":{"type":"string"},
"currency":{"type":"string","pattern":"^[A-Z]{3}$"},
"balance":{"type":"number","minimum":0}
}
}));

7) Datengetriebene Szenarien

email, password, currency u1@example. com, P@ss1, EUR u2@example. com, P@ss2, USD

Die Abfrage verwendet'{{email}}','{{currency}}'.

newman run collection. json -e stage-eu. json -d users. csv

JSON (Array of Objects) - praktisch für komplexe Fälle/Strukturen.

8) Negativfälle und Nachhaltigkeit

• 401/403 (kein Token/falscher Scope/Rolle).
• 400/422 (Validierung des Schemas, Pflichtfelder, Grenzen).
• 404 (BOLA/fremde Ressource).
• 409 (Konflikte, idempotente Schlüssel).
• 429 (Limits) - Überprüfen Sie' Retry-After'.
• 5xx ist die korrekte Degradierung und Retraie des Kunden.

js pm. test ("There is Retry-After at 429," () => {
if (pm. response. code === 429) pm. expect(pm. response. headers. has('Retry-After')). to. be. true;
});

9) Idempotenz, Retrays, Pagination

Übergeben Sie den 'Idempotency-Key' und vergewissern Sie sich, dass die Wiederholung den gleichen 'id/status' ergibt.
Testen Sie die Paginierung: 'limit/offset '/' cursor', ein Detail von Duplikaten und Lücken.
Simulierte Retrays im Test-Skript: aufeinanderfolgende Aufrufe mit demselben Schlüssel.

js pm. test ("Idempotent repetition," () => {
pm. sendRequest(pm. request, (err, res2) => {
pm. expect(res2. code). to. eql(pm. response. code);
pm. expect(res2. json(). id). to. eql(pm. response. json(). id);
});
});

10) Newman в CI/CD

10. 1 Inbetriebnahme

newman run collection. json \
-e stage-eu. json \
-d data. csv \
--timeout-request 30000 \
--reporters cli,htmlextra,junit \
--reporter-htmlextra-export./reports/report. html \
--reporter-junit-export./reports/junit. xml

10. 2 GitHub-Aktionen (Ausschnitt)

yaml
- uses: actions/setup-node@v4 with: { node-version: '20' }
- run: npm i -g newman newman-reporter-htmlextra
- run: newman run collection. json -e stage-eu. json --reporters cli,junit --reporter-junit-export reports/junit. xml
- uses: actions/upload-artifact@v4 with: { name: newman-reports, path: reports }

10. 3 Jenkins/GitLab CI

Exportieren Sie JUnit ('--reporter-junit-export') für die native Visualisierung.
In der Pipeline trennen Sie die Jobs: Rauch (schnell), Regression (voll), Sicherheit (Negativ/Grenzen).

10. 4 Docker

docker run --rm -v $PWD:/etc/newman postman/newman \
run collection. json -e stage-eu. json

11) Moki und Überwachung

Mock-Server Postman sind schnelle Stapel für Front und Verträge.
Monitore - periodischer Lauf von Smokes aus der Cloud (Latenz, 5xx, SSL).
Bewahren Sie im Repository Beispielantwortdateien für deterministische Mocs auf.

12) Testdaten und Reinigung

Erstellen/Löschen von Entitäten (_bootstrap/_teardown).
Markieren Sie die Testobjekte mit dem Präfix' e2e _ 'und der TTL.

js pm. collectionVariables. set("uniq", Date. now()+"_"+Math. floor(Math. random()1e6));

13) Leistung „auf dem Knie“

• Messen Sie' pm. response. responseTime`;
• 5-10 Iterationen ausführen und p95/Schwellenwerte fixieren;
• schwere Performance-Läufe - in JMeter/k6/Gatling (außerhalb dieses Artikels).

14) Lokalisierung und Multiarrangement

Variablen 'tenant', 'region', 'lang'; Wechseln Sie in der Umgebung.
Die Tests sollen überprüfen, dass die Daten nicht zwischen den Tenanten „fließen“ (BOLA-read, tenantenübergreifende Verbote).
Individuelle Sammlungen/Ordner zu regionalen Besonderheiten (Limits, Währungen).

15) Berichterstattung und Artefakte

Speichern Sie CI-Artefakte: HTML-Berichte, 'junit. xml', Protokolle fehlgeschlagener Antworten (response bodies).
Verbinden Sie Slack/Teams Benachrichtigungen auf Smokes fallen.

16) Qualität und Beschichtung

• CRUD per-Ressource (200/201/204 + Negative).
• Autorisierung: Rollen/Scopes/Multi-Tenant.
• Paginierung/Filter/Sortierung.
• Idempotenz und Retrays.
• Grenzen: 413/414/431/429.
• Formate und Schemata (JSON Schema/OpenAPI).
• Integrationen (Webhooks mit HMAC/mTLS) - Anti-Replay.

17) Antipatterns

Ein „glücklicher Weg“ ohne negative Tests.
Langlebige Token in einer Sammlung/einem Repository.
Mischen von Testdaten mit Prod-Daten.
Versteckte Abhängigkeit der Testreihenfolge ohne explizite Korrelation.
Riesige Daten-Dateien ohne Sampling.
Keine JUnit/HTML-Berichte → keine Sichtbarkeit in CI.

18) Checkliste Prod-Ready

• Sammlungen sind nach Domains aufgeschlüsselt, es gibt'_ bootstrap/_ teardown'.
• Umgebungen für dev/stage/prod; Geheimnisse aus dem CI-Geheimnis-Speicher.
• Pre-request для auth (OAuth2/HMAC); Token werden zwischengespeichert und rotiert.
• Tests: positiv + negativ, Schemata (JSON Schema), Pagination, 429/Retry-After.
• Idempotenz: Prüfung 'Idempotency-Key', doppelter Aufruf ist äquivalent.
• Data-driven CSV/JSON, zufällige Suffixe für Einzigartigkeit.
• Newman in CI: JUnit/HTML-Berichte, Artefakte als Build-Outputs.
• Moki/Monitore für Schlüsselrouten; SLA durch Smokes.
• Dokumentation zu Variablen, Tags und Startreihenfolge.

19) TL; DR

Speichern Sie die Testlogik in Postman-Sammlungen, die Parameter in Umgebungen und führen Sie in CI durch Newman mit JUnit/HTML-Berichten. Bedecken Sie Negative, Schemata, Idempotenz, Pagination und Grenzen. Korrelieren Sie die Schritte mit Variablen, verwenden Sie datengetriebene Eingänge und Mooks/Monitore. Geheimnisse sind nur von CI, Berichte sind Artefakte des Bilds.