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 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 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 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()
        {
            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 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();
            }
        }
Beispiel #7
0
        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 (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 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();
            }
        }
Beispiel #10
0
        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();
            }
        }
Beispiel #11
0
        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();
            }
        }
Beispiel #12
0
        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 Task StopAsync()
 {
     return(_websocketTransport.StopAsync());
 }