blokctl 1.2.0 → 1.4.0

package/dist/scaffold-repo/sdks/php/tests/Node/NodeRegistryTest.php

@@ -0,0 +1,139 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Node;
+
+use Blok\Blok\Node\NodeHandler;
+use Blok\Blok\Node\NodeRegistry;
+use Blok\Blok\Types\Context;
+use Blok\Blok\Types\ExecutionRequest;
+use Blok\Blok\Types\NodeConfig;
+use Blok\Blok\Testing\MockContext;
+use PHPUnit\Framework\TestCase;
+
+final class NodeRegistryTest extends TestCase
+{
+    private function createTestNode(mixed $returnValue): NodeHandler
+    {
+        return new class($returnValue) implements NodeHandler {
+            public function __construct(private readonly mixed $data) {}
+
+            public function execute(Context $ctx, array $config): mixed
+            {
+                return $this->data;
+            }
+        };
+    }
+
+    public function testRegisterAndGet(): void
+    {
+        $registry = new NodeRegistry('1.0.0');
+        $node = $this->createTestNode(['msg' => 'hello']);
+
+        $registry->register('test', $node);
+
+        $this->assertNotNull($registry->get('test'));
+        $this->assertNull($registry->get('missing'));
+    }
+
+    public function testNodeNames(): void
+    {
+        $registry = new NodeRegistry('1.0.0');
+        $registry->register('alpha', $this->createTestNode(null));
+        $registry->register('beta', $this->createTestNode(null));
+
+        $names = $registry->nodeNames();
+        $this->assertCount(2, $names);
+        $this->assertContains('alpha', $names);
+        $this->assertContains('beta', $names);
+    }
+
+    public function testCountAndIsEmpty(): void
+    {
+        $registry = new NodeRegistry('1.0.0');
+        $this->assertTrue($registry->isEmpty());
+        $this->assertSame(0, $registry->count());
+
+        $registry->register('test', $this->createTestNode(null));
+        $this->assertFalse($registry->isEmpty());
+        $this->assertSame(1, $registry->count());
+    }
+
+    public function testExecuteSuccess(): void
+    {
+        $registry = new NodeRegistry('1.0.0');
+        $registry->register('test', $this->createTestNode(['msg' => 'hello']));
+
+        $req = new ExecutionRequest(
+            node: new NodeConfig(name: 'test'),
+            context: MockContext::create()->build(),
+        );
+
+        $result = $registry->execute($req);
+
+        $this->assertTrue($result->success);
+        $this->assertSame(['msg' => 'hello'], $result->data);
+        $this->assertNotNull($result->metrics);
+        $this->assertNotNull($result->metrics->durationMs);
+        $this->assertGreaterThanOrEqual(0, $result->metrics->durationMs);
+    }
+
+    public function testExecuteNotFound(): void
+    {
+        $registry = new NodeRegistry('1.0.0');
+
+        $req = new ExecutionRequest(
+            node: new NodeConfig(name: 'missing'),
+            context: MockContext::create()->build(),
+        );
+
+        $result = $registry->execute($req);
+
+        $this->assertFalse($result->success);
+        $this->assertNotNull($result->errors);
+        $this->assertStringContainsString('not found', $result->errors['message']);
+    }
+
+    public function testExecuteHandlesException(): void
+    {
+        $failingNode = new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                throw new \RuntimeException('boom');
+            }
+        };
+
+        $registry = new NodeRegistry('1.0.0');
+        $registry->register('fail', $failingNode);
+
+        $req = new ExecutionRequest(
+            node: new NodeConfig(name: 'fail'),
+            context: MockContext::create()->build(),
+        );
+
+        $result = $registry->execute($req);
+
+        $this->assertFalse($result->success);
+        // Per master plan §17 wiring, the registry now preserves the typed
+        // Throwable on `errors` so the gRPC servicer can derive
+        // `UNCAUGHT_<TYPE>` from the exception class. The legacy
+        // `['message' => ...]` shape is retired in favour of the structured
+        // path.
+        $this->assertInstanceOf(\RuntimeException::class, $result->errors);
+        $this->assertSame('boom', $result->errors->getMessage());
+    }
+
+    public function testHealth(): void
+    {
+        $registry = new NodeRegistry('2.0.0');
+        $registry->register('a', $this->createTestNode(null));
+        $registry->register('b', $this->createTestNode(null));
+
+        $health = $registry->health();
+
+        $this->assertSame('healthy', $health->status);
+        $this->assertSame('2.0.0', $health->version);
+        $this->assertCount(2, $health->nodesLoaded);
+    }
+}

package/dist/scaffold-repo/sdks/php/tests/Node/TypedNodeTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Node;
+
+use Blok\Blok\Errors\BlokError;
+use Blok\Blok\Node\NodeReflector;
+use Blok\Blok\Node\TypedNode;
+use Blok\Blok\Types\Context;
+use PHPUnit\Framework\TestCase;
+
+final class SearchInput
+{
+    public function __construct(public string $query, public int $limit = 10)
+    {
+    }
+}
+
+final class SearchNode extends TypedNode
+{
+    public function name(): string
+    {
+        return '@acme/search';
+    }
+
+    public function description(): string
+    {
+        return 'Full-text search';
+    }
+
+    protected function inputClass(): string
+    {
+        return SearchInput::class;
+    }
+
+    protected function run(Context $ctx, object $input): mixed
+    {
+        /** @var SearchInput $input */
+        $rows = array_fill(0, $input->limit, $input->query);
+
+        return ['results' => $rows, 'count' => count($rows)];
+    }
+}
+
+final class TypedNodeTest extends TestCase
+{
+    public function testValidatesInputAndRuns(): void
+    {
+        $out = (new SearchNode())->execute(new Context(), ['query' => 'ada', 'limit' => 2]);
+        $this->assertSame(2, $out['count']);
+        $this->assertSame(['ada', 'ada'], $out['results']);
+    }
+
+    public function testAppliesDefaultValues(): void
+    {
+        $out = (new SearchNode())->execute(new Context(), ['query' => 'x']);
+        $this->assertSame(10, $out['count']);
+    }
+
+    public function testMissingRequiredFieldThrowsStructuredBlokError(): void
+    {
+        try {
+            (new SearchNode())->execute(new Context(), ['limit' => 3]); // missing 'query'
+            $this->fail('expected a BlokError');
+        } catch (BlokError $e) {
+            $this->assertSame(400, $e->httpStatus);
+            $this->assertSame('NODE_INPUT_VALIDATION', $e->errorCode);
+        }
+    }
+
+    public function testReflectsSchemasAndDescription(): void
+    {
+        $node = new SearchNode();
+        $this->assertInstanceOf(NodeReflector::class, $node);
+        $this->assertSame('Full-text search', $node->description());
+
+        $schema = $node->inputSchema();
+        $this->assertSame('object', $schema['type']);
+        $props = (array) $schema['properties'];
+        $this->assertArrayHasKey('query', $props);
+        $this->assertSame(['query'], $schema['required']);
+    }
+}

package/dist/scaffold-repo/sdks/php/tests/Server/BlokNodeRuntimeServiceTest.php

@@ -0,0 +1,288 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Server;
+
+use Blok\Blok\Node\NodeHandler;
+use Blok\Blok\Node\NodeRegistry;
+use Blok\Blok\Server\BlokNodeRuntimeService;
+use Blok\Blok\Server\DecodeException;
+use Blok\Blok\Server\NodeRuntimeInterface;
+use Blok\Blok\Types\Context;
+use Blok\Blok\Types\ExecutionResult;
+use Blok\Runtime\V1\ErrorCategory;
+use Blok\Runtime\V1\ExecuteRequest;
+use Blok\Runtime\V1\HealthRequest;
+use Blok\Runtime\V1\HealthResponse\Status as HealthStatus;
+use Blok\Runtime\V1\ListNodesRequest;
+use Blok\Runtime\V1\NodeRef;
+use Blok\Runtime\V1\RuntimeState;
+use Blok\Runtime\V1\StepInfo;
+use Blok\Runtime\V1\TriggerInfo;
+use Blok\Runtime\V1\WorkflowInfo;
+use Google\Protobuf\Internal\MapField;
+use Google\Protobuf\Internal\GPBType;
+use PHPUnit\Framework\TestCase;
+use Spiral\RoadRunner\GRPC\Context as GrpcContext;
+
+final class BlokNodeRuntimeServiceTest extends TestCase
+{
+    private function makeRegistry(?NodeHandler $handler = null, string $name = 'hello'): NodeRegistry
+    {
+        $registry = new NodeRegistry('9.9.9');
+        if ($handler !== null) {
+            $registry->register($name, $handler);
+        }
+        return $registry;
+    }
+
+    private function makeService(NodeRegistry $registry): BlokNodeRuntimeService
+    {
+        return new BlokNodeRuntimeService($registry, sdkVersion: '9.9.9');
+    }
+
+    private function makeGrpcContext(): GrpcContext
+    {
+        return new GrpcContext([]);
+    }
+
+    /** @param array<string, string> $entries */
+    private function stringMap(array $entries): MapField
+    {
+        $map = new MapField(GPBType::STRING, GPBType::STRING);
+        foreach ($entries as $k => $v) {
+            $map[$k] = $v;
+        }
+        return $map;
+    }
+
+    public function testServiceImplementsInterfaceWithExpectedName(): void
+    {
+        $svc = $this->makeService($this->makeRegistry());
+        self::assertInstanceOf(NodeRuntimeInterface::class, $svc);
+        self::assertSame('blok.runtime.v1.NodeRuntime', NodeRuntimeInterface::NAME);
+    }
+
+    public function testHealthReportsServingWithRegisteredNodes(): void
+    {
+        $reg = $this->makeRegistry(new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                return null;
+            }
+        }, 'alpha');
+        $reg->register('beta', new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                return null;
+            }
+        });
+
+        $resp = $this->makeService($reg)->Health($this->makeGrpcContext(), new HealthRequest());
+
+        self::assertSame(HealthStatus::SERVING, $resp->getStatus());
+        self::assertSame('9.9.9', $resp->getSdkVersion());
+
+        $names = [];
+        foreach ($resp->getRegisteredNodes() as $n) {
+            $names[] = $n;
+        }
+        self::assertSame(['alpha', 'beta'], $names);
+    }
+
+    public function testListNodesReturnsDescriptorsAndSdkMetadata(): void
+    {
+        $reg = $this->makeRegistry(new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                return null;
+            }
+        }, 'alpha');
+
+        $resp = $this->makeService($reg)->ListNodes($this->makeGrpcContext(), new ListNodesRequest());
+
+        self::assertSame('blok-php', $resp->getSdkName());
+        self::assertSame('9.9.9', $resp->getSdkVersion());
+        self::assertSame('1.0.0', $resp->getProtoVersion());
+
+        $names = [];
+        foreach ($resp->getNodes() as $n) {
+            $names[] = $n->getName();
+        }
+        self::assertSame(['alpha'], $names);
+    }
+
+    public function testExecuteSuccessRoundTripsDataAndPropagatesVars(): void
+    {
+        $handler = new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                $ctx->setVar('greeting', 'hi');
+                return [
+                    'received_inputs' => $config,
+                    'received_body' => $ctx->request->body,
+                    'workflow' => $ctx->workflowName,
+                ];
+            }
+        };
+
+        $reg = $this->makeRegistry($handler, 'echo');
+        $svc = $this->makeService($reg);
+
+        $req = (new ExecuteRequest())
+            ->setNode((new NodeRef())->setName('echo')->setType('runtime.php'))
+            ->setInputs(BlokNodeRuntimeService::encodeJsonBytes(['prefix' => 'Hi']))
+            ->setStep((new StepInfo())->setName('echo')->setIndex(0)->setTotal(1)->setDepth(0))
+            ->setTrigger(
+                (new TriggerInfo())
+                    ->setBody(BlokNodeRuntimeService::encodeJsonBytes(['name' => 'World']))
+                    ->setHeaders($this->stringMap(['Content-Type' => 'application/json']))
+                    ->setMethod('POST')
+                    ->setUrl('/test'),
+            )
+            // Runner always sends `vars` as a JSON object (`{}`), never `[]`.
+            // PHP's json_encode([]) emits `[]`, which the codec correctly wraps
+            // under `_value`, so we set an empty object literal instead.
+            ->setState((new RuntimeState())->setVars('{}'))
+            ->setWorkflow((new WorkflowInfo())->setRunId('run-1')->setName('wf')->setPath('/wf'));
+
+        $resp = $svc->Execute($this->makeGrpcContext(), $req);
+
+        self::assertTrue($resp->getSuccess());
+        self::assertSame('application/json', $resp->getContentType());
+
+        $data = json_decode($resp->getData(), true);
+        self::assertSame(['prefix' => 'Hi'], $data['received_inputs']);
+        self::assertSame(['name' => 'World'], $data['received_body']);
+        self::assertSame('wf', $data['workflow']);
+
+        $varsDelta = json_decode($resp->getVarsDelta(), true);
+        self::assertSame(['greeting' => 'hi'], $varsDelta);
+    }
+
+    public function testExecuteFailureProducesStructuredNodeError(): void
+    {
+        $handler = new class implements NodeHandler {
+            public function execute(Context $ctx, array $config): mixed
+            {
+                throw new \RuntimeException('boom');
+            }
+        };
+
+        $reg = $this->makeRegistry($handler, 'kaboom');
+        $svc = $this->makeService($reg);
+
+        $req = (new ExecuteRequest())
+            ->setNode((new NodeRef())->setName('kaboom')->setType('runtime.php'));
+
+        $resp = $svc->Execute($this->makeGrpcContext(), $req);
+
+        self::assertFalse($resp->getSuccess());
+        $err = $resp->getError();
+        self::assertNotNull($err);
+        // Hardcoded `PHP_NODE_ERROR` retired in favour of `UNCAUGHT_<TYPE>`
+        // per master plan §17.7. Untyped throws now get categorized as
+        // INTERNAL with code derived from the exception class.
+        self::assertSame('UNCAUGHT_RUNTIMEEXCEPTION', $err->getCode());
+        self::assertSame(ErrorCategory::INTERNAL, $err->getCategory());
+        self::assertSame('kaboom', $err->getNode());
+        self::assertSame('blok-php', $err->getSdk());
+        self::assertSame('runtime.php', $err->getRuntimeKind());
+        self::assertSame('boom', $err->getMessage());
+        self::assertSame(500, $err->getHttpStatus());
+        self::assertFalse($err->getRetryable());
+    }
+
+    public function testExecuteWithMissingNodeReturnsStructuredError(): void
+    {
+        $svc = $this->makeService($this->makeRegistry());
+
+        $req = (new ExecuteRequest())
+            ->setNode((new NodeRef())->setName('not-registered')->setType('runtime.php'));
+
+        $resp = $svc->Execute($this->makeGrpcContext(), $req);
+
+        self::assertFalse($resp->getSuccess());
+        $err = $resp->getError();
+        self::assertNotNull($err);
+        self::assertSame('not-registered', $err->getNode());
+        self::assertStringContainsStringIgnoringCase('not found', $err->getMessage());
+    }
+
+    public function testDecodeJsonObjectReturnsEmptyArrayForEmptyBytes(): void
+    {
+        self::assertSame([], BlokNodeRuntimeService::decodeJsonObject('', 'inputs'));
+    }
+
+    public function testDecodeJsonObjectWrapsNonObjectUnderUnderscoreValue(): void
+    {
+        self::assertSame(['_value' => [1, 2, 3]], BlokNodeRuntimeService::decodeJsonObject('[1,2,3]', 'inputs'));
+        self::assertSame(['_value' => 'hello'], BlokNodeRuntimeService::decodeJsonObject('"hello"', 'inputs'));
+    }
+
+    public function testDecodeJsonObjectThrowsOnInvalidJson(): void
+    {
+        $this->expectException(DecodeException::class);
+        $this->expectExceptionMessageMatches('/invalid `inputs` JSON/');
+        BlokNodeRuntimeService::decodeJsonObject('{not-json', 'inputs');
+    }
+
+    public function testDecodeRequestBodyParsesJsonContentType(): void
+    {
+        $body = BlokNodeRuntimeService::decodeRequestBody(
+            '{"x":1}',
+            ['Content-Type' => 'application/json; charset=utf-8'],
+        );
+        self::assertSame(['x' => 1], $body);
+    }
+
+    public function testDecodeRequestBodyReturnsRawForNonJson(): void
+    {
+        $body = BlokNodeRuntimeService::decodeRequestBody('plain', ['content-type' => 'text/plain']);
+        self::assertSame('plain', $body);
+    }
+
+    public function testDecodeRequestBodyReturnsNullForEmpty(): void
+    {
+        self::assertNull(BlokNodeRuntimeService::decodeRequestBody('', []));
+    }
+
+    public function testPickHeaderIsCaseInsensitive(): void
+    {
+        self::assertSame('foo', BlokNodeRuntimeService::pickHeader(['X-Custom' => 'foo'], 'x-custom'));
+        self::assertSame('bar', BlokNodeRuntimeService::pickHeader(['Content-Type' => 'bar'], 'CONTENT-TYPE'));
+        self::assertSame('', BlokNodeRuntimeService::pickHeader([], 'missing'));
+    }
+
+    public function testEncodeJsonBytesPreservesUnicodeAndSlashes(): void
+    {
+        $encoded = BlokNodeRuntimeService::encodeJsonBytes(['url' => '/path/with/slash', 'unicode' => 'café']);
+        self::assertStringContainsString('/path/with/slash', $encoded);
+        self::assertStringContainsString('café', $encoded);
+    }
+
+    public function testDecodeExecuteRequestRequiresNodeName(): void
+    {
+        $svc = $this->makeService($this->makeRegistry());
+        $this->expectException(DecodeException::class);
+        $this->expectExceptionMessage('ExecuteRequest.node is required');
+        $svc->decodeExecuteRequest((new ExecuteRequest())->setNode(new NodeRef()));
+    }
+
+    public function testInternalErrorToProtoHandlesScalarsAndArrays(): void
+    {
+        $svc = $this->makeService($this->makeRegistry());
+
+        $err = $svc->internalErrorToProto('boom', 'n');
+        self::assertSame('boom', $err->getMessage());
+
+        $err = $svc->internalErrorToProto(['message' => 'bad', 'detail' => 42], 'n');
+        self::assertSame('bad', $err->getMessage());
+        $details = json_decode($err->getDetailsJson(), true);
+        self::assertSame(42, $details['detail']);
+
+        $err = $svc->internalErrorToProto(null, 'n');
+        self::assertSame('node error', $err->getMessage());
+    }
+}

package/dist/scaffold-repo/sdks/php/tests/Testing/MockContextTest.php

@@ -0,0 +1,184 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Testing;
+
+use Blok\Blok\Testing\MockContext;
+use PHPUnit\Framework\TestCase;
+
+final class MockContextTest extends TestCase
+{
+    public function testDefaultValues(): void
+    {
+        $ctx = MockContext::create()->build();
+
+        $this->assertSame('test-execution-id', $ctx->id);
+        $this->assertSame('test-workflow', $ctx->workflowName);
+        $this->assertSame('/workflows/test', $ctx->workflowPath);
+        $this->assertSame('POST', $ctx->request->method);
+        $this->assertSame('/test', $ctx->request->url);
+        $this->assertSame('http://localhost:8080', $ctx->request->baseUrl);
+        $this->assertEmpty($ctx->vars);
+        $this->assertEmpty($ctx->env);
+    }
+
+    public function testWithId(): void
+    {
+        $ctx = MockContext::create()
+            ->withId('custom-id')
+            ->build();
+
+        $this->assertSame('custom-id', $ctx->id);
+    }
+
+    public function testWithWorkflow(): void
+    {
+        $ctx = MockContext::create()
+            ->withWorkflow('my-workflow', '/workflows/my')
+            ->build();
+
+        $this->assertSame('my-workflow', $ctx->workflowName);
+        $this->assertSame('/workflows/my', $ctx->workflowPath);
+    }
+
+    public function testWithBody(): void
+    {
+        $ctx = MockContext::create()
+            ->withBody(['name' => 'test', 'value' => 42])
+            ->build();
+
+        $this->assertSame(['name' => 'test', 'value' => 42], $ctx->request->body);
+        $this->assertSame('test', $ctx->request->bodyStr('name'));
+    }
+
+    public function testWithHeaders(): void
+    {
+        $ctx = MockContext::create()
+            ->withHeaders(['Authorization' => 'Bearer token', 'Accept' => 'application/json'])
+            ->build();
+
+        $this->assertSame('Bearer token', $ctx->request->headers['Authorization']);
+        $this->assertSame('application/json', $ctx->request->headers['Accept']);
+    }
+
+    public function testWithMethod(): void
+    {
+        $ctx = MockContext::create()
+            ->withMethod('GET')
+            ->build();
+
+        $this->assertSame('GET', $ctx->request->method);
+    }
+
+    public function testWithUrl(): void
+    {
+        $ctx = MockContext::create()
+            ->withUrl('/api/users')
+            ->build();
+
+        $this->assertSame('/api/users', $ctx->request->url);
+    }
+
+    public function testWithVar(): void
+    {
+        $ctx = MockContext::create()
+            ->withVar('key1', 'value1')
+            ->withVar('key2', ['nested' => true])
+            ->build();
+
+        $this->assertSame('value1', $ctx->getVar('key1'));
+        $this->assertSame(['nested' => true], $ctx->getVar('key2'));
+        $this->assertSame('value1', $ctx->getVarStr('key1'));
+    }
+
+    public function testWithEnv(): void
+    {
+        $ctx = MockContext::create()
+            ->withEnv('API_KEY', 'secret-key')
+            ->withEnv('DEBUG', 'true')
+            ->build();
+
+        $this->assertSame('secret-key', $ctx->env['API_KEY']);
+        $this->assertSame('true', $ctx->env['DEBUG']);
+    }
+
+    public function testWithParams(): void
+    {
+        $ctx = MockContext::create()
+            ->withParams(['id' => '123'])
+            ->build();
+
+        $this->assertSame('123', $ctx->request->params['id']);
+    }
+
+    public function testWithQuery(): void
+    {
+        $ctx = MockContext::create()
+            ->withQuery(['page' => '1', 'limit' => '10'])
+            ->build();
+
+        $this->assertSame('1', $ctx->request->query['page']);
+        $this->assertSame('10', $ctx->request->query['limit']);
+    }
+
+    public function testFluentChaining(): void
+    {
+        $ctx = MockContext::create()
+            ->withId('chain-test')
+            ->withWorkflow('wf', '/wf')
+            ->withBody(['name' => 'test'])
+            ->withHeaders(['X-Custom' => 'yes'])
+            ->withMethod('PUT')
+            ->withVar('prev', 'result')
+            ->withEnv('MODE', 'test')
+            ->build();
+
+        $this->assertSame('chain-test', $ctx->id);
+        $this->assertSame('wf', $ctx->workflowName);
+        $this->assertSame(['name' => 'test'], $ctx->request->body);
+        $this->assertSame('yes', $ctx->request->headers['X-Custom']);
+        $this->assertSame('PUT', $ctx->request->method);
+        $this->assertSame('result', $ctx->getVarStr('prev'));
+        $this->assertSame('test', $ctx->env['MODE']);
+    }
+
+    public function testContextSetAndGetVar(): void
+    {
+        $ctx = MockContext::create()->build();
+
+        $ctx->setVar('key', 'value');
+        $this->assertSame('value', $ctx->getVar('key'));
+        $this->assertSame('value', $ctx->getVarStr('key'));
+        $this->assertNull($ctx->getVar('missing'));
+        $this->assertNull($ctx->getVarStr('missing'));
+    }
+
+    public function testContextGetVarStrReturnsNullForNonString(): void
+    {
+        $ctx = MockContext::create()
+            ->withVar('number', 42)
+            ->build();
+
+        $this->assertSame(42, $ctx->getVar('number'));
+        $this->assertNull($ctx->getVarStr('number'));
+    }
+
+    public function testContextToArrayAndFromArray(): void
+    {
+        $ctx = MockContext::create()
+            ->withId('round-trip')
+            ->withWorkflow('test-wf', '/test')
+            ->withBody(['name' => 'test'])
+            ->withVar('key', 'val')
+            ->build();
+
+        $array = $ctx->toArray();
+
+        $this->assertSame('round-trip', $array['id']);
+        $this->assertSame('test-wf', $array['workflow_name']);
+        $this->assertSame('/test', $array['workflow_path']);
+        $this->assertSame(['name' => 'test'], $array['request']['body']);
+        $this->assertSame('val', $array['vars']['key']);
+    }
+}