public async Task CallbackMethod_Should_InvokeAction() { var builder = new RpcServiceDefinitionsBuilder(); builder.RegisterService <ICallbackService>(); var(server, connection) = this.CreateServerAndConnection(builder); var callbackServiceImpl = new CallbackServiceImpl(); using (var publishedService = server.PublishSingleton <ICallbackService>(callbackServiceImpl)) { try { server.Start(); var callbackService = connection.GetServiceSingleton <ICallbackService>(); int callCount = 0; await callbackService.PerformActionCallbacksAsync(2, 10, v => { Assert.AreEqual(2 + callCount, v.Value); callCount++; }); Assert.AreEqual(callCount, 10); } finally { await server.ShutdownAsync(); } } }
public async Task CallbackWithCancellationTest() { var builder = new RpcServiceDefinitionsBuilder(); builder.RegisterService <ICallbackService>(); var(server, connection) = this.CreateServerAndConnection(builder); var callbackServiceImpl = new CallbackServiceImpl(); using (var publishedService = server.ServicePublisher.PublishSingleton <ICallbackService>(callbackServiceImpl)) { try { server.Start(); var callbackService = connection.GetServiceSingleton <ICallbackService>(); int lastNo = 0; CancellationTokenSource cts = new CancellationTokenSource(); Assert.CatchAsync <OperationCanceledException>(async() => { await callbackService.PerformCancellableCallbacksAsync(1000, TimeSpan.FromMilliseconds(20), 10, true, callbackData => { Assert.AreEqual(lastNo + 1, callbackData.Value); lastNo = callbackData.Value; if (lastNo == 3) { cts.Cancel(); } }, cts.Token); }); if (this.RoundTripCancellation) { Assert.Less(lastNo, 100); Assert.GreaterOrEqual(lastNo, 3); } else { Assert.AreEqual(3, lastNo); } // // Assert.IsTrue(await sequenceServiceImpl.GetIsCancelledAsync().DefaultTimeout()); } finally { await server.ShutdownAsync(); } } }
public async Task CallbackCall_UnpublishedInstance_ShouldThrow(bool cancellable) { var(server, connection) = this.CreateServerAndConnection(); var serviceImpl = new CallbackServiceImpl(); var isCancelledTask = serviceImpl.GetIsCancelledAsync(); var publishedInstance = server.PublishInstance <ICallbackService>(serviceImpl, true); server.Start(); try { var client = connection.GetServiceInstance(publishedInstance.Value); TaskCompletionSource <int> firstTcs = new TaskCompletionSource <int>(TaskCreationOptions.RunContinuationsAsynchronously); Task callbackTask; if (cancellable) { callbackTask = client.PerformCancellableCallbacksAsync(2, TimeSpan.FromSeconds(10), 1, false, Callback, CancellationToken.None); } else { callbackTask = client.PerformDelayedCallbacksAsync(2, TimeSpan.FromSeconds(10), 1, false, Callback); } await firstTcs.Task.DefaultTimeout(); // Unpublish the server side service after the first data has been received publishedInstance.Dispose(); Assert.ThrowsAsync <RpcServiceUnavailableException>(async() => { await callbackTask.TimeoutAfter(TimeSpan.FromSeconds(2)); } ); if (cancellable) { Assert.IsTrue(await isCancelledTask.DefaultTimeout()); } void Callback(CallbackData callbackData) { firstTcs.TrySetResult(callbackData.Value); } } finally { await server.ShutdownAsync(); } }
public async Task CallbackTimeoutTest() { var builder = new RpcServiceDefinitionsBuilder(); builder.RegisterService <ICallbackService>(); var(server, connection) = this.CreateServerAndConnection(builder, null, o => { o.StreamingCallTimeout = TimeSpan.FromSeconds(1); }); var callbackServiceImpl = new CallbackServiceImpl(); using var publishedService = server.ServicePublisher.PublishSingleton <ICallbackService>(callbackServiceImpl); try { server.Start(); var callbackService = connection.GetServiceSingleton <ICallbackService>(); var exceptionExpression = Is.InstanceOf <TimeoutException>(); if (this.ConnectionType == RpcConnectionType.NetGrpc) { // It seems like NetGrpc throws OperationCancelledException instead of DeadlineExceeded RpcException (but // it also seems a bit timing dependent). Let's allow both exceptions. exceptionExpression = exceptionExpression.Or.InstanceOf <OperationCanceledException>(); } DateTime connectStart = DateTime.UtcNow; // Force connection // sequenceService.SimpleCall(); var connectDuration = DateTime.UtcNow - connectStart; Console.WriteLine("Connect duration: " + connectDuration); DateTime start = DateTime.UtcNow; int lastNo = 0; Assert.ThrowsAsync(exceptionExpression, async() => { await callbackService.PerformDelayedCallbacksAsync(2000, TimeSpan.FromMilliseconds(1), 1, true, callbackData => { Assert.AreEqual(lastNo + 1, callbackData.Value); lastNo = callbackData.Value; }).DefaultTimeout(); }); TimeSpan duration = DateTime.UtcNow - start; Assert.GreaterOrEqual(duration, TimeSpan.FromSeconds(1)); Assert.Less(duration, TimeSpan.FromSeconds(2)); Assert.Greater(lastNo, 10); } finally { await server.ShutdownAsync(); } }