public async Task Publish_QoS_1_In_ApplicationMessageReceiveHandler()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
const string client1Topic = "client1/topic";
const string client2Topic = "client2/topic";
const string expectedClient2Message = "hello client2";
var client1 = await testEnvironment.ConnectClientAsync();
client1.UseApplicationMessageReceivedHandler(async c =>
{
await client1.PublishAsync(client2Topic, expectedClient2Message, MqttQualityOfServiceLevel.AtLeastOnce);
});
await client1.SubscribeAsync(client1Topic, MqttQualityOfServiceLevel.AtLeastOnce);
var client2 = await testEnvironment.ConnectClientAsync();
var client2TopicResults = new List <string>();
client2.UseApplicationMessageReceivedHandler(c =>
{
client2TopicResults.Add(Encoding.UTF8.GetString(c.ApplicationMessage.Payload));
});
await client2.SubscribeAsync(client2Topic);
var client3 = await testEnvironment.ConnectClientAsync();
var message = new MqttApplicationMessageBuilder().WithTopic(client1Topic).Build();
await client3.PublishAsync(message);
await client3.PublishAsync(message);
await Task.Delay(500);
Assert.AreEqual(2, client2TopicResults.Count);
Assert.AreEqual(expectedClient2Message, client2TopicResults[0]);
Assert.AreEqual(expectedClient2Message, client2TopicResults[1]);
}
}
public async Task Send_Long_Body()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
const int PayloadSizeInMB = 30;
const int CharCount = PayloadSizeInMB * 1024 * 1024;
var longBody = new byte[CharCount];
byte @char = 32;
for (long i = 0; i < PayloadSizeInMB * 1024L * 1024L; i++)
{
longBody[i] = @char;
@char++;
if (@char > 126)
{
@char = 32;
}
}
byte[] receivedBody = null;
await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
var client1 = await testEnvironment.ConnectClientAsync();
client1.UseApplicationMessageReceivedHandler(c =>
{
receivedBody = c.ApplicationMessage.Payload;
});
await client1.SubscribeAsync("string");
var client2 = await testEnvironment.ConnectClientAsync();
await client2.PublishAsync("string", longBody);
await Task.Delay(500);
Assert.IsTrue(longBody.SequenceEqual(receivedBody ?? new byte[0]));
}
}
public async Task Subscribe_Multiple_In_Multiple_Request()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var receivedMessagesCount = 0;
await testEnvironment.StartServerAsync();
var c1 = await testEnvironment.ConnectClientAsync();
c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter("a")
.Build());
await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter("b")
.Build());
await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
.WithTopicFilter("c")
.Build());
var c2 = await testEnvironment.ConnectClientAsync();
await c2.PublishAsync("a");
await Task.Delay(100);
Assert.AreEqual(receivedMessagesCount, 1);
await c2.PublishAsync("b");
await Task.Delay(100);
Assert.AreEqual(receivedMessagesCount, 2);
await c2.PublishAsync("c");
await Task.Delay(100);
Assert.AreEqual(receivedMessagesCount, 3);
}
}
public async Task Frequent_Connects()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var clients = new List <IMqttClient>();
for (var i = 0; i < 100; i++)
{
clients.Add(await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("a")));
}
var clientStatus = await testEnvironment.Server.GetClientStatusAsync();
var sessionStatus = await testEnvironment.Server.GetSessionStatusAsync();
for (var i = 0; i < 98; i++)
{
Assert.IsFalse(clients[i].IsConnected);
}
Assert.IsTrue(clients[99].IsConnected);
Assert.AreEqual(1, clientStatus.Count);
Assert.AreEqual(1, sessionStatus.Count);
var receiveClient = clients[99];
object receivedPayload = null;
receiveClient.UseApplicationMessageReceivedHandler(e =>
{
receivedPayload = e.ApplicationMessage.ConvertPayloadToString();
});
await receiveClient.SubscribeAsync("x");
var sendClient = await testEnvironment.ConnectClientAsync();
await sendClient.PublishAsync("x", "1");
await Task.Delay(100);
Assert.AreEqual("1", receivedPayload);
}
}
public async Task Publish_After_Client_Connects()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var receivedTopics = new List <string>();
var c1 = await testEnvironment.ConnectClientAsync(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
c1.UseApplicationMessageReceivedHandler(e =>
{
lock (receivedTopics)
{
receivedTopics.Add(e.ApplicationMessage.Topic);
}
});
await c1.SubscribeAsync("#");
var c2 = await testEnvironment.ConnectClientAsync(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
var message = new MqttApplicationMessage
{
Topic = "this_is_the_topic",
TopicAlias = 22
};
await c2.PublishAsync(message);
message.Topic = null;
await c2.PublishAsync(message);
await c2.PublishAsync(message);
await Task.Delay(500);
Assert.AreEqual(3, receivedTopics.Count);
CollectionAssert.AllItemsAreNotNull(receivedTopics);
Assert.IsTrue(receivedTopics.All(t => t.Equals("this_is_the_topic")));
}
}
public async Task Retained_Messages_Flow()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var retainedMessage = new MqttApplicationMessageBuilder().WithTopic("r").WithPayload("r").WithRetainFlag().Build();
await testEnvironment.StartServerAsync();
var c1 = await testEnvironment.ConnectClientAsync();
var receivedMessages = 0;
var c2 = await testEnvironment.ConnectClientAsync();
c2.UseApplicationMessageReceivedHandler(c =>
{
Interlocked.Increment(ref receivedMessages);
});
await c1.PublishAsync(retainedMessage);
await c1.DisconnectAsync();
await Task.Delay(500);
for (var i = 0; i < 5; i++)
{
await c2.UnsubscribeAsync("r");
await Task.Delay(100);
Assert.AreEqual(i, receivedMessages);
await c2.SubscribeAsync("r");
await Task.Delay(100);
Assert.AreEqual(i + 1, receivedMessages);
}
await c2.DisconnectAsync();
}
}
public async Task NoConnectedHandler_Connect_DoesNotThrowException()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync();
Assert.IsTrue(client.IsConnected);
}
}
public async Task Send_Manual_Ping()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync();
await client.PingAsync(CancellationToken.None);
}
}
public async Task Connect_And_Disconnect()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
await client.DisconnectAsync();
}
}
async Task <IMqttClient> TryConnect(TestEnvironment testEnvironment, MqttClientOptionsBuilder options)
{
try
{
return(await testEnvironment.ConnectClientAsync(options));
}
catch (System.Exception)
{
return(null);
}
}
public async Task Collect_Messages_In_Disconnected_Session()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithPersistentSessions());
// Create the session including the subscription.
var client1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("a"));
await client1.SubscribeAsync("x");
await client1.DisconnectAsync();
await Task.Delay(500);
var clientStatus = await server.GetClientStatusAsync();
Assert.AreEqual(0, clientStatus.Count);
var client2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("b"));
await client2.PublishAsync("x", "1");
await client2.PublishAsync("x", "2");
await client2.PublishAsync("x", "3");
await client2.DisconnectAsync();
await Task.Delay(500);
clientStatus = await server.GetClientStatusAsync();
var sessionStatus = await server.GetSessionStatusAsync();
Assert.AreEqual(0, clientStatus.Count);
Assert.AreEqual(2, sessionStatus.Count);
Assert.AreEqual(3, sessionStatus.First(s => s.ClientId == client1.Options.ClientId).PendingApplicationMessagesCount);
}
}
public async Task Send_Reply_In_Message_Handler()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client1 = await testEnvironment.ConnectClientAsync();
var client2 = await testEnvironment.ConnectClientAsync();
await client1.SubscribeAsync("#");
await client2.SubscribeAsync("#");
var replyReceived = false;
client1.UseApplicationMessageReceivedHandler(c =>
{
if (c.ApplicationMessage.Topic == "reply")
{
replyReceived = true;
}
});
client2.UseApplicationMessageReceivedHandler(async c =>
{
// Use AtMostOnce here because with QoS 1 or even QoS 2 the process waits for
// the ACK etc. The problem is that the SpinUntil below only waits until the
// flag is set. It does not wait until the client has sent the ACK
await client2.PublishAsync("reply", null, MqttQualityOfServiceLevel.AtMostOnce);
});
await client1.PublishAsync("request", null, MqttQualityOfServiceLevel.AtLeastOnce);
await Task.Delay(500);
SpinWait.SpinUntil(() => replyReceived, TimeSpan.FromSeconds(10));
Assert.IsTrue(replyReceived);
}
}
public async Task Execute_With_Custom_Topic_Names()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().WithTopicGenerationStrategy(new TestTopicStrategy()).Build());
await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
}
}
public async Task Execute_Timeout()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender);
await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
}
}
public async Task Session_Takeover()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var options = new MqttClientOptionsBuilder()
.WithCleanSession(false)
.WithClientId("a");
var client1 = await testEnvironment.ConnectClientAsync(options);
await Task.Delay(500);
var client2 = await testEnvironment.ConnectClientAsync(options);
await Task.Delay(500);
Assert.IsFalse(client1.IsConnected);
Assert.IsTrue(client2.IsConnected);
}
}
public async Task Use_User_Properties()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var sender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
var receiver = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
var message = new MqttApplicationMessageBuilder()
.WithTopic("A")
.WithUserProperty("x", "1")
.WithUserProperty("y", "2")
.WithUserProperty("z", "3")
.WithUserProperty("z", "4"); // z is here two times to test list of items
await receiver.SubscribeAsync(new MqttClientSubscribeOptions
{
TopicFilters = new List <TopicFilter>
{
new TopicFilter {
Topic = "#"
}
}
}, CancellationToken.None);
MqttApplicationMessage receivedMessage = null;
receiver.UseApplicationMessageReceivedHandler(e => receivedMessage = e.ApplicationMessage);
await sender.PublishAsync(message.Build(), CancellationToken.None);
await Task.Delay(1000);
Assert.IsNotNull(receivedMessage);
Assert.AreEqual("A", receivedMessage.Topic);
Assert.AreEqual(4, receivedMessage.UserProperties.Count);
}
}
private async Task Execute_Success(MqttQualityOfServiceLevel qosLevel, MqttProtocolVersion protocolVersion)
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var responseSender = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithProtocolVersion(protocolVersion));
await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping");
responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
{
await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
});
var requestSender = await testEnvironment.ConnectClientAsync();
var rpcClient = new MqttRpcClient(requestSender);
var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", qosLevel);
Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
}
}
public async Task Round_Trip_Time()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var receiverClient = await testEnvironment.ConnectClientAsync();
var senderClient = await testEnvironment.ConnectClientAsync();
await receiverClient.SubscribeAsync("#");
TaskCompletionSource <string> response = null;
receiverClient.UseApplicationMessageReceivedHandler(e =>
{
response?.SetResult(e.ApplicationMessage.ConvertPayloadToString());
});
var times = new List <TimeSpan>();
var stopwatch = Stopwatch.StartNew();
await Task.Delay(1000);
for (var i = 0; i < 100; i++)
{
response = new TaskCompletionSource <string>();
await senderClient.PublishAsync("test", DateTime.UtcNow.Ticks.ToString());
response.Task.GetAwaiter().GetResult();
stopwatch.Stop();
times.Add(stopwatch.Elapsed);
stopwatch.Restart();
}
}
}
public async Task Subscribe_With_QoS2()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client1 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
var client2 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
var disconnectedFired = false;
client1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(c =>
{
disconnectedFired = true;
});
var messageReceived = false;
client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c =>
{
messageReceived = true;
});
await client1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("topic1").WithExactlyOnceQoS().Build());
await Task.Delay(500);
var message = new MqttApplicationMessageBuilder().WithTopic("topic1").WithPayload("Hello World").WithExactlyOnceQoS().WithRetainFlag().Build();
await client2.PublishAsync(message);
await Task.Delay(500);
Assert.IsTrue(messageReceived);
Assert.IsTrue(client1.IsConnected);
Assert.IsFalse(disconnectedFired);
}
}
public async Task Show_Client_And_Session_Statistics()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var server = await testEnvironment.StartServerAsync();
var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client1"));
var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("client2"));
await Task.Delay(500);
var clientStatus = await server.GetClientStatusAsync();
var sessionStatus = await server.GetSessionStatusAsync();
Assert.AreEqual(2, clientStatus.Count);
Assert.AreEqual(2, sessionStatus.Count);
Assert.IsTrue(clientStatus.Any(s => s.ClientId == c1.Options.ClientId));
Assert.IsTrue(clientStatus.Any(s => s.ClientId == c2.Options.ClientId));
await c1.DisconnectAsync();
await c2.DisconnectAsync();
await Task.Delay(500);
clientStatus = await server.GetClientStatusAsync();
sessionStatus = await server.GetSessionStatusAsync();
Assert.AreEqual(0, clientStatus.Count);
Assert.AreEqual(0, sessionStatus.Count);
}
}
public async Task Receive_No_Retained_Message_After_Subscribe()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync();
var c1 = await testEnvironment.ConnectClientAsync();
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await c1.DisconnectAsync();
var receivedMessagesCount = 0;
var c2 = await testEnvironment.ConnectClientAsync();
c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained_other").Build());
await Task.Delay(500);
Assert.AreEqual(0, receivedMessagesCount);
}
}
public async Task Subscribe_And_Publish()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var receivedMessages = new List <MqttApplicationMessageReceivedEventArgs>();
var client1 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client1"));
client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
{
lock (receivedMessages)
{
receivedMessages.Add(e);
}
});
await client1.SubscribeAsync("a");
var client2 = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client2"));
await client2.PublishAsync("a", "b");
await Task.Delay(500);
await client2.DisconnectAsync();
await client1.DisconnectAsync();
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("client1", receivedMessages[0].ClientId);
Assert.AreEqual("a", receivedMessages[0].ApplicationMessage.Topic);
Assert.AreEqual("b", receivedMessages[0].ApplicationMessage.ConvertPayloadToString());
}
}
public async Task Publish_QoS_2()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
var result = await client.PublishAsync("a", "b", MqttQualityOfServiceLevel.ExactlyOnce);
await client.DisconnectAsync();
Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
}
}
public async Task Set_ClientWasConnected_On_ClientDisconnect()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var server = await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync();
Assert.IsTrue(client.IsConnected);
client.UseDisconnectedHandler(e => Assert.IsTrue(e.ClientWasConnected));
await client.DisconnectAsync();
await Task.Delay(200);
}
}
public async Task Persist_Retained_Message()
{
var serverStorage = new TestServerStorage();
using (var testEnvironment = new TestEnvironment(TestContext))
{
await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder().WithStorage(serverStorage));
var c1 = await testEnvironment.ConnectClientAsync();
await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
await Task.Delay(500);
Assert.AreEqual(1, serverStorage.Messages.Count);
}
}
public async Task Fire_Disconnected_Event_On_Server_Shutdown()
{
using (var testEnvironment = new TestEnvironment())
{
var server = await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync();
var handlerFired = false;
client.UseDisconnectedHandler(e => handlerFired = true);
await server.StopAsync();
await Task.Delay(4000);
Assert.IsTrue(handlerFired);
}
}
public async Task Unsubscribe()
{
using (var testEnvironment = new TestEnvironment())
{
await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync(o => o.WithProtocolVersion(MqttProtocolVersion.V500));
await client.SubscribeAsync("a");
var result = await client.UnsubscribeAsync("a");
await client.DisconnectAsync();
Assert.AreEqual(1, result.Items.Count);
Assert.AreEqual(MqttClientUnsubscribeResultCode.Success, result.Items[0].ReasonCode);
}
}
private async Task <IMqttClient> TryConnect_Subscribe(TestEnvironment testEnvironment, MqttClientOptionsBuilder options, Action onReceive)
{
try
{
var sendClient = await testEnvironment.ConnectClientAsync(options);
sendClient.ApplicationMessageReceivedHandler = new MQTTnet.Client.Receiving.MqttApplicationMessageReceivedHandlerDelegate(e =>
{
onReceive();
});
await sendClient.SubscribeAsync("aaa");
return(sendClient);
}
catch (System.Exception)
{
return(null);
}
}
public async Task Reconnect_While_Server_Offline()
{
using (var testEnvironment = new TestEnvironment())
{
testEnvironment.IgnoreClientLogErrors = true;
var server = await testEnvironment.StartServerAsync();
var client = await testEnvironment.ConnectClientAsync();
await Task.Delay(500);
Assert.IsTrue(client.IsConnected);
await server.StopAsync();
await Task.Delay(500);
Assert.IsFalse(client.IsConnected);
for (var i = 0; i < 5; i++)
{
try
{
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
Assert.Fail("Must fail!");
}
catch
{
}
}
await server.StartAsync(new MqttServerOptionsBuilder().WithDefaultEndpointPort(testEnvironment.ServerPort).Build());
await Task.Delay(500);
await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
Assert.IsTrue(client.IsConnected);
}
}
public async Task Remove_Session()
{
using (var testEnvironment = new TestEnvironment(TestContext))
{
var server = await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
var clientOptions = new MqttClientOptionsBuilder();
var c1 = await testEnvironment.ConnectClientAsync(clientOptions);
await Task.Delay(500);
Assert.AreEqual(1, (await server.GetClientStatusAsync()).Count);
await c1.DisconnectAsync();
await Task.Delay(500);
Assert.AreEqual(0, (await server.GetClientStatusAsync()).Count);
}
}
