public async Task StartShouldStartTheRxWorker(
[Frozen, Substitute] IGatewayRxWorker rxWorker,
[Target] DefaultGatewayService gateway
)
{
await gateway.StartAsync();
await rxWorker.Received().Start(Is(gateway));
}
public async Task RunShouldReceiveChunksFromTheWebSocket(
[Frozen, Options] IOptions <GatewayOptions> options,
[Frozen, Substitute] IClientWebSocket webSocket,
[Frozen, Substitute] IGatewayRxWorker rxWorker,
[Target] DefaultGatewayService gateway
)
{
var cancellationToken = new CancellationToken(false);
webSocket.Receive(Any <Memory <byte> >(), Any <CancellationToken>()).Returns(x => new ValueWebSocketReceiveResult(0, WebSocketMessageType.Text, true));
await gateway.StartAsync();
await gateway.Run(cancellationToken);
await webSocket.Received().Receive(Any <Memory <byte> >(), Is(cancellationToken));
}
public async Task RunShouldNotConnectToTheWebSocketServerIfAlreadyConnected(
[Frozen, Options] IOptions <GatewayOptions> options,
[Frozen, Substitute] IClientWebSocket webSocket,
[Frozen, Substitute] IGatewayRxWorker rxWorker,
[Target] DefaultGatewayService gateway
)
{
var cancellationToken = new CancellationToken(false);
webSocket.State.Returns(WebSocketState.Open);
webSocket.Receive(Any <Memory <byte> >(), Any <CancellationToken>()).Returns(x => new ValueWebSocketReceiveResult(0, WebSocketMessageType.Text, true));
await gateway.StartAsync();
await gateway.Run(cancellationToken);
await webSocket.DidNotReceive().Connect(Is(options.Value.Uri), 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 RunShouldEmitMessageChunksToTheRxWorker(
string messageChunk,
[Frozen] CancellationTokenSource cancellationTokenSource,
[Frozen, Options] IOptions <GatewayOptions> options,
[Frozen, Substitute] IClientWebSocket webSocket,
[Frozen, Substitute] IGatewayRxWorker rxWorker,
[Target] DefaultGatewayService gateway
)
{
var buffer = new byte[messageChunk.Length];
var memoryBuffer = new Memory <byte>(buffer);
var cancellationToken = new CancellationToken(false);
gateway.SetPrivateField("buffer", buffer);
gateway.SetPrivateField("memoryBuffer", memoryBuffer);
webSocket.Receive(Any <Memory <byte> >(), Any <CancellationToken>()).Returns(x =>
{
var buffer = x.ArgAt <Memory <byte> >(0);
((Memory <byte>)Encoding.UTF8.GetBytes(messageChunk)).CopyTo(buffer);
return(new ValueWebSocketReceiveResult(messageChunk.Length, WebSocketMessageType.Text, true));
});
await gateway.StartAsync();
await gateway.Run(cancellationToken);
await rxWorker.Received().Emit(
Is <GatewayMessageChunk>(chunk =>
Encoding.UTF8.GetString(chunk.Bytes.ToArray()) == messageChunk &&
chunk.Count == messageChunk.Length &&
chunk.EndOfMessage
),
Is(cancellationToken)
);
}
