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"); }