Add the ability to create untyped workflow and child workflow stubs; add tests

roxblnfk · roxblnfk · commit d95c27b6af6d · 2024-04-05T22:43:54.000+04:00
diff --git a/composer.json b/composer.json
@@ -38,15 +38,15 @@
     "prefer-stable": true,
     "require": {
         "php": ">=8.1",
-        "temporal/sdk": "^2.7"
+        "temporal/sdk": "^2.8"
     },
     "suggest": {
         "buggregator/trap": "For better debugging and protobuf messages dumping"
     },
     "require-dev": {
-        "buggregator/trap": "^1.3",
+        "buggregator/trap": "^1.4",
         "dereuromark/composer-prefer-lowest": "^0.1.10",
-        "phpunit/phpunit": "^10.4",
-        "vimeo/psalm": "^5.18"
+        "phpunit/phpunit": "^10.5",
+        "vimeo/psalm": "^5.23"
     }
 }
diff --git a/src/Factory/WorkflowStub.php b/src/Factory/WorkflowStub.php
@@ -7,6 +7,7 @@
 use DateInterval;
 use Temporal\Client\WorkflowClientInterface;
 use Temporal\Client\WorkflowOptions;
+use Temporal\Client\WorkflowStubInterface;
 use Temporal\Common\IdReusePolicy;
 use Temporal\Internal\Client\WorkflowProxy;
 use Temporal\Internal\Workflow\ChildWorkflowProxy;
@@ -18,6 +19,7 @@
 use Temporal\Support\Internal\RetryOptions;
 use Temporal\Workflow;
 use Temporal\Workflow\ChildWorkflowCancellationType as ChildCancelType;
+use Temporal\Workflow\ChildWorkflowStubInterface;
 use Temporal\Workflow\ParentClosePolicy;
 use Throwable;
 
@@ -28,7 +30,7 @@ final class WorkflowStub
      *
      * @template T of object
      *
-     * @param class-string<T> $workflow
+     * @param class-string<T>|non-empty-string $type Workflow name or class name.
      * @param non-empty-string|null $taskQueue
      * @param int<0, max>|null $retryAttempts Maximum number of attempts. When exceeded the retries stop even
      *        if not expired yet. If not set or set to 0, it means unlimited, and rely on activity
@@ -73,11 +75,11 @@ final class WorkflowStub
      *        of list workflow.
      * @param list<mixed> $memo Specifies additional non-indexed information in result of list workflow.
      *
-     * @return T|WorkflowProxy
+     * @return ($type is class-string ? T|WorkflowProxy : WorkflowStubInterface)
      */
     public static function workflow(
         WorkflowClientInterface $workflowClient,
-        string $workflow,
+        string $type,
         ?string $taskQueue = null,
         ?int $retryAttempts = null,
         \DateInterval|string|int|null $retryInitInterval = null,
@@ -95,7 +97,8 @@ public static function workflow(
         array $searchAttributes = [],
         array $memo = [],
     ): object {
-        $attributes = self::readAttributes($workflow);
+        $isUntyped = !\class_exists($type) && !\interface_exists($type);
+        $attributes = $isUntyped ? new AttributeCollection([]) : self::readAttributes($type);
 
         // Retry options
         $retryOptions = RetryOptions::create(
@@ -109,6 +112,7 @@ public static function workflow(
 
         $options = WorkflowOptions::new()->withRetryOptions($retryOptions);
         $taskQueue ??= $attributes->first(TaskQueue::class)?->name;
+        $taskQueue === null or $options = $options->withTaskQueue($taskQueue);
         // Start options
         $startDelay === 0 or $options = $options->withWorkflowStartDelay($startDelay);
         $eagerStart and $options = $options->withEagerStart(true);
@@ -125,15 +129,17 @@ public static function workflow(
         $searchAttributes === [] or $options = $options->withSearchAttributes($searchAttributes);
         $memo === [] or $options = $options->withMemo($memo);
 
-        return $workflowClient->newWorkflowStub($workflow, $options);
+        return $isUntyped
+            ? $workflowClient->newUntypedWorkflowStub($type, $options)
+            : $workflowClient->newWorkflowStub($type, $options);
     }
 
     /**
      * Note: must be used in Workflow context only.
      *
      * @template T of object
      *
-     * @param class-string<T> $workflow
+     * @param class-string<T>|non-empty-string $type Workflow name or class name.
      * @param non-empty-string|null $taskQueue Task queue to use for workflow tasks. It should match a task queue
      *        specified when creating a {@see Worker} that hosts the workflow code.
      * @param non-empty-string|null $namespace Specify namespace in which workflow should be started.
@@ -174,10 +180,10 @@ public static function workflow(
      *        of list workflow.
      * @param list<mixed> $memo Specifies additional non-indexed information in result of list workflow.
      *
-     * @return T|ChildWorkflowProxy
+     * @return ($type is class-string ? T|ChildWorkflowProxy : ChildWorkflowStubInterface)
      */
     public static function childWorkflow(
-        string $workflow,
+        string $type,
         ?string $taskQueue = null,
         ?string $namespace = null,
         ?int $retryAttempts = null,
@@ -196,7 +202,8 @@ public static function childWorkflow(
         array $searchAttributes = [],
         array $memo = [],
     ): object {
-        $attributes = self::readAttributes($workflow);
+        $isUntyped = !\class_exists($type) && !\interface_exists($type);
+        $attributes = $isUntyped ? new AttributeCollection([]) : self::readAttributes($type);
 
         // Retry options
         $retryOptions = RetryOptions::create(
@@ -232,7 +239,9 @@ public static function childWorkflow(
         $searchAttributes === [] or $options = $options->withSearchAttributes($searchAttributes);
         $memo === [] or $options = $options->withMemo($memo);
 
-        return Workflow::newChildWorkflowStub($workflow, $options);
+        return $isUntyped
+            ? Workflow::newUntypedChildWorkflowStub($type, $options)
+            : Workflow::newChildWorkflowStub($type, $options);
     }
 
     /**
diff --git a/tests/Unit/Factory/ChildWorkflowStubTest.php b/tests/Unit/Factory/ChildWorkflowStubTest.php
@@ -11,6 +11,7 @@
 use Temporal\Support\Factory\WorkflowStub;
 use Temporal\Support\Tests\Stub\Workflow\AttributedWithoutInterface;
 use Temporal\Workflow;
+use Temporal\Workflow\ChildWorkflowStubInterface;
 
 final class ChildWorkflowStubTest extends TestCase
 {
@@ -28,11 +29,11 @@ protected function setUp(): void
         parent::setUp();
     }
 
-    public function testDefaultsFromAttributes()
+    public function testDefaultsFromAttributes(): void
     {
         /** @var WorkflowOptions $options */
         $options = WorkflowStub::childWorkflow(
-            workflow: AttributedWithoutInterface::class,
+            type: AttributedWithoutInterface::class,
         )->options;
 
         $this->assertSame('test-queue', $options->taskQueue);
@@ -43,11 +44,11 @@ public function testDefaultsFromAttributes()
         $this->assertSame('500.0', $options->retryOptions->maximumInterval->format('%s.%f'));
     }
 
-    public function testAttributeOverrides()
+    public function testAttributeOverrides(): void
     {
         /** @var WorkflowOptions $options */
         $options = WorkflowStub::childWorkflow(
-            workflow: AttributedWithoutInterface::class,
+            type: AttributedWithoutInterface::class,
             taskQueue: 'test-queue-override',
             retryAttempts: 0,
             retryInitInterval: 10,
@@ -66,4 +67,11 @@ public function testAttributeOverrides()
         $this->assertSame('10.0', $options->retryOptions->initialInterval->format('%s.%f'));
         $this->assertSame('200.0', $options->retryOptions->maximumInterval->format('%s.%f'));
     }
+
+    public function testUntypedChildCreated(): void
+    {
+        $wf = WorkflowStub::childWorkflow(type: 'foo-bar');
+
+        self::assertInstanceOf(ChildWorkflowStubInterface::class, $wf);
+    }
 }
diff --git a/tests/Unit/Factory/WorkflowStubTest.php b/tests/Unit/Factory/WorkflowStubTest.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Factory;
+
+use LogicException;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+use Temporal\Client\WorkflowClientInterface;
+use Temporal\Client\WorkflowOptions;
+use Temporal\Client\WorkflowStubInterface;
+use Temporal\Support\Factory\WorkflowStub;
+use Temporal\Support\Tests\Stub\Workflow\AttributedWithoutInterface;
+
+final class WorkflowStubTest extends TestCase
+{
+    public function testDefaultsFromAttributes(): void
+    {
+        $input = new class {
+            public string $type;
+            public WorkflowOptions $options;
+        };
+
+        $clientMock = self::createMock(WorkflowClientInterface::class);
+        $clientMock->method('newWorkflowStub')
+            ->willReturnCallback(function (string $class, WorkflowOptions $options) use ($input) {
+                $input->type = $class;
+                $input->options = $options;
+                return $input;
+            });
+        WorkflowStub::workflow(
+            $clientMock,
+            type: AttributedWithoutInterface::class,
+        );
+
+        self::assertSame(AttributedWithoutInterface::class, $input->type);
+        self::assertSame('test-queue', $input->options->taskQueue);
+        self::assertSame(3, $input->options->retryOptions->maximumAttempts);
+        self::assertSame(10.0, $input->options->retryOptions->backoffCoefficient);
+        self::assertEquals(
+            [RuntimeException::class],
+            $input->options->retryOptions->nonRetryableExceptions,
+        );
+        self::assertSame('5.0', $input->options->retryOptions->initialInterval->format('%s.%f'));
+        self::assertSame('500.0', $input->options->retryOptions->maximumInterval->format('%s.%f'));
+    }
+
+    public function testAttributeOverrides(): void
+    {
+        $input = new class {
+            public string $type;
+            public WorkflowOptions $options;
+        };
+
+        $clientMock = self::createMock(WorkflowClientInterface::class);
+        $clientMock->method('newWorkflowStub')
+            ->willReturnCallback(function (string $class, WorkflowOptions $options) use ($input) {
+                $input->type = $class;
+                $input->options = $options;
+                return $input;
+            });
+        WorkflowStub::workflow(
+            $clientMock,
+            type: AttributedWithoutInterface::class,
+            taskQueue: 'test-queue-override',
+            retryAttempts: 0,
+            retryInitInterval: 10,
+            retryMaxInterval: 200,
+            retryBackoff: 5.0,
+            nonRetryables: [LogicException::class],
+        );
+
+        self::assertSame(AttributedWithoutInterface::class, $input->type);
+        self::assertSame('test-queue-override', $input->options->taskQueue);
+        self::assertSame(0, $input->options->retryOptions->maximumAttempts);
+        self::assertSame(5.0, $input->options->retryOptions->backoffCoefficient);
+        self::assertEquals(
+            [LogicException::class, RuntimeException::class],
+            $input->options->retryOptions->nonRetryableExceptions,
+        );
+        self::assertSame('10.0', $input->options->retryOptions->initialInterval->format('%s.%f'));
+        self::assertSame('200.0', $input->options->retryOptions->maximumInterval->format('%s.%f'));
+    }
+
+    public function testUntypedWorkflowCreated(): void
+    {
+        $clientMock = self::createMock(WorkflowClientInterface::class);
+        $wf = WorkflowStub::workflow($clientMock, 'foo-bar');
+
+        self::assertInstanceOf(WorkflowStubInterface::class, $wf);
+    }
+}
