public async Task SimpleServiceSetGetStubTest()
{
var binder = new TestMethodBinder();
CreateSimpleServiceStub <ISimpleService>(new TestSimpleServiceImpl(), binder);
var callContext = CreateServerCallContext(CancellationToken.None);
var objectId = RpcObjectId.NewId();
var setHandler = binder.GetHandler <UnaryServerMethod <RpcObjectRequest <double>, RpcResponse> >("SetValue");
await setHandler(new RpcObjectRequest <double>(objectId, 123.456), callContext);
var getHandler = binder.GetHandler <UnaryServerMethod <RpcObjectRequest, RpcResponse <double> > >("GetValue");
var getResponse = await getHandler(new RpcObjectRequest(objectId), callContext);
Assert.AreEqual(123.456, getResponse.Result);
}
public async Task GenerateSimpleServiceStubTest()
{
var binder = new TestMethodBinder();
CreateSimpleServiceStub <ISimpleService>(new TestSimpleServiceImpl(), binder);
var callContext = CreateServerCallContext(CancellationToken.None);
var addHandler = binder.GetHandler <GrpcCore.UnaryServerMethod <RpcObjectRequest <int, int>, RpcResponse <int> > >("Add");
Assert.NotNull(addHandler);
var objectId = RpcObjectId.NewId();
var addResponseTask = addHandler.Invoke(new RpcObjectRequest <int, int>(objectId, 5, 6), callContext);
var response = await addResponseTask.DefaultTimeout();
Assert.AreEqual(11, response.Result);
}
public async Task BlockingStubTest()
{
// TODO: Should use a mock instead.
var serviceImpl = new TestBlockingSimpleServiceImpl();
var binder = new TestMethodBinder();
CreateSimpleServiceStub <IBlockingService>(serviceImpl, binder);
var callContext = CreateServerCallContext(CancellationToken.None);
var objectId = RpcObjectId.NewId();
var setMethod = binder.methods.FirstOrDefault(p => p.Item1.Name == "SetValue");
Assert.NotNull(setMethod);
var setValueHandler = (UnaryServerMethod <RpcObjectRequest <double>, RpcResponse>)setMethod.Item2;
await setValueHandler(new RpcObjectRequest <double>(objectId, 123.456), callContext);
//await (Task<RpcResponse>)setMethod.Invoke(serviceStub, new object[] { new RpcObjectRequest<double>(objectId, 123.456), callContext });
Assert.AreEqual(1, serviceImpl.nBlockingSetValue);
var getMethod = binder.methods.FirstOrDefault(p => p.Item1.Name == "GetValue");
Assert.NotNull(getMethod);
var getValueHandler = (UnaryServerMethod <RpcObjectRequest, RpcResponse <double> >)getMethod.Item2;
var getResponse = await getValueHandler(new RpcObjectRequest(objectId), callContext);
Assert.AreEqual(1, serviceImpl.nBlockingGetValue);
Assert.AreEqual(123.456, getResponse.Result);
var addMethod = binder.methods.FirstOrDefault(p => p.Item1.Name == "Add");
var addHandler = (UnaryServerMethod <RpcObjectRequest <int, int>, RpcResponse <int> >)addMethod.Item2;
var addResponse = await addHandler(new RpcObjectRequest <int, int>(objectId, 8, 9), callContext);
Assert.AreEqual(1, serviceImpl.nBlockingAdd);
Assert.AreEqual(17, addResponse.Result);
}
public async Task DeviceServiceTest()
{
var serviceImpl = new ThermostatServiceImpl();
var implProviderMock = new Mock <IRpcServiceActivator>();
implProviderMock.Setup(p => p.GetActivatedService <IDeviceService>(It.IsAny <IServiceProvider>(), It.IsAny <RpcObjectId>())).Returns(new ActivatedService <IDeviceService>(serviceImpl, null));
var callContext = CreateServerCallContext(CancellationToken.None);
var binder = new TestMethodBinder();
CreateSimpleServiceStub <IDeviceService>(serviceImpl, binder);
var objectId = RpcObjectId.NewId();
var getMethod = binder.methods.FirstOrDefault(p => p.Item1.Name == "GetDeviceAcoId");
Assert.NotNull(getMethod);
var getValueHandler = (UnaryServerMethod <RpcObjectRequest, RpcResponse <Guid> >)getMethod.Item2;
var getResponse = await getValueHandler(new RpcObjectRequest(objectId), callContext);
Assert.AreEqual(serviceImpl.DeviceAcoId, getResponse.Result);
}
public async Task EventHandlerTest()
{
var serviceImpl = new TestServiceWithEventsImpl();
var binder = new TestMethodBinder();
CreateSimpleServiceStub <ISimpleServiceWithEvents>(serviceImpl, binder);
var beginHandler = binder.GetHandler <GrpcCore.ServerStreamingServerMethod <RpcObjectRequest, EventArgs> >("BeginValueChanged");
var objectId = RpcObjectId.NewId();
//var valueChangedMethod = stubType.GetMethod($"Begin{nameof(IServiceWithEvents.ValueChanged)}");
var valueChangedStreamWriter = new ServerEventStreamWriter <EventArgs>(10);
CancellationTokenSource eventListerCancellationSource = new CancellationTokenSource();
var callContext = CreateServerCallContext(eventListerCancellationSource.Token);
Task valueChangedTask = beginHandler(new RpcObjectRequest(objectId), valueChangedStreamWriter, callContext);
var detailedValueChangedStreamWriter = new ServerEventStreamWriter <ValueChangedEventArgs>(10);
var beginDetailedHandler = binder.GetHandler <GrpcCore.ServerStreamingServerMethod <RpcObjectRequest, ValueChangedEventArgs> >("BeginDetailedValueChanged");
CancellationTokenSource detailedEventListerCancellationSource = new CancellationTokenSource();
var detailedCallContext = CreateServerCallContext(detailedEventListerCancellationSource.Token);
Task detailedValueChangedTask = beginDetailedHandler(new RpcObjectRequest(objectId), detailedValueChangedStreamWriter, detailedCallContext);
await Task.WhenAny(Task.WhenAll(valueChangedStreamWriter.StartedTask, detailedValueChangedStreamWriter.StartedTask), Task.Delay(5000));
Assert.IsTrue(valueChangedStreamWriter.StartedTask.IsCompletedSuccessfully());
Assert.IsTrue(detailedValueChangedStreamWriter.StartedTask.IsCompletedSuccessfully());
Task.Run(async() =>
{
List <Task> tasks = new List <Task>();
for (int i = 0; i < 20; i++)
{
tasks.Add(serviceImpl.SetValueAsync(18 + i));
}
await Task.WhenAll(tasks);
}
).Forget();
await Task.WhenAny(Task.WhenAll(valueChangedStreamWriter.CompletedTask, detailedValueChangedStreamWriter.CompletedTask), Task.Delay(5000));
Assert.IsTrue(valueChangedStreamWriter.CompletedTask.IsCompletedSuccessfully());
Assert.IsTrue(detailedValueChangedStreamWriter.CompletedTask.IsCompletedSuccessfully());
eventListerCancellationSource.Cancel();
detailedEventListerCancellationSource.Cancel();
//var endProducerHandler = binder.GetHandler<GrpcCore.UnaryServerMethod<RpcObjectEventRequest, RpcResponse>>(nameof(RpcStub<object>.EndEventProducer));
//var endTask = endProducerHandler(new RpcObjectEventRequest(objectId, eventProducerId), callContext);
//var endDetailedTask = endProducerHandler(new RpcObjectEventRequest(objectId, detailedEventProducerId), callContext);
//await Task.WhenAll(endTask, endDetailedTask);
try
{
await Task.WhenAll(valueChangedTask, detailedValueChangedTask);
}
catch (OperationCanceledException) { }
Assert.IsTrue(valueChangedTask.IsCompletedSuccessfully() || valueChangedTask.IsCanceled);
Assert.IsTrue(detailedValueChangedTask.IsCompletedSuccessfully() || detailedValueChangedTask.IsCanceled);
Assert.GreaterOrEqual(valueChangedStreamWriter.GetMessages().Length, 10);
// Too timing dependent
//Assert.Less(valueChangedStreamWriter.GetMessages().Length, 20);
var detailedMessages = detailedValueChangedStreamWriter.GetMessages();
Assert.GreaterOrEqual(detailedMessages.Length, 10);
// Too timing dependent
//Assert.Less(detailedValueChangedStreamWriter.GetMessages().Length, 20);
int oldValue = 0;
int newValue = 18;
for (int i = 0; i < 10; i++)
{
var msg = detailedMessages[i];
Assert.AreEqual(oldValue, msg.OldValue);
Assert.AreEqual(newValue, msg.NewValue);
oldValue = msg.NewValue;
newValue = oldValue + 1;
}
}
