public void when_creating_stream_then_becomes_ready()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
Assert.True(!stream.IsDisposed);
}
public async Task when_sending_payload_with_identifier_then_receives_on_same_identifier()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
var clientReceived = 0;
var clientReceiver = stream
.Receive(EndpointIdentifier.Client)
.Subscribe(payload => {
clientReceived++;
});
var serverReceived = 0;
var serverReceiver = stream
.Receive(EndpointIdentifier.Server)
.Subscribe(payload => {
serverReceived++;
});
stream.Send(new byte[255], EndpointIdentifier.Client);
stream.Send(new byte[100], EndpointIdentifier.Client);
stream.Send(new byte[30], EndpointIdentifier.Client);
stream.Send(new byte[10], EndpointIdentifier.Server);
stream.Send(new byte[500], EndpointIdentifier.Server);
stream.Send(new byte[5], EndpointIdentifier.Server);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
Assert.Equal(3, clientReceived);
Assert.Equal(3, serverReceived);
}
public async Task when_sending_payload_with_identifier_then_receives_on_same_identifier()
{
MqttConfiguration configuration = new MqttConfiguration();
PrivateStream stream = new PrivateStream(configuration);
int clientReceived = 0;
IDisposable clientReceiver = stream
.Receive(EndpointIdentifier.Client)
.Subscribe(payload =>
{
clientReceived++;
});
int serverReceived = 0;
IDisposable serverReceiver = stream
.Receive(EndpointIdentifier.Server)
.Subscribe(payload =>
{
serverReceived++;
});
stream.Send(new byte[255], EndpointIdentifier.Client);
stream.Send(new byte[100], EndpointIdentifier.Client);
stream.Send(new byte[30], EndpointIdentifier.Client);
stream.Send(new byte[10], EndpointIdentifier.Server);
stream.Send(new byte[500], EndpointIdentifier.Server);
stream.Send(new byte[5], EndpointIdentifier.Server);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
3.Should().Be(clientReceived);
3.Should().Be(serverReceived);
}
public async Task when_sending_packet_then_stream_receives_successfully()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
var channel = new PrivateChannel(stream, EndpointIdentifier.Client, configuration);
var packetsReceived = 0;
stream
.Receive(EndpointIdentifier.Client)
.Subscribe(packet => {
packetsReceived++;
});
await channel.SendAsync(new byte[255]);
await channel.SendAsync(new byte[10]);
await channel.SendAsync(new byte[34]);
await channel.SendAsync(new byte[100]);
await channel.SendAsync(new byte[50]);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
Assert.Equal(5, packetsReceived);
}
public void when_disposing_stream_then_becomes_not_ready()
{
MqttConfiguration configuration = new MqttConfiguration();
PrivateStream stream = new PrivateStream(configuration);
stream.Dispose();
Assert.True(stream.IsDisposed);
}
public void when_disposing_channel_then_became_disconnected()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
var channel = new PrivateChannel(stream, EndpointIdentifier.Server, configuration);
channel.Dispose();
Assert.False(channel.IsConnected);
}
public void when_creating_channel_with_stream_ready_then_it_is_connected()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
var channel = new PrivateChannel(stream, EndpointIdentifier.Client, configuration);
Assert.True(channel.IsConnected);
Assert.NotNull(channel.ReceiverStream);
Assert.NotNull(channel.SenderStream);
}
public void when_creating_channel_with_stream_disposed_then_fails()
{
var configuration = new MqttConfiguration();
var stream = new PrivateStream(configuration);
stream.Dispose();
var ex = Assert.Throws <ObjectDisposedException> (() => new PrivateChannel(stream, EndpointIdentifier.Client, configuration));
Assert.NotNull(ex);
}
public async Task when_sending_to_stream_then_channel_receives_successfully()
{
MqttConfiguration configuration = new MqttConfiguration();
PrivateStream stream = new PrivateStream(configuration);
PrivateChannel channel = new PrivateChannel(stream, EndpointIdentifier.Server, configuration);
int packetsReceived = 0;
channel.ReceiverStream.Subscribe(packet =>
{
packetsReceived++;
});
stream.Send(new byte[255], EndpointIdentifier.Client);
stream.Send(new byte[10], EndpointIdentifier.Client);
stream.Send(new byte[34], EndpointIdentifier.Client);
stream.Send(new byte[100], EndpointIdentifier.Client);
stream.Send(new byte[50], EndpointIdentifier.Client);
await Task.Delay(TimeSpan.FromMilliseconds(1000));
5.Should().Be(packetsReceived);
}
