perf(runtime): split trigger evals from the blocking pool; bounded, deadline-aware execution
This commit is contained in:
Joseph Doherty
@@ -0,0 +1,469 @@
|
||||
using Akka.Actor;
|
||||
using Akka.Event;
|
||||
using Akka.TestKit;
|
||||
using Akka.TestKit.Xunit2;
|
||||
using Microsoft.CodeAnalysis.CSharp.Scripting;
|
||||
using Microsoft.CodeAnalysis.Scripting;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Messages.ScriptExecution;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Types.Flattening;
|
||||
using ZB.MOM.WW.ScadaBridge.Commons.Types.Scripts;
|
||||
using ZB.MOM.WW.ScadaBridge.HealthMonitoring;
|
||||
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Actors;
|
||||
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Scripts;
|
||||
using ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.TestSupport;
|
||||
|
||||
namespace ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors;
|
||||
|
||||
/// <summary>
|
||||
/// WP3.1 supervision-parity set (design memo §4, seven pins) — the reworked successor to
|
||||
/// <c>ExecutionActorTests</c>.
|
||||
///
|
||||
/// <para>WP3.1 eliminated the short-lived <c>ScriptExecutionActor</c> and
|
||||
/// <c>AlarmExecutionActor</c>: neither had a <c>Receive</c> handler, a <c>PostStop</c>, or any
|
||||
/// state, and neither's <c>IActorRef</c> was ever a message target — the entire lifecycle lived
|
||||
/// in a detached task. Runs are now launched directly by the coordinator via
|
||||
/// <see cref="ScriptRunLauncher"/>. These tests pin every behaviour the removed actors
|
||||
/// provided onto its replacement: exception and timeout containment, the Ask reply, the
|
||||
/// completion notification, one DI scope per run, the audit ParentExecutionId threading, and
|
||||
/// the supervision outcome (coordinator unaffected — no stop, no restart).</para>
|
||||
/// </summary>
|
||||
public class ScriptRunLauncherParityTests : TestKit, IDisposable
|
||||
{
|
||||
private readonly SharedScriptLibrary _sharedLibrary;
|
||||
private readonly ScriptCompilationService _compilationService;
|
||||
|
||||
/// <summary>Own pool per test class (#18 seam), so a wedged body cannot strand the process-wide one.</summary>
|
||||
private readonly ScriptExecutionScheduler _scheduler = new(4);
|
||||
|
||||
public ScriptRunLauncherParityTests()
|
||||
{
|
||||
_compilationService = new ScriptCompilationService(
|
||||
NullLogger<ScriptCompilationService>.Instance);
|
||||
_sharedLibrary = new SharedScriptLibrary(
|
||||
_compilationService, NullLogger<SharedScriptLibrary>.Instance);
|
||||
}
|
||||
|
||||
void IDisposable.Dispose()
|
||||
{
|
||||
Shutdown();
|
||||
_scheduler.Dispose();
|
||||
}
|
||||
|
||||
// ── helpers ──────────────────────────────────────────────────────────────────
|
||||
|
||||
private static Script<object?> CompileScript(string code)
|
||||
{
|
||||
var scriptOptions = ScriptOptions.Default
|
||||
.WithReferences(typeof(object).Assembly, typeof(Enumerable).Assembly,
|
||||
typeof(RunLauncherHooks).Assembly)
|
||||
.WithImports("System", "System.Collections.Generic", "System.Linq", "System.Threading.Tasks");
|
||||
var script = CSharpScript.Create<object?>(code, scriptOptions, typeof(ScriptGlobals));
|
||||
script.Compile();
|
||||
return script;
|
||||
}
|
||||
|
||||
private static SiteRuntimeOptions Options(int timeoutSeconds = 30, int graceMs = 30000)
|
||||
=> new()
|
||||
{
|
||||
MaxScriptCallDepth = 10,
|
||||
ScriptExecutionTimeoutSeconds = timeoutSeconds,
|
||||
StuckScriptGraceMs = graceMs
|
||||
};
|
||||
|
||||
private static ResolvedScript CallScript(int? timeoutSeconds = null) => new()
|
||||
{
|
||||
CanonicalName = "Runner",
|
||||
TriggerType = "Call",
|
||||
ExecutionTimeoutSeconds = timeoutSeconds
|
||||
};
|
||||
|
||||
private TestActorRef<ScriptActor> BuildScriptActor(
|
||||
Script<object?>? compiled,
|
||||
SiteRuntimeOptions options,
|
||||
IServiceProvider? serviceProvider = null,
|
||||
ISiteHealthCollector? healthCollector = null,
|
||||
ScriptExecutionScheduler? scheduler = null,
|
||||
int? perScriptTimeoutSeconds = null,
|
||||
IActorRef? instanceActor = null)
|
||||
{
|
||||
var instance = instanceActor ?? CreateTestProbe().Ref;
|
||||
return ActorOfAsTestActorRef<ScriptActor>(
|
||||
Props.Create(() => new ScriptActor(
|
||||
"Runner", "Inst1", instance, compiled, CallScript(perScriptTimeoutSeconds),
|
||||
_sharedLibrary, options, NullLogger<ScriptActor>.Instance,
|
||||
null, null, healthCollector, serviceProvider, scheduler ?? _scheduler, null)),
|
||||
"script-" + Guid.NewGuid().ToString("N"));
|
||||
}
|
||||
|
||||
// ── Pin 1: throwing body — coordinator survives, everything is reported ───────
|
||||
|
||||
[Fact]
|
||||
public void ThrowingScriptBody_LeavesScriptActorAliveAndReportsEverything()
|
||||
{
|
||||
var siteLog = new FakeSiteEventLogger();
|
||||
var health = new SiteHealthCollector();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("throw new InvalidOperationException(\"boom\");"),
|
||||
Options(),
|
||||
new SingleServiceProvider(siteLog),
|
||||
health);
|
||||
|
||||
Watch(actor);
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-throw"), caller.Ref);
|
||||
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
Assert.False(result.Success);
|
||||
Assert.Equal("corr-throw", result.CorrelationId);
|
||||
Assert.Contains("boom", result.ErrorMessage);
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
// Error site event + script-error counter, exactly as the execution actor emitted.
|
||||
Assert.Contains(siteLog.OfType("script"),
|
||||
r => r.Severity == "Error" && r.Message.Contains("failed", StringComparison.OrdinalIgnoreCase));
|
||||
// The in-flight slot is released, so the script can run again.
|
||||
Assert.Equal(0, actor.UnderlyingActor.RunsInFlight);
|
||||
}, TimeSpan.FromSeconds(5));
|
||||
|
||||
Assert.Equal(1, health.CollectReport("site-1").ScriptErrorCount);
|
||||
|
||||
// The coordinator is neither stopped nor restarted — a throwing body was always
|
||||
// contained inside the run's own try/catch, and still is. Watch() above means a stop
|
||||
// would deliver Terminated to the TestActor; a still-answering call proves it is live.
|
||||
ExpectNoMsg(TimeSpan.FromMilliseconds(300));
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-still-alive"), caller.Ref);
|
||||
Assert.Equal("corr-still-alive",
|
||||
caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10)).CorrelationId);
|
||||
}
|
||||
|
||||
// ── Pin 2: launch-path throw — improved over the old silent hang ──────────────
|
||||
|
||||
/// <summary>
|
||||
/// The only failure the removed per-run child could surface was a constructor throw —
|
||||
/// e.g. queueing onto a disposed <see cref="ScriptExecutionScheduler"/>. The old
|
||||
/// <c>OneForOneStrategy</c> logged it and stopped the child, leaving the Ask caller to
|
||||
/// hang with no reply at all. WP3.1 folds that into a launch-path catch that replies, an
|
||||
/// intentional improvement pinned here so it is explicit rather than accidental.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void LaunchPathThrow_RepliesToTheCallerAndLeavesTheCoordinatorAlive()
|
||||
{
|
||||
var dead = new ScriptExecutionScheduler(1);
|
||||
dead.Dispose();
|
||||
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("return 1;"), Options(), scheduler: dead);
|
||||
|
||||
Watch(actor);
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-launch"), caller.Ref);
|
||||
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
Assert.False(result.Success);
|
||||
Assert.Equal("corr-launch", result.CorrelationId);
|
||||
Assert.Contains("could not be launched", result.ErrorMessage);
|
||||
|
||||
// Watch() above means a stop would deliver Terminated to the TestActor; none arrives,
|
||||
// so the coordinator neither died nor restarted on a launch failure.
|
||||
ExpectNoMsg(TimeSpan.FromMilliseconds(300));
|
||||
|
||||
// The in-flight counter is incremented before the launch, so the catch MUST balance
|
||||
// it — otherwise a run of launch failures would permanently wedge the script at cap.
|
||||
AwaitAssert(() => Assert.Equal(0, actor.UnderlyingActor.RunsInFlight), TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
// ── Pin 3: exactly one DI scope per run, disposed on every path ───────────────
|
||||
|
||||
[Theory]
|
||||
[InlineData("return 1;", 30)] // success
|
||||
[InlineData("throw new InvalidOperationException(\"boom\");", 30)] // failure
|
||||
[InlineData("while (true) { await Task.Delay(25, CancellationToken); }", 1)] // timeout
|
||||
public void EachRun_CreatesOneDiScope_AndDisposesItExactlyOnce(string code, int timeoutSeconds)
|
||||
{
|
||||
var spy = new ScopeSpyServiceProvider();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript(code), Options(timeoutSeconds), spy);
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-scope"), caller.Ref);
|
||||
caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(15));
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
Assert.Equal(1, spy.ScopesCreated);
|
||||
Assert.Equal(1, spy.ScopesDisposed);
|
||||
}, TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
// ── Pin 4: audit correlation threading survives the actor removal ─────────────
|
||||
|
||||
/// <summary>
|
||||
/// A routed <see cref="ScriptCallRequest.ParentExecutionId"/> must still reach the run's
|
||||
/// <see cref="ScriptRuntimeContext"/> — this is the inbound-API leg of the audit execution
|
||||
/// tree, and it used to be threaded through the execution actor's constructor.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void RoutedParentExecutionId_ReachesTheRunsScriptRuntimeContext()
|
||||
{
|
||||
RunLauncherHooks.CapturedContext = null;
|
||||
var parent = Guid.NewGuid();
|
||||
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript(
|
||||
"ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors.RunLauncherHooks.CapturedContext = Instance; return 1;"),
|
||||
Options());
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(
|
||||
new ScriptCallRequest("Runner", null, 0, "corr-parent", ParentExecutionId: parent),
|
||||
caller.Ref);
|
||||
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
Assert.True(result.Success, result.ErrorMessage);
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
Assert.NotNull(RunLauncherHooks.CapturedContext);
|
||||
Assert.Equal(parent, RunLauncherHooks.CapturedContext!.ParentExecutionId);
|
||||
// The routed run still mints its OWN ExecutionId — the parent is a pointer, not a copy.
|
||||
Assert.NotEqual(parent, RunLauncherHooks.CapturedContext.ExecutionId);
|
||||
}, TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
// ── Pin 5: timeout resolution parity (perScript ?? global, <= 0 => global) ────
|
||||
|
||||
[Theory]
|
||||
[InlineData(300, 1)] // per-script override wins over a much longer global
|
||||
[InlineData(1, null)] // null per-script falls back to the global
|
||||
[InlineData(1, 0)] // non-positive per-script is treated as "use global"
|
||||
public void TimeoutResolution_MatchesTheRemovedExecutionActor(int globalSeconds, int? perScriptSeconds)
|
||||
{
|
||||
var siteLog = new FakeSiteEventLogger();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("while (true) { await Task.Delay(25, CancellationToken); }"),
|
||||
Options(globalSeconds),
|
||||
new SingleServiceProvider(siteLog),
|
||||
perScriptTimeoutSeconds: perScriptSeconds);
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-timeout"), caller.Ref);
|
||||
|
||||
// If the effective timeout were the 300 s global (case 1) or ignored (cases 2/3) this
|
||||
// would not answer inside the window.
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(15));
|
||||
Assert.False(result.Success);
|
||||
Assert.Contains("timed out", result.ErrorMessage);
|
||||
|
||||
AwaitAssert(
|
||||
() => Assert.Contains(siteLog.OfType("script"),
|
||||
r => r.Severity == "Error" && r.Message.Contains("timed out")),
|
||||
TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
// ── Pin 6: stop-during-run parity ────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// Stopping a ScriptActor mid-run must NOT cancel the in-flight run (redeploy/undeploy
|
||||
/// semantics: running scripts are allowed to finish). The run completes normally and its
|
||||
/// completion message dead-letters, exactly as the old per-run child's
|
||||
/// <c>parent.Tell</c> did once the subtree was stopped — dead letters are a health metric,
|
||||
/// not an error.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void StoppingTheScriptActorMidRun_LetsTheRunFinishAndDeadLettersItsCompletion()
|
||||
{
|
||||
RunLauncherHooks.Gate = new SemaphoreSlim(0);
|
||||
RunLauncherHooks.Finished = new ManualResetEventSlim(false);
|
||||
RunLauncherHooks.ObservedCancellation = null;
|
||||
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript(
|
||||
"ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors.RunLauncherHooks.Gate.Wait();" +
|
||||
"ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors.RunLauncherHooks.ObservedCancellation = CancellationToken.IsCancellationRequested;" +
|
||||
"ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors.RunLauncherHooks.Finished.Set();" +
|
||||
"return 1;"),
|
||||
Options());
|
||||
|
||||
var deadLetters = CreateTestProbe();
|
||||
Sys.EventStream.Subscribe(deadLetters.Ref, typeof(DeadLetter));
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-stop"), caller.Ref);
|
||||
|
||||
// Wait until the body is actually on a worker thread, then stop the coordinator.
|
||||
AwaitAssert(() => Assert.Equal(1, _scheduler.BusyThreadCount), TimeSpan.FromSeconds(10));
|
||||
Watch(actor);
|
||||
Sys.Stop(actor);
|
||||
ExpectTerminated(actor, TimeSpan.FromSeconds(10));
|
||||
|
||||
RunLauncherHooks.Gate.Release();
|
||||
|
||||
// The run ran to completion and was never cancelled by the stop.
|
||||
Assert.True(RunLauncherHooks.Finished.Wait(TimeSpan.FromSeconds(10)));
|
||||
Assert.False(RunLauncherHooks.ObservedCancellation);
|
||||
|
||||
// The Ask caller still gets its result (the reply target is not the stopped actor)…
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
Assert.True(result.Success, result.ErrorMessage);
|
||||
|
||||
// …and the completion notification aimed at the now-stopped coordinator dead-letters.
|
||||
deadLetters.FishForMessage<DeadLetter>(
|
||||
d => d.Message is ScriptActor.ScriptExecutionCompleted,
|
||||
TimeSpan.FromSeconds(10));
|
||||
}
|
||||
|
||||
// ── Pin 7: alarm side ────────────────────────────────────────────────────────
|
||||
|
||||
/// <summary>
|
||||
/// An alarm on-trigger run still receives the <c>Alarm</c> globals (name/level/priority/
|
||||
/// message) and still reports <c>AlarmExecutionCompleted</c> back to its AlarmActor —
|
||||
/// observable here through the in-flight counter returning to zero, which only the
|
||||
/// completion message can do.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void AlarmOnTriggerRun_GetsAlarmGlobals_AndCompletesBackToTheAlarmActor()
|
||||
{
|
||||
RunLauncherHooks.CapturedAlarm = null;
|
||||
|
||||
var onTrigger = CompileScript(
|
||||
"ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests.Actors.RunLauncherHooks.CapturedAlarm = Alarm; return null;");
|
||||
|
||||
var instanceProbe = CreateTestProbe();
|
||||
var alarm = ActorOfAsTestActorRef<AlarmActor>(
|
||||
Props.Create(() => new AlarmActor(
|
||||
"TempBand", "Inst1", instanceProbe.Ref,
|
||||
new ResolvedAlarm
|
||||
{
|
||||
CanonicalName = "TempBand",
|
||||
TriggerType = "HiLo",
|
||||
TriggerConfiguration = "{\"attributeName\":\"Temp\",\"hi\":80,\"hiHi\":95,\"hiMessage\":\"too hot\"}",
|
||||
PriorityLevel = 42
|
||||
},
|
||||
onTrigger, _sharedLibrary, Options(), NullLogger<AlarmActor>.Instance,
|
||||
null, null, null, null, null, _scheduler, null)),
|
||||
"alarm-" + Guid.NewGuid().ToString("N"));
|
||||
|
||||
alarm.Tell(new Commons.Messages.Streaming.AttributeValueChanged(
|
||||
"Inst1", "Temp", "Temp", 90.0, "Good", DateTimeOffset.UtcNow));
|
||||
|
||||
instanceProbe.ExpectMsg<Commons.Messages.Streaming.AlarmStateChanged>(TimeSpan.FromSeconds(10));
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
Assert.NotNull(RunLauncherHooks.CapturedAlarm);
|
||||
Assert.Equal("TempBand", RunLauncherHooks.CapturedAlarm!.Name);
|
||||
Assert.Equal(AlarmLevel.High, RunLauncherHooks.CapturedAlarm.Level);
|
||||
Assert.Equal("too hot", RunLauncherHooks.CapturedAlarm.Message);
|
||||
// Only AlarmExecutionCompleted releases the slot.
|
||||
Assert.Equal(0, alarm.UnderlyingActor.RunsInFlight);
|
||||
}, TimeSpan.FromSeconds(10));
|
||||
}
|
||||
|
||||
// ── Retargeted from ExecutionActorTests: success path + operational events ────
|
||||
|
||||
[Fact]
|
||||
public void SuccessfulRun_RepliesWithTheReturnValue()
|
||||
{
|
||||
var actor = BuildScriptActor(CompileScript("return 7 * 6;"), Options());
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-ok"), caller.Ref);
|
||||
|
||||
var result = caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
Assert.True(result.Success, result.ErrorMessage);
|
||||
Assert.Equal("corr-ok", result.CorrelationId);
|
||||
Assert.Equal(42, result.ReturnValue);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void SuccessfulRun_EmitsStartedThenCompletedInfoEvents()
|
||||
{
|
||||
var siteLog = new FakeSiteEventLogger();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("return 7 * 6;"), Options(), new SingleServiceProvider(siteLog));
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-evt"), caller.Ref);
|
||||
caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
var rows = siteLog.OfType("script");
|
||||
Assert.Equal(2, rows.Count);
|
||||
Assert.All(rows, r =>
|
||||
{
|
||||
Assert.Equal("Info", r.Severity);
|
||||
Assert.Equal("Inst1", r.InstanceId);
|
||||
Assert.Equal("ScriptActor:Runner", r.Source);
|
||||
});
|
||||
Assert.Contains("started", rows[0].Message, StringComparison.OrdinalIgnoreCase);
|
||||
Assert.Contains("completed", rows[1].Message, StringComparison.OrdinalIgnoreCase);
|
||||
}, TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FailingRun_EmitsStartedInfoThenErrorEvent()
|
||||
{
|
||||
var siteLog = new FakeSiteEventLogger();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("throw new InvalidOperationException(\"boom\");"),
|
||||
Options(), new SingleServiceProvider(siteLog));
|
||||
|
||||
var caller = CreateTestProbe();
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-evt-err"), caller.Ref);
|
||||
caller.ExpectMsg<ScriptCallResult>(TimeSpan.FromSeconds(10));
|
||||
|
||||
AwaitAssert(() =>
|
||||
{
|
||||
var rows = siteLog.OfType("script");
|
||||
Assert.Equal(2, rows.Count);
|
||||
Assert.Equal("Info", rows[0].Severity);
|
||||
Assert.Contains("started", rows[0].Message, StringComparison.OrdinalIgnoreCase);
|
||||
Assert.Equal("Error", rows[1].Severity);
|
||||
}, TimeSpan.FromSeconds(5));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FireAndForgetRun_NeedsNoReplyTarget()
|
||||
{
|
||||
var siteLog = new FakeSiteEventLogger();
|
||||
var actor = BuildScriptActor(
|
||||
CompileScript("return 1;"), Options(), new SingleServiceProvider(siteLog));
|
||||
|
||||
// Trigger-driven spawns pass ActorRefs.NoSender as replyTo; drive that path via an
|
||||
// interval-free Call script by telling the actor to run with no sender.
|
||||
actor.Tell(new ScriptCallRequest("Runner", null, 0, "corr-nobody"), ActorRefs.NoSender);
|
||||
|
||||
AwaitAssert(
|
||||
() => Assert.Contains(siteLog.OfType("script"),
|
||||
r => r.Message.Contains("completed", StringComparison.OrdinalIgnoreCase)),
|
||||
TimeSpan.FromSeconds(10));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Hooks a compiled test script can reach from inside a script body: a gate to block a
|
||||
/// worker thread deterministically, and capture slots for the run's
|
||||
/// <see cref="ScriptRuntimeContext"/> and <see cref="AlarmContext"/> (both of which the run
|
||||
/// otherwise exposes to nobody).
|
||||
/// </summary>
|
||||
public static class RunLauncherHooks
|
||||
{
|
||||
/// <summary>Gate a blocking test script waits on; reset per test.</summary>
|
||||
public static SemaphoreSlim Gate = new(0);
|
||||
|
||||
/// <summary>Set by a test script once its body has run to completion.</summary>
|
||||
public static ManualResetEventSlim Finished = new(false);
|
||||
|
||||
/// <summary>Whether the script observed a cancellation request at the end of its body.</summary>
|
||||
public static bool? ObservedCancellation;
|
||||
|
||||
/// <summary>The runtime context handed to the last captured run.</summary>
|
||||
public static ScriptRuntimeContext? CapturedContext;
|
||||
|
||||
/// <summary>The <c>Alarm</c> global handed to the last captured on-trigger run.</summary>
|
||||
public static AlarmContext? CapturedAlarm;
|
||||
}
|
||||
Reference in New Issue
Block a user