public async Task StartShouldStartTheTxWorker(
[Frozen, Substitute] IClientWebSocket clientWebSocket,
[Frozen, Substitute] IGatewayTxWorker txWorker,
[Target] DefaultGatewayService gateway
)
{
await gateway.StartAsync();
await txWorker.Received().Start(Is(gateway), Is(clientWebSocket));
}
public async Task StopShouldStopTheTxWorker(
[Frozen, Substitute] IGatewayTxWorker txWorker,
[Target] DefaultGatewayService gateway
)
{
await gateway.StartAsync();
await gateway.StopAsync();
await txWorker.Received().Stop();
}
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 SendShouldEmitTheMessageToTheTxWorker(
int sequenceNumber,
[Frozen, Substitute] IGatewayTxWorker txWorker,
[Target] DefaultGatewayService gateway
)
{
var message = new GatewayMessage {
SequenceNumber = sequenceNumber
};
var cancellationToken = new CancellationToken(false);
await gateway.StartAsync();
await gateway.Send(message, cancellationToken);
await txWorker.Received().Emit(Is(message), Is(cancellationToken));
}
public async Task ShouldSendAHeartbeatToTheTxWorker(
int sequenceNumber,
[Frozen, Substitute] IGatewayTxWorker txWorker,
[Target] DefaultGatewayService gateway,
CancellationToken cancellationToken
)
{
gateway.SequenceNumber = sequenceNumber;
await gateway.Heartbeat(cancellationToken);
await txWorker.Received().Emit(
Is <GatewayMessage>(message =>
message.OpCode == GatewayOpCode.Heartbeat &&
(HeartbeatEvent?)message.Data == sequenceNumber
),
Any <CancellationToken>()
);
}
public async Task SendShouldThrowIfTheOperationWasCanceled(
int sequenceNumber,
[Frozen, Substitute] IGatewayTxWorker txWorker,
[Target] DefaultGatewayService gateway
)
{
var message = new GatewayMessage {
SequenceNumber = sequenceNumber
};
var cancellationToken = new CancellationToken(false);
await gateway.StartAsync();
var operationCancellationToken = new CancellationToken(true);
Func <Task> func = () => gateway.Send(message, operationCancellationToken);
await func.Should().ThrowAsync <OperationCanceledException>();
}
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();
}
/// <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();
}
