Merge from develop.

Tests/MQTTnet.Benchmarks/MQTTnet.Benchmarks.csproj

@@ -3,8 +3,9 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <DebugType>Full</DebugType>
-    <TargetFramework>net461</TargetFramework>
-      <LangVersion>7.2</LangVersion>
+    <TargetFramework Condition=" '$(OS)' == 'Windows_NT' ">net461</TargetFramework>
+    <TargetFramework Condition=" '$(OS)' != 'Windows_NT' ">netcoreapp2.1</TargetFramework>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

Tests/MQTTnet.Core.Tests/MqttClientTests.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -8,6 +10,7 @@ using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Packets;
+using MQTTnet.Server;
 
 namespace MQTTnet.Core.Tests
 {
@@ -15,7 +18,7 @@ namespace MQTTnet.Core.Tests
     public class MqttClientTests
     {
         [TestMethod]
-        public async Task ClientDisconnectException()
+        public async Task Client_Disconnect_Exception()
         {
             var factory = new MqttFactory();
             var client = factory.CreateMqttClient();
@@ -39,9 +42,95 @@ namespace MQTTnet.Core.Tests
             Assert.IsInstanceOfType(ex.InnerException, typeof(SocketException));
         }
 
+        [TestMethod]
+        public async Task Client_Publish()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            
+            try
+            {
+                var receivedMessages = new List<MqttApplicationMessage>();
+
+                await server.StartAsync(new MqttServerOptions());
+
+                var client1 = new MqttFactory().CreateMqttClient();
+                client1.ApplicationMessageReceived += (_, e) =>
+                {
+                    lock (receivedMessages)
+                    {
+                        receivedMessages.Add(e.ApplicationMessage);
+                    }
+                };
+
+                await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").Build());
+                await client1.SubscribeAsync("a");
+
+                var client2 = new MqttFactory().CreateMqttClient();
+                await client2.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").Build());
+                var message = new MqttApplicationMessageBuilder().WithTopic("a").WithRetainFlag().Build();
+                await client2.PublishAsync(message);
+
+                await Task.Delay(500);
+
+                Assert.AreEqual(1, receivedMessages.Count);
+                Assert.IsFalse(receivedMessages.First().Retain); // Must be false even if set above!
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
+        [TestMethod]
+        public async Task Publish_Special_Content()
+        {
+            var factory = new MqttFactory();
+            var server = factory.CreateMqttServer();
+            var serverOptions = new MqttServerOptionsBuilder().Build();
+
+            var receivedMessages = new List<MqttApplicationMessage>();
+
+            var client = factory.CreateMqttClient();
+
+            try
+            {
+                await server.StartAsync(serverOptions);
+
+                client.Connected += async (s, e) =>
+                {
+                    await client.SubscribeAsync("RCU/P1/H0001/R0003");
+
+                    var msg = new MqttApplicationMessageBuilder()
+                        .WithPayload("DA|18RS00SC00XI0000RV00R100R200R300R400L100L200L300L400Y100Y200AC0102031800BELK0000BM0000|")
+                        .WithTopic("RCU/P1/H0001/R0003");
+
+                    await client.PublishAsync(msg.Build());
+                };
+
+                client.ApplicationMessageReceived += (s, e) =>
+                {
+                    lock (receivedMessages)
+                    {
+                        receivedMessages.Add(e.ApplicationMessage);
+                    }
+                };
+
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build());
+
+                await Task.Delay(500);
+
+                Assert.AreEqual(1, receivedMessages.Count);
+                Assert.AreEqual("DA|18RS00SC00XI0000RV00R100R200R300R400L100L200L300L400Y100Y200AC0102031800BELK0000BM0000|", receivedMessages.First().ConvertPayloadToString());
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
+
 #if DEBUG
         [TestMethod]
-        public async Task ClientCleanupOnAuthentificationFails()
+        public async Task Client_Cleanup_On_Authentification_Fails()
         {
             var channel = new TestMqttCommunicationAdapter();
             var channel2 = new TestMqttCommunicationAdapter();
@@ -50,7 +139,10 @@ namespace MQTTnet.Core.Tests
 
             Task.Run(async () => {
                 var connect = await channel2.ReceivePacketAsync(TimeSpan.Zero, CancellationToken.None);
-                await channel2.SendPacketAsync(new MqttConnAckPacket { ConnectReturnCode = Protocol.MqttConnectReturnCode.ConnectionRefusedNotAuthorized }, CancellationToken.None);
+                await channel2.SendPacketAsync(new MqttConnAckPacket
+                {
+                    ConnectReturnCode = Protocol.MqttConnectReturnCode.ConnectionRefusedNotAuthorized
+                }, CancellationToken.None);
             });
             
             var fake = new TestMqttCommunicationAdapterFactory(channel);

Tests/MQTTnet.Core.Tests/MqttServerTests.cs

@@ -4,6 +4,7 @@ using MQTTnet.Diagnostics;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -227,6 +228,39 @@ namespace MQTTnet.Core.Tests
 
             Assert.AreEqual(2000, receivedMessagesCount);
         }
+        
+        [TestMethod]
+        public async Task MqttServer_SessionTakeover()
+        {
+            var server = new MqttFactory().CreateMqttServer();
+            try
+            {
+                await server.StartAsync(new MqttServerOptions());
+
+                var client1 = new MqttFactory().CreateMqttClient();
+                var client2 = new MqttFactory().CreateMqttClient();
+
+                var options = new MqttClientOptionsBuilder()
+                    .WithTcpServer("localhost")
+                    .WithCleanSession(false)
+                    .WithClientId("a").Build();
+
+                await client1.ConnectAsync(options);
+
+                await Task.Delay(500);
+
+                await client2.ConnectAsync(options);
+
+                await Task.Delay(500);
+
+                Assert.IsFalse(client1.IsConnected);
+                Assert.IsTrue(client2.IsConnected);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+        }
 
         private static async Task Publish(IMqttClient c1, MqttApplicationMessage message)
         {
@@ -267,11 +301,6 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public async Task MqttServer_HandleCleanDisconnect()
         {
-            MqttNetGlobalLogger.LogMessagePublished += (_, e) =>
-            {
-                System.Diagnostics.Debug.WriteLine($"[{e.TraceMessage.Timestamp:s}] {e.TraceMessage.Source} {e.TraceMessage.Message}");
-            };
-
             var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
             var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
@@ -304,6 +333,51 @@ namespace MQTTnet.Core.Tests
             Assert.AreEqual(clientConnectedCalled, clientDisconnectedCalled);
         }
 
+        [TestMethod]
+        public async Task MqttServer_Client_Disconnect_Without_Errors()
+        {
+            var errors = 0;
+
+            MqttNetGlobalLogger.LogMessagePublished += (_, e) =>
+            {
+                System.Diagnostics.Debug.WriteLine($"[{e.TraceMessage.Timestamp:s}] {e.TraceMessage.Source} {e.TraceMessage.Message}");
+
+                if (e.TraceMessage.Level == MqttNetLogLevel.Error)
+                {
+                    errors++;
+                }
+            };
+
+            bool clientWasConnected;
+
+            var server = new MqttFactory().CreateMqttServer();
+            try
+            {
+                var options = new MqttServerOptionsBuilder().Build();
+                await server.StartAsync(options);
+
+                var client = new MqttFactory().CreateMqttClient();
+                var clientOptions = new MqttClientOptionsBuilder()
+                    .WithTcpServer("localhost")
+                    .Build();
+
+                await client.ConnectAsync(clientOptions);
+
+                clientWasConnected = true;
+
+                await client.DisconnectAsync();
+
+                await Task.Delay(500);
+            }
+            finally
+            {
+                await server.StopAsync();
+            }
+            
+            Assert.IsTrue(clientWasConnected);
+            Assert.AreEqual(0, errors);
+        }
+
         [TestMethod]
         public async Task MqttServer_LotsOfRetainedMessages()
         {
@@ -389,6 +463,8 @@ namespace MQTTnet.Core.Tests
             }
 
             await c2.DisconnectAsync();
+
+            await s.StopAsync();
         }
 
         [TestMethod]
@@ -427,7 +503,7 @@ namespace MQTTnet.Core.Tests
             var serverAdapter = new TestMqttServerAdapter();
             var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
-            var receivedMessagesCount = 0;
+            var receivedMessages = new List<MqttApplicationMessage>();
             try
             {
                 await s.StartAsync(new MqttServerOptions());
@@ -437,7 +513,14 @@ namespace MQTTnet.Core.Tests
                 await c1.DisconnectAsync();
 
                 var c2 = await serverAdapter.ConnectTestClient("c2");
-                c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
+                c2.ApplicationMessageReceived += (_, e) =>
+                {
+                    lock (receivedMessages)
+                    {
+                        receivedMessages.Add(e.ApplicationMessage);
+                    }
+                };
+
                 await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained").Build());
 
                 await Task.Delay(500);
@@ -447,7 +530,8 @@ namespace MQTTnet.Core.Tests
                 await s.StopAsync();
             }
 
-            Assert.AreEqual(1, receivedMessagesCount);
+            Assert.AreEqual(1, receivedMessages.Count);
+            Assert.IsTrue(receivedMessages.First().Retain);
         }
 
         [TestMethod]
@@ -655,26 +739,29 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public async Task MqttServer_SameClientIdConnectDisconnectEventOrder()
         {
-            var serverAdapter = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
-            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
+            var s = new MqttFactory().CreateMqttServer();
 
-            var connectedClient = false;
-            var connecteCalledBeforeConnectedClients = false;
+            var events = new List<string>();
 
             s.ClientConnected += (_, __) =>
             {
-                connecteCalledBeforeConnectedClients |= connectedClient;
-                connectedClient = true;
+                lock (events)
+                {
+                    events.Add("c");
+                }
             };
 
             s.ClientDisconnected += (_, __) =>
             {
-                connectedClient = false;
+                lock (events)
+                {
+                    events.Add("d");
+                }
             };
 
             var clientOptions = new MqttClientOptionsBuilder()
                 .WithTcpServer("localhost")
-                .WithClientId(Guid.NewGuid().ToString())
+                .WithClientId("same_id")
                 .Build();
 
             await s.StartAsync(new MqttServerOptions());
@@ -684,20 +771,24 @@ namespace MQTTnet.Core.Tests
 
             await c1.ConnectAsync(clientOptions);
 
-            await Task.Delay(100);
+            await Task.Delay(250);
 
             await c2.ConnectAsync(clientOptions);
 
-            await Task.Delay(100);
+            await Task.Delay(250);
 
             await c1.DisconnectAsync();
+
+            await Task.Delay(250);
+
             await c2.DisconnectAsync();
 
+            await Task.Delay(250);
+
             await s.StopAsync();
 
-            await Task.Delay(100);
-
-            Assert.IsFalse(connecteCalledBeforeConnectedClients, "ClientConnected was called before ClientDisconnect was called");
+            var flow = string.Join(string.Empty, events);
+            Assert.AreEqual("cdcd", flow);
         }
 
 
@@ -725,6 +816,8 @@ namespace MQTTnet.Core.Tests
             await server.StartAsync(new MqttServerOptions());
             var client3 = new MqttFactory().CreateMqttClient();
             await client3.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build());
+
+            await server.StopAsync();
         }
 
         private class TestStorage : IMqttServerStorage

Tests/MQTTnet.Core.Tests/MqttSubscriptionsManagerTests.cs

@@ -1,6 +1,4 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
@@ -13,7 +11,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeSingleSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServer(new IMqttServerAdapter[0], new MqttNetLogger().CreateChildLogger("")));
+            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilterBuilder().WithTopic("A/B/C").Build());
@@ -28,7 +26,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeDifferentQoSSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServer(new IMqttServerAdapter[0], new MqttNetLogger().CreateChildLogger("")));
+            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilter("A/B/C", MqttQualityOfServiceLevel.AtMostOnce));
@@ -43,7 +41,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeTwoTimesSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServer(new IMqttServerAdapter[0], new MqttNetLogger().CreateChildLogger("")));
+            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilter("#", MqttQualityOfServiceLevel.AtMostOnce));
@@ -59,7 +57,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeSingleNoSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServer(new IMqttServerAdapter[0], new MqttNetLogger().CreateChildLogger("")));
+            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilterBuilder().WithTopic("A/B/C").Build());
@@ -72,7 +70,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeAndUnsubscribeSingle()
         {
-            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServer(new IMqttServerAdapter[0], new MqttNetLogger().CreateChildLogger("")));
+            var sm = new MqttClientSubscriptionsManager("", new MqttServerOptions(), new MqttServerEventDispatcher());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilterBuilder().WithTopic("A/B/C").Build());

Tests/MQTTnet.TestApp.NetCore/MQTTnet.TestApp.NetCore.csproj

@@ -3,7 +3,8 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <DebugType>Full</DebugType>
-    <TargetFrameworks>netcoreapp2.1;net452;net461</TargetFrameworks>
+    <TargetFrameworks>netcoreapp2.1</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netcoreapp2.1|AnyCPU'">

Tests/MQTTnet.TestApp.NetCore/ManagedClientTest.cs

@@ -61,13 +61,7 @@ namespace MQTTnet.TestApp.NetCore
 
         public class RandomPassword : IMqttClientCredentials
         {
-            public string Password
-            {
-                get
-                {
-                    return Guid.NewGuid().ToString(); // The random password.
-                }
-            }
+            public string Password => Guid.NewGuid().ToString();
 
             public string Username => "the_static_user";
         }