1205 lines
56 KiB
C#
1205 lines
56 KiB
C#
// Copyright (c) .NET Foundation. All rights reserved.
|
|
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
|
|
|
|
using System;
|
|
using System.Diagnostics;
|
|
using System.Net;
|
|
using System.Net.Http;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Channels;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Client.Tests;
|
|
using Microsoft.AspNetCore.Sockets.Client.Http;
|
|
using Microsoft.AspNetCore.Sockets.Features;
|
|
using Microsoft.Extensions.Logging;
|
|
using Microsoft.Extensions.Logging.Testing;
|
|
using Moq;
|
|
using Moq.Protected;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
|
|
namespace Microsoft.AspNetCore.Sockets.Client.Tests
|
|
{
|
|
public partial class HttpConnectionTests : LoggedTest
|
|
{
|
|
public HttpConnectionTests(ITestOutputHelper output) : base(output)
|
|
{
|
|
}
|
|
|
|
[Fact]
|
|
public void CannotCreateConnectionWithNullUrl()
|
|
{
|
|
var exception = Assert.Throws<ArgumentNullException>(() => new HttpConnection(null));
|
|
Assert.Equal("url", exception.ParamName);
|
|
}
|
|
|
|
[Fact]
|
|
public void ConnectionReturnsUrlUsedToStartTheConnection()
|
|
{
|
|
var connectionUrl = new Uri("http://fakeuri.org/");
|
|
Assert.Equal(connectionUrl, new HttpConnection(connectionUrl).Url);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData((TransportType)0)]
|
|
[InlineData(TransportType.All + 1)]
|
|
public void CannotStartConnectionWithInvalidTransportType(TransportType requestedTransportType)
|
|
{
|
|
Assert.Throws<ArgumentOutOfRangeException>(
|
|
() => new HttpConnection(new Uri("http://fakeuri.org/"), requestedTransportType));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CannotStartRunningConnection()
|
|
{
|
|
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.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 });
|
|
try
|
|
{
|
|
await connection.StartAsync();
|
|
var exception =
|
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
|
async () => await connection.StartAsync());
|
|
Assert.Equal("Cannot start a connection that is not in the Disconnected state.", exception.Message);
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CannotStartConnectionDisposedAfterStarting()
|
|
{
|
|
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.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 Disconnected state.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CannotStartDisposedConnection()
|
|
{
|
|
using (var httpClient = new HttpClient())
|
|
{
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"));
|
|
await connection.DisposeAsync();
|
|
var exception =
|
|
await Assert.ThrowsAsync<InvalidOperationException>(
|
|
async () => await connection.StartAsync());
|
|
|
|
Assert.Equal("Cannot start a connection that is not in the Disconnected state.", exception.Message);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanDisposeStartingConnection()
|
|
{
|
|
// 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 ResponseUtils.IsNegotiateRequest(request)
|
|
? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse())
|
|
: ResponseUtils.CreateResponse(HttpStatusCode.OK);
|
|
});
|
|
|
|
var transport = new Mock<ITransport>();
|
|
Channel<byte[], SendMessage> channel = null;
|
|
transport.SetupGet(t => t.Mode).Returns(TransferMode.Text);
|
|
transport.Setup(t => t.StartAsync(It.IsAny<Uri>(), It.IsAny<Channel<byte[], SendMessage>>(), It.IsAny<TransferMode>(), It.IsAny<string>(), It.IsAny<IConnection>()))
|
|
.Returns<Uri, Channel<byte[], SendMessage>, TransferMode, string, IConnection>((_, c, __, ___, ____) =>
|
|
{
|
|
channel = c;
|
|
return Task.CompletedTask;
|
|
});
|
|
transport.Setup(t => t.StopAsync()).Returns(async () =>
|
|
{
|
|
await releaseDisposeTcs.Task;
|
|
channel.Writer.TryComplete();
|
|
});
|
|
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();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanStartConnectionThatFailedToStart()
|
|
{
|
|
var failNegotiate = true;
|
|
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 (ResponseUtils.IsNegotiateRequest(request))
|
|
{
|
|
return failNegotiate
|
|
? ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError)
|
|
: ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse());
|
|
}
|
|
|
|
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().OrTimeout();
|
|
}
|
|
catch { }
|
|
failNegotiate = false;
|
|
await connection.StartAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanStartStoppedConnection()
|
|
{
|
|
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.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.StopAsync().OrTimeout();
|
|
await connection.StartAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanStopStartingConnection()
|
|
{
|
|
var allowStopTcs = 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();
|
|
if (ResponseUtils.IsNegotiateRequest(request))
|
|
{
|
|
allowStopTcs.SetResult(null);
|
|
return ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse());
|
|
}
|
|
else
|
|
{
|
|
var content = request.Content != null ? await request.Content.ReadAsByteArrayAsync() : null;
|
|
return (content?.Length == 1 && content[0] == 0x42)
|
|
? 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 });
|
|
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e => closeTcs.TrySetResult(null);
|
|
|
|
var startTask = connection.StartAsync();
|
|
await allowStopTcs.Task.OrTimeout();
|
|
|
|
await Task.WhenAll(startTask, connection.StopAsync()).OrTimeout();
|
|
await closeTcs.Task.OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanStartConnectionAfterConnectionStoppedWithError()
|
|
{
|
|
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 (ResponseUtils.IsNegotiateRequest(request))
|
|
{
|
|
return ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse());
|
|
}
|
|
|
|
var content = request.Content != null ? await request.Content.ReadAsByteArrayAsync() : null;
|
|
return (content?.Length == 1 && content[0] == 0x42)
|
|
? 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 });
|
|
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e => closeTcs.TrySetResult(null);
|
|
|
|
await connection.StartAsync().OrTimeout();
|
|
try
|
|
{
|
|
await connection.SendAsync(new byte[] { 0x42 }).OrTimeout();
|
|
}
|
|
catch { }
|
|
await closeTcs.Task.OrTimeout();
|
|
await connection.StartAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanDisposeStoppedConnection()
|
|
{
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"));
|
|
await connection.StopAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StoppingStoppingConnectionNoOps()
|
|
{
|
|
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 (ResponseUtils.IsNegotiateRequest(request))
|
|
{
|
|
return ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse());
|
|
}
|
|
else
|
|
{
|
|
var content = request.Content != null ? await request.Content.ReadAsByteArrayAsync() : null;
|
|
return (content?.Length == 1 && content[0] == 0x42)
|
|
? 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 });
|
|
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e => closeTcs.TrySetResult(null);
|
|
|
|
await connection.StartAsync().OrTimeout();
|
|
await Task.WhenAll(connection.StopAsync().OrTimeout(), connection.StopAsync().OrTimeout());
|
|
await closeTcs.Task.OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DisposedStoppingConnectionDisposesConnection()
|
|
{
|
|
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 (ResponseUtils.IsNegotiateRequest(request))
|
|
{
|
|
return ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse());
|
|
}
|
|
else
|
|
{
|
|
var content = request.Content != null ? await request.Content.ReadAsByteArrayAsync() : null;
|
|
return (content?.Length == 1 && content[0] == 0x42)
|
|
? 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 });
|
|
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e => closeTcs.TrySetResult(null);
|
|
|
|
await connection.StartAsync().OrTimeout();
|
|
await Task.WhenAll(connection.StopAsync().OrTimeout(), connection.DisposeAsync().OrTimeout());
|
|
await closeTcs.Task.OrTimeout();
|
|
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(() => connection.StartAsync());
|
|
Assert.Equal("Cannot start a connection that is not in the Disconnected state.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SendThrowsIfConnectionIsNotStarted()
|
|
{
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"));
|
|
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);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SendThrowsIfConnectionIsDisposed()
|
|
{
|
|
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.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.SendAsync(new byte[0]));
|
|
Assert.Equal("Cannot send messages when the connection is not in the Connected state.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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 });
|
|
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e =>
|
|
{
|
|
if (e != null)
|
|
{
|
|
closeTcs.SetException(e);
|
|
}
|
|
else
|
|
{
|
|
closeTcs.SetResult(null);
|
|
}
|
|
};
|
|
await connection.StartAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
await closeTcs.Task.OrTimeout();
|
|
}
|
|
|
|
[Fact]
|
|
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)
|
|
: ResponseUtils.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 });
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e =>
|
|
{
|
|
if (e != null)
|
|
{
|
|
closeTcs.SetException(e);
|
|
}
|
|
else
|
|
{
|
|
closeTcs.SetResult(null);
|
|
}
|
|
};
|
|
|
|
try
|
|
{
|
|
await connection.StartAsync().OrTimeout();
|
|
await Assert.ThrowsAsync<HttpRequestException>(() => closeTcs.Task.OrTimeout());
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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>(), It.IsAny<IConnection>()))
|
|
.Returns<Uri, Channel<byte[], SendMessage>, TransferMode, string, IConnection>((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 closedTcs = 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(_ =>
|
|
{
|
|
callbackInvokedTcs.SetResult(null);
|
|
return closedTcs.Task;
|
|
});
|
|
|
|
await connection.StartAsync();
|
|
channel.Writer.TryWrite(Array.Empty<byte>());
|
|
|
|
// Ensure that the Received callback has been called before attempting the second write
|
|
await callbackInvokedTcs.Task.OrTimeout();
|
|
channel.Writer.TryWrite(Array.Empty<byte>());
|
|
|
|
// Ensure that SignalR isn't blocked by the receive callback
|
|
Assert.False(channel.Reader.TryRead(out var message));
|
|
|
|
closedTcs.SetResult(null);
|
|
|
|
await connection.DisposeAsync();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task EventQueueTimeout()
|
|
{
|
|
using (StartLog(out var loggerFactory))
|
|
{
|
|
var logger = loggerFactory.CreateLogger<HttpConnectionTests>();
|
|
|
|
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.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>(), It.IsAny<IConnection>()))
|
|
.Returns<Uri, Channel<byte[], SendMessage>, TransferMode, string, IConnection>((url, c, transferMode, connectionId, _) =>
|
|
{
|
|
logger.LogInformation("Transport started");
|
|
channel = c;
|
|
return Task.CompletedTask;
|
|
});
|
|
mockTransport.Setup(t => t.StopAsync())
|
|
.Returns(() =>
|
|
{
|
|
logger.LogInformation("Transport stopped");
|
|
channel.Writer.TryComplete();
|
|
return Task.CompletedTask;
|
|
});
|
|
mockTransport.SetupGet(t => t.Mode).Returns(TransferMode.Text);
|
|
|
|
var blockReceiveCallbackTcs = new TaskCompletionSource<object>();
|
|
var onReceivedCalledTcs = new TaskCompletionSource<object>();
|
|
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(mockTransport.Object), loggerFactory,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
connection.OnReceived(async _ =>
|
|
{
|
|
onReceivedCalledTcs.TrySetResult(null);
|
|
await blockReceiveCallbackTcs.Task;
|
|
});
|
|
|
|
logger.LogInformation("Starting connection");
|
|
await connection.StartAsync().OrTimeout();
|
|
logger.LogInformation("Started connection");
|
|
channel.Writer.TryWrite(Array.Empty<byte>());
|
|
await onReceivedCalledTcs.Task.OrTimeout();
|
|
|
|
// Ensure that SignalR isn't blocked by the receive callback
|
|
Assert.False(channel.Reader.TryRead(out var message));
|
|
|
|
logger.LogInformation("Disposing connection");
|
|
await connection.DisposeAsync().OrTimeout(TimeSpan.FromSeconds(10));
|
|
logger.LogInformation("Disposed connection");
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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>(), It.IsAny<IConnection>()))
|
|
.Returns<Uri, Channel<byte[], SendMessage>, TransferMode, string, IConnection>((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();
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ClosedEventNotRaisedWhenTheClientIsStoppedButWasNeverStarted()
|
|
{
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"));
|
|
var closeInvoked = false;
|
|
connection.Closed += e => closeInvoked = true;
|
|
await connection.DisposeAsync();
|
|
Assert.False(closeInvoked);
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.IsNegotiateRequest(request)
|
|
? ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationResponse())
|
|
: ResponseUtils.CreateResponse(HttpStatusCode.OK);
|
|
});
|
|
|
|
using (var httpClient = new HttpClient(mockHttpHandler.Object))
|
|
{
|
|
var longPollingTransport = new LongPollingTransport(httpClient, null, new LoggerFactory());
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"), new TestTransportFactory(longPollingTransport), loggerFactory: null,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
|
|
try
|
|
{
|
|
await connection.StartAsync();
|
|
|
|
Assert.False(longPollingTransport.Running.IsCompleted);
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
|
|
await longPollingTransport.Running.OrTimeout();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
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 (ResponseUtils.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();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task SendAsyncThrowsIfConnectionIsNotStarted()
|
|
{
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"));
|
|
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);
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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);
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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();
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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 += e =>
|
|
{
|
|
if (e != null)
|
|
{
|
|
receiveTcs.TrySetException(e);
|
|
}
|
|
else
|
|
{
|
|
receiveTcs.TrySetCanceled();
|
|
}
|
|
};
|
|
|
|
await connection.StartAsync().OrTimeout();
|
|
Assert.Equal("42", await receiveTcs.Task.OrTimeout());
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CanReceiveDataEvenIfExceptionThrownFromPreviousReceivedEvent()
|
|
{
|
|
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 ResponseUtils.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>();
|
|
|
|
var receivedRaised = false;
|
|
connection.OnReceived(data =>
|
|
{
|
|
if (!receivedRaised)
|
|
{
|
|
receivedRaised = true;
|
|
return Task.FromException(new InvalidOperationException());
|
|
}
|
|
|
|
receiveTcs.TrySetResult(Encoding.UTF8.GetString(data));
|
|
return Task.CompletedTask;
|
|
});
|
|
|
|
connection.Closed += e =>
|
|
{
|
|
if (e != null)
|
|
{
|
|
receiveTcs.TrySetException(e);
|
|
}
|
|
else
|
|
{
|
|
receiveTcs.TrySetCanceled();
|
|
}
|
|
};
|
|
|
|
await connection.StartAsync();
|
|
|
|
Assert.Equal("42", await receiveTcs.Task.OrTimeout());
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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>();
|
|
|
|
var receivedRaised = false;
|
|
connection.OnReceived((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();
|
|
}
|
|
};
|
|
|
|
await connection.StartAsync();
|
|
|
|
Assert.Equal("42", await receiveTcs.Task.OrTimeout());
|
|
}
|
|
finally
|
|
{
|
|
await connection.DisposeAsync();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
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)
|
|
: ResponseUtils.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 });
|
|
try
|
|
{
|
|
var closeTcs = new TaskCompletionSource<object>();
|
|
connection.Closed += e =>
|
|
{
|
|
if (e != null)
|
|
{
|
|
closeTcs.SetException(e);
|
|
}
|
|
else
|
|
{
|
|
closeTcs.SetResult(null);
|
|
}
|
|
};
|
|
|
|
await connection.StartAsync().OrTimeout();
|
|
await Assert.ThrowsAsync<HttpRequestException>(() => closeTcs.Task.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();
|
|
}
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("Not Json")]
|
|
public async Task StartThrowsFormatExceptionIfNegotiationResponseIsInvalid(string negotiatePayload)
|
|
{
|
|
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, negotiatePayload);
|
|
});
|
|
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
var exception = await Assert.ThrowsAsync<FormatException>(
|
|
() => connection.StartAsync());
|
|
|
|
Assert.Equal("Invalid negotiation response received.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartThrowsFormatExceptionIfNegotiationResponseHasNoConnectionId()
|
|
{
|
|
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(connectionId: null));
|
|
});
|
|
|
|
var connection = new HttpConnection(new Uri("http://fakeuri.org/"), TransportType.LongPolling, loggerFactory: null,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
var exception = await Assert.ThrowsAsync<FormatException>(
|
|
() => connection.StartAsync());
|
|
|
|
Assert.Equal("Invalid connection id returned in negotiation response.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
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,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
var exception = await Assert.ThrowsAsync<FormatException>(
|
|
() => connection.StartAsync());
|
|
|
|
Assert.Equal("No transports returned in negotiation response.", exception.Message);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData((TransportType)0)]
|
|
[InlineData(TransportType.ServerSentEvents)]
|
|
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,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
var exception = await Assert.ThrowsAsync<InvalidOperationException>(
|
|
() => connection.StartAsync());
|
|
|
|
Assert.Equal("No requested transports available on the server.", exception.Message);
|
|
}
|
|
|
|
[Fact]
|
|
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 ResponseUtils.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>(), It.IsAny<IConnection>()))
|
|
.Returns<Uri, Channel<byte[], SendMessage>, TransferMode, string, IConnection>((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>(), It.IsAny<IConnection>()), Times.Once);
|
|
Assert.NotNull(transferModeFeature);
|
|
Assert.Equal(TransferMode.Binary, transferModeFeature.TransferMode);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("http://fakeuri.org/", "http://fakeuri.org/negotiate")]
|
|
[InlineData("http://fakeuri.org/?q=1/0", "http://fakeuri.org/negotiate?q=1/0")]
|
|
[InlineData("http://fakeuri.org?q=1/0", "http://fakeuri.org/negotiate?q=1/0")]
|
|
[InlineData("http://fakeuri.org/endpoint", "http://fakeuri.org/endpoint/negotiate")]
|
|
[InlineData("http://fakeuri.org/endpoint/", "http://fakeuri.org/endpoint/negotiate")]
|
|
[InlineData("http://fakeuri.org/endpoint?q=1/0", "http://fakeuri.org/endpoint/negotiate?q=1/0")]
|
|
public async Task CorrectlyHandlesQueryStringWhenAppendingNegotiateToUrl(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,
|
|
httpOptions: new HttpOptions { HttpMessageHandler = mockHttpHandler.Object });
|
|
await connection.StartAsync().OrTimeout();
|
|
await connection.DisposeAsync().OrTimeout();
|
|
}
|
|
}
|
|
}
|