public async Task AutoRecomputeTest()
{
var stateFactory = Services.StateFactory();
var time = Services.GetRequiredService <ITimeService>();
var c = await Computed.Capture(
_ => time.GetTimeWithOffset(TimeSpan.FromSeconds(1)));
var count = 0L;
using var state = stateFactory.NewComputed <DateTime>(
UpdateDelayer.ZeroDelay,
async(_, ct) => await c.Use(ct));
state.Updated += (s, _)
=> Log.LogInformation($"{++count} -> {s.Value:hh:mm:ss:fff}");
await TestExt.WhenMet(
() => count.Should().BeGreaterThan(2),
TimeSpan.FromSeconds(5));
var lastCount = count;
state.Dispose();
await Task.Delay(1000);
count.Should().Be(lastCount);
}
public async Task TimerTest()
{
await using var serving = await WebHost.Serve();
var publisher = WebServices.GetRequiredService <IPublisher>();
var replicator = ClientServices.GetRequiredService <IReplicator>();
var tp = WebServices.GetRequiredService <ITimeService>();
var pub = await publisher.Publish(_ => tp.GetTime());
var rep = replicator.GetOrAdd <DateTime>(pub.Ref);
var count = 0;
using var state = Services.StateFactory().NewComputed <DateTime>(
UpdateDelayer.ZeroDelay,
async(_, ct) => await rep.Computed.Use(ct));
state.Updated += (s, _) => {
Out.WriteLine($"{s.Value}");
count++;
};
await TestExt.WhenMet(
() => count.Should().BeGreaterThan(2),
TimeSpan.FromSeconds(5));
}
public async Task BasicTest()
{
await using var _ = await WebHost.Serve();
var kv = WebServices.GetRequiredService <IKeyValueService <string> >();
(await kv.TryGet("")).Should().Be(Option.None <string>());
(await kv.Get("")).Should().BeNull();
await kv.Set("", "1");
(await kv.TryGet("")).Should().Be(Option.Some("1"));
(await kv.Get("")).Should().Be("1");
using var kvm = ClientServices.GetRequiredService <IComputedState <KeyValueModel <string> > >();
var kvc = ClientServices.GetRequiredService <IKeyValueServiceClient <string> >();
// First read
var c = kvm.Computed;
c.IsConsistent().Should().BeFalse();
c.Value.Should().Be(null);
await TestExt.WhenMet(() => {
var snapshot = kvm.Snapshot;
snapshot.Computed.HasValue.Should().BeTrue();
var c = snapshot.Computed;
c.IsConsistent().Should().BeTrue();
c.Value.Key.Should().Be("");
c.Value.Value.Should().Be("1");
c.Value.UpdateCount.Should().Be(1);
}, TimeSpan.FromSeconds(1));
// Update
await kvc.Set(kvm.Computed.Value.Key, "2");
await Task.Delay(300);
c = kvm.Computed;
c.IsConsistent().Should().BeFalse();
c.Value.Value.Should().Be("1");
c.Value.UpdateCount.Should().Be(1);
await Task.Delay(1000);
c = kvm.Computed;
c.IsConsistent().Should().BeTrue();
c.Value.Value.Should().Be("2");
c.Value.UpdateCount.Should().Be(2);
}
public async Task BasicTest()
{
if (OSInfo.IsAnyUnix)
{
// Screenshots don't work on Unix
return;
}
var c = await GetScreenshotComputed();
for (var i = 0; i < 10; i++)
{
c.Value.Image.Data.Length.Should().BeGreaterThan(0);
await TestExt.WhenMet(
() => c.IsConsistent().Should().BeFalse(),
TimeSpan.FromSeconds(0.5));
c = await GetScreenshotComputed();
}
}
public async Task DropReconnectTest()
{
if (TestRunnerInfo.IsBuildAgent())
{
// TODO: Fix intermittent failures on GitHub
return;
}
var serving = await WebHost.Serve(false);
var replicator = ClientServices.GetRequiredService <IReplicator>();
var kvsClient = ClientServices.GetRequiredService <IKeyValueServiceClient <string> >();
Debug.WriteLine("0");
var kvs = WebServices.GetRequiredService <IKeyValueService <string> >();
await kvs.Set("a", "b");
var c = (ReplicaMethodComputed <string>)
await Computed.Capture(_ => kvsClient.Get("a"));
c.Value.Should().Be("b");
c.IsConsistent().Should().BeTrue();
Debug.WriteLine("1");
await c.Replica !.RequestUpdate().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromSeconds(5));
c.IsConsistent().Should().BeTrue();
Debug.WriteLine("2");
var cs = replicator.GetPublisherConnectionState(c.Replica.PublicationRef.PublisherId);
cs.Value.Should().BeTrue();
cs.Computed.IsConsistent().Should().BeTrue();
await cs.Recompute();
Debug.WriteLine("3");
cs.Value.Should().BeTrue();
cs.Computed.IsConsistent().Should().BeTrue();
var cs1 = replicator.GetPublisherConnectionState(c.Replica.PublicationRef.PublisherId);
cs1.Should().BeSameAs(cs);
Debug.WriteLine("WebServer: stopping.");
await serving.DisposeAsync();
Debug.WriteLine("WebServer: stopped.");
// First try -- should fail w/ WebSocketException or ChannelClosedException
c.IsConsistent().Should().BeTrue();
c.Value.Should().Be("b");
Debug.WriteLine("4");
await cs.Update();
cs.Error.Should().BeAssignableTo <Exception>();
cs.Computed.IsConsistent().Should().BeTrue();
var updateTask = c.Replica.RequestUpdate();
updateTask.IsCompleted.Should().BeFalse();
Debug.WriteLine("5");
await kvs.Set("a", "c");
await Delay(0.1);
c.IsConsistent().Should().BeTrue();
c.Value.Should().Be("b");
Debug.WriteLine("6");
Debug.WriteLine("WebServer: starting.");
serving = await WebHost.Serve();
await Delay(1);
Debug.WriteLine("WebServer: started.");
await TestExt.WhenMet(
() => cs.Error.Should().BeNull(),
TimeSpan.FromSeconds(30));
Debug.WriteLine("7");
await Delay(1);
updateTask.IsCompleted.Should().BeTrue();
c = (ReplicaMethodComputed <string>) await c.Update();
c.IsConsistent().Should().BeTrue();
c.Value.Should().Be("c");
await serving.DisposeAsync();
}
