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); } }