From 69ca2513f9472cff98ad2ff29c18358c89c4b4bb Mon Sep 17 00:00:00 2001
From: Spencer Judge <spencer@temporal.io>
Date: Wed, 31 Jan 2024 13:43:39 -0800
Subject: [PATCH] Dotnet Update Features (#418)

---
 dotnet.csproj                                 |   2 +-
 features/update/activities/feature.cs         |   2 +-
 features/update/basic/feature.cs              |  60 +++++++++
 features/update/basic_async/feature.cs        |  64 +++++++++
 features/update/client_interceptor/feature.cs |  70 ++++++++++
 features/update/deduplication/feature.cs      |  52 ++++++++
 features/update/non_durable_reject/feature.cs |  71 ++++++++++
 features/update/self/feature.cs               |  62 +++++++++
 features/update/task_failure/feature.cs       |  87 ++++++++++++
 features/update/validation_replay/feature.cs  |  68 ++++++++++
 features/update/worker_restart/feature.cs     |  65 +++++++++
 .../dotnet/Temporalio.Features.Harness/App.cs |  58 ++++----
 .../Temporalio.Features.Harness/IFeature.cs   |   7 +
 .../Temporalio.Features.Harness/Runner.cs     | 124 ++++++++++++++----
 14 files changed, 745 insertions(+), 47 deletions(-)
 create mode 100644 features/update/basic/feature.cs
 create mode 100644 features/update/basic_async/feature.cs
 create mode 100644 features/update/client_interceptor/feature.cs
 create mode 100644 features/update/deduplication/feature.cs
 create mode 100644 features/update/non_durable_reject/feature.cs
 create mode 100644 features/update/self/feature.cs
 create mode 100644 features/update/task_failure/feature.cs
 create mode 100644 features/update/validation_replay/feature.cs
 create mode 100644 features/update/worker_restart/feature.cs

diff --git a/dotnet.csproj b/dotnet.csproj
index 151fb48e..f80e9002 100644
--- a/dotnet.csproj
+++ b/dotnet.csproj
@@ -23,7 +23,7 @@
     <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="7.0.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
-    <PackageReference Include="Temporalio" Version="0.1.0-beta2">
+    <PackageReference Include="Temporalio" Version="1.0.0">
       <!--
         We have to make sure this isn't included transitively so it can be
         overridden.
diff --git a/features/update/activities/feature.cs b/features/update/activities/feature.cs
index 07a61221..2a0bc3c3 100644
--- a/features/update/activities/feature.cs
+++ b/features/update/activities/feature.cs
@@ -27,7 +27,7 @@ public Task<int> DoActivitiesAsync() =>
                 Enumerable.Range(0, 5).Select(_ =>
                     Workflow.ExecuteActivityAsync(
                         () => MyActivities.MyActivity(),
-                        new() { StartToCloseTimeout = TimeSpan.FromSeconds(5) } ))).
+                        new() { StartToCloseTimeout = TimeSpan.FromSeconds(5) }))).
                 ContinueWith(vals => Enumerable.Sum(vals.Result));
     }
 
diff --git a/features/update/basic/feature.cs b/features/update/basic/feature.cs
new file mode 100644
index 00000000..ac1d0583
--- /dev/null
+++ b/features/update/basic/feature.cs
@@ -0,0 +1,60 @@
+namespace update.basic;
+
+using Temporalio.Exceptions;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public Task RunAsync() => Workflow.WaitConditionAsync(() => shutdown);
+
+        [WorkflowUpdate]
+        public async Task<string> MyUpdate(string _)
+        {
+            shutdown = true;
+            return "hi";
+        }
+
+        [WorkflowUpdateValidator(nameof(MyUpdate))]
+        public void ValidateMyUpdate(string arg)
+        {
+            if (arg == "invalid")
+            {
+                throw new ApplicationFailureException("invalid");
+            }
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>();
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        try
+        {
+            await handle.ExecuteUpdateAsync(wf => wf.MyUpdate("invalid"));
+            throw new Exception("Expected to fail");
+        }
+        catch (WorkflowUpdateFailedException)
+        {
+            // Expected
+        }
+
+        Assert.Equal("hi", await handle.ExecuteUpdateAsync(wf => wf.MyUpdate("valid")));
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/basic_async/feature.cs b/features/update/basic_async/feature.cs
new file mode 100644
index 00000000..2bf03df3
--- /dev/null
+++ b/features/update/basic_async/feature.cs
@@ -0,0 +1,64 @@
+namespace update.basic_async;
+
+using Temporalio.Exceptions;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public Task RunAsync() => Workflow.WaitConditionAsync(() => shutdown);
+
+        [WorkflowUpdate]
+        public async Task<string> MyUpdate(string _)
+        {
+            shutdown = true;
+            return "hi";
+        }
+
+        [WorkflowUpdateValidator(nameof(MyUpdate))]
+        public void ValidateMyUpdate(string arg)
+        {
+            if (arg == "invalid")
+            {
+                throw new ApplicationFailureException("invalid");
+            }
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>();
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        var badUpdateHandle = await handle.StartUpdateAsync(wf => wf.MyUpdate("invalid"));
+
+        try
+        {
+            await badUpdateHandle.GetResultAsync();
+            throw new Exception("Expected to fail");
+        }
+        catch (WorkflowUpdateFailedException)
+        {
+            // Expected
+        }
+
+        var goodUpdateHandle = await handle.StartUpdateAsync(wf => wf.MyUpdate("valid"));
+        Assert.Equal("hi", await goodUpdateHandle.GetResultAsync());
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/client_interceptor/feature.cs b/features/update/client_interceptor/feature.cs
new file mode 100644
index 00000000..1b6ff358
--- /dev/null
+++ b/features/update/client_interceptor/feature.cs
@@ -0,0 +1,70 @@
+namespace update.client_interceptor;
+
+using Temporalio.Client.Interceptors;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class MyOutboundClientInterceptor : IClientInterceptor
+{
+    public ClientOutboundInterceptor InterceptClient(
+        ClientOutboundInterceptor nextInterceptor) =>
+        new ClientOutbound(nextInterceptor);
+
+    private sealed class ClientOutbound : ClientOutboundInterceptor
+    {
+        public ClientOutbound(ClientOutboundInterceptor next) : base(next)
+        {
+        }
+
+        public override Task<WorkflowUpdateHandle<TResult>> StartWorkflowUpdateAsync<TResult>(
+            StartWorkflowUpdateInput input)
+        {
+            var newInput = input with { Args = new object[] { "intercepted" } };
+            return base.StartWorkflowUpdateAsync<TResult>(newInput);
+        }
+    }
+}
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public Task RunAsync() => Workflow.WaitConditionAsync(() => shutdown);
+
+        [WorkflowUpdate]
+        public async Task<string> MyUpdate(string arg)
+        {
+            shutdown = true;
+            return arg;
+        }
+    }
+
+    public void ConfigureClient(Runner runner, TemporalClientConnectOptions options)
+    {
+        options.Interceptors = new[] { new MyOutboundClientInterceptor() };
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options)
+    {
+        options.AddWorkflow<MyWorkflow>();
+    }
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        Assert.Equal("intercepted", await handle.ExecuteUpdateAsync(wf => wf.MyUpdate("Enchicat")));
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/deduplication/feature.cs b/features/update/deduplication/feature.cs
new file mode 100644
index 00000000..4337b56f
--- /dev/null
+++ b/features/update/deduplication/feature.cs
@@ -0,0 +1,52 @@
+namespace update.deduplication;
+
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public Task RunAsync() => Workflow.WaitConditionAsync(() => shutdown);
+
+        [WorkflowUpdate]
+        public async Task<int> MyUpdate(bool exit)
+        {
+            shutdown = exit;
+            Count++;
+            return Count;
+        }
+
+        [WorkflowQuery]
+        public int Count { get; set; }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options)
+    {
+        options.AddWorkflow<MyWorkflow>();
+    }
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        var updateId = "myid";
+        await handle.ExecuteUpdateAsync(wf => wf.MyUpdate(false), new() {UpdateID = updateId});
+        Assert.Equal(1, await handle.QueryAsync(wf => wf.Count));
+        await handle.ExecuteUpdateAsync(wf => wf.MyUpdate(false), new() {UpdateID = updateId});
+        Assert.Equal(1, await handle.QueryAsync(wf => wf.Count));
+        await handle.ExecuteUpdateAsync(wf => wf.MyUpdate(true));
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/non_durable_reject/feature.cs b/features/update/non_durable_reject/feature.cs
new file mode 100644
index 00000000..de63b38b
--- /dev/null
+++ b/features/update/non_durable_reject/feature.cs
@@ -0,0 +1,71 @@
+using Temporalio.Api.Enums.V1;
+
+namespace update.non_durable_reject;
+
+using Temporalio.Exceptions;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public Task RunAsync() => Workflow.WaitConditionAsync(() => shutdown);
+
+        [WorkflowUpdate]
+        public async Task<string> MyUpdate(string _)
+        {
+            shutdown = true;
+            return "hi";
+        }
+
+        [WorkflowUpdateValidator(nameof(MyUpdate))]
+        public void ValidateMyUpdate(string arg)
+        {
+            if (arg == "invalid")
+            {
+                throw new ApplicationFailureException("invalid");
+            }
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>();
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        for (var i = 0; i < 5; i++)
+        {
+            try
+            {
+                await handle.ExecuteUpdateAsync(wf => wf.MyUpdate("invalid"));
+            }
+            catch (WorkflowUpdateFailedException)
+            {
+                // Expected
+            }
+        }
+
+        await handle.ExecuteUpdateAsync(wf => wf.MyUpdate("valid"));
+        await handle.GetResultAsync();
+
+        // Verify there are no rejections written to history
+        var history = await handle.FetchHistoryAsync();
+        Assert.DoesNotContain(history.Events,
+            e => e.EventType == EventType.WorkflowExecutionUpdateRejected);
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/self/feature.cs b/features/update/self/feature.cs
new file mode 100644
index 00000000..b97b3b26
--- /dev/null
+++ b/features/update/self/feature.cs
@@ -0,0 +1,62 @@
+namespace update.self;
+
+using Temporalio.Activities;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public async Task RunAsync()
+        {
+            await Workflow.ExecuteActivityAsync((MyActivities act) => act.MyActivity(),
+                new() { StartToCloseTimeout = TimeSpan.FromSeconds(5) });
+            await Workflow.WaitConditionAsync(() => shutdown);
+        }
+
+        [WorkflowUpdate]
+        public async Task UpdateMe()
+        {
+            shutdown = true;
+        }
+    }
+
+    class MyActivities
+    {
+        public MyActivities(ITemporalClient client)
+        {
+            Client = client;
+        }
+
+        private ITemporalClient Client { get; }
+
+        [Activity]
+        public async Task MyActivity()
+        {
+            var handle =
+                Client.GetWorkflowHandle<MyWorkflow>(ActivityExecutionContext.Current.Info
+                    .WorkflowId);
+            await handle.ExecuteUpdateAsync(wf => wf.UpdateMe());
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>().AddAllActivities<MyActivities>(new(runner.Client));
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+        await handle.ExecuteUpdateAsync(wf => wf.UpdateMe());
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/task_failure/feature.cs b/features/update/task_failure/feature.cs
new file mode 100644
index 00000000..8f18257d
--- /dev/null
+++ b/features/update/task_failure/feature.cs
@@ -0,0 +1,87 @@
+namespace update.task_failure;
+
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+using Temporalio.Exceptions;
+
+class Feature : IFeature
+{
+    // Don't do this. We do here because we need to fail the workflow task a controlled # of times.
+    static int failCounter;
+
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public async Task RunAsync()
+        {
+            await Workflow.WaitConditionAsync(() => shutdown);
+        }
+
+        [WorkflowUpdate]
+        public async Task UpdateMe()
+        {
+            if (failCounter < 2)
+            {
+                failCounter++;
+                throw new Exception("I'll fail the task");
+            }
+
+            throw new ApplicationFailureException("I'll fail the update");
+        }
+
+        [WorkflowUpdate]
+        public async Task ThrowOrEnd(bool _)
+        {
+            shutdown = true;
+        }
+
+        [WorkflowUpdateValidator(nameof(ThrowOrEnd))]
+        public void ValidateUpdate(bool doShutdown)
+        {
+            if (!doShutdown)
+            {
+                throw new Exception("this will fail validation, not task");
+            }
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>();
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+        try
+        {
+            await handle.ExecuteUpdateAsync(wf => wf.UpdateMe());
+        }
+        catch (WorkflowUpdateFailedException)
+        {
+            // Expected
+        }
+
+        try
+        {
+            await handle.ExecuteUpdateAsync(wf => wf.ThrowOrEnd(false));
+        }
+        catch (WorkflowUpdateFailedException)
+        {
+            // Expected
+        }
+
+        await handle.ExecuteUpdateAsync(wf => wf.ThrowOrEnd(true));
+        await handle.GetResultAsync();
+
+        Assert.Equal(2, failCounter);
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/validation_replay/feature.cs b/features/update/validation_replay/feature.cs
new file mode 100644
index 00000000..700f2a7e
--- /dev/null
+++ b/features/update/validation_replay/feature.cs
@@ -0,0 +1,68 @@
+namespace update.validation_replay;
+
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+using Temporalio.Exceptions;
+
+class Feature : IFeature
+{
+    // Don't do this. We do here because we need to fail the workflow task a controlled # of times.
+    static int failCounter;
+
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public async Task RunAsync()
+        {
+            await Workflow.WaitConditionAsync(() => shutdown);
+        }
+
+        [WorkflowUpdate]
+        public async Task UpdateMe()
+        {
+            if (failCounter == 0)
+            {
+                failCounter++;
+                throw new Exception("I'll fail the task");
+            }
+
+            shutdown = true;
+        }
+
+        [WorkflowUpdateValidator(nameof(UpdateMe))]
+        public void ValidateUpdate()
+        {
+            // We will start rejecting things once we've failed the task, and hence are now
+            // replaying. The fact that the workflow completes demonstrates that even though the
+            // validator would "reject" on replay, it doesn't even run, since the update has already
+            // been accepted.
+            if (failCounter > 1)
+            {
+                throw new Exception("I would reject if I ever ran");
+            }
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>();
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        await handle.ExecuteUpdateAsync(wf => wf.UpdateMe());
+        await handle.GetResultAsync();
+
+        Assert.Equal(1, failCounter);
+
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/features/update/worker_restart/feature.cs b/features/update/worker_restart/feature.cs
new file mode 100644
index 00000000..42dc4281
--- /dev/null
+++ b/features/update/worker_restart/feature.cs
@@ -0,0 +1,65 @@
+namespace update.worker_restart;
+
+using Temporalio.Activities;
+using Temporalio.Client;
+using Temporalio.Features.Harness;
+using Temporalio.Worker;
+using Temporalio.Workflows;
+
+class Feature : IFeature
+{
+    // Don't do this. We do here because we need to fail the workflow task a controlled # of times.
+    static SemaphoreSlim activityStarted = new(0);
+    static SemaphoreSlim finishActivity = new(0);
+
+    [Workflow]
+    class MyWorkflow
+    {
+        private bool shutdown;
+
+        [WorkflowRun]
+        public async Task RunAsync()
+        {
+            await Workflow.WaitConditionAsync(() => shutdown);
+        }
+
+        [WorkflowUpdate]
+        public async Task UpdateMe()
+        {
+            await Workflow.ExecuteActivityAsync((MyActivities act) => act.MyActivity(),
+                new() { StartToCloseTimeout = TimeSpan.FromSeconds(30) });
+            shutdown = true;
+        }
+    }
+
+    class MyActivities
+    {
+        [Activity]
+        public async Task MyActivity()
+        {
+            activityStarted.Release();
+            await finishActivity.WaitAsync(ActivityExecutionContext.Current.CancellationToken);
+        }
+    }
+
+    public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) =>
+        options.AddWorkflow<MyWorkflow>().AddAllActivities(new MyActivities());
+
+    public async Task<WorkflowHandle?> ExecuteAsync(Runner runner)
+    {
+        await runner.SkipIfUpdateNotSupportedAsync();
+        var handle = await runner.Client.StartWorkflowAsync(
+            (MyWorkflow wf) => wf.RunAsync(),
+            runner.NewWorkflowOptions());
+
+        var updateTask = handle.ExecuteUpdateAsync(wf => wf.UpdateMe());
+
+        await activityStarted.WaitAsync();
+        await runner.StopWorker();
+        runner.StartWorker();
+        finishActivity.Release();
+
+        await updateTask;
+        return handle;
+    }
+}
\ No newline at end of file
diff --git a/harness/dotnet/Temporalio.Features.Harness/App.cs b/harness/dotnet/Temporalio.Features.Harness/App.cs
index b1b99ec4..ac1d91cf 100644
--- a/harness/dotnet/Temporalio.Features.Harness/App.cs
+++ b/harness/dotnet/Temporalio.Features.Harness/App.cs
@@ -11,11 +11,13 @@ public static class App
 {
     private static readonly Option<string> serverOption = new(
         name: "--server",
-        description: "The host:port of the server") { IsRequired = true };
+        description: "The host:port of the server")
+    { IsRequired = true };
 
     private static readonly Option<string> namespaceOption = new(
         name: "--namespace",
-        description: "The namespace to use") { IsRequired = true };
+        description: "The namespace to use")
+    { IsRequired = true };
 
     private static readonly Option<FileInfo?> clientCertPathOption = new(
         name: "--client-cert-path",
@@ -34,9 +36,11 @@ public static class App
             {
                 throw new ArgumentException("Feature must be dir + ':' + task queue");
             }
+
             return (pieces[0], pieces[1]);
         }).ToList(),
-        description: "Features as dir + ':' + task queue") { Arity = ArgumentArity.OneOrMore };
+        description: "Features as dir + ':' + task queue")
+    { Arity = ArgumentArity.OneOrMore };
 
     /// <summary>
     /// Run this harness with the given args.
@@ -60,50 +64,60 @@ private static Command CreateCommand()
     private static async Task RunCommandAsync(InvocationContext ctx)
     {
         // Create logger factory
-        using var loggerFactory = LoggerFactory.Create(builder => builder.AddSimpleConsole(options =>
-        {
-            options.IncludeScopes = true;
-            options.SingleLine = true;
-            options.TimestampFormat = "HH:mm:ss ";
-        }));
+        using var loggerFactory = LoggerFactory.Create(builder => builder.AddSimpleConsole(
+            options =>
+            {
+                options.IncludeScopes = true;
+                options.SingleLine = true;
+                options.TimestampFormat = "HH:mm:ss ";
+            }));
         var logger = loggerFactory.CreateLogger(typeof(App));
 
         // Connect a client
-        var client = await TemporalClient.ConnectAsync(new(ctx.ParseResult.GetValueForOption(serverOption)!)
-        {
-            Namespace = ctx.ParseResult.GetValueForOption(namespaceOption)!,
-            Tls = ctx.ParseResult.GetValueForOption(clientCertPathOption) is not {} certPath ? null : new()
+        var clientOptions =
+            new TemporalClientConnectOptions(ctx.ParseResult.GetValueForOption(serverOption)!)
             {
-                ClientCert = File.ReadAllBytes(certPath.FullName),
-                ClientPrivateKey = File.ReadAllBytes(ctx.ParseResult.GetValueForOption(clientKeyPathOption)?.FullName ??
-                    throw new ArgumentException("Missing key with cert")),
-            },
-        });
+                Namespace = ctx.ParseResult.GetValueForOption(namespaceOption)!,
+                Tls = ctx.ParseResult.GetValueForOption(clientCertPathOption) is not { } certPath
+                    ? null
+                    : new()
+                    {
+                        ClientCert = File.ReadAllBytes(certPath.FullName),
+                        ClientPrivateKey = File.ReadAllBytes(
+                            ctx.ParseResult.GetValueForOption(clientKeyPathOption)?.FullName ??
+                            throw new ArgumentException("Missing key with cert"))
+                    }
+            };
 
         // Go over each feature, calling the runner for it
         var failureCount = 0;
         foreach (var (dir, taskQueue) in ctx.ParseResult.GetValueForArgument(featuresArgument))
         {
-            var feature = PreparedFeature.AllFeatures.SingleOrDefault(feature => feature.Dir == dir) ??
+            var feature =
+                PreparedFeature.AllFeatures.SingleOrDefault(feature => feature.Dir == dir) ??
                 throw new InvalidOperationException($"Unable to find feature for dir {dir}");
             try
             {
-                await new Runner(client, taskQueue, feature, loggerFactory).RunAsync(ctx.GetCancellationToken());
+                await new Runner(clientOptions, taskQueue, feature, loggerFactory).RunAsync(
+                    ctx.GetCancellationToken());
             }
             catch (TestSkippedException e)
             {
-                logger.LogInformation("Feature {Feature} skipped: {Reason}", feature.Dir, e.Message);
+                logger.LogInformation("Feature {Feature} skipped: {Reason}", feature.Dir,
+                    e.Message);
             }
-            catch(Exception e)
+            catch (Exception e)
             {
                 logger.LogError(e, "Feature {Feature} failed", feature.Dir);
                 failureCount++;
             }
         }
+
         if (failureCount > 0)
         {
             throw new InvalidOperationException($"{failureCount} feature(s) failed");
         }
+
         logger.LogInformation("All features passed");
     }
 }
\ No newline at end of file
diff --git a/harness/dotnet/Temporalio.Features.Harness/IFeature.cs b/harness/dotnet/Temporalio.Features.Harness/IFeature.cs
index 3f50ef2b..c04fa05c 100644
--- a/harness/dotnet/Temporalio.Features.Harness/IFeature.cs
+++ b/harness/dotnet/Temporalio.Features.Harness/IFeature.cs
@@ -8,6 +8,13 @@ namespace Temporalio.Features.Harness;
 /// </summary>
 public interface IFeature
 {
+    /// <summary>
+    /// Configure any extra client options.
+    /// </summary>
+    /// <param name="runner">Current runner.</param>
+    /// <param name="options">Options to mutate.</param>
+    void ConfigureClient(Runner runner, TemporalClientConnectOptions options) { }
+
     /// <summary>
     /// Configure the worker options. This is where workflows and activities
     /// should be added.
diff --git a/harness/dotnet/Temporalio.Features.Harness/Runner.cs b/harness/dotnet/Temporalio.Features.Harness/Runner.cs
index dad615cb..925768e3 100644
--- a/harness/dotnet/Temporalio.Features.Harness/Runner.cs
+++ b/harness/dotnet/Temporalio.Features.Harness/Runner.cs
@@ -3,7 +3,6 @@ namespace Temporalio.Features.Harness;
 using Temporalio.Client;
 using Temporalio.Exceptions;
 using Temporalio.Worker;
-using Temporalio.Workflows;
 
 /// <summary>
 /// Runner for running features.
@@ -11,22 +10,56 @@ namespace Temporalio.Features.Harness;
 public class Runner
 {
     private bool? maybeUpdateSupported;
+    private ITemporalClient? client;
+    private WorkerState? workerState;
+    private CancellationToken? runCancelToken;
+
+    class WorkerState
+    {
+        private readonly CancellationTokenSource workerStopper;
+        private readonly Task workerTask;
+
+        public WorkerState(
+            CancellationTokenSource workerStopper,
+            TemporalWorker worker
+        )
+        {
+            this.workerStopper = workerStopper;
+            workerTask = Task.Run(async () => await worker.ExecuteAsync(workerStopper.Token));
+        }
+
+        public async Task StopAndWait()
+        {
+            workerStopper.Cancel();
+            try
+            {
+                await workerTask;
+            }
+            catch (OperationCanceledException)
+            {
+                // No good option here to not get an exception thrown when waiting on potentially
+                // different worker instances.
+            }
+        }
+    }
+
 
     internal Runner(
-        ITemporalClient client,
+        TemporalClientConnectOptions clientConnectOptions,
         string taskQueue,
         PreparedFeature feature,
         ILoggerFactory loggerFactory)
     {
-        Client = client;
         PreparedFeature = feature;
-        Feature = (IFeature)Activator.CreateInstance(PreparedFeature.FeatureType, true)!;
         Logger = loggerFactory.CreateLogger(PreparedFeature.FeatureType);
+        Feature = (IFeature)Activator.CreateInstance(PreparedFeature.FeatureType, true)!;
+
+        ClientOptions = clientConnectOptions;
+        Feature.ConfigureClient(this, clientConnectOptions);
         WorkerOptions = new(taskQueue) { LoggerFactory = loggerFactory };
-        Feature.ConfigureWorker(this, WorkerOptions);
     }
 
-    public ITemporalClient Client { get; private init; }
+    public ITemporalClient Client => client!;
 
     public IFeature Feature { get; private init; }
 
@@ -34,6 +67,8 @@ internal Runner(
 
     public PreparedFeature PreparedFeature { get; private init; }
 
+    public TemporalClientConnectOptions ClientOptions { get; private init; }
+
     public TemporalWorkerOptions WorkerOptions { get; private init; }
 
     /// <summary>
@@ -43,21 +78,27 @@ internal Runner(
     /// <returns></returns>
     public async Task RunAsync(CancellationToken cancellationToken)
     {
-        // Run inside worker
         Logger.LogInformation("Executing feature {Feature}", PreparedFeature.Dir);
-        using var worker = new TemporalWorker(Client, WorkerOptions);
-        await worker.ExecuteAsync(async () =>
+        runCancelToken = cancellationToken;
+        client = await TemporalClient.ConnectAsync(ClientOptions);
+        Feature.ConfigureWorker(this, WorkerOptions);
+        StartWorker();
+
+        var run = await Feature.ExecuteAsync(this);
+        if (run == null)
         {
-            var run = await Feature.ExecuteAsync(this);
-            if (run == null)
-            {
-                Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir);
-                return;
-            }
-            Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir);
-            await Feature.CheckResultAsync(this, run);
-            await Feature.CheckHistoryAsync(this, run);
-        }, cancellationToken);
+            Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir);
+            return;
+        }
+
+        Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir);
+        await Feature.CheckResultAsync(this, run);
+        await Feature.CheckHistoryAsync(this, run);
+
+        if (workerState != null)
+        {
+            await workerState.StopAndWait();
+        }
     }
 
     /// <summary>
@@ -67,8 +108,9 @@ await worker.ExecuteAsync(async () =>
     public Task<WorkflowHandle> StartSingleParameterlessWorkflowAsync()
     {
         var workflow = WorkerOptions.Workflows.SingleOrDefault() ??
-            throw new InvalidOperationException("Must have a single workflow");
-        return Client.StartWorkflowAsync(workflow.Name!, Array.Empty<object?>(), NewWorkflowOptions());
+                       throw new InvalidOperationException("Must have a single workflow");
+        return Client.StartWorkflowAsync(workflow.Name!, Array.Empty<object?>(),
+            NewWorkflowOptions());
     }
 
     public WorkflowOptions NewWorkflowOptions() =>
@@ -96,9 +138,11 @@ public async Task CheckCurrentHistoryAsync(WorkflowHandle handle)
         {
             replayerOptions.AddWorkflow(workflow);
         }
+
         try
         {
-            await new WorkflowReplayer(replayerOptions).ReplayWorkflowAsync(await handle.FetchHistoryAsync());
+            await new WorkflowReplayer(replayerOptions).ReplayWorkflowAsync(
+                await handle.FetchHistoryAsync());
         }
         catch (Exception e)
         {
@@ -117,6 +161,7 @@ public async Task SkipIfUpdateNotSupportedAsync()
         {
             return;
         }
+
         throw new TestSkippedException("Update not supported");
     }
 
@@ -140,6 +185,7 @@ public async Task SkipIfAsyncUpdateNotSupportedAsync()
         {
             return;
         }
+
         throw new TestSkippedException("Async update not supported");
     }
 
@@ -152,6 +198,36 @@ public Task<bool> CheckAsyncUpdateSupportedAsync() =>
             Client.GetWorkflowHandle("does-not-exist").StartUpdateAsync(
                 "does-not-exist", Array.Empty<object?>()));
 
+    /// <summary>
+    /// Start the worker.
+    /// </summary>
+    public void StartWorker()
+    {
+        if (workerState != null)
+        {
+            throw new InvalidOperationException("Worker already started");
+        }
+
+        workerState = new(
+            CancellationTokenSource.CreateLinkedTokenSource(
+                runCancelToken ?? CancellationToken.None),
+            new TemporalWorker(Client, WorkerOptions)
+        );
+    }
+
+
+    /// <summary>
+    /// Stop the worker.
+    /// </summary>
+    public async Task StopWorker()
+    {
+        if (workerState != null)
+        {
+            await workerState.StopAndWait();
+            workerState = null;
+        }
+    }
+
     private async Task<bool> CheckUpdateSupportCallAsync(Func<Task> failingFunc)
     {
         // Don't care about races
@@ -176,13 +252,15 @@ private async Task<bool> CheckUpdateSupportCallAsync(Func<Task> failingFunc)
                 maybeUpdateSupported = true;
             }
             catch (RpcException e) when (
-                e.Code == RpcException.StatusCode.Unimplemented || e.Code == RpcException.StatusCode.PermissionDenied)
+                e.Code == RpcException.StatusCode.Unimplemented ||
+                e.Code == RpcException.StatusCode.PermissionDenied)
             {
                 // Not implemented or permission denied means not supported,
                 // everything else is an error
                 maybeUpdateSupported = false;
             }
         }
+
         return maybeUpdateSupported.Value;
     }
 }
\ No newline at end of file