public async Task connect_throw_timeout()
{
Queue <TestPacket> packets = new();
packets.Enqueue(TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"));
PacketReplayer packetReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
Task <ConnectResult> connectTask = client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials("CKMqttTest", true));
connectTask.IsCompleted.Should().BeFalse();
await packetReplayer.LastWorkTask !;
packetReplayer.TestDelayHandler.IncrementTime(TimeSpan.FromMilliseconds(4999));
await Task.WhenAny(connectTask, Task.Delay(50));
connectTask.IsCompleted.Should().BeFalse();
packetReplayer.TestDelayHandler.IncrementTime(TimeSpan.FromMilliseconds(2));
(await connectTask).ConnectError.Should().Be(ConnectError.Timeout);
packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
/// <param name="client">The client that will send the message.</param>
/// <param name="m">The monitor used to log.</param>
/// <param name="message">The message that will be sent. It will be disposed after being stored.</param>
/// <returns>A ValueTask, that complete when the message has been stored, containing a Task that complete when the publish has been ack.
/// On QoS 0, the message is directly sent and the returned Task is Task.CompletedTask.
/// </returns>
public static async ValueTask <Task> PublishAsync(this IMqtt3Client client, IActivityMonitor?m, DisposableApplicationMessage message)
{
Task task = await client.PublishAsync(m, message.Topic, message.QoS, message.Retain, message.Payload); //The packet has been stored
message.Dispose(); // So we can dispose after it has been stored.
return(task); // The task we return complete when the packet has been acked.
}
public async Task connect_with_clean_session_but_connack_session_present_is_not_zero_should_fail()
{
Queue <TestPacket> packets = new();
TestPacket connectPacket = TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374");
for (byte i = 1; i != 0; i++) //Ok there we loop over all non zero bytes.
{
packets.Enqueue(connectPacket);
packets.Enqueue(TestPacket.Incoming("2002" + BitConverter.ToString(new byte[] { i }) + "00"));
}
PacketReplayer pcktReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
ConnectResult res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
res.ConnectError.Should().Be(ConnectError.ProtocolError_SessionNotFlushed);
for (byte i = 2; i != 0; i++)
{
res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
res.ConnectError.Should().Be(ConnectError.ProtocolError_InvalidConnackState);
}
pcktReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
public async Task connect_with_clean_session_but_connack_return_code_is_invalid_should_throw()
{
Queue <TestPacket> packets = new();
TestPacket connectPacket = TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374");
const int startSkipCount = 6; // These packets are valid, so we skip them.
for (byte i = startSkipCount; i != 0; i++) //Ok there we loop over all non zero bytes.
{
packets.Enqueue(connectPacket);
packets.Enqueue(TestPacket.Incoming("200200" + BitConverter.ToString(new byte[] { i })));
}
PacketReplayer packetReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
for (byte i = startSkipCount; i != 0; i++)
{
ConnectResult res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
res.ConnectError.Should().Be(ConnectError.ProtocolError_UnknownReturnCode);
}
packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
public async Task connect_while_being_connected_should_throw_friendly_exception()
{
Queue <TestPacket> packets = new();
packets.Enqueue(TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"));
packets.Enqueue(TestPacket.Incoming("20020000"));
PacketReplayer packetReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
try
{
await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
Assert.Fail();
}
catch (Exception e)
{
e.Should().BeOfType <InvalidOperationException>();
e.Message.Should().Be("This client is already connected.");
}
packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
public static (PacketReplayer packetReplayer, IMqtt3Client client) CreateTestClient(Queue <TestPacket> packets)
{
PacketReplayer pcktReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
return(pcktReplayer, client);
}
public async Task simple_connection_works()
{
PacketReplayer pcktReplayer = new(new Queue <TestPacket>(new List <TestPacket>()
{
TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"),
TestPacket.Incoming("20020000")
}));
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
pcktReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
public static async Task <(PacketReplayer packetReplayer, IMqtt3Client client)> ConnectedClient(IEnumerable <TestPacket> packets)
{
PacketReplayer pcktReplayer = new(new Queue <TestPacket>(new List <TestPacket>()
{
TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374"),
TestPacket.Incoming("20020000")
}.Concat(packets)));
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(pcktReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
return(pcktReplayer, client);
}
public async Task connect_after_failed_connect_works()
{
TestPacket connectPacket = TestPacket.Outgoing("101600044d5154540402001e000a434b4d71747454657374");
Queue <TestPacket> packets = new();
packets.Enqueue(connectPacket);
packets.Enqueue(TestPacket.Incoming("20021000")); // Invalid response.
packets.Enqueue(connectPacket);
packets.Enqueue(TestPacket.Incoming("20020000")); // Valid response.
PacketReplayer packetReplayer = new(packets);
IMqtt3Client client = MqttClient.Factory.CreateMQTT3Client(TestConfigs.DefaultTestConfig(packetReplayer), (IActivityMonitor m, DisposableApplicationMessage msg) =>
{
msg.Dispose();
return(new ValueTask());
});
ConnectResult res = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
res.ConnectError.Should().NotBe(ConnectError.Ok);
ConnectResult res2 = await client.ConnectAsync(TestHelper.Monitor, new MqttClientCredentials( "CKMqttTest", true ));
res2.ConnectError.Should().Be(ConnectError.Ok);
packetReplayer.LastWorkTask !.IsCompletedSuccessfully.Should().BeTrue();
}
public static ValueTask <Task> PublishAsync(this IMqtt3Client @this, IActivityMonitor m, ApplicationMessage message) => @this.PublishAsync(m, message.Topic, message.QoS, message.Retain, message.Payload);
public static void SetMessageHandler(this IMqtt3Client client, Func <IActivityMonitor, DisposableApplicationMessage, ValueTask> handler) => client.SetMessageHandler(new HandlerClosure(handler).HandleMessage);
public static async ValueTask <Task> PublishAsync(this IMqtt3Client client, IActivityMonitor m, string topic, QualityOfService qos, bool retain,
Func <int> getPayloadSize, PayloadWriterDelegate payloadWriter) //Async required to convert wrapped Task<object> to Task.
=> await client.SendPacket <object>(m, new BasicOutgoingApplicationMessage( topic, qos, retain, getPayloadSize, payloadWriter ));
public static async ValueTask <Task> PublishAsync(this IMqtt3Client client, IActivityMonitor?m, string topic, QualityOfService qos, bool retain, ReadOnlyMemory <byte> payload) => await client.SendPacket <object>(m, new SmallOutgoingApplicationMessage( topic, qos, retain, payload ));
