public async Task WebSocketsTransportSendsUserAgent()
{
await using (var server = await StartServer <Startup>())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: LoggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/httpheader"),
TransferFormat.Binary).DefaultTimeout();
await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("User-Agent"));
// The HTTP header endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.DefaultTimeout();
Assert.True(webSocketsTransport.Input.TryRead(out var result));
var userAgent = Encoding.UTF8.GetString(result.Buffer.ToArray());
// user agent version should come from version embedded in assembly metadata
var assemblyVersion = typeof(Constants)
.Assembly
.GetCustomAttribute <AssemblyInformationalVersionAttribute>();
var majorVersion = typeof(HttpConnection).Assembly.GetName().Version.Major;
var minorVersion = typeof(HttpConnection).Assembly.GetName().Version.Minor;
Assert.StartsWith($"Microsoft SignalR/{majorVersion}.{minorVersion} ({assemblyVersion.InformationalVersion}; ", userAgent);
}
}
public async Task WebSocketsTransportSendsUserAgent()
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/httpheader"), pair.Application,
TransferMode.Binary, connection : Mock.Of <IConnection>()).OrTimeout();
await pair.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("User-Agent"));
// The HTTP header endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(pair.Transport.Input.TryRead(out var result));
string userAgent = Encoding.UTF8.GetString(result.Buffer.ToArray());
// user agent version should come from version embedded in assembly metadata
var assemblyVersion = typeof(Constants)
.Assembly
.GetCustomAttribute <AssemblyInformationalVersionAttribute>();
Assert.Equal("Microsoft.AspNetCore.Sockets.Client.Http/" + assemblyVersion.InformationalVersion, userAgent);
}
}
public async Task WebSocketsTransportStopsWhenConnectionClosedByTheServer(TransferMode transferMode)
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection, transferMode, connectionId : string.Empty, connection : Mock.Of <IConnection>());
var sendTcs = new TaskCompletionSource <object>();
connectionToTransport.Writer.TryWrite(new SendMessage(new byte[] { 0x42 }, sendTcs));
try
{
await sendTcs.Task;
}
catch (OperationCanceledException)
{
// Because the server and client are run in the same process there is a race where websocket.SendAsync
// can send a message but before returning be suspended allowing the server to run the EchoEndpoint and
// send a close frame which triggers a cancellation token on the client and cancels the websocket.SendAsync.
// Our solution to this is to just catch OperationCanceledException from the sent message if the race happens
// because we know the send went through, and its safe to check the response.
}
// The echo endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(transportToConnection.Reader.TryRead(out var buffer));
Assert.Equal(new byte[] { 0x42 }, buffer);
}
}
public async Task HttpOptionsWebSocketFactoryIsUsed()
{
var httpOptions = new HttpConnectionOptions();
var webSocketMock = new Mock <WebSocket>();
bool factoryWasUsed = false;
// we emulate that connection is closed right away after it was established
webSocketMock.Setup(socket => socket.CloseStatus).Returns(WebSocketCloseStatus.NormalClosure);
webSocketMock.Setup(socket => socket.ReceiveAsync(It.IsAny <Memory <byte> >(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new ValueWebSocketReceiveResult(0, WebSocketMessageType.Close, true));
httpOptions.WebSocketFactory = (context, token) =>
{
factoryWasUsed = true;
return(ValueTask.FromResult(webSocketMock.Object));
};
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: httpOptions, loggerFactory: null, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri("http://FakeEndpot.com/echo"), TransferFormat.Binary).DefaultTimeout();
await webSocketsTransport.StopAsync().DefaultTimeout();
webSocketMock.Verify((socket) => socket.ReceiveAsync(It.IsAny <Memory <byte> >(), It.IsAny <CancellationToken>()), Times.Once());
Assert.True(factoryWasUsed);
}
public async Task WebSocketsTransportSendsUserAgent()
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/httpheader"),
TransferFormat.Binary).OrTimeout();
await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("User-Agent"));
// The HTTP header endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(webSocketsTransport.Input.TryRead(out var result));
var userAgent = Encoding.UTF8.GetString(result.Buffer.ToArray());
// user agent version should come from version embedded in assembly metadata
var assemblyVersion = typeof(Constants)
.Assembly
.GetCustomAttribute <AssemblyInformationalVersionAttribute>();
Assert.Equal("Microsoft.AspNetCore.Http.Connections.Client/" + assemblyVersion.InformationalVersion, userAgent);
}
}
public async Task HttpOptionsSetOntoWebSocketOptions()
{
ClientWebSocketOptions webSocketsOptions = null;
var httpOptions = new HttpConnectionOptions();
httpOptions.Cookies.Add(new Cookie("Name", "Value", string.Empty, "fakeuri.org"));
var clientCertificate = new X509Certificate(Array.Empty <byte>());
httpOptions.ClientCertificates.Add(clientCertificate);
httpOptions.UseDefaultCredentials = false;
httpOptions.Credentials = Mock.Of <ICredentials>();
httpOptions.Proxy = Mock.Of <IWebProxy>();
httpOptions.WebSocketConfiguration = options => webSocketsOptions = options;
await using (var server = await StartServer <Startup>())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: httpOptions, loggerFactory: null, accessTokenProvider: null);
Assert.NotNull(webSocketsTransport);
// we need to open a connection so it would apply httpOptions to webSocketOptions
await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/echo"),
TransferFormat.Binary).DefaultTimeout();
await webSocketsTransport.StopAsync().DefaultTimeout();
}
Assert.NotNull(webSocketsOptions);
Assert.Equal(1, webSocketsOptions.Cookies.Count);
Assert.Single(webSocketsOptions.ClientCertificates);
Assert.Same(clientCertificate, webSocketsOptions.ClientCertificates[0]);
Assert.False(webSocketsOptions.UseDefaultCredentials);
Assert.Same(httpOptions.Proxy, webSocketsOptions.Proxy);
Assert.Same(httpOptions.Credentials, webSocketsOptions.Credentials);
}
public async Task WebSocketsTransportStopsWhenConnectionChannelClosed()
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/echo"),
TransferFormat.Binary);
webSocketsTransport.Output.Complete();
await webSocketsTransport.Running.OrTimeout(TimeSpan.FromSeconds(10));
}
}
public async Task WebSocketsTransportThrowsForInvalidTransferFormat(TransferFormat transferFormat)
{
using (StartVerifiableLog())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, LoggerFactory, accessTokenProvider: null);
var exception = await Assert.ThrowsAsync <ArgumentException>(() =>
webSocketsTransport.StartAsync(new Uri("http://fakeuri.org"), transferFormat));
Assert.Contains($"The '{transferFormat}' transfer format is not supported by this transport.", exception.Message);
Assert.Equal("transferFormat", exception.ParamName);
}
}
public async Task WebSocketsTransportStopsWhenConnectionChannelClosed()
{
await using (var server = await StartServer <Startup>())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: LoggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/echo"),
TransferFormat.Binary);
webSocketsTransport.Output.Complete();
await webSocketsTransport.Running.DefaultTimeout(TimeSpan.FromSeconds(10));
}
}
public async Task WebSocketsTransportStopsSendAndReceiveLoopsWhenTransportIsStopped()
{
await using (var server = await StartServer <Startup>())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: LoggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/echo"),
TransferFormat.Binary).DefaultTimeout();
await webSocketsTransport.StopAsync().DefaultTimeout();
await webSocketsTransport.Running.DefaultTimeout();
}
}
public async Task WebSocketsTransportStopsSendAndReceiveLoopsWhenTransportIsStopped()
{
using (StartLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"),
TransferFormat.Binary).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportStopsSendAndReceiveLoopsWhenTransportIsStopped()
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/echo"),
TransferFormat.Binary).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportStopsWhenConnectionChannelClosed()
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), pair.Application,
TransferFormat.Binary, connection : Mock.Of <IConnection>());
pair.Transport.Output.Complete();
await webSocketsTransport.Running.OrTimeout(TimeSpan.FromSeconds(10));
}
}
public async Task WebSocketsTransportStopsSendAndReceiveLoopsWhenTransportIsStopped()
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), pair.Application,
TransferFormat.Binary, connection : Mock.Of <IConnection>()).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportSetsTransferFormat(TransferFormat transferFormat)
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/echo"),
transferFormat).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportSetsTransferFormat(TransferFormat transferFormat)
{
await using (var server = await StartServer <Startup>())
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: LoggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(server.WebSocketsUrl + "/echo"),
transferFormat).DefaultTimeout();
await webSocketsTransport.StopAsync().DefaultTimeout();
await webSocketsTransport.Running.DefaultTimeout();
}
}
public async Task WebSocketsTransportSetsTransferFormat(TransferFormat transferFormat)
{
using (StartLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"),
transferFormat).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportStopsWhenConnectionChannelClosed()
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection,
TransferMode.Binary, connectionId : string.Empty, connection : Mock.Of <IConnection>());
connectionToTransport.Writer.TryComplete();
await webSocketsTransport.Running.OrTimeout(TimeSpan.FromSeconds(10));
}
}
public async Task WebSocketsTransportStopsWhenConnectionClosedByTheServer(TransferFormat transferFormat)
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/echoAndClose"), transferFormat);
await webSocketsTransport.Output.WriteAsync(new byte[] { 0x42 });
// The echoAndClose endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(webSocketsTransport.Input.TryRead(out var result));
Assert.Equal(new byte[] { 0x42 }, result.Buffer.ToArray());
webSocketsTransport.Input.AdvanceTo(result.Buffer.End);
}
}
public async Task WebSocketsTransportStopsSendAndReceiveLoopsWhenTransportIsStopped()
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection,
TransferMode.Binary, connectionId : string.Empty, connection : Mock.Of <IConnection>()).OrTimeout();
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportSetsTransferMode(TransferMode transferMode)
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
Assert.Null(webSocketsTransport.Mode);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), pair.Application,
transferMode, connection : Mock.Of <IConnection>()).OrTimeout();
Assert.Equal(transferMode, webSocketsTransport.Mode);
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task WebSocketsTransportStopsWhenConnectionClosedByTheServer(TransferFormat transferFormat)
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echoAndClose"), pair.Application, transferFormat, connection : Mock.Of <IConnection>());
await pair.Transport.Output.WriteAsync(new byte[] { 0x42 });
// The echoAndClose endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(pair.Transport.Input.TryRead(out var result));
Assert.Equal(new byte[] { 0x42 }, result.Buffer.ToArray());
pair.Transport.Input.AdvanceTo(result.Buffer.End);
}
}
public async Task WebSocketsTransportSendsXRequestedWithHeader()
{
using (StartVerifiableLog(out var loggerFactory))
{
var webSocketsTransport = new WebSocketsTransport(httpConnectionOptions: null, loggerFactory: loggerFactory, accessTokenProvider: null);
await webSocketsTransport.StartAsync(new Uri(ServerFixture.WebSocketsUrl + "/httpheader"),
TransferFormat.Binary).OrTimeout();
await webSocketsTransport.Output.WriteAsync(Encoding.UTF8.GetBytes("X-Requested-With"));
// The HTTP header endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(webSocketsTransport.Input.TryRead(out var result));
var headerValue = Encoding.UTF8.GetString(result.Buffer.ToArray());
Assert.Equal("XMLHttpRequest", headerValue);
}
}
public async Task WebSocketsTransportSendsXRequestedWithHeader()
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/httpheader"), pair.Application,
TransferFormat.Binary, connection : Mock.Of <IConnection>()).OrTimeout();
await pair.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("X-Requested-With"));
// The HTTP header endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(pair.Transport.Input.TryRead(out var result));
var headerValue = Encoding.UTF8.GetString(result.Buffer.ToArray());
Assert.Equal("XMLHttpRequest", headerValue);
}
}
public async Task WebSocketsTransportSetsTransferMode(TransferMode transferMode)
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
Assert.Null(webSocketsTransport.Mode);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection,
transferMode, connectionId : string.Empty, connection : Mock.Of <IConnection>()).OrTimeout();
Assert.Equal(transferMode, webSocketsTransport.Mode);
await webSocketsTransport.StopAsync().OrTimeout();
await webSocketsTransport.Running.OrTimeout();
}
}
public async Task StartAsync(Uri url, CancellationToken cancellationToken = default)
{
await _websocketTransport.StartAsync(url, cancellationToken).ForceAsync();
}
public async Task WebSocketsTransportThrowsForInvalidTransferMode()
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
var exception = await Assert.ThrowsAsync <ArgumentException>(() =>
webSocketsTransport.StartAsync(new Uri("http://fakeuri.org"), pair.Application, TransferMode.Text | TransferMode.Binary, connection: Mock.Of <IConnection>()));
Assert.Contains("Invalid transfer mode.", exception.Message);
Assert.Equal("requestedTransferMode", exception.ParamName);
}
}
public async Task WebSocketsTransportThrowsForInvalidTransferMode()
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
var exception = await Assert.ThrowsAsync <ArgumentException>(() =>
webSocketsTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, TransferMode.Text | TransferMode.Binary, connectionId: string.Empty, connection: Mock.Of <IConnection>()));
Assert.Contains("Invalid transfer mode.", exception.Message);
Assert.Equal("requestedTransferMode", exception.ParamName);
}
}
public async Task StartAsync(CancellationToken cancel = default)
{
await Transport.StartAsync(Url, Microsoft.AspNetCore.Connections.TransferFormat.Binary);
//await Transport2.ConnectAsync(cancel);
}
public async Task WebSocketsTransportThrowsForInvalidTransferFormat(TransferFormat transferFormat)
{
using (StartLog(out var loggerFactory))
{
var pair = DuplexPipe.CreateConnectionPair(PipeOptions.Default, PipeOptions.Default);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
var exception = await Assert.ThrowsAsync <ArgumentException>(() =>
webSocketsTransport.StartAsync(new Uri("http://fakeuri.org"), pair.Application, transferFormat, connection: Mock.Of <IConnection>()));
Assert.Contains($"The '{transferFormat}' transfer format is not supported by this transport.", exception.Message);
Assert.Equal("transferFormat", exception.ParamName);
}
}
