Update version to 1.11.0 (#607)

jmaeagle99 · web-flow · commit 392e93e61448 · 2026-02-10T16:04:06.000-08:00
diff --git a/.editorconfig b/.editorconfig
@@ -40,6 +40,9 @@ dotnet_diagnostic.CA1847.severity = none
 # We accept logging performance can improve later
 dotnet_diagnostic.CA1848.severity = none
 
+# We accept logging performance can improve later
+dotnet_diagnostic.CA1873.severity = none
+
 # Do not want to make all exceptions [Serializable], we don't support
 # cross-AppDomain currently
 dotnet_diagnostic.CA2237.severity = none
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -18,7 +18,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <Version>1.10.0</Version>
+    <Version>1.11.0</Version>
     <!--
       .NET does not allow the above version format for AssemblyVersion, and this
       is the version used in gRPC headers. The format is
@@ -33,7 +33,7 @@
       and 0.2.0 then is 0.2.0.5. But if there is no prerelease version, just
       leave revision off.
     -->
-    <AssemblyVersion>1.10.0</AssemblyVersion>
+    <AssemblyVersion>1.11.0</AssemblyVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/Temporalio.Tests/Extensions/Hosting/ActivityScopeTests.cs b/tests/Temporalio.Tests/Extensions/Hosting/ActivityScopeTests.cs
@@ -114,25 +114,31 @@ public async Task ActivityScope_CustomInstance_IsAccessible()
 
         // Start the host
         using var tokenSource = new CancellationTokenSource();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Execute the workflow successfully. confirming no scope leak
-        Assert.Null(ActivityScope.ServiceScope);
-        Assert.Null(ActivityScope.ScopedInstance);
-        await Client.ExecuteWorkflowAsync(
-            (MyWorkflow wf) => wf.RunAsync("should-succeed"),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        Assert.Null(ActivityScope.ServiceScope);
-        Assert.Null(ActivityScope.ScopedInstance);
-
-        // Now execute a workflow with state that the interceptor will see set on the activity and
-        // fail
-        var exc = await Assert.ThrowsAsync<WorkflowFailedException>(() =>
-            Client.ExecuteWorkflowAsync(
-                (MyWorkflow wf) => wf.RunAsync("should-fail"),
-                new($"wf-{Guid.NewGuid()}", taskQueue)));
-        var exc2 = Assert.IsType<ActivityFailureException>(exc.InnerException);
-        var exc3 = Assert.IsType<ApplicationFailureException>(exc2.InnerException);
-        Assert.Equal("Intentional failure", exc3.Message);
+        await host.StartAsync(tokenSource.Token);
+        try
+        {
+            // Execute the workflow successfully. confirming no scope leak
+            Assert.Null(ActivityScope.ServiceScope);
+            Assert.Null(ActivityScope.ScopedInstance);
+            await Client.ExecuteWorkflowAsync(
+                (MyWorkflow wf) => wf.RunAsync("should-succeed"),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            Assert.Null(ActivityScope.ServiceScope);
+            Assert.Null(ActivityScope.ScopedInstance);
+
+            // Now execute a workflow with state that the interceptor will see set on the activity and
+            // fail
+            var exc = await Assert.ThrowsAsync<WorkflowFailedException>(() =>
+                Client.ExecuteWorkflowAsync(
+                    (MyWorkflow wf) => wf.RunAsync("should-fail"),
+                    new($"wf-{Guid.NewGuid()}", taskQueue)));
+            var exc2 = Assert.IsType<ActivityFailureException>(exc.InnerException);
+            var exc3 = Assert.IsType<ApplicationFailureException>(exc2.InnerException);
+            Assert.Equal("Intentional failure", exc3.Message);
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
     }
 }
diff --git a/tests/Temporalio.Tests/Extensions/Hosting/TemporalWorkerServiceTests.cs b/tests/Temporalio.Tests/Extensions/Hosting/TemporalWorkerServiceTests.cs
@@ -93,18 +93,24 @@ public async Task TemporalWorkerService_ExecuteAsync_SimpleWorker()
 
         // Start the host
         using var tokenSource = new CancellationTokenSource();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Execute the workflow
-        var result = await Client.ExecuteWorkflowAsync(
-            (DatabaseWorkflow wf) => wf.RunAsync(),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        // Single activity calls use the same client but different calls use different clients
-        Assert.Equal(
-            new List<string> { "something-6", "something-7", "something-6", "something-7", "something-static" },
-            result);
-        // Confirm the log appeared
-        Assert.Contains(loggerFactory.Logs, e => e.Formatted == "Running database workflow");
+        await host.StartAsync(tokenSource.Token);
+        try
+        {
+            // Execute the workflow
+            var result = await Client.ExecuteWorkflowAsync(
+                (DatabaseWorkflow wf) => wf.RunAsync(),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            // Single activity calls use the same client but different calls use different clients
+            Assert.Equal(
+                new List<string> { "something-6", "something-7", "something-6", "something-7", "something-static" },
+                result);
+            // Confirm the log appeared
+            Assert.Contains(loggerFactory.Logs, e => e.Formatted == "Running database workflow");
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
     }
 
     public class SingletonCounter
@@ -186,27 +192,33 @@ public async Task TemporalWorkerService_ExecuteAsync_MultipleWorkers()
         // Start the host
         using var tokenSource = new CancellationTokenSource();
         using var host = bld.Build();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Execute the workflow
-        var result = await Client.ExecuteWorkflowAsync(
-            (MultiTaskQueueWorkflow wf) => wf.RunAsync(taskQueue2),
-            new($"wf-{Guid.NewGuid()}", taskQueue1));
-        Assert.Equal(
-            new Dictionary<string, string>()
-            {
-                // Singletons share
-                ["singleton1"] = $"tq: {taskQueue1}, counter: 6",
-                ["singleton2"] = $"tq: {taskQueue1}, counter: 7",
-                ["singleton-other1"] = $"tq: {taskQueue2}, counter: 8",
-                ["singleton-other2"] = $"tq: {taskQueue2}, counter: 9",
-                // Scoped do not share
-                ["scoped1"] = $"tq: {taskQueue1}, counter: 6",
-                ["scoped2"] = $"tq: {taskQueue1}, counter: 6",
-                ["scoped-other1"] = $"tq: {taskQueue2}, counter: 6",
-                ["scoped-other2"] = $"tq: {taskQueue2}, counter: 6",
-            },
-            result);
+        await host.StartAsync(tokenSource.Token);
+        try
+        {
+            // Execute the workflow
+            var result = await Client.ExecuteWorkflowAsync(
+                (MultiTaskQueueWorkflow wf) => wf.RunAsync(taskQueue2),
+                new($"wf-{Guid.NewGuid()}", taskQueue1));
+            Assert.Equal(
+                new Dictionary<string, string>()
+                {
+                    // Singletons share
+                    ["singleton1"] = $"tq: {taskQueue1}, counter: 6",
+                    ["singleton2"] = $"tq: {taskQueue1}, counter: 7",
+                    ["singleton-other1"] = $"tq: {taskQueue2}, counter: 8",
+                    ["singleton-other2"] = $"tq: {taskQueue2}, counter: 9",
+                    // Scoped do not share
+                    ["scoped1"] = $"tq: {taskQueue1}, counter: 6",
+                    ["scoped2"] = $"tq: {taskQueue1}, counter: 6",
+                    ["scoped-other1"] = $"tq: {taskQueue2}, counter: 6",
+                    ["scoped-other2"] = $"tq: {taskQueue2}, counter: 6",
+                },
+                result);
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
     }
 
     [Workflow]
@@ -266,25 +278,31 @@ public async Task TemporalWorkerService_WorkerClientReplacement_UsesNewClient()
         // Start the host
         using var tokenSource = new CancellationTokenSource();
         using var host = bld.Build();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Confirm the first ticking workflow has completed a task but not the second workflow
-        await AssertMore.HasEventEventuallyAsync(handle1, e => e.WorkflowTaskCompletedEventAttributes != null);
-        await foreach (var evt in handle2.FetchHistoryEventsAsync())
+        await host.StartAsync(tokenSource.Token);
+        try
         {
-            Assert.Null(evt.WorkflowTaskCompletedEventAttributes);
-        }
+            // Confirm the first ticking workflow has completed a task but not the second workflow
+            await AssertMore.HasEventEventuallyAsync(handle1, e => e.WorkflowTaskCompletedEventAttributes != null);
+            await foreach (var evt in handle2.FetchHistoryEventsAsync())
+            {
+                Assert.Null(evt.WorkflowTaskCompletedEventAttributes);
+            }
 
-        // Now replace the client, which should be used fairly quickly because we should have
-        // timer-done poll completions every 100ms
-        workerClientUpdater.UpdateClient(otherEnv.Client);
+            // Now replace the client, which should be used fairly quickly because we should have
+            // timer-done poll completions every 100ms
+            workerClientUpdater.UpdateClient(otherEnv.Client);
 
-        // Now confirm the other workflow has started
-        await AssertMore.HasEventEventuallyAsync(handle2, e => e.WorkflowTaskCompletedEventAttributes != null);
+            // Now confirm the other workflow has started
+            await AssertMore.HasEventEventuallyAsync(handle2, e => e.WorkflowTaskCompletedEventAttributes != null);
 
-        // Terminate both
-        await handle1.TerminateAsync();
-        await handle2.TerminateAsync();
+            // Terminate both
+            await handle1.TerminateAsync();
+            await handle2.TerminateAsync();
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
     }
 
     [Workflow("DeploymentVersioningWorkflow", VersioningBehavior = VersioningBehavior.Pinned)]
@@ -323,23 +341,29 @@ public async Task TemporalWorkerService_ExecuteAsync_MultipleVersionsSameQueue()
         // Start the host
         using var tokenSource = new CancellationTokenSource();
         using var host = bld.Build();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Set 1.0 as default and run
-        await Env.Client.UpdateWorkerBuildIdCompatibilityAsync(
-            taskQueue, new BuildIdOp.AddNewDefault("1.0"));
-        var res = await Client.ExecuteWorkflowAsync(
-            (WorkflowV1 wf) => wf.RunAsync(),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        Assert.Equal("done-v1", res);
-
-        // Update default and run again
-        await Env.Client.UpdateWorkerBuildIdCompatibilityAsync(
-            taskQueue, new BuildIdOp.AddNewDefault("2.0"));
-        res = await Client.ExecuteWorkflowAsync(
-            (WorkflowV1 wf) => wf.RunAsync(),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        Assert.Equal("done-v2", res);
+        await host.StartAsync(tokenSource.Token);
+        try
+        {
+            // Set 1.0 as default and run
+            await Env.Client.UpdateWorkerBuildIdCompatibilityAsync(
+                taskQueue, new BuildIdOp.AddNewDefault("1.0"));
+            var res = await Client.ExecuteWorkflowAsync(
+                (WorkflowV1 wf) => wf.RunAsync(),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            Assert.Equal("done-v1", res);
+
+            // Update default and run again
+            await Env.Client.UpdateWorkerBuildIdCompatibilityAsync(
+                taskQueue, new BuildIdOp.AddNewDefault("2.0"));
+            res = await Client.ExecuteWorkflowAsync(
+                (WorkflowV1 wf) => wf.RunAsync(),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            Assert.Equal("done-v2", res);
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
 #pragma warning restore CS0618
     }
 
@@ -362,23 +386,29 @@ public async Task TemporalWorkerService_ExecuteAsync_MultipleDeploymentVersionsS
         // Start the host
         using var tokenSource = new CancellationTokenSource();
         using var host = bld.Build();
-        var hostTask = Task.Run(() => host.RunAsync(tokenSource.Token));
-
-        // Set 1.0 as default and run
-        var describe1 = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, workerV1);
-        await TestUtils.SetCurrentDeploymentVersionAsync(Client, describe1.ConflictToken, workerV1);
-        var res = await Client.ExecuteWorkflowAsync(
-            (WorkflowV1 wf) => wf.RunAsync(),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        Assert.Equal("done-v1", res);
-
-        // Update default and run again
-        var describe2 = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, workerV2);
-        await TestUtils.SetCurrentDeploymentVersionAsync(Client, describe2.ConflictToken, workerV2);
-        res = await Client.ExecuteWorkflowAsync(
-            (WorkflowV1 wf) => wf.RunAsync(),
-            new($"wf-{Guid.NewGuid()}", taskQueue));
-        Assert.Equal("done-v2", res);
+        await host.StartAsync(tokenSource.Token);
+        try
+        {
+            // Set 1.0 as default and run
+            var describe1 = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, workerV1);
+            await TestUtils.SetCurrentDeploymentVersionAsync(Client, describe1.ConflictToken, workerV1);
+            var res = await Client.ExecuteWorkflowAsync(
+                (WorkflowV1 wf) => wf.RunAsync(),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            Assert.Equal("done-v1", res);
+
+            // Update default and run again
+            var describe2 = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, workerV2);
+            await TestUtils.SetCurrentDeploymentVersionAsync(Client, describe2.ConflictToken, workerV2);
+            res = await Client.ExecuteWorkflowAsync(
+                (WorkflowV1 wf) => wf.RunAsync(),
+                new($"wf-{Guid.NewGuid()}", taskQueue));
+            Assert.Equal("done-v2", res);
+        }
+        finally
+        {
+            await host.StopAsync(tokenSource.Token);
+        }
     }
 
     [Fact]
diff --git a/tests/Temporalio.Tests/Worker/WorkerDeploymentVersioningTests.cs b/tests/Temporalio.Tests/Worker/WorkerDeploymentVersioningTests.cs
@@ -105,13 +105,13 @@ public async Task WorkerWithDeploymentOptions_FollowsVersioningBehavior()
                 DeploymentOptions = new(workerV3, true),
             }.AddWorkflow<DeploymentVersioningWorkflowV3AutoUpgrade>());
 
-        var testTask = ExecuteTest(worker1, worker2, worker3);
+        var testTask = ExecuteTest();
         await Task.WhenAll(
             worker1.ExecuteAsync(() => testTask),
             worker2.ExecuteAsync(() => testTask),
             worker3.ExecuteAsync(() => testTask));
 
-        async Task ExecuteTest(TemporalWorker w1, TemporalWorker w2, TemporalWorker w3)
+        async Task ExecuteTest()
         {
             // Wait for deployment version to be registered and make it current
             var describe1 = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, workerV1);
@@ -181,12 +181,12 @@ public async Task WorkerDeploymentRamp_ChangesTaskDistribution()
                 DeploymentOptions = new(v2, true),
             }.AddWorkflow<DeploymentVersioningWorkflowV2Pinned>());
 
-        var testTask = ExecuteRampTest(worker1, worker2);
+        var testTask = ExecuteRampTest();
         await Task.WhenAll(
             worker1.ExecuteAsync(() => testTask),
             worker2.ExecuteAsync(() => testTask));
 
-        async Task ExecuteRampTest(TemporalWorker w1, TemporalWorker w2)
+        async Task ExecuteRampTest()
         {
             await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, v1);
             var describeResp = await TestUtils.WaitUntilWorkerDeploymentVisibleAsync(Client, v2);
