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