public async Task ClosedEventRaisedWhenTheClientIsBeingStopped() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); await connection.StartAsync().OrTimeout(); await connection.DisposeAsync().OrTimeout(); await connection.Closed.OrTimeout(); // in case of clean disconnect error should be null }
public async Task ClosedEventRaisedWhenConnectionToServerLost() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(request.Method == HttpMethod.Get ? ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError) : IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); try { await connection.StartAsync().OrTimeout(); await Assert.ThrowsAsync <HttpRequestException>(() => connection.Closed.OrTimeout()); } finally { await connection.DisposeAsync(); } }
public async Task CallerReceivesExceptionsFromSendAsync() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : request.Method == HttpMethod.Post ? ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); await connection.StartAsync(); var exception = await Assert.ThrowsAsync <HttpRequestException>( async() => await connection.SendAsync(new byte[0])); await connection.DisposeAsync(); }
public async Task SendAsyncThrowsIfConnectionIsDisposed() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); var content = string.Empty; if (request.Method == HttpMethod.Get) { content = "T2:T:42;"; } return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK, content)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); await connection.StartAsync(); await connection.DisposeAsync(); var exception = await Assert.ThrowsAsync <InvalidOperationException>( async() => await connection.SendAsync(new byte[0])); Assert.Equal("Cannot send messages when the connection is not in the Connected state.", exception.Message); }
public async Task TransportIsStoppedWhenConnectionIsStopped() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(request.Method == HttpMethod.Options ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); using (var httpClient = new HttpClient(mockHttpHandler.Object)) { var longPollingTransport = new LongPollingTransport(httpClient, new LoggerFactory()); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(longPollingTransport), loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); try { await connection.StartAsync(); Assert.False(longPollingTransport.Running.IsCompleted); } finally { await connection.DisposeAsync(); } await longPollingTransport.Running.OrTimeout(); } }
public async Task ClosedEventRaisedWhenTheClientIsBeingStopped() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(request.Method == HttpMethod.Options ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); var closedEventTcs = new TaskCompletionSource <Exception>(); connection.Closed += e => { closedEventTcs.SetResult(e); return(Task.CompletedTask); }; await connection.StartAsync(); await connection.DisposeAsync(); // in case of clean disconnect error should be null Assert.Null(await closedEventTcs.Task.OrTimeout()); }
public async Task CannotSendAfterReceiveThrewException() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(request.Method == HttpMethod.Get ? ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError) : IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); try { await connection.StartAsync().OrTimeout(); // Exception in send should shutdown the connection await Assert.ThrowsAsync <HttpRequestException>(() => connection.Closed.OrTimeout()); var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => connection.SendAsync(new byte[0])); Assert.Equal("Cannot send messages when the connection is not in the Connected state.", exception.Message); } finally { await connection.DisposeAsync(); } }
public async Task CannotStartStoppedConnection() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); await connection.StartAsync(); await connection.DisposeAsync(); var exception = await Assert.ThrowsAsync <InvalidOperationException>( async() => await connection.StartAsync()); Assert.Equal("Cannot start a connection that is not in the Initial state.", exception.Message); }
public async Task CanReceiveData() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); var content = string.Empty; if (request.Method == HttpMethod.Get) { content = "42"; } return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK, content)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); try { var receiveTcs = new TaskCompletionSource <string>(); connection.OnReceived((data, state) => { var tcs = ((TaskCompletionSource <string>)state); tcs.TrySetResult(Encoding.UTF8.GetString(data)); return(Task.CompletedTask); }, receiveTcs); _ = connection.Closed.ContinueWith(task => { if (task.Exception != null) { receiveTcs.TrySetException(task.Exception); } else { receiveTcs.TrySetCanceled(); } return(Task.CompletedTask); }); await connection.StartAsync().OrTimeout(); Assert.Equal("42", await receiveTcs.Task.OrTimeout()); } finally { await connection.DisposeAsync(); } }
public async Task EventsAreNotRunningOnMainLoop() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(request.Method == HttpMethod.Options ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var mockTransport = new Mock <ITransport>(); Channel <byte[], SendMessage> channel = null; mockTransport.Setup(t => t.StartAsync(It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), It.IsAny <TransferMode>(), It.IsAny <string>())) .Returns <Uri, Channel <byte[], SendMessage>, TransferMode, string>((url, c, transferMode, connectionId) => { channel = c; return(Task.CompletedTask); }); mockTransport.Setup(t => t.StopAsync()) .Returns(() => { channel.Out.TryComplete(); return(Task.CompletedTask); }); mockTransport.SetupGet(t => t.Mode).Returns(TransferMode.Text); var callbackInvokedTcs = new TaskCompletionSource <object>(); var closedTcs = new TaskCompletionSource <object>(); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(mockTransport.Object), loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); connection.Received += async m => { callbackInvokedTcs.SetResult(null); await closedTcs.Task; }; await connection.StartAsync(); channel.Out.TryWrite(Array.Empty <byte>()); // Ensure that the Received callback has been called before attempting the second write await callbackInvokedTcs.Task.OrTimeout(); channel.Out.TryWrite(Array.Empty <byte>()); // Ensure that SignalR isn't blocked by the receive callback Assert.False(channel.In.TryRead(out var message)); closedTcs.SetResult(null); await connection.DisposeAsync(); }
public async Task ReceivedCallbackNotRaisedAfterConnectionIsDisposed() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var mockTransport = new Mock <ITransport>(); Channel <byte[], SendMessage> channel = null; mockTransport.Setup(t => t.StartAsync(It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), It.IsAny <TransferMode>(), It.IsAny <string>())) .Returns <Uri, Channel <byte[], SendMessage>, TransferMode, string>((url, c, transferMode, connectionId) => { channel = c; return(Task.CompletedTask); }); mockTransport.Setup(t => t.StopAsync()) .Returns(() => { // The connection is now in the Disconnected state so the Received event for // this message should not be raised channel.Writer.TryWrite(Array.Empty <byte>()); channel.Writer.TryComplete(); return(Task.CompletedTask); }); mockTransport.SetupGet(t => t.Mode).Returns(TransferMode.Text); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(mockTransport.Object), loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); var onReceivedInvoked = false; connection.OnReceived(_ => { onReceivedInvoked = true; return(Task.CompletedTask); }); await connection.StartAsync(); await connection.DisposeAsync(); Assert.False(onReceivedInvoked); }
public async Task EventQueueTimeoutWithException() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var mockTransport = new Mock <ITransport>(); Channel <byte[], SendMessage> channel = null; mockTransport.Setup(t => t.StartAsync(It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), It.IsAny <TransferMode>(), It.IsAny <string>())) .Returns <Uri, Channel <byte[], SendMessage>, TransferMode, string>((url, c, transferMode, connectionId) => { channel = c; return(Task.CompletedTask); }); mockTransport.Setup(t => t.StopAsync()) .Returns(() => { channel.Writer.TryComplete(); return(Task.CompletedTask); }); mockTransport.SetupGet(t => t.Mode).Returns(TransferMode.Text); var callbackInvokedTcs = new TaskCompletionSource <object>(); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(mockTransport.Object), loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); connection.OnReceived(_ => { throw new OperationCanceledException(); }); await connection.StartAsync(); channel.Writer.TryWrite(Array.Empty <byte>()); // Ensure that SignalR isn't blocked by the receive callback Assert.False(channel.Reader.TryRead(out var message)); await connection.DisposeAsync(); }
public async Task CanStopStartingConnection() { // Used to make sure StartAsync is not completed before DisposeAsync is called var releaseNegotiateTcs = new TaskCompletionSource <object>(); // Used to make sure that DisposeAsync runs after we check the state in StartAsync var allowDisposeTcs = new TaskCompletionSource <object>(); // Used to make sure that DisposeAsync continues only after StartAsync finished var releaseDisposeTcs = new TaskCompletionSource <object>(); var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); // allow DisposeAsync to continue once we know we are past the connection state check allowDisposeTcs.SetResult(null); await releaseNegotiateTcs.Task; return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var transport = new Mock <ITransport>(); transport.Setup(t => t.StopAsync()).Returns(async() => { await releaseDisposeTcs.Task; }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(transport.Object), loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); var startTask = connection.StartAsync(); await allowDisposeTcs.Task; var disposeTask = connection.DisposeAsync(); // allow StartAsync to continue once DisposeAsync has started releaseNegotiateTcs.SetResult(null); // unblock DisposeAsync only after StartAsync completed await startTask.OrTimeout(); releaseDisposeTcs.SetResult(null); await disposeTask.OrTimeout(); transport.Verify(t => t.StartAsync(It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), It.IsAny <TransferMode>(), It.IsAny <string>()), Times.Never); }
public async Task CanStartConnectionWithoutSettingTransferModeFeature() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(IsNegotiateRequest(request) ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var mockTransport = new Mock <ITransport>(); Channel <byte[], SendMessage> channel = null; mockTransport.Setup(t => t.StartAsync(It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), It.IsAny <TransferMode>(), It.IsAny <string>())) .Returns <Uri, Channel <byte[], SendMessage>, TransferMode, string>((url, c, transferMode, connectionId) => { channel = c; return(Task.CompletedTask); }); mockTransport.Setup(t => t.StopAsync()) .Returns(() => { channel.Writer.TryComplete(); return(Task.CompletedTask); }); mockTransport.SetupGet(t => t.Mode).Returns(TransferMode.Binary); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(mockTransport.Object), loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); await connection.StartAsync().OrTimeout(); var transferModeFeature = connection.Features.Get <ITransferModeFeature>(); await connection.DisposeAsync().OrTimeout(); mockTransport.Verify(t => t.StartAsync( It.IsAny <Uri>(), It.IsAny <Channel <byte[], SendMessage> >(), TransferMode.Text, It.IsAny <string>()), Times.Once); Assert.NotNull(transferModeFeature); Assert.Equal(TransferMode.Binary, transferModeFeature.TransferMode); }
public async Task query(string requested, string expectedNegotiate) { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); Assert.Equal(expectedNegotiate, request.RequestUri.ToString()); return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse())); }); var connection = new HttpConnection(new Uri(requested), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); await connection.StartAsync().OrTimeout(); await connection.DisposeAsync().OrTimeout(); }
public async Task ConnectionCannotBeStartedIfNoCommonTransportsBetweenClientAndServer(TransportType serverTransports) { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse(transportTypes: serverTransports))); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); var exception = await Assert.ThrowsAsync <InvalidOperationException>( () => connection.StartAsync()); Assert.Equal("No requested transports available on the server.", exception.Message); }
public async Task StartThrowsFormatExceptionIfNegotiationResponseHasNoTransports() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse(transportTypes: null))); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); var exception = await Assert.ThrowsAsync <FormatException>( () => connection.StartAsync()); Assert.Equal("No transports returned in negotiation response.", exception.Message); }
public async Task CanSendData() { var data = new byte[] { 1, 1, 2, 3, 5, 8 }; var sendTcs = new TaskCompletionSource <byte[]>(); var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); if (IsNegotiateRequest(request)) { return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse())); } if (request.Method == HttpMethod.Post) { sendTcs.SetResult(await request.Content.ReadAsByteArrayAsync()); } return(ResponseUtils.CreateResponse(HttpStatusCode.OK)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object }); try { await connection.StartAsync(); await connection.SendAsync(data); Assert.Equal(data, await sendTcs.Task.OrTimeout()); } finally { await connection.DisposeAsync(); } }
public async Task CanReceiveDataEvenIfExceptionThrownSynchronouslyFromPreviousReceivedEvent() { var mockHttpHandler = new Mock <HttpMessageHandler>(); mockHttpHandler.Protected() .Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>()) .Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) => { await Task.Yield(); var content = string.Empty; if (request.Method == HttpMethod.Get) { content = "42"; } return(request.Method == HttpMethod.Options ? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse()) : ResponseUtils.CreateResponse(HttpStatusCode.OK, content)); }); var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null, httpMessageHandler: mockHttpHandler.Object); try { var receiveTcs = new TaskCompletionSource <string>(); var receivedRaised = false; connection.Received += data => { if (!receivedRaised) { receivedRaised = true; throw new InvalidOperationException(); } receiveTcs.TrySetResult(Encoding.UTF8.GetString(data)); return(Task.CompletedTask); }; connection.Closed += e => { if (e != null) { receiveTcs.TrySetException(e); } else { receiveTcs.TrySetCanceled(); } return(Task.CompletedTask); }; await connection.StartAsync(); Assert.Equal("42", await receiveTcs.Task.OrTimeout()); } finally { await connection.DisposeAsync(); } }