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