Behat API Extension

https://github.com/imbo/behat-api-extension
Admin
API extension for Behat that provides an easy way to test JSON-based APIs in Behat 3.
Tokens:27,857
Snippets:232
Trust Score:8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install with Composer

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/installation.rst

Use Composer to install the extension as a development dependency. Run this command in your project root.

```console
composer require --dev imbo/behat-api-extension
```

--------------------------------

### Install dependencies with composer install

Source: https://github.com/imbo/behat-api-extension/blob/main/AGENTS.md

Installs project dependencies. Requires PHP 8.3 or later and the fileinfo, json, and sockets extensions.

```sh
composer install
```

--------------------------------

### Example response body for array length matchers

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Example response body used for the array length matcher examples.

```json
{
  "items":
  [
    "foo",
    "bar",
    "foobar",
    "barfoo",
    123
  ]
}
```

--------------------------------

### Start dev server and run Behat tests

Source: https://github.com/imbo/behat-api-extension/blob/main/AGENTS.md

Starts the HTTP server for Behat feature tests and then runs the Behat suite. The server must be running at http://localhost:8080 serving features/bootstrap.

```sh
composer run dev
composer run behat
```

--------------------------------

### Start dev server with composer dev

Source: https://github.com/imbo/behat-api-extension/blob/main/features/README.md

Starts a PHP built-in web server for the Behat tests, listening on http://localhost:8080 with the document root set to the bootstrap directory. The --timeout=0 flag prevents the script from timing out.

```bash
composer dev --timeout=0
```

--------------------------------

### Example JSON response body

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/extending-the-extension.rst

Example response body used to demonstrate the custom @gt matcher. The number key holds the value 42 that will be compared.

```json
{
  "number": 42
}
```

--------------------------------

### Configuration change: base_uri to apiClient.base_uri

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Shows the configuration change from v1 to v2: the base_uri option moved under the apiClient key. The v1 example uses the old flat structure, while the v2 example nests it under apiClient.

```yaml
default:
  suites:
    default:
      # ...

  extensions:
    Imbo\BehatApiExtension:
      base_uri: http://localhost:8080
```

```yaml
default:
  suites:
    default:
      # ...

  extensions:
    Imbo\BehatApiExtension:
      apiClient:
        base_uri: http://localhost:8080
```

--------------------------------

### Example JSON response body

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Example JSON response body used for the examples in the 'Then the response body contains JSON' section.

```json
{
  "string": "string value",
  "integer": 123,
  "double": 1.23,
  "bool": true,
  "null": null,
  "object":
  {
    "string": "string value",
    "integer": 123,
    "double": 1.23,
    "bool": true,
    "null": null,
    "object":
    {
      "string": "string value",
      "integer": 123,
      "double": 1.23,
      "bool": true,
      "null": null
    }
  },
  "array":
  [
    "string value",
    123,
    1.23,
    true,
    null,
    {
      "string": "string value",
      "integer": 123,
      "double": 1.23,
      "bool": true,
      "null": null
    }
  ]
}
```

--------------------------------

### Configure the API client with a custom header

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/extending-the-extension.rst

Override initializeClient to customize the internal GuzzleHttp\Client. This example adds a custom header to every request by pushing a middleware onto the handler stack. The method must call parent::initializeClient($config) to complete initialization.

```php
<?php
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use Imbo\BehatApiExtension\Context\ApiContext;

class FeatureContext extends ApiContext
{
    public function initializeClient(array $config): static
    {
        $stack = $config['handler'] ?? HandlerStack::create();
        $stack->push(Middleware::mapRequest(
            fn ($req) => $req->withAddedHeader('Some-Custom-Header', 'some value')
        ));
        $config['handler'] = $stack;
        return parent::initializeClient($config);
    }
}
```

--------------------------------

### Numeric comparison - @gt / @lt

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Use @gt and @lt to verify that numeric values are greater than or less than a given value. Works with integers, doubles, and strings that represent numbers. The example shows both greater-than and less-than assertions.

```json
{
  "some-int": 123,
  "some-double": 1.23,
  "some-string": "123"
}
```

```gherkin
Then the response body contains JSON:
    """
    {
      "some-int": "@gt(120)",
      "some-double": "@gt(1.20)",
      "some-string": "@gt(120)"
    }
    """
And the response body contains JSON:
    """
    {
      "some-int": "@lt(125)",
      "some-double": "@lt(1.25)",
      "some-string": "@lt(125)"
    }
    """
```

--------------------------------

### Match specific keys in a numerically indexed array - <key>[<index>]

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Use the key[<index>] notation to verify elements at specific indices in a numerically indexed array. This example shows how to validate array elements including nested objects, regular expressions, and array length checks.

```json
{
  "items":
  [
    "foo",
    "bar",
    {
      "some":
      {
        "nested": "object",
        "foo": "bar"
      }
    },
    [1, 2, 3]
  ]
}
```

```gherkin
Then the response body contains JSON:
    """
    {
      "items[0]": "foo",
      "items[1]": "@regExp(/(foo|bar|baz)/)",
      "items[2]":
      {
        "some":
        {
          "foo": "@regExp(/ba(r|z)/)"
        }
      },
      "items[3]": "@arrayLength(3)"
    }
    """
```

--------------------------------

### Then the response body is: <PyStringNode> - exact text comparison

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the response body equals the text provided in the PyStringNode. The comparison is case-sensitive. Two examples are shown: one with a JSON string and one with plain text.

```gherkin
Then the response body is:
    """
    {"foo":"bar"}
    """
```

```gherkin
Then the response body is:
    """
    foo
    """
```

--------------------------------

### Given the request body is: <PyStringNode>

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets the request body to the string contained in the PyStringNode. The example shows a JSON payload, but any string can be used.

```gherkin
Given the request body is:
    """
    {
        "some": "data"
    }
    """
```

--------------------------------

### Numerical array root node validation

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

When the response body is a numerical array at the root, use special syntax with indices like [0], [1], etc. This example shows how to validate each element of a root-level array.

```json
[
  "foo",
  123,
  {
    "foo": "bar"
  },
  "bar",
  [1, 2, 3]
]
```

```gherkin
Then the response body contains JSON:
    """
    {
      "[0]": "foo",
      "[1]": 123,
      "[2]":
      {
        "foo": "bar"
      },
      "[3]": "@regExp(/bar/)",
      "[4]": "@arrayLength(3)"
    }
    """
```

--------------------------------

### Verify JWT in response body with @jwt matcher

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Shows how to register a JWT with a name and secret, then match it in the response body using the @jwt matcher. The JSON block is an example response body containing a JWT placeholder. The Gherkin steps register the JWT and then verify the response contains the JWT at the specified path.

```json
{
  "value": "<some JWT token>"
}
```

```gherkin
# Register the JWT
Given the response body contains a JWT identified by "my JWT", signed with "some secret that must be sufficiently long":
    """
    {
        "user": "Some user"
    }
    """

# Other steps ...

# After the request has been made, one can match the JWT in the response
And the response body contains JSON:
    """
    {
      "value": "@jwt(my JWT)"
    }
    """
```

--------------------------------

### Given the request body is: v1 vs v2

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Shows the v1 and v2 syntax for setting the request body. In v2, the step uses a PyStringNode instead of a regular string.

```gherkin
Given the request body is "some data"
```

```gherkin
Given the request body is:
    """
    some data
    """
```

--------------------------------

### v2: Set request body then request

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 steps: set the request body with a Given step, then perform the request with the When step.

```gherkin
Given the request body is:
    """
    {"some":"data"}
    """
When I request "/some/path" using HTTP POST
```

--------------------------------

### v2: Assert JSON array minimum length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body is a JSON array with a length of at least 5
```

--------------------------------

### v2: Set JSON body and Content-Type header

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 steps: set the request body, set the Content-Type header to application/json, then perform the request.

```gherkin
Given the request body is:
    """
    {"some":"data"}
    """
And the "Content-Type" request header is "application/json"
When I request "/some/path" using HTTP POST
```

--------------------------------

### v2: Assert JSON array length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body is a JSON array of length 5
```

--------------------------------

### v1: When I request with body

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for setting the request body directly in the When step. The body needs to be set using a Given step in v2.

```gherkin
When I request "/some/path" using HTTP POST with body:
    """
    {"some":"data"}
    """
```

--------------------------------

### Set multiple query parameters with table

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets multiple query parameters at once using a table with name and value columns. The resulting request URL includes all parameters, e.g., /path?foo=bar&bar=foo. Note that any query parameters in the path of the request step are ignored.

```gherkin
Given the following query parameters are set:
    | name | value |
    | foo  | bar   |
    | bar  | foo   |
When I request "/path"
```

--------------------------------

### v1: When I request with JSON body

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for setting a JSON body directly in the When step. The Content-Type header and body must be set using Given steps in v2.

```gherkin
When I request "/some/path" using HTTP POST with JSON body:
    """
    {"some":"data"}
    """
```

--------------------------------

### Run Behat tests directly with --strict

Source: https://github.com/imbo/behat-api-extension/blob/main/features/README.md

Alternative command to run Behat tests directly, with the --strict flag to fail on undefined or pending steps.

```bash
./vendor/bin/behat --strict
```

--------------------------------

### v2: Assert empty JSON object response

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body is an empty JSON object
```

--------------------------------

### v2: Assert empty JSON array response

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body is an empty JSON array
```

--------------------------------

### v2: Assert JSON array maximum length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body is a JSON array with a length of at most 5
```

--------------------------------

### v1: Assert array minimum length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting a minimum array length.

```gherkin
Then the response body is an array with a length of at least 5
```

--------------------------------

### v2: Send file with guessed mime type

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 steps for sending a file, guessing the mime type from the file extension.

```gherkin
Given the request body contains "/some/file.jpg"
When I request "/some/endpoint" using HTTP POST
```

--------------------------------

### v1: Send file with guessed mime type

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for sending a file, guessing the mime type from the file extension.

```gherkin
When I send "/some/file.jpg" to "/some/endpoint" using HTTP POST
```

--------------------------------

### Set single query parameter with Given the query parameter

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets a single query parameter to a specific value for the upcoming request. Multiple parameters can be set by chaining steps. The resulting request URL includes the parameters in the order they are set, e.g., /path?foo=bar&bar=foo. Note that any query parameters in the path of the request step are ignored.

```gherkin
Given the query parameter "foo" is "bar"
And the query parameter "bar" is "foo"
When I request "/path"
```

--------------------------------

### Activate Behat API extension in behat.dist.php

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/configuration.rst

Activates the Behat API extension in a Behat configuration file (e.g., behat.dist.php). The apiClient.base_uri option is required and defaults to http://localhost:8080; all apiClient options are passed directly to the internal Guzzle client.

```php
<?php declare(strict_types=1);

use Behat\Config\Config;
use Behat\Config\Extension;
use Behat\Config\Profile;
use Imbo\BehatApiExtension\ServiceContainer\BehatApiExtension;

$config = new Config();
$profile = new Profile('default');
$extension = new Extension(BehatApiExtension::class, [
    'apiClient' => ['base_uri' => '...'],
]);

return $config->withProfile($profile->withExtension($extension));
```

--------------------------------

### v2: Send file with explicit mime type

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 steps for sending a file with an explicit mime type, setting the Content-Type header.

```gherkin
Given the request body contains "/some/file"
And the "Content-Type" request header is "application/json"
When I request "/some/endpoint" using HTTP POST
```

--------------------------------

### v1: Send file with explicit mime type

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for sending a file with an explicit mime type.

```gherkin
When I send "/some/file" as "application/json" to "/some/endpoint" using HTTP POST
```

--------------------------------

### Set multiple values to a query parameter with table

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets multiple values to a single query parameter using a table. The values are sent as an array, e.g., /path?foo[0]=foo&foo[1]=bar. Note that any query parameters in the path of the request step are ignored.

```gherkin
Given the query parameter "foo" is:
    | value |
    | foo   |
    | bar   |
When I request "/path"
```

--------------------------------

### Assert array length bounds with @arrayMaxLength and @arrayMinLength

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the array length is at most 10 and at least 3 using the @arrayMaxLength and @arrayMinLength matchers.

```gherkin
Then the response body contains JSON:
    """
    {"items": "@arrayMaxLength(10)"}
    """
And the response body contains JSON:
    """
    {"items": "@arrayMinLength(3)"}
    """
```

--------------------------------

### v1: Assert array maximum length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting a maximum array length.

```gherkin
Then the response body is an array with a length of at most 5
```

--------------------------------

### v1: Assert array length

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting an array of a specific length.

```gherkin
Then the response body is an array of length 5
```

--------------------------------

### v1: Assert empty object response

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting an empty object response body.

```gherkin
Then the response body is an empty object
```

--------------------------------

### v1: Assert empty array response

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting an empty array response body.

```gherkin
Then the response body is an empty array
```

--------------------------------

### OAuth password grant steps

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

The first step obtains an OAuth token via password grant from the given path and stores it. The second step then includes the Authorization header with the token when requesting the specified path.

```gherkin
Given I get an OAuth token using password grant from "/token" with "user" and "password" in scope "scope" using client ID "id" and client secret "secret"
When I request "/path/that/requires/token/in/header"
```

--------------------------------

### Add a custom step with PHP attribute

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/extending-the-extension.rst

Add a custom step definition by defining a method in your FeatureContext class with a PHP attribute. The method can access the protected $this->response property, but note that it is only populated after a request has been made by the client.

```php
<?php
use Behat\Step\Then;
use Imbo\BehatApiExtension\Context\ApiContext;
use Imbo\BehatApiExtension\Exception\AssertionFailedException;

class FeatureContext extends ApiContext
{
    #[Then('I want to check something')]
    public function assertSomething()
    {
        // do some assertions on $this->response, and throw a AssertionFailedException
        // exception if the assertion fails.
    }
}
```

--------------------------------

### Assert response body matches /foo/

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the response body matches the regular expression /foo/.

```gherkin
Then the response body matches:
    """
    /foo/
    """
```

--------------------------------

### v2: Assert response body contains JSON

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

New v2 step with 'JSON' added for clarification.

```gherkin
Then the response body contains JSON:
    """
    {"some": "value"}
    """
```

--------------------------------

### Use the custom @gt matcher in a step

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/extending-the-extension.rst

Gherkin step that uses the custom @gt matcher to verify that the number in the response body is greater than 40. The matcher is invoked inside the JSON string.

```gherkin
Then the response body contains JSON:
    """
    {
      "number": "@gt(40)"
    }
    """
```

--------------------------------

### Run Behat tests with composer test:behat

Source: https://github.com/imbo/behat-api-extension/blob/main/features/README.md

Runs the Behat test suite via Composer script.

```bash
composer test:behat
```

--------------------------------

### Set multipart form parameters with TableNode

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets multipart form parameters for a request. The first row must contain 'name' and 'value' headers; subsequent rows define fields and values. This step sets the HTTP method to POST and the Content-Type header to multipart/form-data by default. Cannot be used with a request body; doing so throws an InvalidArgumentException.

```gherkin
Given the following multipart form parameters are set:
    | name | value |
    | foo  | bar   |
    | bar  | foo   |
    | bar  | bar   |
```

--------------------------------

### Assert exact array length with @arrayLength

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the array at the given key has exactly the specified length using the @arrayLength matcher.

```gherkin
Then the response body contains JSON:
    """
    {"items": "@arrayLength(5)"}
    """
```

--------------------------------

### Set form parameters with a table node

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Sets form parameters for a request. The first row must contain 'name' and 'value' headers. This step sets the HTTP method to POST and the Content-Type header to application/x-www-form-urlencoded by default, unless combined with the attach step, which changes Content-Type to multipart/form-data. Cannot be used with a request body; doing so throws an InvalidArgumentException.

```gherkin
Given the following form parameters are set:
    | name | value |
    | foo  | bar   |
    | bar  | foo   |
    | bar  | bar   |
```

--------------------------------

### Run focused validation checks

Source: https://github.com/imbo/behat-api-extension/blob/main/AGENTS.md

Runs the focused validation checks: PHPUnit tests, static analysis, and coding standards. Use before running the full suite.

```sh
composer run phpunit
composer run sa
composer run cs
```

--------------------------------

### Register a custom matcher function @gt

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/extending-the-extension.rst

Register a custom matcher function named @gt by overriding setArrayContainsComparator and calling addFunction. The callback receives the value from the JSON and the argument from the matcher, and throws an InvalidArgumentException when the assertion fails.

```php
<?php
use Imbo\BehatApiExtension\Context\ApiContext;
use Imbo\BehatApiExtension\ArrayContainsComparator;

class FeatureContext extends ApiContext
{
    /**
     * Add a custom function called @gt to the comparator
     */
    public function setArrayContainsComparator(ArrayContainsComparator $comparator): self
    {
        $comparator->addFunction('gt', function ($num, $gt) {
            $num = (int) $num;
            $gt = (int) $gt;

            if ($num <= $gt) {
                throw new InvalidArgumentException(sprintf(
                    'Expected number to be greater than %d, got: %d.',
                    $gt,
                    $num
                ));
            }
        });

        return parent::setArrayContainsComparator($comparator);
    }
}
```

--------------------------------

### Match a subset of the response body

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Matches a subset of the response body against the given JSON blob. Only the specified keys are checked.

```gherkin
Then the response body contains JSON:
    """
    {
      "string": "string value",
      "bool": true
    }
    """
```

--------------------------------

### Assert response body is not equal to a value

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the response body does not equal the given value. The comparison is case sensitive.

```gherkin
Then the response body is not:
    """
    some value
    """
```

--------------------------------

### Regular expression matching - @regExp

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Use @regExp to match values against a PHP regular expression. The expression must include delimiters and optional modifiers. Only string, integer, and float/double values can be matched; values are cast to string before matching.

```gherkin
Then the response body contains JSON:
    """
    {
      "foo": "@regExp(/(some|expression)/i)",
      "bar":
      {
        "baz": "@regExp(/[0-9]+/)"
      }
    }
    """
```

--------------------------------

### v1: Assert response body contains

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/installation/upgrade.rst

Old v1 step for asserting that the response body contains a given JSON snippet.

```gherkin
Then the response body contains:
    """
    {"some": "value"}
    """
```

--------------------------------

### Check array contents

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Checks numerically indexed array contents. The order of the values in the arrays does not matter.

```gherkin
Then the response body contains JSON:
    """
    {
      "array":
      [
        true,
        "string value",
        {
          "integer": 123
        }
      ]
    }
    """
```

--------------------------------

### Given the response body contains a JWT identified by :name, signed with :secret

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

Registers a JWT for matching with the @jwt() custom matcher. The PyStringNode is the JWT payload, which can include custom matcher functions like @regExp(). The secret must be sufficiently long.

```gherkin
Given the response body contains a JWT identified by "my JWT", signed with "some secret that must be sufficiently long":
    """
    {
        "some": "data",
        "value": "@regExp(/(some|expression)/i)"
    }
    """
```

--------------------------------

### Assert response body matches a regular expression

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Asserts that the response body matches the given regular expression pattern. The expression must be a valid regular expression, including delimiters and optional modifiers.

```gherkin
Then the response body matches:
    """
    /^{
```

--------------------------------

### OAuth token response JSON

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/setup-request.rst

The OAuth token endpoint must respond with a JSON object containing the access_token key. The value of this key is used as the bearer token in the Authorization header for the next request.

```json
{
    "access_token": "some-token"
}
```

--------------------------------

### Check values in nested objects

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Checks values inside nested objects in the response body.

```gherkin
Then the response body contains JSON:
    """
    {
      "object":
      {
        "string": "string value",
        "object":
        {
          "null": null,
          "integer": 123
        }
      }
    }
    """
```

--------------------------------

### Variable type assertion - @variableType

Source: https://github.com/imbo/behat-api-extension/blob/main/docs/guide/verify-server-response.rst

Use @variableType to assert the type of values in a JSON response. Supports bool, int, double, string, array, object, null, scalar, and any. Multiple types can be matched with | (e.g., @variableType(int|double|string)). Validation stops at the first matching type.

```json
{
  "bool value": true,
  "int value": 123,
  "double value": 1.23,
  "string value": "some string",
  "array value": [1, 2, 3],
  "object value": {"foo": "bar"},
  "null value": null,
  "scalar value": 3.1416
}
```

```gherkin
Then the response body contains JSON:
    """
    {
      "bool value": "@variableType(bool)",
      "int value": "@variableType(int)",
      "double value": "@variableType(double)",
      "string value": "@variableType(string)",
      "array value": "@variableType(array)",
      "object value": "@variableType(object)",
      "null value": "@variableType(null)",
      "scalar value": "@variableType(scalar)"
    }
    """
```
Tokens:
Raw