public void RebootTest()
{
var bootCount = 0;
var test = new TestDef()
{
MaxTime = 2.Minutes(),
MaxInactive = 2.Minutes()
};
test.AddScript("com:test", async env => {
bootCount++;
while (!env.Token.IsCancellationRequested)
{
await env.SimulateWork(100.Ms());
}
});
test.Run(async plan => {
plan.StartServices();
await plan.Delay(TimeSpan.FromMinutes(1));
await plan.StopServices();
plan.StartServices();
});
Assert.AreEqual(2, bootCount);
}
public void NonResponsiveServiceIsKilledWithoutMercy()
{
var test = new TestDef {
MaxTime = TimeSpan.FromMinutes(1)
};
var launched = true;
var terminated = false;
test.AddScript("com:test", async env => {
launched = true;
try {
while (!env.Token.IsCancellationRequested)
{
await env.SimulateWork(10000.Ms());
}
} finally {
// this should never hit
terminated = true;
}
});
test.Run(async plan => {
plan.StartServices();
await plan.Delay(1.Sec());
await plan.StopServices(grace: 1.Sec());
});
Assert.IsTrue(launched, nameof(launched));
Assert.IsFalse(terminated, nameof(terminated));
}
public void StopResponsiveService()
{
var test = new TestDef {
MaxTime = TimeSpan.FromMinutes(1)
};
var terminated = TimeSpan.Zero;
test.AddScript("com:test", async env => {
try {
while (!env.Token.IsCancellationRequested)
{
await env.SimulateWork(10.Sec(), env.Token);
}
} finally {
terminated = env.Time;
}
});
test.Run(async plan => {
plan.StartServices();
await plan.Delay(TimeSpan.FromSeconds(1));
await plan.StopServices();
});
Assert.AreEqual(TimeSpan.FromSeconds(1), terminated);
}
public void SlowDisposeIsKilled()
{
var test = new TestDef();
bool disposeStart = false;
bool disposeComplete = false;
test.AddService("run", e => new TestEngine(
async() => {
try {
await e.SimulateWork(Timeout.InfiniteTimeSpan, e.Token);
} catch (TaskCanceledException) {
}
e.Debug("Shutting down");
},
async() => {
e.Debug("Disposing");
disposeStart = true;
await e.SimulateWork(10.Sec());
disposeComplete = true;
}
));
test.Run(async e => {
e.StartServices();
await e.Delay(5.Sec());
e.Debug(LogType.Info, "Start shutting down");
await e.StopServices(grace: 2.Sec());
});
Assert.IsTrue(disposeStart, nameof(disposeStart));
Assert.IsFalse(disposeComplete, nameof(disposeComplete));
}
public void CancellationAbortsPromise()
{
var test = new TestDef();
var cancel = TimeSpan.MinValue;
var result = false;
test.AddScript("m:m", async env => {
var promise = new SimFuture <bool>(5000, env.Token);
try {
result = await promise.Task;
} catch (TaskCanceledException) {
cancel = env.Time;
}
});
test.Run(async plan => {
plan.StartServices();
await plan.Delay(1000.Sec());
await plan.StopServices(grace: 1.Sec());
});
Assert.IsFalse(result);
Assert.AreEqual(TimeSpan.FromMilliseconds(1000), cancel, nameof(cancel));
}
public void DisposeIsFiredOnNormalTermination()
{
var test = new TestDef();
bool run = false;
bool disposed = false;
test.AddService("run", e => new TestEngine(
async() => { run = true; },
async() => { disposed = true; }
));
test.Run();
Assert.IsTrue(disposed, nameof(disposed));
Assert.IsTrue(run, nameof(run));
}
public void DisposeIsFiredOnAbnormalTermination()
{
var runtime = new TestDef();
bool run = false;
bool disposed = false;
runtime.AddService("run", e => new TestEngine(
async() => {
run = true;
throw new InvalidOperationException();
},
async() => { disposed = true; }
));
runtime.Run();
Assert.IsTrue(disposed, nameof(disposed));
Assert.IsTrue(run, nameof(run));
}
public void DisposeIsNotFiredOnKill()
{
var runtime = new TestDef();
bool run = false;
bool disposed = false;
runtime.AddService("run", e => new TestEngine(
async() => {
run = true;
await e.Delay(10.Minutes());
},
async() => { disposed = true; }
));
runtime.Run(async e => {
e.StartServices();
await e.Delay(5.Sec());
await e.StopServices(grace: 2.Sec());
});
Assert.IsFalse(disposed, nameof(disposed));
Assert.IsTrue(run, nameof(run));
}