REST und GraphQL in PHPStorm testen: HTTP-Client, Environments und Variables

1. PHPStorm HTTP-Client: Überblick und Stärken

Der in PHPStorm integrierte HTTP-Client ist seit Version 2017.3 verfügbar und hat sich seither zu einem vollwertigen API-Testing-Tool entwickelt. Im Gegensatz zu externen Tools wie Postman oder Insomnia ist der HTTP-Client direkt in die IDE integriert: Requests werden in .http-Dateien als Plain-Text gespeichert, die ins Git eingecheckt werden können. Das macht API-Tests Teil des Repositories – mit Versionierung, Code-Review und Teamzugang.

Die wichtigsten Stärken des PHPStorm HTTP-Clients: Syntaxhighlighting und Autocomplete für HTTP-Methoden, Header und JSON-Bodies. Environment-Dateien für verschiedene Zielumgebungen ohne Änderung an den eigentlichen Request-Dateien. Variablen-Extraktion aus Responses, die in Folge-Requests verwendet werden können. JavaScript-basierte Response-Handler für automatische Assertions. Für Magento-Entwicklung bedeutet das: REST-Endpoints und GraphQL direkt aus PHPStorm testen, ohne die IDE zu verlassen.

2. .http-Dateien: Syntax und Aufbau

Eine .http-Datei enthält einen oder mehrere HTTP-Requests, getrennt durch ###. Jeder Request beginnt mit der HTTP-Methode, URL und optionalen Headern, gefolgt von einem optionalen Body nach einer Leerzeile. PHPStorm zeigt über jedem Request einen "Run"-Knopf, mit dem der Request direkt ausgeführt werden kann. Die Response erscheint in einem eigenen Tool-Window mit Syntax-Highlighting, Status-Code und allen Response-Headern.

Die Datei kann beliebig viele Requests enthalten und wird üblicherweise thematisch organisiert: eine Datei pro API-Bereich oder pro Feature. Für Magento könnte man magento-catalog.http für Catalog-Endpoints und magento-customer.http für Customer-Endpoints anlegen. Alle Dateien werden ins Git eingecheckt – unter tests/api/ oder direkt im Projektroot. Sensible Daten wie Tokens kommen nicht in die .http-Dateien, sondern in die Environment-Dateien, die nicht eingecheckt werden.

### Magento 2 REST API — Catalog Endpoints
### File: tests/api/magento-catalog.http

### Get all categories
GET { {baseUrl} }/rest/V1/categories
Authorization: Bearer { {adminToken} }
Content-Type: application/json

###

### Get product by SKU
GET { {baseUrl} }/rest/V1/products/{ {testSku} }
Authorization: Bearer { {adminToken} }
Content-Type: application/json

###

### Create new category
POST { {baseUrl} }/rest/V1/categories
Authorization: Bearer { {adminToken} }
Content-Type: application/json

{
  "category": {
    "parent_id": 2,
    "name": "Test Category",
    "is_active": true,
    "include_in_menu": true
  }
}

3. Environments: dev, staging, prod ohne Code-Änderung

Das Environment-System ist einer der größten Vorteile des PHPStorm HTTP-Clients gegenüber manuellen curl-Befehlen. In einer http-client.env.json-Datei werden Environments mit ihren Variablen definiert. Eine http-client.private.env.json (nicht eingecheckt) enthält sensible Werte wie Tokens und Passwörter. PHPStorm zeigt beim Ausführen eines Requests eine Dropdown-Liste der verfügbaren Environments – ein Klick wechselt zwischen local, staging und production, ohne dass eine Zeile in der .http-Datei geändert werden muss.

Die http-client.env.json enthält nicht-sensible Konfigurationswerte, die ins Git eingecheckt werden können: Base-URL, API-Version, Test-SKUs. Die http-client.private.env.json enthält sensible Werte und wird in .gitignore aufgenommen. Beide Dateien werden von PHPStorm automatisch erkannt und zusammengeführt. Variables aus der private-Datei überschreiben gleichnamige Variables aus der normalen env-Datei.

// http-client.env.json — commitable, no secrets
{
  "local": {
    "baseUrl": "https://mironsoft.local",
    "apiVersion": "V1",
    "testSku": "TEST-SKU-001",
    "storeCode": "default"
  },
  "staging": {
    "baseUrl": "https://staging.mironsoft.de",
    "apiVersion": "V1",
    "testSku": "STAGING-SKU-001",
    "storeCode": "de"
  },
  "production": {
    "baseUrl": "https://mironsoft.de",
    "apiVersion": "V1",
    "testSku": "PROD-SKU-001",
    "storeCode": "de"
  }
}

// http-client.private.env.json — in .gitignore, contains secrets
{
  "local": {
    "adminToken": "abc123...",
    "customerToken": "def456..."
  },
  "staging": {
    "adminToken": "staging-token...",
    "customerToken": "staging-customer-token..."
  }
}

4. Variables: Tokens, IDs und Response-Werte weitergeben

Variables in .http-Dateien werden mit doppelten geschweiften Klammern referenziert: { {variableName} }. Neben statischen Variables aus den Environment-Dateien unterstützt PHPStorm dynamische Variables: { {$uuid} } generiert eine UUID, { {$timestamp} } den aktuellen Unix-Timestamp, { {$randomInt} } eine Zufallszahl. Diese dynamischen Variables sind nützlich, um bei jedem Request-Run eindeutige Werte zu erzeugen, ohne manuell Daten zu ändern.

Das mächtigste Feature ist die Variablen-Extraktion aus Response-Daten. Im Response-Handler-Script kann ein Wert aus der Response in eine globale Variable geschrieben werden, die dann in nachfolgenden Requests verfügbar ist. Das klassische Anwendungsfall für Magento: zuerst einen Admin-Token per POST-Request erzeugen, den Token aus der Response extrahieren und in { {adminToken} } schreiben, danach alle folgenden Requests mit diesem Token ausführen. Ohne Environment-Dateien zu editieren.

5. Magento 2 REST API testen

Magento 2 stellt eine vollständige REST API bereit, die sich ideal mit dem PHPStorm HTTP-Client testen lässt. Der erste Schritt für jede Testsession ist das Erzeugen eines Admin-Tokens. Der Endpoint dafür ist POST /rest/V1/integration/admin/token mit Username und Passwort im Body. Der zurückgegebene Token wird per Response-Handler in eine Variable geschrieben und für alle weiteren Requests genutzt.

Magento's REST API folgt konsistenten Mustern: GET für Lesen, POST für Erstellen, PUT für vollständiges Ersetzen, PATCH für partielle Updates, DELETE für Löschen. Die Authentifizierung erfolgt immer über den Bearer-Token im Authorization-Header. Für Multistore-Setups wird der Store-Code als Teil der URL angegeben: /rest/de/V1/products für den deutschen Store. Der PHPStorm HTTP-Client verwaltet diese Variationen über die Environment-Variable { {storeCode} }.

### Magento 2 — Auth + Customer Flow
### tests/api/magento-auth-flow.http

### Step 1: Get Admin Token
# @name getAdminToken
POST { {baseUrl} }/rest/V1/integration/admin/token
Content-Type: application/json

{
  "username": "{ {adminUsername} }",
  "password": "{ {adminPassword} }"
}

> {%
  // Store token for subsequent requests
  client.global.set("adminToken", response.body.replace(/"/g, ""));
  client.test("Status 200", function() {
    client.assert(response.status === 200, "Expected 200, got " + response.status);
  });
%}

###

### Step 2: Get Customer List (uses token from Step 1)
GET { {baseUrl} }/rest/V1/customers/search?searchCriteria[pageSize]=5
Authorization: Bearer { {adminToken} }
Content-Type: application/json

###

### Step 3: Create Customer
POST { {baseUrl} }/rest/V1/customers
Authorization: Bearer { {adminToken} }
Content-Type: application/json

{
  "customer": {
    "email": "test-{ {$randomInt} }@mironsoft.de",
    "firstname": "Test",
    "lastname": "Customer",
    "store_id": 1,
    "website_id": 1
  },
  "password": "Test@12345"
}

6. GraphQL-Queries und Mutations in PHPStorm

PHPStorm unterstützt GraphQL in .http-Dateien mit einem speziellen Content-Type: application/json und einem Body-Format mit query und optionalen variables. Alternativ kann PHPStorm mit dem GraphQL-Plugin native .graphql-Dateien mit Syntax-Highlighting und Schema-Validierung unterstützen, die dann über den HTTP-Client ausgeführt werden. Für Magento 2 sind beide Ansätze geeignet.

Magento 2 stellt GraphQL seit Version 2.3 bereit. Der Endpoint ist einheitlich /graphql. Für authentifizierte Requests (Warenkorb, Bestellungen, Kundendaten) wird der Customer-Token im Authorization-Header übergeben. Das PHPStorm-Setup für GraphQL-Tests: eine magento-graphql.http-Datei mit Queries und Mutations, die { {baseUrl} }/graphql als URL nutzt und Environment-Variables für Token und Test-IDs. Der Response-Handler extrahiert entityId-Werte aus Mutations für Folge-Queries.

7. Response-Handler: automatische Assertions und Variablen-Extraktion

Response-Handler sind JavaScript-Skripte, die nach jedem Request ausgeführt werden. Sie ermöglichen automatische Assertions (ähnlich wie in Postman-Tests) und die Extraktion von Werten aus der Response in globale Variables. Der Response-Handler wird direkt in der .http-Datei nach dem Request in einem > {% %}-Block definiert.

Im Response-Handler stehen zwei Objekte zur Verfügung: response (mit status, headers, body und dem geparsten body als JavaScript-Objekt) und client (mit global.set() zum Setzen von globalen Variables und test() zum Definieren von Test-Assertions). Mit client.test() werden Bedingungen geprüft, die im HTTP-Client Test-Runner angezeigt werden – ähnlich wie Unit-Tests, aber für API-Responses.

### GraphQL — Magento 2 Product Query with Response Handler
### tests/api/magento-graphql.http

### Get Product by URL Key
POST { {baseUrl} }/graphql
Content-Type: application/json

{
  "query": "query GetProduct($urlKey: String!) { products(filter: { url_key: { eq: $urlKey } }) { items { id name sku price_range { minimum_price { regular_price { value currency } } } } } }",
  "variables": {
    "urlKey": "{ {testProductUrlKey} }"
  }
}

> {%
  client.test("Status 200", function() {
    client.assert(response.status === 200, "Got: " + response.status);
  });
  client.test("Has products", function() {
    const data = response.body;
    client.assert(data.data.products.items.length > 0, "No products returned");
  });
  // Store product ID for next request
  if (response.body.data.products.items.length > 0) {
    client.global.set("productId", response.body.data.products.items[0].id);
  }
%}

###

### Add to Cart Mutation (uses productId from above)
POST { {baseUrl} }/graphql
Authorization: Bearer { {customerToken} }
Content-Type: application/json

{
  "query": "mutation AddToCart($cartId: String!, $sku: String!, $qty: Float!) { addSimpleProductsToCart(input: { cart_id: $cartId, cart_items: [{ data: { quantity: $qty, sku: $sku } }] }) { cart { items { quantity product { name } } } } }",
  "variables": {
    "cartId": "{ {cartId} }",
    "sku": "{ {testSku} }",
    "qty": 1.0
  }
}

8. HTTP-Client vs. Postman: direkter Vergleich

9. Zusammenfassung

Der PHPStorm HTTP-Client ist für PHP-Entwickler, die ohnehin PHPStorm nutzen, eine überzeugende Alternative zu Postman. Die Stärke liegt nicht in der Feature-Parität, sondern in der Integration: .http-Dateien leben im Git-Repository, Environments sind in JSON-Dateien konfiguriert, Response-Handler ermöglichen automatische Assertions und Variablen-Extraktion. Für Magento-REST- und GraphQL-APIs bedeutet das: authentifizierte Multi-Step-Flows ohne Tool-Wechsel direkt aus PHPStorm ausführen.

10. FAQ: REST und GraphQL in PHPStorm testen