public async Task TestFormattedTime()
{
await using var serving = await WebSocketHost.ServeAsync();
var service = Services.GetRequiredService <IClientTimeService>();
(await service.GetFormattedTimeAsync("")).Should().Be("");
(await service.GetFormattedTimeAsync("null")).Should().Be("");
var format = "{0}";
var matchCount = 0;
for (int i = 0; i < 20; i++)
{
var time = await service.GetTimeAsync();
var formatted = await service.GetFormattedTimeAsync(format);
var expected = string.Format(format, time);
if (formatted == expected)
{
matchCount++;
}
await Task.Delay(TimeSpan.FromSeconds(0.1));
}
matchCount.Should().BeGreaterThan(2);
}
public async Task Test1()
{
var epsilon = TimeSpan.FromSeconds(0.5);
await using var serving = await WebSocketHost.ServeAsync();
var client = Services.GetRequiredService <IClientTimeService>();
var cTime = await Computed.CaptureAsync(_ => client.GetTimeAsync());
cTime.Options.AutoInvalidateTime.Should().Be(ComputedOptions.Default.AutoInvalidateTime);
if (!cTime.IsConsistent())
{
cTime = await cTime.UpdateAsync(false);
cTime.IsConsistent().Should().BeTrue();
}
(DateTime.Now - cTime.Value).Should().BeLessThan(epsilon);
await TestEx.WhenMet(
() => cTime.IsConsistent().Should().BeFalse(),
TimeSpan.FromSeconds(5));
var time = await cTime.UseAsync();
(DateTime.Now - time).Should().BeLessThan(epsilon);
}
public async Task TimerTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(pub.Ref);
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromMinutes(1));
var count = 0;
using var state = StateFactory.NewLive <DateTime>(
o => o.WithZeroUpdateDelay(),
async(_, ct) => await rep.Computed.UseAsync(ct));
state.Updated += s => {
Out.WriteLine($"Client: {s.Value}");
count++;
};
await TestEx.WhenMet(
() => count.Should().BeGreaterThan(2),
TimeSpan.FromSeconds(5));
}
public async Task CommandTest()
{
// Server commands
var kv = Services.GetRequiredService <IKeyValueService <string> >();
(await kv.GetAsync("")).Should().BeNull();
await kv.SetCommandAsync(new IKeyValueService <string> .SetCommand("", "1"));
(await kv.GetAsync("")).Should().Be("1");
await Services.Commander().CallAsync(new IKeyValueService <string> .SetCommand("", "2"));
(await kv.GetAsync("")).Should().Be("2");
// Client commands
await using var serving = await WebSocketHost.ServeAsync();
var kvc = ClientServices.GetRequiredService <IKeyValueServiceClient <string> >();
await kvc.SetCommandAsync(new IKeyValueService <string> .SetCommand("", "1"));
await Task.Delay(100); // Remote invalidation takes some time
(await kvc.GetAsync("")).Should().Be("1");
await ClientServices.Commander().CallAsync(new IKeyValueService <string> .SetCommand("", "2"));
await Task.Delay(100); // Remote invalidation takes some time
(await kvc.GetAsync("")).Should().Be("2");
}
public async Task TestRewriteClient()
{
await using var serving = await WebSocketHost.ServeAsync();
var tfv = Services.GetTypeViewFactory <IEdgeCaseService>();
var client = Services.GetRequiredService <IEdgeCaseRewriteClient>();
var service = tfv.CreateView(client);
// ReSharper disable once SuspiciousTypeConversion.Global
(service is TypeView <IEdgeCaseService>).Should().BeTrue();
// ReSharper disable once SuspiciousTypeConversion.Global
(service is TypeView <IEdgeCaseRewriteClient, IEdgeCaseService>).Should().BeTrue();
// This part tests that proxy builder generates
// a different type for each combination of <TView, TImplementation>
var otherClient = Services.GetRequiredService <IEdgeCaseClient>();
var otherService = tfv.CreateView(otherClient);
service.GetType().Should().NotBeSameAs(otherService.GetType());
ThrowIfContainsErrorExceptionType = typeof(ServiceException);
ThrowIfContainsErrorNonComputeExceptionType = typeof(ServiceException);
ThrowIfContainsErrorRewriteErrorsExceptionType = typeof(ServiceException);
await ActualTest(service);
}
public async Task BasicTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var sp = Services.GetRequiredService <ISimplestProvider>();
sp.SetValue("");
var p1 = await Publisher.PublishAsync(_ => sp.GetValueAsync());
p1.Should().NotBeNull();
var r1 = Replicator.GetOrAdd <string>(p1.Ref, true);
var r1c = await r1.Computed.UpdateAsync(false);
r1c.IsConsistent.Should().BeTrue();
r1c.Value.Should().Be("");
r1.Computed.Should().Be(r1c);
sp.SetValue("1");
await Task.Delay(100);
r1c.IsConsistent.Should().BeFalse();
r1.Computed.Should().Be(r1c);
r1c = await r1c.UpdateAsync(false);
r1c.Value.Should().Be("1");
var r1c1 = await r1c.UpdateAsync(false);
r1c1.Should().Be(r1c);
}
public async Task ConnectToPublisherTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var channel = await ConnectToPublisherAsync();
channel.Writer.Complete();
}
public async Task Test1()
{
var epsilon = TimeSpan.FromSeconds(0.5);
await using var serving = await WebSocketHost.ServeAsync();
var client = ClientServices.GetRequiredService <IClientTimeService>();
var cTime = await Computed.CaptureAsync(_ => client.GetTimeAsync(default));
public async Task ServerTimeModelTest1()
{
await using var serving = await WebSocketHost.ServeAsync();
using var stm = Services.GetRequiredService <ILiveState <ServerTimeModel> >();
var c = stm.State;
c.IsConsistent.Should().BeFalse();
c.Value.Time.Should().Be(default);
public async Task TestClient()
{
await using var serving = await WebSocketHost.ServeAsync();
var client = Services.GetRequiredService <IEdgeCaseClient>();
var tfv = Services.GetTypeViewFactory <IEdgeCaseService>();
var service = tfv.CreateView(client);
await ActualTest(service);
}
public async Task NoConnectionTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(("NoPublisher", pub.Id));
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().ThrowAsync <WebSocketException>();
}
public async Task BasicTest()
{
var kv = Services.GetRequiredService <IKeyValueService <string> >();
(await kv.TryGetAsync("")).Should().Be(Option.None <string>());
(await kv.GetAsync("")).Should().BeNull();
await kv.SetAsync("", "1");
(await kv.TryGetAsync("")).Should().Be(Option.Some("1"));
(await kv.GetAsync("")).Should().Be("1");
await using var serving = await WebSocketHost.ServeAsync();
using var kvm = Services.GetRequiredService <ILiveState <KeyValueModel <string> > >();
var kvc = Services.GetRequiredService <IKeyValueServiceClient <string> >();
// First read
var c = kvm.Computed;
c.IsConsistent().Should().BeFalse();
c.Value.Key.Should().Be("");
c.Value.Value.Should().BeNull();
c.Value.UpdateCount.Should().Be(0);
await TestEx.WhenMetAsync(() => {
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.SetAsync(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 ClientTimeServiceTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var service = Services.GetRequiredService <IClientTimeService>();
var time = await service.GetTimeAsync();
(DateTime.Now - time).Should().BeLessThan(TimeSpan.FromSeconds(1));
await Task.Delay(TimeSpan.FromSeconds(2));
time = await service.GetTimeAsync();
(DateTime.Now - time).Should().BeLessThan(TimeSpan.FromSeconds(1));
}
public async Task ExceptionTest()
{
var kv = Services.GetRequiredService <IKeyValueService <string> >();
await using var serving = await WebSocketHost.ServeAsync();
var kvc = Services.GetRequiredService <IKeyValueServiceClient <string> >();
try {
await kvc.GetAsync("error");
}
catch (ApplicationException ae) {
ae.Message.Should().Be("Error!");
}
}
public async Task BasicTest()
{
var kv = Services.GetRequiredService <IKeyValueService <string> >();
(await kv.GetValueAsync("")).Should().Be(Option.None <string>());
await kv.SetValueAsync("", "1");
(await kv.GetValueAsync("")).Should().Be(Option.Some("1"));
await using var serving = await WebSocketHost.ServeAsync();
using var kvm = Services.GetRequiredService <ILiveState <KeyValueModel <string> > >();
var kvc = Services.GetRequiredService <IStringKeyValueClient>();
// First read
var c = kvm.State;
c.IsConsistent.Should().BeFalse();
c.Value.Key.Should().Be("");
c.Value.Value.Should().BeNull();
c.Value.UpdateCount.Should().Be(0);
await Task.Delay(300);
kvm.UpdateError.Should().BeNull();
c = kvm.State;
c.IsConsistent.Should().BeTrue();
c.Value.Key.Should().Be("");
c.Value.Value.Should().Be("1");
c.Value.UpdateCount.Should().Be(1);
// Update
await kvc.SetValueAsync(kvm.State.Value.Key, "2");
await Task.Delay(300);
c = kvm.State;
c.IsConsistent.Should().BeFalse();
c.Value.Value.Should().Be("1");
c.Value.UpdateCount.Should().Be(1);
await Task.Delay(1000);
c = kvm.State;
c.IsConsistent.Should().BeTrue();
c.Value.Value.Should().Be("2");
c.Value.UpdateCount.Should().Be(2);
}
public async Task Test2()
{
var epsilon = TimeSpan.FromSeconds(0.5);
await using var serving = await WebSocketHost.ServeAsync();
var service = Services.GetRequiredService <IClientTimeService>();
for (int i = 0; i < 20; i++)
{
var time = await service.GetTimeAsync();
(DateTime.Now - time).Should().BeLessThan(epsilon);
await Task.Delay(TimeSpan.FromSeconds(0.1));
}
}
public async Task TimeServiceClientTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var client = Services.GetRequiredService <ITimeServiceClient>();
var cTime = await client.GetComputedTimeAsync();
cTime.IsConsistent.Should().BeTrue();
(DateTime.Now - cTime.Value).Should().BeLessThan(TimeSpan.FromSeconds(1));
await Task.Delay(TimeSpan.FromSeconds(2));
cTime.IsConsistent.Should().BeFalse();
var time = await cTime.UseAsync();
(DateTime.Now - time).Should().BeLessThan(TimeSpan.FromSeconds(1));
}
public async Task BasicTest()
{
var epsilon = TimeSpan.FromSeconds(0.5);
await using var serving = await WebSocketHost.ServeAsync();
var service = Services.GetRequiredService <IScreenshotServiceClient>();
ScreenshotController.CallCount = 0;
for (int i = 0; i < 20; i++)
{
var screenshot = await service.GetScreenshotAsync(100);
(DateTime.Now - screenshot.CapturedAt).Should().BeLessThan(epsilon);
await Task.Delay(TimeSpan.FromSeconds(0.1));
}
ScreenshotController.CallCount.Should().Be(1);
}
public async Task Test1()
{
var epsilon = TimeSpan.FromSeconds(0.5);
await using var serving = await WebSocketHost.ServeAsync();
var client = Services.GetRequiredService <IClientTimeService>();
var cTime = await Computed.CaptureAsync(_ => client.GetTimeAsync());
cTime.IsConsistent.Should().BeTrue();
(DateTime.Now - cTime.Value).Should().BeLessThan(epsilon);
await Task.Delay(TimeSpan.FromSeconds(2));
cTime.IsConsistent.Should().BeFalse();
var time = await cTime.UseAsync();
(DateTime.Now - time).Should().BeLessThan(epsilon);
}
public async Task TimerTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(pub.Ref);
var count = 0;
using var _ = rep.Computed.AutoUpdate((c, o, _) => {
Out.WriteLine($"{c.Value}");
count++;
});
await Task.Delay(1100);
count.Should().BeGreaterThan(2);
}
public async Task BasicTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var authServer = ServerServices.GetRequiredService <IServerSideAuthService>();
var authClient = ClientServices.GetRequiredService <IAuthService>();
var sessionFactory = ClientServices.GetRequiredService <ISessionFactory>();
var sessionA = sessionFactory.CreateSession();
var sessionB = sessionFactory.CreateSession();
var alice = new User("Local", "alice", "Alice");
var bob = new User("Local", "bob", "Bob");
var guest = new User("<guest>");
var session = sessionA;
await ServerServices.Commander().CallAsync(new SignInCommand(bob, session).MarkServerSide());
var user = await authServer.GetUserAsync(session);
user.Name.Should().Be(bob.Name);
user = await authClient.GetUserAsync(sessionA);
user.Name.Should().Be(bob.Name);
user = await authClient.GetUserAsync(session);
user.Name.Should().Be(bob.Name);
session = sessionB;
user = await authClient.GetUserAsync(session);
user.Id.Should().Be(sessionB.Id);
user.Name.Should().Be(User.GuestName);
session = sessionFactory.CreateSession();
user = await authClient.GetUserAsync(session);
// User.Id should be equal to new AuthSession.Id
user.Id.Length.Should().BeGreaterThan(8);
user.Name.Should().Be(User.GuestName);
}
public async Task BasicTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var auth = Services.GetRequiredService <IServerAuthenticator>();
var authClient = Services.GetRequiredService <IAuthenticatorClient>();
var sessionAccessor = Services.GetRequiredService <ISessionAccessor>();
var sessionA = new Session("a");
var sessionB = new Session("b");
var alice = new Principal("alice", "Alice", "Local");
var bob = new Principal("bob", "Bob", "Local");
sessionAccessor.Session = sessionA;
await auth.LoginAsync(bob);
var user = await auth.GetUserAsync();
user.Name.Should().Be(bob.Name);
user = await authClient.GetUserAsync(sessionA);
user.Name.Should().Be(bob.Name);
user = await authClient.GetUserAsync();
user.Name.Should().Be(bob.Name);
sessionAccessor.Session = sessionB;
user = await authClient.GetUserAsync();
user.Id.Should().Be(sessionB.Id);
user.Name.Should().Be(Principal.GuestName);
sessionAccessor.Session = null;
user = await authClient.GetUserAsync();
user.Id.Length.Should().BeGreaterThan(8);
user.Name.Should().Be(Principal.GuestName);
}
public async Task TimerTest()
{
await using var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(pub !.Publisher.Id, pub.Id);
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromMinutes(1));
var count = 0;
using var _ = rep.Computed.AutoUpdate((c, o, _) => {
Out.WriteLine($"Client: {c.Value}");
count++;
});
await Task.Delay(2000);
count.Should().BeGreaterThan(2);
}
public async Task DropReconnectTest()
{
if (TestRunnerInfo.GitHub.IsActionRunning)
{
// TODO: Fix intermittent failures on GitHub
return;
}
var serving = await WebSocketHost.ServeAsync();
var tp = Services.GetRequiredService <ITimeService>();
Debug.WriteLine("0");
var pub = await Publisher.PublishAsync(_ => tp.GetTimeAsync());
var rep = Replicator.GetOrAdd <DateTime>(pub.Ref);
Debug.WriteLine("1");
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromMinutes(1));
Debug.WriteLine("2");
var state = Replicator.GetPublisherConnectionState(pub.Publisher.Id);
state.IsConsistent.Should().BeFalse();
Debug.WriteLine("3");
state = await state.UpdateAsync(false);
Debug.WriteLine("4");
state.Should().Be(Replicator.GetPublisherConnectionState(pub.Publisher.Id));
state.Value.Should().BeTrue();
Debug.WriteLine("WebServer: stopping.");
await serving.DisposeAsync();
Debug.WriteLine("WebServer: stopped.");
// First try -- should fail w/ WebSocketException or ChannelClosedException
Debug.WriteLine("5");
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().ThrowAsync <Exception>();
Debug.WriteLine("6");
state.Should().Be(Replicator.GetPublisherConnectionState(pub.Publisher.Id));
state = await state.UpdateAsync(false);
Debug.WriteLine("7");
state.Should().Be(Replicator.GetPublisherConnectionState(pub.Publisher.Id));
state.Error.Should().BeAssignableTo <Exception>();
// Second try -- should fail w/ WebSocketException
Debug.WriteLine("8");
await rep.Computed.UpdateAsync(false).AsAsyncFunc()
.Should().ThrowAsync <WebSocketException>();
Debug.WriteLine("9");
rep.UpdateError.Should().BeOfType <WebSocketException>();
state = await state.UpdateAsync(false);
Debug.WriteLine("10");
state.Error.Should().BeOfType <WebSocketException>();
Debug.WriteLine("WebServer: starting.");
serving = await WebSocketHost.ServeAsync();
await Task.Delay(1000);
Debug.WriteLine("WebServer: started.");
Debug.WriteLine("11");
await rep.RequestUpdateAsync().AsAsyncFunc()
.Should().CompleteWithinAsync(TimeSpan.FromMinutes(1));
Debug.WriteLine("12");
state = await state.UpdateAsync(false);
Debug.WriteLine("13");
state.Value.Should().BeTrue();
Debug.WriteLine("100");
await serving.DisposeAsync();
Debug.WriteLine("101");
}
