Add Durable Execution Testing Library

[GarrettBeatty]

Issue #, if available:

Description of changes:

Adds Amazon.Lambda.DurableExecution.Testing (preview) — test durable workflows without deploying to AWS. You code against IDurableTestRunner<TInput, TOutput> and the same test runs unchanged against the in-memory DurableTestRunner (fast, no AWS) or the CloudDurableTestRunner (a deployed function).

Basic workflow

Construct a runner with your handler, call RunAsync, and assert on the TestResult — including individual steps:

await using var runner = new DurableTestRunner<int, int>(
    handler: async (input, ctx) =>
    {
        var doubled = await ctx.StepAsync(async (_, _) => input * 2, name: "double");
        return await ctx.StepAsync(async (_, _) => doubled + 10, name: "add_ten");
    });

var result = await runner.RunAsync(5);

result.EnsureSucceeded();
Assert.Equal(20, result.Result);

var doubleStep = result.GetStep("double");
Assert.Equal(OperationKind.Step, doubleStep.Kind);
Assert.Equal(OperationStatus.Succeeded, doubleStep.Status);
Assert.Equal(10, doubleStep.GetResult<int>());

Time-skipping

By default waits and retry backoffs complete immediately, so a 30-day wait runs in milliseconds — and is still recorded as a step you can assert on:

await ctx.WaitAsync(TimeSpan.FromDays(30), name: "long_wait");
// ...
var wait = result.GetStep("long_wait");
Assert.Equal(OperationKind.Wait, wait.Kind);

Set TestRunnerOptions.SkipTime = false to assert on real durations.

Callbacks

For workflows that suspend on a callback, use the two-call pattern: StartAsync runs until suspension, WaitForCallbackAsync returns the pending callback id, you send a result, then WaitForResultAsync drives it to completion:

var arn        = await runner.StartAsync("request-1");
var callbackId = await runner.WaitForCallbackAsync(arn, name: "approval");

await runner.SendCallbackSuccessAsync(callbackId, "yes");
var result = await runner.WaitForResultAsync(arn);

result.EnsureSucceeded();
Assert.Equal("approved: yes", result.Result);

SendCallbackFailureAsync and SendCallbackHeartbeatAsync are also available.

Sibling functions

When a workflow calls ctx.InvokeAsync, register the target on the runner so it resolves in-process:

// A plain (non-durable) Lambda handler
runner.RegisterFunction<PaymentRequest, PaymentResult>(
    "process-payment",
    (req, _) => Task.FromResult(new PaymentResult { Status = $"approved-{req.Amount}" }));

// A durable sibling runs in its own nested runner with its own steps
runner.RegisterDurableFunction<PaymentRequest, PaymentResult>(
    "audit",
    async (req, childCtx) => await childCtx.StepAsync(/* ... */));

Testing against a deployed function

CloudDurableTestRunner implements the same IDurableTestRunner interface against a real deployed durable function, so portable tests run unchanged on either backend:

await using var runner = new CloudDurableTestRunner<Order, OrderResult>(
    functionArn: "arn:aws:lambda:us-east-1:123456789012:function:order-processor:live");

var result = await runner.RunAsync(new Order(/* ... */));
result.EnsureSucceeded();

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.

[GarrettBeatty]

i dont think this change requires a new version to be released in order for the durableexecution.testing package to build since testing package uses a project refrerence right

[GarrettBeatty]

had to manually set as -preview here as well. i will also do an override when doing the first release to make it be preview.

without setting it here, build fails because a non preview package would reference a preview package (durable execution)