public async Task SetAsyncEventHandlerOverrideTrue() { // Setup: Create two mock event handlers var eventHandler1 = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); var eventHandler2 = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); // If: // ... I assign an event handler on the JSON RPC host // ... And I reassign the event handler with an override var jh = new JsonRpcHost(GetChannelBase(null, null).Object); jh.SetAsyncEventHandler(CommonObjects.EventType, eventHandler1.Object); jh.SetAsyncEventHandler(CommonObjects.EventType, eventHandler2.Object, true); // Then: There should only be one event handler Assert.Single(jh.eventHandlers); Assert.Contains(CommonObjects.EventType.MethodName, jh.eventHandlers.Keys); // If: I call the stored event handler await jh.eventHandlers[CommonObjects.EventType.MethodName](CommonObjects.EventMessage); // Then: The correct event handler should have been called eventHandler2.Verify(a => a( It.Is <CommonObjects.TestMessageContents>(p => p.Equals(CommonObjects.TestMessageContents.DefaultInstance)), It.Is <EventContext>(p => p.messageQueue == jh.outputQueue) ), Times.Once); eventHandler1.Verify(a => a( It.IsAny <CommonObjects.TestMessageContents>(), It.IsAny <EventContext>() ), Times.Never); }
public async Task SetSyncRequestHandler(bool nullContents) { // Setup: Create a mock request handler var requestHandler = new Mock <Action <CommonObjects.TestMessageContents, RequestContext <CommonObjects.TestMessageContents> > >(); var message = nullContents ? Message.CreateRequest(CommonObjects.RequestType, CommonObjects.MessageId, null) : CommonObjects.RequestMessage; // If: I assign a request handler on the JSON RPC host var jh = new JsonRpcHost(GetChannelBase(null, null).Object); jh.SetRequestHandler(CommonObjects.RequestType, requestHandler.Object); // Then: It should be the only request handler set Assert.Single(jh.requestHandlers); Assert.Contains(CommonObjects.RequestType.MethodName, jh.requestHandlers.Keys); // If: I call the stored request handler await jh.requestHandlers[CommonObjects.RequestType.MethodName](message); await jh.requestHandlers[CommonObjects.RequestType.MethodName](message); // Then: The request handler should have been called with the params and a proper request context var expectedContents = nullContents ? null : CommonObjects.TestMessageContents.DefaultInstance; requestHandler.Verify(a => a( It.Is <CommonObjects.TestMessageContents>(p => p == expectedContents), It.Is <RequestContext <CommonObjects.TestMessageContents> >(rc => rc.messageQueue == jh.outputQueue && rc.requestMessage == message) ), Times.Exactly(2)); }
public void SetSyncEventHandlerNull() { // If: I assign an event handler on the message gispatcher with a null event handler var jh = new JsonRpcHost(GetChannelBase(null, null).Object); Assert.Throws <ArgumentNullException>(() => jh.SetEventHandler(CommonObjects.EventType, null)); }
public async Task ConsumeInputRequestMethodNotFound() { // Setup: Create a message reader that will return a request with method that doesn't exist var mr = new Mock <MessageReader>(Stream.Null, null); mr.SetupSequence(o => o.ReadMessage()) .ReturnsAsync(CommonObjects.RequestMessage) .Returns(Task.FromException <Message>(new EndOfStreamException())); // If: I start the input consumption loop var jh = new JsonRpcHost(GetChannelBase(mr.Object, null).Object); await jh.ConsumeInput().WithTimeout(TimeSpan.FromSeconds(1)); // Then: // ... Read message should have been called twice mr.Verify(o => o.ReadMessage(), Times.Exactly(2)); // ... There should be an outgoing message with the error var outgoing = jh.outputQueue.ToArray(); Assert.Single(outgoing); Assert.Equal(MessageType.ResponseError, outgoing[0].MessageType); Assert.Equal(CommonObjects.MessageId, outgoing[0].Id); Assert.Equal(-32601, outgoing[0].Contents.Value <int>("code")); }
public async Task ConsumeInputRequestException() { // Setup: // ... Create a message reader that will return a request var mr = new Mock <MessageReader>(Stream.Null, null); mr.SetupSequence(o => o.ReadMessage()) .ReturnsAsync(CommonObjects.RequestMessage) .Returns(Task.FromException <Message>(new EndOfStreamException())); // ... Create a JSON RPC host and register the request handler to throw exception var jh = new JsonRpcHost(GetChannelBase(mr.Object, null).Object); var mockHandler = new Mock <Action <CommonObjects.TestMessageContents, RequestContext <CommonObjects.TestMessageContents> > >(); mockHandler.Setup(m => m(It.IsAny <CommonObjects.TestMessageContents>(), It.IsAny <RequestContext <CommonObjects.TestMessageContents> >())) .Throws(new Exception()); jh.SetRequestHandler(CommonObjects.RequestType, mockHandler.Object); // If: I start the input consumption loop await jh.ConsumeInput().WithTimeout(TimeSpan.FromSeconds(1)); // Then: // ... Read message should have been called twice mr.Verify(o => o.ReadMessage(), Times.Exactly(2)); // ... There should not be any outgoing messages var outgoing = jh.outputQueue.ToArray(); Assert.Empty(outgoing); }
public async Task SetAsyncEventHandler(bool nullContents) { // Setup: Create a mock request handler var eventHandler = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); var message = nullContents ? Message.CreateEvent(CommonObjects.EventType, null) : CommonObjects.EventMessage; // If: I assign an event handler on the JSON RPC host var jh = new JsonRpcHost(GetChannelBase(null, null).Object); jh.SetAsyncEventHandler(CommonObjects.EventType, eventHandler.Object); // Then: It should be the only event handler set Assert.Single(jh.eventHandlers); Assert.Contains(CommonObjects.EventType.MethodName, jh.eventHandlers.Keys); // If: I call the stored event handler await jh.eventHandlers[CommonObjects.EventType.MethodName](message); await jh.eventHandlers[CommonObjects.EventType.MethodName](message); // Then: The event handler should have been called with the params and a proper event context var expectedContents = nullContents ? null : CommonObjects.TestMessageContents.DefaultInstance; eventHandler.Verify(a => a( It.Is <CommonObjects.TestMessageContents>(p => p == expectedContents), It.Is <EventContext>(p => p.messageQueue == jh.outputQueue) ), Times.Exactly(2)); }
public async Task SendRequestNotConnected() { // If: I send an event when the protocol channel isn't connected // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); await Assert.ThrowsAsync <InvalidOperationException>(() => jh.SendRequest(CommonObjects.RequestType, CommonObjects.TestMessageContents.DefaultInstance)); }
public void StopBeforeStarting() { // If: I stop the JSON RPC host without starting it first // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); Assert.Throws <InvalidOperationException>(() => jh.Stop()); }
public void SetSyncRequestHandlerNullRequestHandler() { // If: I assign a request handler on the JSON RPC host with a null request handler // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); Assert.Throws <ArgumentNullException>(() => jh.SetRequestHandler(CommonObjects.RequestType, null)); }
public void WaitForExitNotStarted() { // If: I wait for exit on the JSON RPC host without starting it // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); Assert.Throws <InvalidOperationException>(() => jh.WaitForExit()); }
public async Task DispatchMessageEventWithoutHandler() { // Setup: Create a JSON RPC host without a request handler var jh = new JsonRpcHost(GetChannelBase(null, null).Object); // If: I dispatch a request that doesn't have a handler // Then: I should get an exception await Assert.ThrowsAsync <MethodHandlerDoesNotExistException>(() => jh.DispatchMessage(CommonObjects.EventMessage)); }
public void SetAsyncRequestHandlerNullRequestType() { // If: I assign a request handler on the JSON RPC host with a null request type // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); Assert.Throws <ArgumentNullException>(() => jh.SetAsyncRequestHandler <object, object>(null, (a, b) => Task.FromResult(false))); }
public void SetAsyncEventHandlerOverrideFalse() { // Setup: Create a mock event handler var eventHandler = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); // If: // ... I assign an event handler on the JSON RPC host // ... And I reassign the event handler without overriding // Then: I should get an exception var jh = new JsonRpcHost(GetChannelBase(null, null).Object); jh.SetAsyncEventHandler(CommonObjects.EventType, eventHandler.Object); Assert.ThrowsAny <Exception>(() => jh.SetAsyncEventHandler(CommonObjects.EventType, eventHandler.Object)); }
public async Task DispatchMessageEventException() { // Setup: Create a JSON RPC host with a request handler that throws an unhandled exception every time var jh = new JsonRpcHost(GetChannelBase(null, null).Object); var mockHandler = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); mockHandler.Setup(f => f(It.IsAny <CommonObjects.TestMessageContents>(), It.IsAny <EventContext>())) .Returns(Task.FromException(new Exception())); jh.SetAsyncEventHandler(CommonObjects.EventType, mockHandler.Object); // If: I dispatch a message whose handler throws // Then: I should get an exception await Assert.ThrowsAsync <Exception>(() => jh.DispatchMessage(CommonObjects.EventMessage)); }
public void StopMultiple() { // Setup: Create json rpc host and start it var mr = new Mock <MessageReader>(Stream.Null, null); var mw = new Mock <MessageWriter>(Stream.Null); var jh = new JsonRpcHost(GetChannelBase(mr.Object, mw.Object).Object); jh.Start(); // If: I stop the JSON RPC host after stopping it // Then: I should get an exception jh.Stop(); Assert.Throws <InvalidOperationException>(() => jh.Stop()); }
public void SendEvent() { // Setup: Create a Json RPC Host with a connected channel var jh = new JsonRpcHost(GetChannelBase(null, null, true).Object); // If: I send an event jh.SendEvent(CommonObjects.EventType, CommonObjects.TestMessageContents.DefaultInstance); // Then: The message should be added to the output queue Assert.Single(jh.outputQueue.ToArray()); var m = jh.outputQueue.ToArray()[0]; Assert.Equal(CommonObjects.TestMessageContents.SerializedContents, m.Contents); Assert.Equal(CommonObjects.EventType.MethodName, m.Method); }
public async Task DispatchMessageResponseWithHandler() { // Setup: Create a new JSON RPC host that has a pending request handler var jh = new JsonRpcHost(GetChannelBase(null, null).Object); var mockPendingRequest = new TaskCompletionSource <Message>(); jh.pendingRequests.TryAdd(CommonObjects.MessageId, mockPendingRequest); // If: I dispatch a response await jh.DispatchMessage(CommonObjects.ResponseMessage); // Then: The task completion source should have completed with the message that was given await mockPendingRequest.Task.WithTimeout(TimeSpan.FromSeconds(1)); Assert.Equal(CommonObjects.ResponseMessage, mockPendingRequest.Task.Result); }
public async Task SendRequest() { // If: I send a request with the JSON RPC host var jh = new JsonRpcHost(GetChannelBase(null, null, true).Object); Task <CommonObjects.TestMessageContents> requestTask = jh.SendRequest(CommonObjects.RequestType, CommonObjects.TestMessageContents.DefaultInstance); // Then: There should be a pending request Assert.Single(jh.pendingRequests); // If: I then trick it into completing the request jh.pendingRequests.First().Value.SetResult(CommonObjects.ResponseMessage); var responseContents = await requestTask; // Then: The returned results should be the contents of the message Assert.Equal(CommonObjects.TestMessageContents.DefaultInstance, responseContents); }
public async Task ConsumeInputEndOfStream() { // Setup: Create a message reader that will throw an end of stream exception on read var mr = new Mock <MessageReader>(Stream.Null, null); mr.Setup(o => o.ReadMessage()).Returns(Task.FromException <Message>(new EndOfStreamException())); // If: I start the input consumption thread // Then: // ... It should stop gracefully var jh = new JsonRpcHost(GetChannelBase(mr.Object, null).Object); await jh.ConsumeInput().WithTimeout(TimeSpan.FromSeconds(1)); // ... The read message should have only been called once mr.Verify(o => o.ReadMessage(), Times.Once); }
public async Task ConsumeOutputException() { // Setup: Create a mock message writer var mw = new Mock <MessageWriter>(Stream.Null); mw.Setup(o => o.WriteMessage(It.IsAny <Message>())).Returns(Task.FromResult(true)); // If: I start the output consumption thread with a completed blocking collection var jh = new JsonRpcHost(GetChannelBase(null, mw.Object).Object); jh.outputQueue.CompleteAdding(); await jh.ConsumeOutput().WithTimeout(TimeSpan.FromSeconds(1)); // Then: The message writer should not have been called mw.Verify(o => o.WriteMessage(It.IsAny <Message>()), Times.Never); }
public async Task WaitForExit() { // Setup: Create json rpc host and start it var mr = new Mock <MessageReader>(Stream.Null, null); var mw = new Mock <MessageWriter>(Stream.Null); var jh = new JsonRpcHost(GetChannelBase(mr.Object, mw.Object).Object); jh.Start(); // If: I wait for JSON RPC host to exit and stop it // NOTE: We are wrapping this execution in a task to make sure we can properly stop the host Task waitForExit = Task.Run(() => { jh.WaitForExit(); }); jh.Stop(); // Then: The host should be stopped await waitForExit.WithTimeout(TimeSpan.FromSeconds(1)); }
public async Task ConsumeInputException() { // Setup: // ... Create a message reader that will throw an exception on first read // ... throw an end of stream on second read var mr = new Mock <MessageReader>(Stream.Null, null); mr.SetupSequence(o => o.ReadMessage()) .Returns(Task.FromException <Message>(new Exception())) .Returns(Task.FromException <Message>(new EndOfStreamException())); // If: I start the input consumption loop var jh = new JsonRpcHost(GetChannelBase(mr.Object, null).Object); await jh.ConsumeInput().WithTimeout(TimeSpan.FromSeconds(1)); // Then: // ... Read message should have been called twice mr.Verify(o => o.ReadMessage(), Times.Exactly(2)); }
public async Task DispatchMessageEventWithHandler(Task result) { // Setup: Create a JSON RPC host with an event handler setup var jh = new JsonRpcHost(GetChannelBase(null, null).Object); var mockHandler = new Mock <Func <CommonObjects.TestMessageContents, EventContext, Task> >(); mockHandler.Setup(f => f( It.Is <CommonObjects.TestMessageContents>(m => m == CommonObjects.TestMessageContents.DefaultInstance), It.Is <EventContext>(ec => ec.messageQueue == jh.outputQueue) )).Returns(result); jh.SetAsyncEventHandler(CommonObjects.EventType, mockHandler.Object); // If: I dispatch an event await jh.DispatchMessage(CommonObjects.EventMessage); // Then: The event handler should have been called mockHandler.Verify(f => f( It.Is <CommonObjects.TestMessageContents>(m => m == CommonObjects.TestMessageContents.DefaultInstance), It.IsAny <EventContext>() )); }
public async Task ConsumeOutput() { // Setup: // ... Create a mock message writer var mw = new Mock <MessageWriter>(Stream.Null); mw.Setup(o => o.WriteMessage(CommonObjects.ResponseMessage)).Returns(Task.FromResult(true)); // ... Create the JSON RPC host and add an item to the output queue var jh = new JsonRpcHost(GetChannelBase(null, mw.Object).Object); jh.outputQueue.Add(CommonObjects.ResponseMessage); jh.outputQueue.CompleteAdding(); // This will cause the thread to stop after processing the items // If: I start the output consumption thread Task consumeOutputTask = jh.ConsumeOutput(); await consumeOutputTask.WithTimeout(TimeSpan.FromSeconds(1)); // Then: The message writer should have been called once mw.Verify(o => o.WriteMessage(CommonObjects.ResponseMessage), Times.Once); }
public async Task StartMultiple() { // Setup: Create mocked message reader and writer var mr = new Mock <MessageReader>(Stream.Null, null); var mw = new Mock <MessageWriter>(Stream.Null); // If: // ... I start a JSON RPC host var cb = GetChannelBase(mr.Object, mw.Object); var jh = new JsonRpcHost(cb.Object); jh.Start(); // ... And I start it again // Then: I should get an exception Assert.Throws <InvalidOperationException>(() => jh.Start()); // Cleanup: Stop the JSON RPC host jh.Stop(); await Task.WhenAll(jh.consumeInputTask, jh.consumeOutputTask).WithTimeout(TimeSpan.FromSeconds(1)); }
public async Task ConsumeOutputCancelled() { // NOTE: This test validates that the blocking collection breaks out when cancellation is requested // Setup: Create a mock message writer var mw = new Mock <MessageWriter>(Stream.Null); mw.Setup(o => o.WriteMessage(It.IsAny <Message>())).Returns(Task.FromResult(true)); // If: // ... I start the output consumption thread var jh = new JsonRpcHost(GetChannelBase(null, mw.Object).Object); Task consumeOuputTask = jh.ConsumeOutput(); // ... and I stop the thread via cancellation and wait for completion jh.cancellationTokenSource.Cancel(); await consumeOuputTask.WithTimeout(TimeSpan.FromSeconds(1)); // Then: The message writer should not have been called mw.Verify(o => o.WriteMessage(It.IsAny <Message>()), Times.Never); }
public async Task ConsumeInput() { // Setup: // ... Create a message reader that will return a message every time var mr = new Mock <MessageReader>(Stream.Null, null); var waitForRead = new TaskCompletionSource <bool>(); mr.Setup(o => o.ReadMessage()) .Callback(() => waitForRead.TrySetResult(true)) .ReturnsAsync(CommonObjects.EventMessage); // ... Create a no-op event handler to handle the message from the message reader var noOpHandler = new Mock <Func <Message, Task> >(); noOpHandler.Setup(f => f(It.IsAny <Message>())).Returns(Task.FromResult(true)); // ... Wire up the event handler to a new JSON RPC host var jh = new JsonRpcHost(GetChannelBase(mr.Object, null).Object); jh.eventHandlers[CommonObjects.EventType.MethodName] = noOpHandler.Object; // If: // ... I start the input consumption thread Task consumeInputTask = jh.ConsumeInput(); // ... Wait for the handler to be called once, indicating the message was processed await waitForRead.Task.WithTimeout(TimeSpan.FromSeconds(1)); // ... Stop the input consumption thread (the hard way) and wait for completion jh.cancellationTokenSource.Cancel(); await consumeInputTask.WithTimeout(TimeSpan.FromSeconds(1)); // Then: The event handler and read message should have been called at least once noOpHandler.Verify(f => f(It.IsAny <Message>()), Times.AtLeastOnce); mr.Verify(o => o.ReadMessage(), Times.AtLeastOnce); }
public async Task StartStop() { // Setup: Create mocked message reader and writer var mr = new Mock <MessageReader>(Stream.Null, null); var mw = new Mock <MessageWriter>(Stream.Null); // If: I start a JSON RPC host var cb = GetChannelBase(mr.Object, mw.Object); var jh = new JsonRpcHost(cb.Object); jh.Start(); // Then: The channel protocol should have been cb.Verify(o => o.Start(), Times.Once); cb.Verify(o => o.WaitForConnection(), Times.Once); // If: I stop the JSON RPC host jh.Stop(); // Then: The long running tasks should stop gracefully await Task.WhenAll(jh.consumeInputTask, jh.consumeOutputTask).WithTimeout(TimeSpan.FromSeconds(1)); cb.Verify(o => o.Stop(), Times.Once); }