public async Task RunShouldWaitUntilTheWebSocketIsOpen( int sequenceNumber, [Substitute] IClientWebSocket clientWebSocket, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] IChannel <GatewayMessage> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayTxWorker worker ) { var tries = 0; var message = new GatewayMessage { SequenceNumber = sequenceNumber }; var cancellationToken = new CancellationToken(false); clientWebSocket.State.Returns(WebSocketState.Connecting); channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message)); channel.WaitToRead(Any <CancellationToken>()).Returns(true); factory.CreateDelay(Any <uint>(), Any <CancellationToken>()).Returns(async x => { if (++tries == 2) { clientWebSocket.State.Returns(WebSocketState.Open); } await Task.CompletedTask; }); await worker.Start(gateway, clientWebSocket); await worker.Run(cancellationToken); await factory.Received(2).CreateDelay(100, Is(cancellationToken)); }
public async Task RunShouldReadFromChannelIfWaitToReadReturnsTrue( int sequenceNumber, [Substitute] IClientWebSocket clientWebSocket, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] IChannel <GatewayMessage> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayTxWorker worker ) { var message = new GatewayMessage { SequenceNumber = sequenceNumber }; var cancellationToken = new CancellationToken(false); channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message)); clientWebSocket.State.Returns(WebSocketState.Open); await worker.Start(gateway, clientWebSocket); await worker.Run(cancellationToken); await channel.Received().WaitToRead(Is(cancellationToken)); await channel.Received().Read(Is(cancellationToken)); }
public async Task RunShouldRouteTheMessageIfEndOfMessageIsReached( byte[] bytes, uint interval, int sequenceNumber, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Frozen, Substitute] IEventRouter router, [Target] DefaultGatewayRxWorker worker ) { var @event = new HelloEvent { HeartbeatInterval = interval }; var message = new GatewayMessage { SequenceNumber = sequenceNumber, Data = @event }; var cancellationToken = new CancellationToken(false); serializer.Deserialize <GatewayMessage>(Any <Stream>(), Any <CancellationToken>()).Returns(message); channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); await worker.Start(gateway); await worker.Run(cancellationToken); await router.Received().Route(Is(@event), Is(cancellationToken)); }
public async Task RunShouldNotUpdateSequenceNumberIfEndOfMessageIsReachedButSequenceNumberIsNull( byte[] bytes, int sequenceNumber, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Target] DefaultGatewayRxWorker worker ) { var message = new GatewayMessage { SequenceNumber = null }; serializer.Deserialize <GatewayMessage>(Any <Stream>(), Any <CancellationToken>()).Returns(message); channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); gateway.SequenceNumber = sequenceNumber; await worker.Start(gateway); await worker.Run(); gateway.SequenceNumber.Should().Be(sequenceNumber); }
public async Task RunShouldWriteBytesToWebSocket( int sequenceNumber, byte[] bytes, [Substitute] IClientWebSocket clientWebSocket, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] IChannel <GatewayMessage> channel, [Frozen, Substitute] ISerializer serializer, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayTxWorker worker ) { var message = new GatewayMessage { SequenceNumber = sequenceNumber }; var cancellationToken = new CancellationToken(false); serializer.SerializeToBytes(Any <GatewayMessage>()).Returns(bytes); channel.Read(Any <CancellationToken>()).Returns(new ValueTask <GatewayMessage>(message)); clientWebSocket.State.Returns(WebSocketState.Open); await worker.Start(gateway, clientWebSocket); await worker.Run(cancellationToken); await clientWebSocket.Received().Send(Is <ArraySegment <byte> >(bytes), Is(WebSocketMessageType.Text), Is(true), Is(cancellationToken)); }
public async Task StartShouldCreateWebSocketClient( [Frozen, Substitute] IGatewayUtilsFactory gatewayUtilsFactory, [Target] DefaultGatewayService gateway ) { await gateway.StartAsync(); gatewayUtilsFactory.Received().CreateWebSocketClient(); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultGatewayRestartService" /> class. /// </summary> /// <param name="utilsFactory">Factory used to create various utilities.</param> /// <param name="reporter">Reporter used to report metrics.</param> /// <param name="logger">Logger used to log info to some destination(s).</param> public DefaultGatewayRestartService( IGatewayUtilsFactory utilsFactory, IMetricReporter reporter, ILogger <DefaultGatewayRestartService> logger ) { this.utilsFactory = utilsFactory; this.reporter = reporter; this.logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="ReconnectEventController" /> class. /// </summary> /// <param name="gateway">The gateway service to use.</param> /// <param name="utilsFactory">Factory to create utilities with.</param> /// <param name="reporter">Reporter used to report metrics.</param> /// <param name="logger">Logger used to log information to some destination(s).</param> public ReconnectEventController( IGatewayService gateway, IGatewayUtilsFactory utilsFactory, IMetricReporter reporter, ILogger <ReconnectEventController> logger ) { this.gateway = gateway; this.utilsFactory = utilsFactory; this.logger = logger; this.reporter = reporter; }
/// <summary> /// Initializes a new instance of the <see cref="DefaultGatewayTxWorker" /> class. /// </summary> /// <param name="serializer">Serializer used for deserializing messages from the gateway.</param> /// <param name="timerFactory">Factory used to create timers.</param> /// <param name="gatewayUtilsFactory">Factory to create various utils with.</param> /// <param name="logger">Logger used to log information to some destination(s).</param> public DefaultGatewayTxWorker( ISerializer serializer, ITimerFactory timerFactory, IGatewayUtilsFactory gatewayUtilsFactory, ILogger <DefaultGatewayTxWorker> logger ) { this.serializer = serializer; this.timerFactory = timerFactory; this.logger = logger; this.gatewayUtilsFactory = gatewayUtilsFactory; channel = gatewayUtilsFactory.CreateChannel <GatewayMessage>(); }
public async Task StopShouldSetIsReadyToFalse( [Frozen, Substitute] IGatewayTxWorker txWorker, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayService gateway ) { gateway.IsReady = true; await gateway.StartAsync(); await gateway.StopAsync(); gateway.IsReady.Should().BeFalse(); }
public async Task ShouldWaitRandomAmountOfTimeBetween1And5Seconds( string sessionId, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayRestartService service ) { var cancellationToken = new CancellationToken(false); var resume = true; await service.Restart(gateway, resume, cancellationToken); await factory.Received().CreateRandomDelay(1000, 5000, Is(cancellationToken)); }
public async Task RunShouldCreateAStream( byte[] bytes, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Target] DefaultGatewayRxWorker worker ) { channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, 0, true)); await worker.Start(gateway); await worker.Run(); factory.Received().CreateStream(); }
public async Task RunShouldNotTruncateTheStreamIfEndOfMessageIsNotReached( byte[] bytes, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Target] DefaultGatewayRxWorker worker ) { channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, false)); await worker.Start(gateway); await worker.Run(); stream.DidNotReceive().SetLength(0); }
public async Task RunShouldWriteTheBytesToTheStream( byte[] bytes, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Target] DefaultGatewayRxWorker worker ) { var cancellationToken = new CancellationToken(false); channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); await worker.Start(gateway); await worker.Run(cancellationToken); await stream.Received().WriteAsync(Is <ReadOnlyMemory <byte> >(givenBytes => Encoding.UTF8.GetString(bytes) == Encoding.UTF8.GetString(bytes)), Is(cancellationToken)); }
public async Task ShouldStopSendingHeartbeatsToTheTxWorker( uint interval, int sequenceNumber, [Frozen] ITimer heartbeat, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayTxWorker txWorker, [Frozen, Substitute] ITimerFactory timerFactory, [Target] DefaultGatewayService gateway ) { gateway.SequenceNumber = sequenceNumber; await gateway.StartAsync(); await gateway.StartHeartbeat(interval); await gateway.StopHeartbeat(); await heartbeat.Received().Stop(); }
public async Task RunShouldNotReadFromTheChannelIfWaitToReadReturnedFalse( byte[] bytes, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Target] DefaultGatewayRxWorker worker ) { var cancellationToken = new CancellationToken(false); channel.WaitToRead(Any <CancellationToken>()).Returns(false); await worker.Start(gateway); await worker.Run(cancellationToken); await channel.DidNotReceive().Read(Is(cancellationToken)); }
public async Task RunShouldNotReadFromChannelIfWaitToReadReturnsFalse( [Substitute] IClientWebSocket clientWebSocket, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] IChannel <GatewayMessage> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayTxWorker worker ) { var cancellationToken = new CancellationToken(false); channel.WaitToRead(Any <CancellationToken>()).Returns(false); clientWebSocket.State.Returns(WebSocketState.Open); await worker.Start(gateway, clientWebSocket); await worker.Run(cancellationToken); await channel.DidNotReceive().Read(Is(cancellationToken)); }
/// <summary> /// Initializes a new instance of the <see cref="DefaultGatewayService" /> class. /// </summary> /// <param name="rxWorker">The worker to use for receiving message chunks and parsing messages.</param> /// <param name="txWorker">The worker to use for sending messages to the gateway.</param> /// <param name="timerFactory">Factory to create timers with.</param> /// <param name="restartService">Service used to restart the gateway.</param> /// <param name="gatewayUtilsFactory">Factory to create various utils with.</param> /// <param name="options">Options to use for interacting with the gateway.</param> /// <param name="logger">Logger used to log information to some destination(s).</param> public DefaultGatewayService( IGatewayRxWorker rxWorker, IGatewayTxWorker txWorker, ITimerFactory timerFactory, IGatewayRestartService restartService, IGatewayUtilsFactory gatewayUtilsFactory, IOptions <GatewayOptions> options, ILogger <DefaultGatewayService> logger ) { this.rxWorker = rxWorker; this.txWorker = txWorker; this.timerFactory = timerFactory; this.restartService = restartService; this.gatewayUtilsFactory = gatewayUtilsFactory; this.options = options.Value; this.logger = logger; buffer = new byte[this.options.BufferSize]; memoryBuffer = new Memory <byte>(buffer); }
public async Task ShouldStartSendingAHeartbeatToTheTxWorker( uint interval, int sequenceNumber, [Frozen] ITimer timer, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayTxWorker txWorker, [Frozen, Substitute] ITimerFactory timerFactory, [Target] DefaultGatewayService gateway ) { var cancellationToken = new CancellationToken(false); gateway.SequenceNumber = sequenceNumber; await gateway.StartAsync(); await gateway.StartHeartbeat(interval); timerFactory.Received().CreateTimer(Is <AsyncTimerCallback>(gateway.Heartbeat), Is((int)interval), Is("Heartbeat")); await timer.Received().Start(); }
public async Task StopShouldStopTheHeartbeat( ITimer heartbeat, [Frozen, Substitute] ITimerFactory timerFactory, [Frozen, Substitute] IGatewayTxWorker txWorker, [Frozen, Substitute] IGatewayUtilsFactory factory, [Target] DefaultGatewayService gateway ) { var cancellationToken = new CancellationToken(false); timerFactory.CreateTimer(Any <AsyncTimerCallback>(), Any <int>(), Is("Heartbeat")).Returns(heartbeat); await gateway.StartAsync(); await gateway.StartHeartbeat(10); await gateway.StopAsync(); await heartbeat.Received().Stop(); }
public async Task RunShouldNotDeserializeTheMessageIfEndOfMessageIsNotReached( byte[] bytes, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Target] DefaultGatewayRxWorker worker ) { var cancellationToken = new CancellationToken(false); channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, false)); await worker.Start(gateway); await worker.Run(cancellationToken); await serializer.DidNotReceive().Deserialize <GatewayMessage>(Is(stream), Is(cancellationToken)); }
public async Task RunShouldNotRouteTheMessageIfEndOfMessageIsReachedButEventDataIsNull( byte[] bytes, uint interval, int sequenceNumber, [Frozen, Substitute] Stream stream, [Frozen, Substitute] IChannel <GatewayMessageChunk> channel, [Frozen, Substitute] IGatewayUtilsFactory factory, [Frozen, Substitute] IGatewayService gateway, [Frozen, Substitute] ISerializer serializer, [Frozen, Substitute] IEventRouter router, [Target] DefaultGatewayRxWorker worker ) { channel.Read(Any <CancellationToken>()).Returns(new GatewayMessageChunk(bytes, bytes.Length, true)); await worker.Start(gateway); await worker.Run(); await router.DidNotReceive().Route(Any <IGatewayEvent>(), Any <CancellationToken>()); }