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