diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index c945ec9b..1a692860 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -232,7 +232,7 @@ jobs: - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0 - uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5 - run: dotnet build - - run: dotnet test + - run: dotnet test tests/dotnet/Temporalio.Features.Harness.Tests.csproj build-ruby: strategy: diff --git a/dotnet.csproj b/dotnet.csproj index cc990406..9d4f4baa 100644 --- a/dotnet.csproj +++ b/dotnet.csproj @@ -48,6 +48,7 @@ + - \ No newline at end of file + diff --git a/harness/dotnet/Temporalio.Features.Harness/Runner.cs b/harness/dotnet/Temporalio.Features.Harness/Runner.cs index 03043e72..c27bd176 100644 --- a/harness/dotnet/Temporalio.Features.Harness/Runner.cs +++ b/harness/dotnet/Temporalio.Features.Harness/Runner.cs @@ -91,20 +91,35 @@ public async Task RunAsync(CancellationToken cancellationToken) Feature.ConfigureWorker(this, WorkerOptions); StartWorker(); - var run = await Feature.ExecuteAsync(this); - if (run == null) + var featureFailed = false; + try { - 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); + var run = await Feature.ExecuteAsync(this); + if (run == null) + { + Logger.LogInformation("Feature {Feature} returned null", PreparedFeature.Dir); + return; + } - if (workerState != null) + Logger.LogInformation("Checking result of feature {Feature}", PreparedFeature.Dir); + await Feature.CheckResultAsync(this, run); + await Feature.CheckHistoryAsync(this, run); + } + catch { - await workerState.StopAndWait(); + featureFailed = true; + throw; + } + finally + { + try + { + await StopWorker(); + } + catch (Exception e) when (featureFailed) + { + Logger.LogError(e, "Failed stopping worker for feature {Feature}", PreparedFeature.Dir); + } } } diff --git a/tests/dotnet/RunnerTests.cs b/tests/dotnet/RunnerTests.cs new file mode 100644 index 00000000..66ed263c --- /dev/null +++ b/tests/dotnet/RunnerTests.cs @@ -0,0 +1,158 @@ +namespace Temporalio.Features.Harness.Tests; + +using System.Reflection; +using Microsoft.Extensions.Logging.Abstractions; +using Temporalio.Activities; +using Temporalio.Client; +using Temporalio.Testing; +using Temporalio.Worker; +using Xunit; + +public class RunnerTests : IAsyncLifetime +{ + private WorkflowEnvironment environment = null!; + + public async Task InitializeAsync() => + environment = await WorkflowEnvironment.StartLocalAsync(); + + public async Task DisposeAsync() => await environment.DisposeAsync(); + + public enum Outcome { NoWorkflow, ExecuteFailure, ResultFailure, HistoryFailure, Success } + public enum WorkerLifecycle { Running, Stopped, Restarted, Faulted } + + [Theory] + [InlineData(Outcome.NoWorkflow, WorkerLifecycle.Running)] + [InlineData(Outcome.ExecuteFailure, WorkerLifecycle.Running)] + [InlineData(Outcome.ResultFailure, WorkerLifecycle.Running)] + [InlineData(Outcome.HistoryFailure, WorkerLifecycle.Running)] + [InlineData(Outcome.Success, WorkerLifecycle.Running)] + [InlineData(Outcome.NoWorkflow, WorkerLifecycle.Stopped)] + [InlineData(Outcome.NoWorkflow, WorkerLifecycle.Restarted)] + [InlineData(Outcome.ExecuteFailure, WorkerLifecycle.Faulted)] + [InlineData(Outcome.Success, WorkerLifecycle.Faulted)] + public async Task RunAsyncStopsWorker(Outcome outcome, WorkerLifecycle workerLifecycle) + { + var runner = new Runner( + new(environment.Client.Connection.Options.TargetHost!) + { + Namespace = environment.Client.Options.Namespace, + }, + Guid.NewGuid().ToString(), + null, + new(typeof(TestFeature)), + NullLoggerFactory.Instance, + null); + var feature = (TestFeature)runner.Feature; + feature.Outcome = outcome; + feature.WorkerLifecycle = workerLifecycle; + + try + { + var error = await Record.ExceptionAsync(() => runner.RunAsync(CancellationToken.None)); + if (outcome is Outcome.ExecuteFailure or Outcome.ResultFailure or Outcome.HistoryFailure) + { + Assert.Same(feature.Failure, error); + } + else if (workerLifecycle == WorkerLifecycle.Faulted) + { + Assert.Same(feature.WorkerFailure, error); + } + else + { + Assert.Null(error); + } + + if (workerLifecycle == WorkerLifecycle.Faulted) + { + try + { + await feature.WorkerTask.WaitAsync(TimeSpan.FromSeconds(5)); + } + catch (OperationCanceledException) + { + } + } + else + { + Assert.True(feature.WorkerTask.IsCompleted, "Feature worker is still running"); + } + Assert.Equal(outcome != Outcome.NoWorkflow && outcome != Outcome.ExecuteFailure, feature.ResultChecked); + Assert.Equal(outcome is Outcome.HistoryFailure or Outcome.Success, feature.HistoryChecked); + + if (workerLifecycle != WorkerLifecycle.Faulted) + { + runner.StartWorker(); + } + } + finally + { + try + { + await runner.StopWorker(); + } + catch (Exception e) when (e == feature.WorkerFailure) + { + } + } + } + + private class TestFeature : IFeature + { + public Outcome Outcome { get; set; } + public WorkerLifecycle WorkerLifecycle { get; set; } + public Exception Failure { get; } = new InvalidOperationException("Feature failed"); + public Exception WorkerFailure { get; } = new InvalidOperationException("Worker failed"); + public Task WorkerTask { get; private set; } = null!; + public bool ResultChecked { get; private set; } + public bool HistoryChecked { get; private set; } + + public void ConfigureWorker(Runner runner, TemporalWorkerOptions options) => + options.AddAllActivities(this); + + [Activity] + public string Echo(string value) => value; + + public async Task ExecuteAsync(Runner runner) + { + if (WorkerLifecycle is WorkerLifecycle.Stopped or WorkerLifecycle.Restarted) + { + await runner.StopWorker(); + } + if (WorkerLifecycle == WorkerLifecycle.Restarted) + { + runner.StartWorker(); + } + + // Capture the task so clearing runner state alone cannot satisfy the cleanup assertion. + var state = typeof(Runner).GetField("workerState", BindingFlags.Instance | BindingFlags.NonPublic)! + .GetValue(runner); + WorkerTask = state == null ? Task.CompletedTask : + (Task)state.GetType().GetField("workerTask", BindingFlags.Instance | BindingFlags.NonPublic)! + .GetValue(state)!; + if (WorkerLifecycle == WorkerLifecycle.Faulted) + { + // Inject a worker failure without depending on a particular SDK poller failure mode. + state!.GetType().GetField("workerTask", BindingFlags.Instance | BindingFlags.NonPublic)! + .SetValue(state, Task.FromException(WorkerFailure)); + } + + if (Outcome == Outcome.ExecuteFailure) + { + throw Failure; + } + return Outcome == Outcome.NoWorkflow ? null : runner.Client.GetWorkflowHandle("unused"); + } + + public Task CheckResultAsync(Runner runner, WorkflowHandle handle) + { + ResultChecked = true; + return Outcome == Outcome.ResultFailure ? Task.FromException(Failure) : Task.CompletedTask; + } + + public Task CheckHistoryAsync(Runner runner, WorkflowHandle handle) + { + HistoryChecked = true; + return Outcome == Outcome.HistoryFailure ? Task.FromException(Failure) : Task.CompletedTask; + } + } +} diff --git a/tests/dotnet/Temporalio.Features.Harness.Tests.csproj b/tests/dotnet/Temporalio.Features.Harness.Tests.csproj new file mode 100644 index 00000000..fd36d824 --- /dev/null +++ b/tests/dotnet/Temporalio.Features.Harness.Tests.csproj @@ -0,0 +1,16 @@ + + + net8.0 + enable + enable + true + false + true + + + + + + + +