Behat Messenger Context Bundle

https://github.com/macpaw/behat-messenger-context
Admin
This bundle provides custom Behat step definitions for working with Symfony Messenger transports,...
Tokens:6,245
Snippets:69
Trust Score:9.8
License:MIT
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install Behat Messenger Context using Composer

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/install.md

Installs the behat-messenger-context package using Composer. This command works for both Symfony Flex and non-Flex applications. Composer must be installed globally.

```bash
composer require --dev macpaw/behat-messenger-context
```

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

### Register Behat Messenger Context Bundle in AppKernel.php

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/install.md

Manually registers the BehatMessengerContextBundle in the AppKernel.php file for applications not using Symfony Flex. This ensures the bundle is loaded for testing.

```php
// app/AppKernel.php

class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = [
            // Other bundles
            BehatMessengerContext\BehatMessengerContextBundle::class => ['test' => true],
        ];
    }
}
```

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

### Register MessengerContext in behat.yml

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/install.md

Registers the Behat MessengerContext in the behat.yml configuration file. This makes the MessengerContext available for use in Behat feature files, enabling testing of Symfony Messenger functionalities.

```yaml
default:
    suites:
        default:
            contexts:
                - BehatMessengerContext\Context\MessengerContext
```

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

### Install and Configure Zenstruck Messenger Test (Bash & PHP)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/clear_transport.md

This section covers the installation of the zentruck/messenger-test library via Composer and its integration into a Symfony application. It also demonstrates how to configure messenger transports in the 'test' environment to use the 'test://' transport provided by the library, enabling automatic message queue clearing.

```bash
composer require --dev zenstruck/messenger-test
```

```php
<?php

// config/bundles.php

return [
    // ...
    Zenstruck\Messenger\Test\ZenstruckMessengerTestBundle::class => ['test' => true],
];

```

```yaml
# config/packages/messenger.yaml

# ...

when@test:
    framework:
        messenger:
            transports:
                async: test://

```

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

### Gherkin Example for Transport JSON Assertion (Gherkin)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_transport_message_regexp.md

An example illustrating how to use the custom Behat step in a Gherkin feature file. It specifies the transport name, the fields to be treated as regular expressions, and the expected JSON structure with regex patterns.

```gherkin
And transport "webhook" should contain message with JSON and variable fields "time, payload":
    """
    {
        "event": "customer_agreement_status_updated",
        "time": "~^\\d{13}$",
        "payload": "~^\\{.*\\}$"
    }
    """
```

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

### TransportRetriever API for Inspecting Transports (PHP)

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Provides an example of using the TransportRetriever API in PHP to programmatically access and inspect all available Messenger transports. This allows for advanced testing scenarios, such as checking the message count or type of different transports like InMemoryTransport.

```php
<?php

use BehatMessengerContext\Context\TransportRetriever;
use Symfony\Component\Messenger\Transport\InMemory\InMemoryTransport;

class TransportInspector
{
    private TransportRetriever $retriever;

    public function __construct(TransportRetriever $retriever)
    {
        $this->retriever = $retriever;
    }

    public function inspectAllTransports(): array
    {
        $transports = $this->retriever->getAllTransports();
        $report = [];

        foreach ($transports as $name => $transport) {
            if ($transport instanceof InMemoryTransport) {
                $report[$name] = [
                    'message_count' => count($transport->get()),
                    'type' => 'in_memory'
                ];
            }
        }

        return $report;
    }
}
```

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

### Configure Symfony Messenger for Testing with In-Memory Transport

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/install.md

Configures Symfony Messenger to use an in-memory transport for testing. This is achieved by copying the messenger configuration to the test environment and setting the transport to 'in-memory://'. This prevents actual message delivery during tests.

```yaml
framework:
    messenger:
        transports:
            async: 'in-memory://'
            async_priority_high: 'in-memory://'
```

```yaml
framework:
  messenger:
    transports:
      async: 'in-memory://'
      async_priority_high: 'in-memory://'
```

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

### Gherkin Feature: Test Transport Messages with Variable Fields

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_all_transport_message_regexp.md

An example of how to use the Behat custom step in a Gherkin feature file. It demonstrates specifying the transport name, variable fields, and the expected JSON structure with regex patterns for variable fields.

```gherkin
Then all transport ":transportName" messages should be JSON with variable fields ":variableFields":
"""
    [
        {
            "event": "status_updated",
            "time": "~^\\d{13}$",
            "payload": "dqwdwdwdw"
        },
        {
            "event": "order_created",
            "time": "~^\\d{13}$",
            "payload": "otherPayload"
        }
    ]
"""
```

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

### Integration with Zenstruck Messenger Test for Isolation (Bash & Gherkin)

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Explains how to integrate Zenstruck Messenger Test with Behat to automatically clear message transports between scenarios, ensuring test isolation. This is achieved by installing the package via Composer and then utilizing the automatic cleanup feature in Gherkin feature files.

```bash
composer require --dev zenstruck/messenger-test
```

```gherkin
Feature: Isolated scenario testing
    Scenario: First test with clean state
        When I dispatch a message
        Then there is 1 messages in transport "async"

    # Transport automatically cleared before this scenario
    Scenario: Second test starts fresh
        Then there is 0 messages in transport "async"
        When I dispatch two messages
        Then there is 2 messages in transport "async"
```

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

### Using MessengerContext in Custom Contexts (PHP)

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Demonstrates how to integrate and utilize the MessengerContext within custom Behat contexts in PHP. This allows for extending the testing capabilities by composing MessengerContext's functionalities with your application's specific logic, such as verifying messages sent to a payment queue.

```php
<?php

use Behat\Behat\Context\Context;
use BehatMessengerContext\Context\MessengerContext;
use Behat\Gherkin\Node\PyStringNode;

class CustomOrderContext implements Context
{
    private MessengerContext $messengerContext;

    public function __construct(MessengerContext $messengerContext)
    {
        $this->messengerContext = $messengerContext;
    }

    /**
     * @When I complete order checkout
     */
    public function iCompleteOrderCheckout(): void
    {
        // Trigger order processing logic
        $this->orderService->checkout($this->currentOrder);
    }

    /**
     * @Then the payment processor should receive order details
     */
    public function paymentProcessorShouldReceiveOrderDetails(): void
    {
        $expectedJson = new PyStringNode([
            '{',
            '    "amount": 100.00,',
            '    "currency": "USD"',
            '}'
        ], 1);

        $this->messengerContext->transportShouldContainMessageWithJson(
            'payment_queue',
            $expectedJson
        );
    }
}
```

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

### Configure Behat with Messenger Context

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Configures Behat to use the MessengerContext. This step definition allows Behat to interact with and test Symfony Messenger components.

```yaml
# behat.yml
default:
    suites:
        default:
            contexts:
                - BehatMessengerContext\Context\MessengerContext
```

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

### Configure Messenger Transports for Testing

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Configures Symfony Messenger transports to use the 'in-memory://' transport for testing purposes. This allows for isolated and fast testing of message queues.

```yaml
# config/packages/test/messenger.yaml
framework:
    messenger:
        transports:
            async: 'in-memory://'
            async_priority_high: 'in-memory://'
```

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

### Register Behat Messenger Context Bundle in AppKernel

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Registers the Behat Messenger Context Bundle within the Symfony application kernel for non-Flex applications. This ensures the bundle is active during testing.

```php
<?php
// app/AppKernel.php
class AppKernel extends Kernel
{
    public function registerBundles()
    {
        $bundles = [
            // Other bundles
            BehatMessengerContext\BehatMessengerContextBundle::class => ['test' => true],
        ];
    }
}
```

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

### Configure In-Memory Messenger Transports (YAML)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/clear_transport.md

This configuration snippet shows how to set up multiple messenger transports to use the 'in-memory' transport for testing environments. This ensures that all queue messages are automatically cleared before each test scenario begins.

```yaml
# config/packages/messenger.yaml

# ...

when@test:
    framework:
        messenger:
            transports:
                async: in-memory://
                some-another: in-memory://
                # ...

```

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

### Behat: Verify All Messages in Transport

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

A Behat Gherkin feature to assert that all messages within a transport match a provided list of JSON structures, including exact ordering. This is useful for testing batch processing or sequential message delivery.

```gherkin
Feature: Batch notification processing
    Scenario: Process multiple notifications in sequence
        When I trigger batch notification for users
        Then all transport "notification" messages should be JSON:
            """
            [
                {
                    "type": "email",
                    "userId": "100",
                    "subject": "Welcome"
                },
                {
                    "type": "sms",
                    "userId": "101",
                    "message": "Verify your account"
                },
                {
                    "type": "email",
                    "userId": "102",
                    "subject": "Promotion"
                }
            ]
            """
```

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

### Behat: Verify All Messages with Variable Fields

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

A Behat Gherkin feature to check if all messages in a transport conform to expected structures, while allowing specific fields to vary using regular expressions. This is valuable for testing event streams where certain data points are dynamic.

```gherkin
Feature: Event tracking
    Scenario: Track multiple user events with timestamps
        When users perform multiple actions
        Then all transport "analytics" messages should be JSON with variable fields "timestamp, sessionId":
            """
            [
                {
                    "event": "page_view",
                    "timestamp": "~^\\d{13}$",
                    "sessionId": "~^[a-f0-9-]{36}$",
                    "page": "/home"
                },
                {
                    "event": "button_click",
                    "timestamp": "~^\\d{13}$",
                    "sessionId": "~^[a-f0-9-]{36}$",
                    "button": "signup"
                }
            ]
            """
```

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

### PHP Behat Step: Verify Transport Messages with Variable Fields

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_all_transport_message_regexp.md

Defines a Behat step to assert that all messages in a specified transport match a list of expected JSON structures. It supports variable fields where values can be compared using regular expressions. Dependencies include the Behat PyStringNode for multiline string arguments.

```php
/**
 * @Then all transport :transportName messages should be JSON with variable fields :variableFields:
 */
public function allTransportMessagesShouldBeJsonWithVariableFields(
    string $transportName,
    string $variableFields,
    PyStringNode $expectedMessageList
): void
```

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

### Behat Gherkin Step: Verify Transport Messages

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_all_transport_message.md

Defines a Behat custom step using Gherkin syntax to verify that all messages in a specified Symfony Messenger transport match a provided JSON array. This step takes the transport name as a string and the expected message structures as a PyString. It is useful for testing asynchronous message processing.

```gherkin
Then all transport ":transportName" messages should be JSON:
"""
    [
        {
            "event": "status_updated",
            "time": "123123123",
            "payload": "dqwdwdwdw"
        },
        {
            "event": "order_created",
            "time": "456456456",
            "payload": "otherPayload"
        }
    ]
    """
```

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

### Validate All Messages Match Mask Pattern (Gherkin)

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Ensures all messages within a specified transport adhere to a common structural template, allowing for variable fields to be matched using regular expressions. This is useful for verifying consistent API responses or event structures.

```gherkin
Feature: Webhook delivery
    Scenario: Send identical webhook structure for all events
        When I trigger multiple status update events
        Then all transport "webhook" messages should contain message with JSON and variable fields "timestamp, payload" by mask:
            """
            {
                "event": "status_updated",
                "timestamp": "~^\\d{13}$",
                "payload": "~^\\\{.*\\\}$",
                "apiVersion": "v2"
            }
            """
```

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

### Verify Message Count in Transport (PHP)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/count_message_transport.md

This custom Behat step verifies that a specific number of messages exist in a given Symfony Messenger transport. It takes the expected message count and the transport name as parameters. This is useful for ensuring messages are correctly dispatched into queues during Behat tests.

```gherkin
Then there is 1 messages in transport "command"
```

```php
/**
 * @Then there is :expectationMessageCount messages in transport :transportName
 */
public function thereIsCountMessagesInTransport(int $expectedMessageCount, string $transportName): void
{
    // Implementation to check message count in the transport.
}
```

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

### Assert JSON Message in Transport with Variable Fields (PHP)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_transport_message_regexp.md

Verifies if a Symfony Messenger transport contains a message matching a JSON structure, using regular expressions for specified fields. Useful for testing messages with dynamic data like timestamps or UUIDs. Requires the Behat framework and Symfony Messenger components.

```PHP
/**
 * @Then transport :transportName should contain message with JSON and variable fields :variableFields:
 */
public function transportShouldContainMessageWithJsonAndVariableFields(
    string $transportName,
    string $variableFields,
    PyStringNode $expectedMessage
): void {}
```

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

### Assert JSON Message in Transport with Regexp Fields (PHP)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_transport_messages_regexp_mask.md

This PHP function, designed for Behat, verifies if all messages within a specified transport match a JSON mask. It allows certain fields to be treated as regular expressions for dynamic value validation. It requires the Symfony Messenger component and Behat.

```PHP
/**
 * @Then all transport :transportName messages have JSON by :fields with mask :mask:
 */
public function allTransportMessagesHaveJsonByFieldsWithMask(
    string $transportName,
    string $variableFields,
    PyStringNode $expectedMessageList,
): void {
    // Implementation details would go here.
}
```

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

### Count Messages in Transport (Gherkin)

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

Verifies the exact number of messages present in a specific transport. This feature is crucial for confirming that operations result in the expected number of dispatches or that no messages are sent when an operation is skipped.

```gherkin
Feature: Command processing
    Scenario: Dispatch exactly three commands
        When I process a bulk operation
        Then there is 3 messages in transport "command"

    Scenario: Verify no messages sent when operation is skipped
        When I skip the operation due to validation failure
        Then there is 0 messages in transport "command"
```

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

### Behat: Check Transport Contains Message with Variable Fields

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

A Behat Gherkin feature to validate messages in a transport, allowing specific fields like timestamps or IDs to match using regular expressions. This enables testing of dynamic message content.

```gherkin
Feature: Order processing
    Scenario: Process order and send webhook notification
        When I create an order for product "12345"
        Then transport "webhook" should contain message with JSON and variable fields "timestamp, orderId":
            """
            {
                "event": "order_created",
                "timestamp": "~^\\d{10,13}$",
                "orderId": "~^[a-f0-9]{32}$",
                "productId": "12345",
                "status": "pending"
            }
            """
```

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

### Assert Transport Contains JSON Message (Gherkin)

Source: https://github.com/macpaw/behat-messenger-context/blob/develop/docs/MessengerContext/check_transport_message.md

This Gherkin step definition is used to check if a Symfony Messenger transport contains a message matching the provided JSON structure. It takes the transport name and the expected JSON payload as input.

```gherkin
Then transport ":transportName" should contain message with JSON:
    """
    {
        "event": "status_updated",
        "time": "123123123",
        "payload": "dqwdwdwdw"
    }
    """
```

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

### Behat: Check Transport Contains Specific Message

Source: https://context7.com/macpaw/behat-messenger-context/llms.txt

A Behat Gherkin feature to verify that a specific transport contains a message with an exact JSON structure. Useful for ensuring precise message payloads are sent.

```gherkin
Feature: User registration notification
    Scenario: Send welcome email after user registration
        When I register a new user with email "user@example.com"
        Then transport "async" should contain message with JSON:
            """
            {
                "event": "user_registered",
                "email": "user@example.com",
                "timestamp": "1640000000"
            }
            """
```
Tokens:
Raw