tests(acceptance): add Deployment Versioning test

Author: roxblnfk

src/Worker/Transport/RoadRunner.php

@@ -39,7 +39,7 @@ final class RoadRunner implements HostConnectionInterface
     private RoadRunnerWorker $worker;
     private CodecInterface $codec;
 
-    public function __construct(RoadRunnerWorker $worker)
+    private function __construct(RoadRunnerWorker $worker)
     {
         $this->worker = $worker;
         $this->codec = new JsonCodec();

testing/src/Environment.php

@@ -94,9 +94,6 @@ public function startTemporalServer(
                 $this->systemInfo->temporalCliExecutable,
                 "server", "start-dev",
                 "--port", $temporalPort,
-                '--dynamic-config-value', 'frontend.enableUpdateWorkflowExecution=true',
-                '--dynamic-config-value', 'frontend.enableUpdateWorkflowExecutionAsyncAccepted=true',
-                '--dynamic-config-value', 'frontend.enableExecuteMultiOperation=true',
                 '--log-level', 'error',
                 '--headless',
                 ...$parameters,
@@ -202,4 +199,19 @@ public function stop(): void
             $this->output->writeln('<info>done.</info>');
         }
     }
+
+    /**
+     * @internal
+     */
+    public function executeTemporalCommand(array|string $command, int $timeout = 10): void
+    {
+        $command = \array_merge(
+            [$this->systemInfo->temporalCliExecutable],
+            (array) $command,
+        );
+
+        $process = new Process($command);
+        $process->setTimeout($timeout);
+        $process->run();
+    }
 }

tests/Acceptance/App/Runtime/TemporalStarter.php

@@ -4,6 +4,7 @@
 
 namespace Temporal\Tests\Acceptance\App\Runtime;
 
+use Symfony\Component\Process\Process;
 use Temporal\Common\SearchAttributes\ValueType;
 use Temporal\Testing\Environment;
 
@@ -49,13 +50,25 @@ public function start(): void
         $this->started = true;
     }
 
-    public function stop(): void
+    public function executeTemporalCommand(array|string $command, int $timeout = 10): void
+    {
+        $this->environment->executeTemporalCommand(
+            command: $command,
+            timeout: $timeout,
+        );
+    }
+
+    /**
+     * @return bool Returns true if the server was stopped successfully, false if it was not started.
+     */
+    public function stop(): bool
     {
         if (!$this->started) {
-            return;
+            return false;
         }
 
         $this->environment->stop();
         $this->started = false;
+        return true;
     }
 }

tests/Acceptance/Extra/Versioning/DeploymentTest.php

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Temporal\Tests\Acceptance\Extra\Versioning\Deployment;
+
+use PHPUnit\Framework\Attributes\Test;
+use Temporal\Client\WorkflowClientInterface;
+use Temporal\Client\WorkflowOptions;
+use Temporal\Tests\Acceptance\App\Attribute\Worker;
+use Temporal\Tests\Acceptance\App\Runtime\Feature;
+use Temporal\Tests\Acceptance\App\Runtime\TemporalStarter;
+use Temporal\Tests\Acceptance\App\TestCase;
+use Temporal\Worker\Versioning\VersioningBehavior;
+use Temporal\Worker\Versioning\WorkerDeploymentOptions;
+use Temporal\Worker\Versioning\WorkerDeploymentVersion;
+use Temporal\Worker\WorkerOptions;
+use Temporal\Workflow\WorkflowInterface;
+use Temporal\Workflow\WorkflowMethod;
+
+#[Worker(options: [WorkerFactory::class, 'options'])]
+class DeploymentTest extends TestCase
+{
+    #[Test]
+    public function sendEmpty(
+        TemporalStarter $starter,
+        WorkflowClientInterface $client,
+        Feature $feature,
+    ): void {
+        $starter->executeTemporalCommand([
+            'worker',
+            'deployment',
+            'set-current-version',
+            '--deployment-name', WorkerFactory::DEPLOYMENT_NAME,
+            '--build-id', WorkerFactory::BUILD_ID,
+            '--yes',
+        ], timeout: 5);
+
+        try {
+            # Create a Workflow stub with an execution timeout 12 seconds
+            $stub = $client
+                ->withTimeout(10)
+                ->newUntypedWorkflowStub(
+                    'Extra_Versioning_Deployment',
+                    WorkflowOptions::new()
+                        ->withTaskQueue($feature->taskQueue)
+                        ->withWorkflowExecutionTimeout(20),
+                );
+
+            # Start the Workflow
+            $client->start($stub);
+
+            $result = $stub->getResult(timeout: 5);
+            self::assertSame('default', $result);
+
+            $version = null;
+            $behavior = null;
+            foreach ($client->getWorkflowHistory($stub->getExecution()) as $event) {
+                if ($event->hasWorkflowTaskCompletedEventAttributes()) {
+                    $version = $event->getWorkflowTaskCompletedEventAttributes()?->getDeploymentVersion();
+                    $behavior = $event->getWorkflowTaskCompletedEventAttributes()?->getVersioningBehavior();
+                    break;
+                }
+            }
+
+            self::assertNotNull($version);
+            self::assertSame(WorkerFactory::DEPLOYMENT_NAME, $version->getDeploymentName());
+            self::assertSame(WorkerFactory::BUILD_ID, $version->getBuildId());
+            self::assertSame(VersioningBehavior::AutoUpgrade->value, $behavior);
+        } finally {
+            $starter->stop() and $starter->start();
+        }
+    }
+}
+
+class WorkerFactory
+{
+    public const DEPLOYMENT_NAME = 'foo';
+    public const BUILD_ID = 'baz';
+
+    public static function options(): WorkerOptions
+    {
+        return WorkerOptions::new()
+            ->withDeploymentOptions(
+                WorkerDeploymentOptions::new()
+                    ->withUseVersioning(true)
+                    ->withVersion(WorkerDeploymentVersion::new(self::DEPLOYMENT_NAME, self::BUILD_ID))
+                    ->withDefaultVersioningBehavior(VersioningBehavior::AutoUpgrade),
+            );
+    }
+}
+
+#[WorkflowInterface]
+class TestWorkflow
+{
+    #[WorkflowMethod(name: "Extra_Versioning_Deployment")]
+    public function handle()
+    {
+        return 'default';
+    }
+}