Add device test

2025-08-01 08:39:21 +02:00
parent 307e253588
commit 45ff96ef39
12 changed files with 760 additions and 192 deletions
--- a/Aperio_Control_Centre.UnitTest/AperioServer/AperioBaseDevice_Test.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/AperioBaseDevice_Test.cs
@@ -0,0 +1,271 @@
+using Aperio_Control_Centre.Aadp;
+using Aperio_Control_Centre.Aadp.ApplicationTypes;
+using Aperio_Control_Centre.ACSDatabase;
+using Aperio_Control_Centre.ACSDatabase.Models;
+using Aperio_Control_Centre.ACSDatabase.Types;
+using Aperio_Control_Centre.AperioServer;
+using Microsoft.AspNetCore.Connections;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+using System.Net;
+
+namespace Aperio_Control_Centre.UnitTest.AperioServer
+{
+    [TestClass]
+    public class AperioBaseDevice_Test : AperioTestSetup
+    {
+        private DeviceDefinition? _deviceDefinition;
+
+        public AperioBaseDevice CreateAperioBaseDevice()
+        {
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_dbContextFactory);
+
+            _deviceDefinition = new("AA11BB", "445566", Enumerations.ProductClass.LOCK);
+            AperioLockDevice lockDevice = new(_deviceDefinition.DeviceIdentity, _deviceDefinition.Host, _screenLogging, _statusBroadcast, _dbContextFactory);
+
+            Assert.AreEqual("AA11BB", lockDevice.Id);
+            Assert.AreEqual("445566", lockDevice.HubDeviceId.ToId());
+            Assert.AreNotEqual(0, lockDevice.LastData.Ticks);
+
+            //Task.Run(async () =>
+            //{
+            //    await lockDevice.SetConnection(_connectionMoq.Object, _token);
+            //}).GetAwaiter().GetResult();
+
+            //Assert.AreEqual("64.226.1.0", lockDevice.IPAddress);
+
+            Assert.IsNull(lockDevice.GetConnection());
+            Assert.AreEqual(ConnectionStates.Offline, lockDevice.GetConnectionState());            
+
+            //lockDevice.DataBaseDeviceID = 1;
+            //Assert.AreEqual(1, lockDevice.DataBaseDeviceID);
+
+            Assert.AreEqual(Enumerations.Status.UNKNOWN, lockDevice.GetDeviceStatus());
+
+            Assert.AreEqual("445566", lockDevice.HubDeviceId.ToId());
+
+            Assert.AreEqual(BatteryStates.Unknown, lockDevice.GetBatteryState());
+            Assert.AreEqual(Enumerations.DoorMode.UNKNOWN, lockDevice.GetDoorMode());
+            Assert.AreEqual(Enumerations.DoorState.UNKNOWN, lockDevice.GetDoorState());
+            Assert.AreEqual(Enumerations.LockState.UNKNOWN, lockDevice.GetLockState());
+            Assert.AreEqual(Enumerations.KeyCylinderState.UNKNOWN, lockDevice.GetKeyCylinderState());
+            Assert.AreEqual(Enumerations.HandleState.UNKNOWN, lockDevice.GetHandleState());
+            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.GetTamperState());
+
+            Assert.AreEqual(string.Empty, lockDevice.FirmwareVersion);
+            Assert.IsNull(lockDevice.HwVersion);
+            //Assert.IsNotNull(optaDevice.HwVersion);
+            //Assert.AreEqual("", optaDevice.HwVersion.PCBSerialNumber);
+            //Assert.AreEqual("", optaDevice.HwVersion.BOMVersion);
+            //Assert.AreEqual("", optaDevice.HwVersion.PCBVersion);
+            //Assert.AreEqual(Aadp.Types.PCBIdentity.OPTA_V1, optaDevice.HwVersion.PCBIdentity);
+
+            Assert.AreEqual(Enumerations.LockVersions.UNKNOWN, lockDevice.LockVersion);
+
+            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyInsideState);
+            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyOutsideState);
+            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.ManualOpenState);
+
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+
+            return lockDevice;
+        }
+
+
+        [TestMethod]
+        public void AperioBaseDevice_Init_Test()
+        {
+            AperioBaseDevice device = CreateAperioBaseDevice();
+            Assert.IsNotNull(device);
+        }
+
+
+        [TestMethod]
+        public void AperioBaseDevice_BatteryState_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+
+            AperioBaseDevice device = CreateAperioBaseDevice();
+
+            Assert.AreEqual(BatteryStates.Unknown, device.GetBatteryState());
+
+            Task.Run(async () =>
+            {
+                await device.SetBatteryState(BatteryStates.Low, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(BatteryStates.Low, device.GetBatteryState());
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendBatteryStatus AA11BB Low", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            //Assert.AreEqual("Ip address veranderd naar 64.226.1.0", logs[0].Message);
+            Assert.AreEqual("Batterij laag", logs[0].Message);
+
+            Assert.AreEqual(BatteryStates.Low, logs[0].Device?.BatteryState);
+        }
+
+        [TestMethod]
+        public void AperioBaseDevice_DoorState_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+
+            AperioBaseDevice device = CreateAperioBaseDevice();
+
+            Assert.AreEqual(Enumerations.DoorState.UNKNOWN, device.GetDoorState());
+
+            Task.Run(async () =>
+            {
+                await device.SetDoorState(Enumerations.DoorState.CLOSED, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(Enumerations.DoorState.CLOSED, device.GetDoorState());
+
+            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            //Assert.AreEqual("Ip address veranderd naar 64.226.1.0", logs[0].Message);
+            Assert.AreEqual("Doorstate (CLOSED)", logs[0].Message);
+
+            Assert.AreEqual(Enumerations.DoorState.CLOSED, logs[0].Device?.DoorState);
+        }
+
+        [TestMethod]
+        public void AperioBaseDevice_LockState_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+
+            AperioBaseDevice device = CreateAperioBaseDevice();
+
+            Assert.AreEqual(Enumerations.LockState.UNKNOWN, device.GetLockState());
+
+            Task.Run(async () =>
+            {
+                await device.SetLockState(Enumerations.LockState.JAMMED, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(Enumerations.LockState.JAMMED, device.GetLockState());
+
+            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            //Assert.AreEqual("Ip address veranderd naar 64.226.1.0", logs[0].Message);
+            Assert.AreEqual("Slot geblokkeerd", logs[0].Message);
+
+            Assert.AreEqual(Enumerations.LockState.JAMMED, logs[0].Device?.LockState);
+        }
+
+        [TestMethod]
+        public void AperioBaseDevice_ChangeIpAddress_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+
+            AperioBaseDevice device = CreateAperioBaseDevice();
+
+            Task.Run(async () =>
+            {
+                await device.SetConnection(_connectionMoq.Object, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual("64.226.1.0", device.IPAddress);
+
+            _connectionMoq = new Mock<ConnectionContext>();
+            _ = _connectionMoq.Setup(s => s.RemoteEndPoint).Returns(new IPEndPoint(654321, 1234));
+            _ = _connectionMoq.Setup(s => s.Transport.Output.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>()));
+
+            Task.Run(async () =>
+            {
+                await device.SetConnection(_connectionMoq.Object, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual("241.251.9.0", device.IPAddress);
+
+            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(2, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Ip address veranderd naar 64.226.1.0", logs[0].Message);
+            Assert.AreEqual("Ip address veranderd naar 241.251.9.0", logs[1].Message);
+
+            Assert.AreEqual("241.251.9.0", logs[0].Device?.Ipaddress);
+        }
+
+        [TestMethod]
+        public void AperioBaseDevice_SetConnectionState_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+
+            AperioBaseDevice device = CreateAperioBaseDevice();
+
+            Assert.AreEqual(ConnectionStates.Offline, device.GetConnectionState());
+
+
+            Assert.IsNotNull(_dbContextFactory);
+            using (ACSDatabaseContext db = _dbContextFactory.CreateDbContext())
+            {
+                db.Devices.First().ConnectionState = ConnectionStates.Offline;
+                db.SaveChanges();
+            }
+
+            Task.Run(async () =>
+            {
+                await device.SetConnectionState(ConnectionStates.Online, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(ConnectionStates.Online, device.GetConnectionState());
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendConnectionStatus AA11BB Online", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            using ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Apparaat online", logs[0].Message);
+
+            Assert.AreEqual(ConnectionStates.Online, logs[0].Device?.ConnectionState);
+        }
+    }
+}
--- a/Aperio_Control_Centre.UnitTest/AperioServer/AperioHubDevice_Test.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/AperioHubDevice_Test.cs
@@ -1,6 +1,10 @@
 using Aperio_Control_Centre.Aadp;
+using Aperio_Control_Centre.Aadp.ApplicationTypes;
+using Aperio_Control_Centre.ACSDatabase;
+using Aperio_Control_Centre.ACSDatabase.Models;
 using Aperio_Control_Centre.ACSDatabase.Types;
 using Aperio_Control_Centre.AperioServer;
+using Microsoft.EntityFrameworkCore;

 namespace Aperio_Control_Centre.UnitTest.AperioServer
 {
@@ -19,13 +23,13 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            Assert.IsNotNull(hubDevice.LastData);
            Assert.AreNotEqual(0, hubDevice.LastData.Ticks);

-            Task.Run(async () =>
-            {
-                await hubDevice.SetConnection(_connectionMoq.Object, _token);
-            }).GetAwaiter().GetResult();
+            //Task.Run(async () =>
+            //{
+            //    await hubDevice.SetConnection(_connectionMoq.Object, _token);
+            //}).GetAwaiter().GetResult();


-            Assert.AreEqual("64.226.1.0", hubDevice.IPAddress);
+            //Assert.AreEqual("64.226.1.0", hubDevice.IPAddress);
            Assert.AreEqual(ConnectionStates.Offline, hubDevice.GetConnectionState());

            Assert.AreEqual(0, hubDevice.DataBaseDeviceID);
@@ -64,7 +68,91 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
        public void AperioHubDevice_Init_Test()
        {
            AperioHubDevice aperioHub = CreateHubDevice();
+            Assert.IsNotNull(aperioHub);
            aperioHub.Dispose();
        }
+
+        [TestMethod]
+        public void AperioHUBDevice_UpdateDataBaseDevice_New_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
+            using AperioHubDevice device = new(new("FF00AA"), _screenLogging, _statusBroadcast, _dbContextFactory);
+
+            Assert.AreEqual("FF00AA", device.Id);
+            Assert.IsNull(device.GetConnection());
+
+            Task.Run(async () =>
+            {
+                await device.UpdateDataBaseDevice(_connectionMoq.Object, _token);
+            }).GetAwaiter().GetResult();
+
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendDeviceAdded FF00AA", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("HUB apparaat FF00AA aangemaakt", logs[0].Message);
+            //Assert.AreEqual("Hub address veranderd naar FFEECC", logs[1].Message);
+            //Assert.AreEqual("Locatie veranderd naar 1234AB", logs[2].Message);
+
+            Assert.AreEqual("FF00AA", logs[0].Device?.DeviceId);
+            Assert.AreEqual("FF00AA", logs[0].Device?.Name);
+            Assert.IsNull(logs[0].Device?.LocationId);
+            Assert.AreEqual("64.226.1.0", logs[0].Device?.Ipaddress);
+        }
+
+        [TestMethod]
+        public void AperioHUBDevice_UpdateDataBaseDevice_Update_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
+            using AperioHubDevice device = new(new("445566"), _screenLogging, _statusBroadcast, _dbContextFactory);
+
+            Assert.AreEqual("445566", device.Id);
+            Assert.AreEqual(ConnectionStates.Offline, device.GetConnectionState());
+            Assert.AreEqual(Enumerations.TamperState.UNKNOWN, device.GetTamperState());
+            Assert.IsNull(device.GetConnection());
+
+            Task.Run(async () =>
+            {
+                await device.UpdateDataBaseDevice(_connectionMoq.Object, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(ConnectionStates.Offline, device.GetConnectionState());
+
+            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            //Assert.AreEqual("SendDeviceAdded FF00AA", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            Assert.IsNotNull(_dbContextFactory);
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("HUB apparaat FF00AA aangemaakt", logs[0].Message);
+            //Assert.AreEqual("Hub address veranderd naar FFEECC", logs[1].Message);
+            //Assert.AreEqual("Locatie veranderd naar 1234AB", logs[2].Message);
+
+            Assert.AreEqual("FF00AA", logs[0].Device?.DeviceId);
+            Assert.AreEqual("FF00AA", logs[0].Device?.Name);
+            Assert.IsNull(logs[0].Device?.LocationId);
+            Assert.AreEqual("64.226.1.0", logs[0].Device?.Ipaddress);
+        }
    }
 }
--- a/Aperio_Control_Centre.UnitTest/AperioServer/AperioLockDevice_Test.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/AperioLockDevice_Test.cs
@@ -1,156 +1,181 @@
 using Aperio_Control_Centre.Aadp;
-using Aperio_Control_Centre.Aadp.ApplicationTypes;
 using Aperio_Control_Centre.ACSDatabase;
 using Aperio_Control_Centre.ACSDatabase.Models;
 using Aperio_Control_Centre.ACSDatabase.Types;
 using Aperio_Control_Centre.AperioServer;
+using Microsoft.EntityFrameworkCore;

 namespace Aperio_Control_Centre.UnitTest.AperioServer
 {
    [TestClass]
    public class AperioLockDevice_Test : AperioTestSetup
    {
-        private DeviceDefinition? _deviceDefinition;
+        //private DeviceDefinition? _deviceDefinition;

-        public AperioLockDevice CreateAperioDevice()
+        //public AperioLockDevice CreateAperioLockDevice()
+        //{
+        //    Assert.IsNotNull(_screenLogging);
+        //    Assert.IsNotNull(_statusBroadcast);
+        //    Assert.IsNotNull(_dbContextFactory);
+
+        //    _deviceDefinition = new("AA11BB", "445566", Enumerations.ProductClass.LOCK);
+        //    AperioLockDevice lockDevice = new(_deviceDefinition.DeviceIdentity, _deviceDefinition.Host, _screenLogging, _statusBroadcast, _dbContextFactory);
+
+        //    Assert.AreEqual("AA11BB", lockDevice.Id);
+        //    Assert.AreEqual("445566", lockDevice.HubDeviceId.ToId());
+        //    Assert.AreNotEqual(0, lockDevice.LastData.Ticks);
+
+        //    //Task.Run(async () =>
+        //    //{
+        //    //    await lockDevice.SetConnection(_connectionMoq.Object, _token);
+        //    //}).GetAwaiter().GetResult();
+
+        //    //Assert.AreEqual("64.226.1.0", lockDevice.IPAddress);
+
+        //    Assert.IsNull(lockDevice.GetConnection());
+        //    Assert.AreEqual(ConnectionStates.Offline, lockDevice.GetConnectionState());            
+
+        //    //lockDevice.DataBaseDeviceID = 1;
+        //    //Assert.AreEqual(1, lockDevice.DataBaseDeviceID);
+
+        //    Assert.AreEqual(Enumerations.Status.UNKNOWN, lockDevice.GetDeviceStatus());
+
+        //    Assert.AreEqual("445566", lockDevice.HubDeviceId.ToId());
+
+        //    Assert.AreEqual(BatteryStates.Unknown, lockDevice.GetBatteryState());
+        //    Assert.AreEqual(Enumerations.DoorMode.UNKNOWN, lockDevice.GetDoorMode());
+        //    Assert.AreEqual(Enumerations.DoorState.UNKNOWN, lockDevice.GetDoorState());
+        //    Assert.AreEqual(Enumerations.LockState.UNKNOWN, lockDevice.GetLockState());
+        //    Assert.AreEqual(Enumerations.KeyCylinderState.UNKNOWN, lockDevice.GetKeyCylinderState());
+        //    Assert.AreEqual(Enumerations.HandleState.UNKNOWN, lockDevice.GetHandleState());
+        //    //Assert.ThrowsException<NotImplementedException>(() => lockDevice.GetTamperState());
+
+        //    Assert.AreEqual(string.Empty, lockDevice.FirmwareVersion);
+        //    Assert.IsNull(lockDevice.HwVersion);
+        //    //Assert.IsNotNull(optaDevice.HwVersion);
+        //    //Assert.AreEqual("", optaDevice.HwVersion.PCBSerialNumber);
+        //    //Assert.AreEqual("", optaDevice.HwVersion.BOMVersion);
+        //    //Assert.AreEqual("", optaDevice.HwVersion.PCBVersion);
+        //    //Assert.AreEqual(Aadp.Types.PCBIdentity.OPTA_V1, optaDevice.HwVersion.PCBIdentity);
+
+        //    Assert.AreEqual(Enumerations.LockVersions.UNKNOWN, lockDevice.LockVersion);
+
+        //    //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyInsideState);
+        //    //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyOutsideState);
+        //    //Assert.ThrowsException<NotImplementedException>(() => lockDevice.ManualOpenState);
+
+
+        //    Assert.AreEqual(0, _screenLogging.Messages.Count);
+        //    Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+
+        //    return lockDevice;
+        //}
+
+
+        //[TestMethod]
+        //public void AperioLockDevice_Init_Test()
+        //{
+        //    AperioLockDevice device = CreateAperioLockDevice();
+        //    Assert.IsNotNull(device);
+        //}
+
+        [TestMethod]
+        public void AperioLockDevice_UpdateDataBaseDevice_New_Test()
        {
-            Assert.IsNotNull(_screenLogging);
            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
            Assert.IsNotNull(_dbContextFactory);

-            _deviceDefinition = new("AA11BB", "445566", Enumerations.ProductClass.LOCK);
-            //AperioLockDevice lockDevice = new(_deviceDefinition, _connectionMoq.Object, _screenLogging, _statusBroadcastMoq.Object, _dbContextFactory);
-            AperioLockDevice lockDevice = new(_deviceDefinition.DeviceIdentity, _deviceDefinition.Host, _screenLogging, _statusBroadcast, _dbContextFactory);
+            AperioLockDevice device = new(new("FF00AA"), new("445566"), _screenLogging, _statusBroadcast, _dbContextFactory);

-            Assert.AreEqual("AA11BB", lockDevice.Id);
-            //Assert.AreEqual(Enumerations.ProductClass.LOCK, lockDevice.ProductClass);
-            Assert.IsNotNull(lockDevice.LastData);
-            Assert.AreNotEqual(0, lockDevice.LastData.Ticks);
+            Assert.AreEqual("FF00AA", device.Id);
+            Assert.AreEqual("445566", device.HubDeviceId.ToId());
+            Assert.IsNull(device.GetConnection());

            Task.Run(async () =>
            {
-                await lockDevice.SetConnection(_connectionMoq.Object, _token);
+                await device.UpdateDataBaseDevice(_connectionMoq.Object, _token);
            }).GetAwaiter().GetResult();

-            Assert.AreEqual("64.226.1.0", lockDevice.IPAddress);
-            Assert.AreEqual(ConnectionStates.Offline, lockDevice.GetConnectionState());
-
-            lockDevice.DataBaseDeviceID = 1;
-            Assert.AreEqual(1, lockDevice.DataBaseDeviceID);
-
-            Assert.AreEqual(Enumerations.Status.UNKNOWN, lockDevice.GetDeviceStatus());
-
-            Assert.AreEqual("445566", lockDevice.HubDeviceId.ToId());
-
-            Assert.AreEqual(BatteryStates.Unknown, lockDevice.GetBatteryState());
-            Assert.AreEqual(Enumerations.DoorMode.UNKNOWN, lockDevice.GetDoorMode());
-            Assert.AreEqual(Enumerations.DoorState.UNKNOWN, lockDevice.GetDoorState());
-            Assert.AreEqual(Enumerations.LockState.UNKNOWN, lockDevice.GetLockState());
-            Assert.AreEqual(Enumerations.KeyCylinderState.UNKNOWN, lockDevice.GetKeyCylinderState());
-            Assert.AreEqual(Enumerations.HandleState.UNKNOWN, lockDevice.GetHandleState());
-            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.GetTamperState());
-
-            Assert.AreEqual(string.Empty, lockDevice.FirmwareVersion);
-            Assert.IsNull(lockDevice.HwVersion);
-            //Assert.IsNotNull(optaDevice.HwVersion);
-            //Assert.AreEqual("", optaDevice.HwVersion.PCBSerialNumber);
-            //Assert.AreEqual("", optaDevice.HwVersion.BOMVersion);
-            //Assert.AreEqual("", optaDevice.HwVersion.PCBVersion);
-            //Assert.AreEqual(Aadp.Types.PCBIdentity.OPTA_V1, optaDevice.HwVersion.PCBIdentity);
-
-            Assert.AreEqual(Enumerations.LockVersions.UNKNOWN, lockDevice.LockVersion);
-
-            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyInsideState);
-            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.EmergencyOutsideState);
-            //Assert.ThrowsException<NotImplementedException>(() => lockDevice.ManualOpenState);
-
-            return lockDevice;
-        }
-
-
-        [TestMethod]
-        public void AperioLockDevice_Init_Test()
-        {
-            AperioLockDevice device = CreateAperioDevice();
-        }
-
-        [TestMethod]
-        public void AperioLockDevice_BatteryState_Test()
-        {
-            AperioLockDevice device = CreateAperioDevice();
-
-            Assert.AreEqual(BatteryStates.Unknown, device.GetBatteryState());
-
-            Task.Run(async () =>
-            {
-                await device.SetBatteryState(BatteryStates.Low, _token);
-            }).GetAwaiter().GetResult();
-
-            Assert.AreEqual(BatteryStates.Low, device.GetBatteryState());
+            Assert.AreEqual("445566", device.HubDeviceId.ToId());

            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
-            Assert.AreEqual("SendBatteryStatus AA11BB Low", _statusBroadcast.Messages[0]);
+            Assert.AreEqual("SendDeviceAdded FF00AA", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);

            Assert.IsNotNull(_dbContextFactory);
            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();

            Assert.AreEqual(1, context.Loggings.Count());

-            Logging? log = context.Loggings.Find(1);
-            Assert.IsNotNull(log);
-            Assert.AreEqual("Batterij laag", log.Message);
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Apparaat FF00AA aangemaakt", logs[0].Message);
+            //Assert.AreEqual("Hub address veranderd naar FFEECC", logs[1].Message);
+            //Assert.AreEqual("Locatie veranderd naar 1234AB", logs[2].Message);
+
+            Assert.AreEqual("FF00AA", logs[0].Device?.DeviceId);
+            Assert.AreEqual("FF00AA", logs[0].Device?.Name);
+            Assert.AreEqual("445566", logs[0].Device?.HubId);
+            Assert.AreEqual(2, logs[0].Device?.LocationId);
+            Assert.AreEqual("64.226.1.0", logs[0].Device?.Ipaddress);
        }

        [TestMethod]
-        public void AperioLockDevice_DoorState_Test()
+        public void AperioLockDevice_UpdateDataBaseDevice_Update_Test()
        {
-            AperioLockDevice device = CreateAperioDevice();
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);

-            Assert.AreEqual(Enumerations.DoorState.UNKNOWN, device.GetDoorState());
+            AperioLockDevice device = new(new("AA11BB"), new("445566"), _screenLogging, _statusBroadcast, _dbContextFactory);

-            Task.Run(async () =>
-            {
-                await device.SetDoorState(Enumerations.DoorState.CLOSED, _token);
-            }).GetAwaiter().GetResult();
-
-            Assert.AreEqual(Enumerations.DoorState.CLOSED, device.GetDoorState());
-
-            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("445566", device.HubDeviceId.ToId());
+            Assert.IsNull(device.GetConnection());

            Assert.IsNotNull(_dbContextFactory);
            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();

-            Assert.AreEqual(1, context.Loggings.Count());
+            context.Devices.Add(new()
+            {
+                DeviceId = "FFEECC",
+                ProductClass = Enumerations.ProductClass.GATEWAY,
+                Ipaddress = device.IPAddress,
+                Active = ActiveStates.Active,
+                LocationId = 2
+            });
+            context.SaveChanges();

-            Logging? log = context.Loggings.Find(1);
-            Assert.IsNotNull(log);
-            Assert.AreEqual("Doorstate (CLOSED)", log.Message);
-        }
-
-        [TestMethod]
-        public void AperioLockDevice_LockState_Test()
-        {
-            AperioLockDevice device = CreateAperioDevice();
-
-            Assert.AreEqual(Enumerations.LockState.UNKNOWN, device.GetLockState());
+            device.HubDeviceId = new("FFEECC");

            Task.Run(async () =>
            {
-                await device.SetLockState(Enumerations.LockState.JAMMED, _token);
+                await device.UpdateDataBaseDevice(_connectionMoq.Object, _token);
            }).GetAwaiter().GetResult();

-            Assert.AreEqual(Enumerations.LockState.JAMMED, device.GetLockState());
+            Assert.IsNotNull(device.GetConnection());
+
+            Assert.AreEqual("FFEECC", device.HubDeviceId.ToId());

            Assert.AreEqual(0, _statusBroadcast.Messages.Count);
+            Assert.AreEqual(0, _screenLogging.Messages.Count);

-            Assert.IsNotNull(_dbContextFactory);
-            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+            Assert.AreEqual(3, context.Loggings.Count());

-            Assert.AreEqual(1, context.Loggings.Count());
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Ip address veranderd naar 64.226.1.0", logs[0].Message);
+            Assert.AreEqual("Hub address veranderd naar FFEECC", logs[1].Message);
+            Assert.AreEqual("Locatie veranderd naar 1234AB", logs[2].Message);

-            Logging? log = context.Loggings.Find(1);
-            Assert.IsNotNull(log);
-            Assert.AreEqual("Slot geblokkeerd", log.Message);
+
+            Assert.AreEqual("AA11BB", logs[0].Device?.DeviceId);
+            Assert.AreEqual("TestDevice", logs[0].Device?.Name);
+            Assert.AreEqual("FFEECC", logs[0].Device?.HubId);
+            Assert.AreEqual(2, logs[0].Device?.LocationId);
+            Assert.AreEqual("64.226.1.0", logs[0].Device?.Ipaddress);
        }
+
    }
 }
--- a/Aperio_Control_Centre.UnitTest/AperioServer/AperioOptaDevice_Test.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/AperioOptaDevice_Test.cs
@@ -1,7 +1,10 @@
-using Aperio_Control_Centre.AperioServer;
-using Aperio_Control_Centre.Aadp;
-using Aperio_Control_Centre.ACSDatabase.Types;
+using Aperio_Control_Centre.Aadp;
 using Aperio_Control_Centre.Aadp.ApplicationTypes;
+using Aperio_Control_Centre.ACSDatabase;
+using Aperio_Control_Centre.ACSDatabase.Models;
+using Aperio_Control_Centre.ACSDatabase.Types;
+using Aperio_Control_Centre.AperioServer;
+using Microsoft.EntityFrameworkCore;
 using System.Threading.Tasks;

 namespace Aperio_Control_Centre.UnitTest.AperioServer
@@ -18,20 +21,21 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            Assert.IsNotNull(_dbContextFactory);

            _deviceDefinition = new("0412F5", "0055FF", Enumerations.ProductClass.OPTA_V1);
-            //AperioOptaDevice optaDevice = new(_deviceDefinition, _connectionMoq.Object, _screenLogging, _statusBroadcastMoq.Object, _dbContextFactory);
            AperioOptaDevice optaDevice = new(_deviceDefinition.DeviceIdentity, _screenLogging, _statusBroadcast, _dbContextFactory);
+            //AperioOptaDevice optaDevice = new(new("0412F5"), _screenLogging, _statusBroadcast, _dbContextFactory);

            Assert.AreEqual("0412F5", optaDevice.Id);
            //Assert.AreEqual(Enumerations.ProductClass.OPTA_V1, optaDevice.ProductClass);
-            Assert.IsNotNull(optaDevice.LastData);
+            //Assert.IsNotNull(optaDevice.LastData);
            Assert.AreNotEqual(0, optaDevice.LastData.Ticks);
            
-            Task.Run(async () =>
-            {
-                await optaDevice.SetConnection(_connectionMoq.Object, _token);
-            }).GetAwaiter().GetResult();
+            //Task.Run(async () =>
+            //{
+            //    await optaDevice.SetConnection(_connectionMoq.Object, _token);
+            //}).GetAwaiter().GetResult();

-            Assert.AreEqual("64.226.1.0", optaDevice.IPAddress);
+            //Assert.AreEqual("64.226.1.0", optaDevice.IPAddress);
+            Assert.IsNull(optaDevice.GetConnection());
            Assert.AreEqual(ConnectionStates.Offline, optaDevice.GetConnectionState());

            Assert.AreEqual(0, optaDevice.DataBaseDeviceID);
@@ -70,19 +74,69 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
        [TestMethod]
        public void AperioOptaDevice_Init_Test()
        {
-            //Assert.IsNotNull(_screenLogging);
-            //Assert.IsNotNull(_statusBroadcastMoq);
-            //Assert.IsNotNull(_dbContextFactory);
-
            AperioOptaDevice device = CreateOptaDevice();
+            Assert.IsNotNull(device);
        }

        [TestMethod]
-        public void AperioOptaDevice_UpdateActivatorState_Test()
+        public void AperioOptaDevice_UpdateDataBaseDevice_New_Test()
        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
+            //_deviceDefinition = new("0412F5", "0055FF", Enumerations.ProductClass.OPTA_V1);
+            //_deviceDefinition = new("DEAD00", "0055FF", Enumerations.ProductClass.OPTA_V1);
+            //AperioOptaDevice device = new(_deviceDefinition.DeviceIdentity, _screenLogging, _statusBroadcast, _dbContextFactory);
+            AperioOptaDevice device = new(new("DEAD00"), _screenLogging, _statusBroadcast, _dbContextFactory);
+
+            Assert.AreEqual("DEAD00", device.Id);
+            Assert.IsNull(device.GetConnection());
+
+            Task.Run(async () =>
+            {
+                await device.UpdateDataBaseDevice(_connectionMoq.Object, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendDeviceAdded DEAD00", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Apparaat DEAD00 aangemaakt", logs[0].Message);
+            //Assert.AreEqual("Hub address veranderd naar FFEECC", logs[1].Message);
+            //Assert.AreEqual("Locatie veranderd naar 1234AB", logs[2].Message);
+
+            Assert.AreEqual("DEAD00", logs[0].Device?.DeviceId);
+            Assert.AreEqual("DEAD00", logs[0].Device?.Name);
+            Assert.IsNull(logs[0].Device?.HubId);
+            Assert.IsNull(logs[0].Device?.LocationId);
+            Assert.AreEqual("64.226.1.0", logs[0].Device?.Ipaddress);
+
+            //Assert.AreEqual(2, logs[0].Device?.Locatio);
+        }
+
+
+        [TestMethod]
+        public void AperioOptaDevice_UpdateActivatorState_Inside_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
            AperioOptaDevice device = CreateOptaDevice();
            Assert.IsNotNull(_deviceDefinition);

+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyInsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyOutsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.ManualOpenState);
+
            ActivatorInfo activatorInfo = new()
            {
                DeviceIdentity = _deviceDefinition.DeviceIdentity,
@@ -98,6 +152,104 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            Assert.AreEqual(Enumerations.ActivatorState.USED, device.EmergencyInsideState);
            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyOutsideState);
            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.ManualOpenState);
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendEmergencyStatus 0412F5 EmergencyInside USED", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Breekruit binnenzijde geactiveerd", logs[0].Message);
+        }
+
+        [TestMethod]
+        public void AperioOptaDevice_UpdateActivatorState_Outside_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
+            AperioOptaDevice device = CreateOptaDevice();
+            Assert.IsNotNull(_deviceDefinition);
+
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyInsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyOutsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.ManualOpenState);
+
+            ActivatorInfo activatorInfo = new()
+            {
+                DeviceIdentity = _deviceDefinition.DeviceIdentity,
+                ActivatorId = new((int)ActivatorTypes.EmergencyOutside),
+                ActivatorState = Enumerations.ActivatorState.USED
+            };
+
+            Task.Run(async () =>
+            {
+                await device.UpdateActivatorState(activatorInfo, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyInsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.USED, device.EmergencyOutsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.ManualOpenState);
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendEmergencyStatus 0412F5 EmergencyOutside USED", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Breekruit buitenzijde geactiveerd", logs[0].Message);
+        }
+
+        [TestMethod]
+        public void AperioOptaDevice_UpdateActivatorState_Manual_Test()
+        {
+            Assert.IsNotNull(_statusBroadcast);
+            Assert.IsNotNull(_screenLogging);
+            Assert.IsNotNull(_dbContextFactory);
+
+            AperioOptaDevice device = CreateOptaDevice();
+            Assert.IsNotNull(_deviceDefinition);
+
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyInsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyOutsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.ManualOpenState);
+
+            ActivatorInfo activatorInfo = new()
+            {
+                DeviceIdentity = _deviceDefinition.DeviceIdentity,
+                ActivatorId = new((int)ActivatorTypes.ManualOpen),
+                ActivatorState = Enumerations.ActivatorState.USED
+            };
+
+            Task.Run(async () =>
+            {
+                await device.UpdateActivatorState(activatorInfo, _token);
+            }).GetAwaiter().GetResult();
+
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyInsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.UNKNOWN, device.EmergencyOutsideState);
+            Assert.AreEqual(Enumerations.ActivatorState.USED, device.ManualOpenState);
+
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            Assert.AreEqual("SendEmergencyStatus 0412F5 EmergencyOutside USED", _statusBroadcast.Messages[0]);
+
+            Assert.AreEqual(0, _screenLogging.Messages.Count);
+
+            ACSDatabaseContext context = _dbContextFactory.CreateDbContext();
+
+            Assert.AreEqual(1, context.Loggings.Count());
+            List<Logging> logs = context.Loggings.Include(d => d.Device).ToList();
+            Assert.IsNotNull(logs);
+            Assert.AreEqual("Breekruit buitenzijde geactiveerd", logs[0].Message);
        }
    }
 }
--- a/Aperio_Control_Centre.UnitTest/AperioServer/AperioTestSetup.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/AperioTestSetup.cs
@@ -71,6 +71,7 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            _screenLogging = new TestingScreenLogger();
            _statusBroadcast = new TestingStatusBroadcastHandler();

+            _connectionMoq = new Mock<ConnectionContext>();
            _ = _connectionMoq.Setup(s => s.RemoteEndPoint).Returns(new IPEndPoint(123456, 1234));
            _ = _connectionMoq.Setup(s => s.Transport.Output.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), It.IsAny<CancellationToken>()));

@@ -85,7 +86,7 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
                Name = "TestDevice",
                Active = ActiveStates.Active,
                ConnectionState = ConnectionStates.Online,
-                ProductClass = Aadp.Enumerations.ProductClass.LOCK,
+                ProductClass = Enumerations.ProductClass.LOCK,
            });
            //dbContext.Devices.Add(new Device()
            //            {
@@ -103,20 +104,20 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
                Name = "TestHost 2",
                Active = ActiveStates.Active,
                ProductClass = Enumerations.ProductClass.GATEWAY,
-                //Ipaddress = "[::ffff:192.168.0.100]:12345",
+                Ipaddress = "64.226.1.0",
                LocationId = 2
            });
-            //            dbContext.Devices.Add(new Device()
-            //            {
-            //                DeviceId = "332211",
-            //                Name = "TestHost 3",
-            //                Active = ActiveStates.Active,
-            //                ConnectionState = ConnectionStates.Online,
-            //                ProductClass = ProductClass.Lock,
-            //                Ipaddress = "[::ffff:192.168.0.172]:49494",
-            //                LocationId = 1,
-            //                UnlockTime = 42
-            //            });
+            dbContext.Devices.Add(new Device()
+            {
+                DeviceId = "0412F5",
+                Name = "Opta lock",
+                Active = ActiveStates.Active,
+                ConnectionState = ConnectionStates.Online,
+                ProductClass = Enumerations.ProductClass.OPTA_V1,
+                Ipaddress = "[::ffff:192.168.0.172]:49494",
+                LocationId = 2,
+                UnlockTime = 42
+            });

            //            dbContext.Timezones.Add(new Timezone()
            //            {
@@ -235,13 +236,13 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            //                GroupId = 6
            //            });

-            //            dbContext.Locations.Add(new Location()
-            //            {
-            //                Id = 2,
-            //                Zipcode = "1234AB",
-            //                Active = ActiveStates.Active,
-            //                LastChanged = DateTime.UtcNow,
-            //            });
+            dbContext.Locations.Add(new Location()
+            {
+                Id = 2,
+                Zipcode = "1234AB",
+                Active = ActiveStates.Active,
+                LastChanged = DateTime.UtcNow,
+            });

            //            dbContext.Users.Add(new User()
            //            {
--- a/Aperio_Control_Centre.UnitTest/AperioServer/DeviceList_Test.cs
+++ b/Aperio_Control_Centre.UnitTest/AperioServer/DeviceList_Test.cs
@@ -326,9 +326,9 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer

            //Device added
            //_statusBroadcastMoq.Verify(a => a.SendDeviceAdded("0392BC", _token));
-            Assert.AreEqual(2, _statusBroadcast.Messages.Count);
-            Assert.AreEqual("SendDeviceAdded 0392BC", _statusBroadcast.Messages[0]);
-            Assert.AreEqual("SendConnectionStatus 0392BC Online", _statusBroadcast.Messages[1]);
+            Assert.AreEqual(1, _statusBroadcast.Messages.Count);
+            //Assert.AreEqual("SendDeviceAdded 0392BC", _statusBroadcast.Messages[0]);
+            Assert.AreEqual("SendConnectionStatus 0392BC Online", _statusBroadcast.Messages[0]);

            Assert.IsTrue(fired);
            Assert.AreEqual(1, _devicesList.GetConnections().Count());
@@ -361,10 +361,10 @@ namespace Aperio_Control_Centre.UnitTest.AperioServer
            }).Wait();

            //Connection status update
-            Assert.AreEqual(3, _statusBroadcast.Messages.Count);
-            Assert.AreEqual("SendDeviceAdded 0392BC", _statusBroadcast.Messages[0]);
-            Assert.AreEqual("SendConnectionStatus 0392BC Online", _statusBroadcast.Messages[1]);
-            Assert.AreEqual("SendConnectionStatus 0392BC Offline", _statusBroadcast.Messages[2]);
+            Assert.AreEqual(2, _statusBroadcast.Messages.Count);
+            //Assert.AreEqual("SendDeviceAdded 0392BC", _statusBroadcast.Messages[0]);
+            Assert.AreEqual("SendConnectionStatus 0392BC Online", _statusBroadcast.Messages[0]);
+            Assert.AreEqual("SendConnectionStatus 0392BC Offline", _statusBroadcast.Messages[1]);

            Assert.IsTrue(fired);
            Assert.AreEqual(1, _devicesList.GetConnections().Count());