예제 #1
0
        public async Task <ServerWebSocketTransport> GetTargetAsync()
        {
            await Listener.StartAsync();

            await Client.OpenAsync(ListenerUri, CancellationToken);

            return((ServerWebSocketTransport)await Listener.AcceptTransportAsync(CancellationToken));
        }
 public async Task<ServerWebSocketTransport> GetTargetAsync()
 {
     await Listener.StartAsync(CancellationToken);
     var listenerTask = Listener.AcceptTransportAsync(CancellationToken);
     await Client.OpenAsync(ListenerUri, CancellationToken);
     var webSocketTransport = (ServerWebSocketTransport)await listenerTask;
     await webSocketTransport.OpenAsync(ListenerUri, CancellationToken);
     return webSocketTransport;
 }
예제 #3
0
        public async Task <RedisTransport> GetTargetAndEstablish()
        {
            var transport = await GetTargetAndOpenAsync();

            await transport.SendAsync(new Session { State = SessionState.New }, CancellationToken);

            ServerTransport = await Listener.AcceptTransportAsync(CancellationToken);

            await ServerTransport.ReceiveAsync(CancellationToken);

            EstablishedSession = Dummy.CreateSession(SessionState.Established);
            await ServerTransport.SendAsync(EstablishedSession, CancellationToken);

            await transport.ReceiveAsync(CancellationToken);

            return(transport);
        }
예제 #4
0
        public async Task SendAsync_NewSessionEnvelope_ServerShouldReceive()
        {
            // Arrange
            var session = Dummy.CreateSession(SessionState.New);

            session.Id = null;
            var target = await GetTargetAndOpenAsync();

            // Act
            await target.SendAsync(session, CancellationToken);

            // Assert
            var serverTransport = await Listener.AcceptTransportAsync(CancellationToken);

            var receivedEnvelope = await serverTransport.ReceiveAsync(CancellationToken);

            var receivedSession = receivedEnvelope.ShouldBeOfType <Session>();

            receivedSession.State.ShouldBe(SessionState.New);
        }
        public async Task <TServerTransport> GetTargetAsync()
        {
            if (Listener == null)
            {
                Listener = CreateTransportListener();
            }
            if (Client == null)
            {
                Client = CreateClientTransport();
            }

            await Listener.StartAsync(CancellationToken);

            var listenerTask = Listener.AcceptTransportAsync(CancellationToken);
            await Client.OpenAsync(ListenerUri, CancellationToken);

            var webSocketTransport = (TServerTransport)await listenerTask;
            await webSocketTransport.OpenAsync(ListenerUri, CancellationToken);

            return(webSocketTransport);
        }