git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2022 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.binding.livisismarthome.internal.handler;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.mockito.ArgumentMatchers.any;
  17 import static org.mockito.Mockito.*;
  18 import static org.openhab.binding.livisismarthome.internal.LivisiBindingConstants.*;
  19 import static org.openhab.binding.livisismarthome.internal.client.api.entity.capability.CapabilityStateDTO.STATE_VALUE_OPERATION_MODE_AUTO;
  20 import static org.openhab.binding.livisismarthome.internal.client.api.entity.capability.CapabilityStateDTO.STATE_VALUE_OPERATION_MODE_MANUAL;
  21 import static org.openhab.binding.livisismarthome.internal.client.api.entity.link.LinkDTO.LINK_TYPE_CAPABILITY;
  22 import static org.openhab.binding.livisismarthome.internal.client.api.entity.link.LinkDTO.LINK_TYPE_DEVICE;
  23
  24 import java.util.Collections;
  25 import java.util.HashMap;
  26 import java.util.LinkedHashMap;
  27 import java.util.LinkedHashSet;
  28 import java.util.Map;
  29 import java.util.Objects;
  30 import java.util.Optional;
  31 import java.util.Set;
  32 import java.util.function.Consumer;
  33
  34 import org.eclipse.jdt.annotation.NonNullByDefault;
  35 import org.eclipse.jdt.annotation.Nullable;
  36 import org.junit.jupiter.api.AfterEach;
  37 import org.junit.jupiter.api.BeforeEach;
  38 import org.junit.jupiter.api.Test;
  39 import org.openhab.binding.livisismarthome.internal.client.api.entity.action.ShutterActionType;
  40 import org.openhab.binding.livisismarthome.internal.client.api.entity.capability.CapabilityConfigDTO;
  41 import org.openhab.binding.livisismarthome.internal.client.api.entity.capability.CapabilityDTO;
  42 import org.openhab.binding.livisismarthome.internal.client.api.entity.capability.CapabilityStateDTO;
  43 import org.openhab.binding.livisismarthome.internal.client.api.entity.device.DeviceConfigDTO;
  44 import org.openhab.binding.livisismarthome.internal.client.api.entity.device.DeviceDTO;
  45 import org.openhab.binding.livisismarthome.internal.client.api.entity.device.DeviceStateDTO;
  46 import org.openhab.binding.livisismarthome.internal.client.api.entity.event.EventDTO;
  47 import org.openhab.binding.livisismarthome.internal.client.api.entity.event.EventPropertiesDTO;
  48 import org.openhab.core.config.core.Configuration;
  49 import org.openhab.core.library.types.DecimalType;
  50 import org.openhab.core.library.types.OnOffType;
  51 import org.openhab.core.library.types.OpenClosedType;
  52 import org.openhab.core.library.types.QuantityType;
  53 import org.openhab.core.library.types.StopMoveType;
  54 import org.openhab.core.library.types.StringType;
  55 import org.openhab.core.library.types.UpDownType;
  56 import org.openhab.core.library.unit.SIUnits;
  57 import org.openhab.core.library.unit.Units;
  58 import org.openhab.core.thing.Bridge;
  59 import org.openhab.core.thing.Channel;
  60 import org.openhab.core.thing.ChannelUID;
  61 import org.openhab.core.thing.CommonTriggerEvents;
  62 import org.openhab.core.thing.Thing;
  63 import org.openhab.core.thing.ThingStatus;
  64 import org.openhab.core.thing.ThingStatusDetail;
  65 import org.openhab.core.thing.ThingStatusInfo;
  66 import org.openhab.core.thing.ThingTypeUID;
  67 import org.openhab.core.thing.ThingUID;
  68 import org.openhab.core.thing.binding.ThingHandlerCallback;
  69 import org.openhab.core.thing.binding.builder.ChannelBuilder;
  70 import org.openhab.core.thing.binding.builder.ThingStatusInfoBuilder;
  71 import org.openhab.core.types.State;
  72 import org.slf4j.LoggerFactory;
  73
  74 import ch.qos.logback.classic.Level;
  75 import ch.qos.logback.classic.Logger;
  76
  77 /**
  78  * @author Sven Strohschein - Initial contribution
  79  */
  80 @NonNullByDefault
  81 public class LivisiDeviceHandlerTest {
  82
  83     private @NonNullByDefault({}) LivisiBridgeHandler bridgeHandlerMock;
  84     private @NonNullByDefault({}) ThingStatusInfo thingStatusInfo;
  85     private @NonNullByDefault({}) Map<String, State> updatedChannels;
  86     private @NonNullByDefault({}) Set<TriggeredEvent> triggeredChannels;
  87
  88     private @NonNullByDefault({}) Level previousLoggingLevel;
  89
  90     @BeforeEach
  91     public void before() {
  92         bridgeHandlerMock = mock(LivisiBridgeHandler.class);
  93         thingStatusInfo = ThingStatusInfoBuilder.create(ThingStatus.UNINITIALIZED, ThingStatusDetail.NONE).build();
  94         updatedChannels = new LinkedHashMap<>();
  95         triggeredChannels = new LinkedHashSet<>();
  96
  97         Logger logger = (Logger) LoggerFactory.getLogger(LivisiDeviceHandler.class);
  98         previousLoggingLevel = logger.getLevel();
  99         logger.setLevel(Level.OFF); // avoid log messages (which would be logged to the console)
 100     }
 101
 102     @AfterEach
 103     public void after() {
 104         Logger logger = (Logger) LoggerFactory.getLogger(LivisiDeviceHandler.class);
 105         logger.setLevel(previousLoggingLevel);
 106     }
 107
 108     @Test
 109     public void testInitialize() {
 110         LivisiDeviceHandler deviceHandler = createDeviceHandler(createDevice());
 111         assertEquals(ThingStatus.ONLINE, deviceHandler.getThing().getStatus());
 112     }
 113
 114     @Test
 115     public void testOnDeviceStateChanged() {
 116         DeviceDTO device = createDevice();
 117         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 118
 119         deviceHandler.onDeviceStateChanged(device);
 120     }
 121
 122     @Test
 123     public void testOnDeviceStateChanged_IsReachable() {
 124         DeviceStateDTO deviceState = new DeviceStateDTO();
 125         deviceState.setReachable(true);
 126
 127         DeviceDTO device = createDevice();
 128         device.setDeviceState(deviceState);
 129
 130         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 131
 132         deviceHandler.onDeviceStateChanged(device);
 133         assertEquals(ThingStatus.ONLINE, deviceHandler.getThing().getStatus());
 134         assertEquals(ThingStatusDetail.NONE, deviceHandler.getThing().getStatusInfo().getStatusDetail());
 135     }
 136
 137     @Test
 138     public void testOnDeviceStateChanged_IsNotReachable() {
 139         DeviceStateDTO deviceState = new DeviceStateDTO();
 140         deviceState.setReachable(false);
 141
 142         DeviceDTO device = createDevice();
 143         device.setDeviceState(deviceState);
 144
 145         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 146
 147         deviceHandler.onDeviceStateChanged(device);
 148         assertEquals(ThingStatus.OFFLINE, deviceHandler.getThing().getStatus());
 149         assertEquals(ThingStatusDetail.COMMUNICATION_ERROR, deviceHandler.getThing().getStatusInfo().getStatusDetail());
 150     }
 151
 152     @Test
 153     public void testOnDeviceStateChanged_IsReachable_VariableActuator() {
 154         DeviceStateDTO deviceState = new DeviceStateDTO();
 155         deviceState.setReachable(true);
 156
 157         DeviceDTO device = createDevice();
 158         device.setType(DEVICE_VARIABLE_ACTUATOR);
 159         device.setDeviceState(deviceState);
 160
 161         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 162
 163         deviceHandler.onDeviceStateChanged(device);
 164         assertEquals(ThingStatus.ONLINE, deviceHandler.getThing().getStatus());
 165         assertEquals(ThingStatusDetail.NONE, deviceHandler.getThing().getStatusInfo().getStatusDetail());
 166     }
 167
 168     @Test
 169     public void testOnDeviceStateChanged_LowBattery() {
 170         DeviceDTO device = createDevice();
 171         device.setIsBatteryPowered(true);
 172         device.setLowBattery(true);
 173
 174         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 175
 176         deviceHandler.onDeviceStateChanged(device);
 177         assertTrue(isChannelUpdated(CHANNEL_BATTERY_LOW, OnOffType.ON));
 178     }
 179
 180     @Test
 181     public void testOnDeviceStateChanged_NoLowBattery() {
 182         DeviceDTO device = createDevice();
 183         device.setIsBatteryPowered(true);
 184         device.setLowBattery(false);
 185
 186         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 187
 188         deviceHandler.onDeviceStateChanged(device);
 189         assertTrue(isChannelUpdated(CHANNEL_BATTERY_LOW, OnOffType.OFF));
 190     }
 191
 192     @Test
 193     public void testOnDeviceStateChanged_NotBatteryPowered() {
 194         DeviceDTO device = createDevice();
 195         device.setIsBatteryPowered(false);
 196
 197         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 198
 199         deviceHandler.onDeviceStateChanged(device);
 200         assertFalse(isChannelUpdated(CHANNEL_BATTERY_LOW));
 201     }
 202
 203     @Test
 204     public void testOnDeviceStateChanged_VariableActuator_On() {
 205         DeviceDTO device = createDevice();
 206         addCapabilityToDevice(CapabilityDTO.TYPE_VARIABLEACTUATOR, c -> c.setVariableActuatorState(true), device);
 207
 208         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 209
 210         deviceHandler.onDeviceStateChanged(device);
 211         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
 212     }
 213
 214     @Test
 215     public void testOnDeviceStateChanged_VariableActuator_Off() {
 216         DeviceDTO device = createDevice();
 217         addCapabilityToDevice(CapabilityDTO.TYPE_VARIABLEACTUATOR, c -> c.setVariableActuatorState(false), device);
 218
 219         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 220
 221         deviceHandler.onDeviceStateChanged(device);
 222         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.OFF));
 223     }
 224
 225     @Test
 226     public void testOnDeviceStateChanged_VariableActuator_EmptyState() {
 227         DeviceDTO device = createDevice();
 228         addCapabilityToDevice(CapabilityDTO.TYPE_VARIABLEACTUATOR, null, device);
 229
 230         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 231
 232         deviceHandler.onDeviceStateChanged(device);
 233         assertFalse(isChannelUpdated(CHANNEL_SWITCH));
 234     }
 235
 236     @Test
 237     public void testOnDeviceStateChanged_TemperatureSensor_FrostWarning_On() {
 238         DeviceDTO device = createDevice();
 239         addCapabilityToDevice(CapabilityDTO.TYPE_TEMPERATURESENSOR, c -> {
 240             c.setTemperatureSensorTemperatureState(21.5);
 241             c.setTemperatureSensorFrostWarningState(true);
 242         }, device);
 243
 244         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 245
 246         deviceHandler.onDeviceStateChanged(device);
 247         assertTrue(isChannelUpdated(CHANNEL_CURRENT_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
 248         assertTrue(isChannelUpdated(CHANNEL_FROST_WARNING, OnOffType.ON));
 249     }
 250
 251     @Test
 252     public void testOnDeviceStateChanged_TemperatureSensor_FrostWarning_Off() {
 253         DeviceDTO device = createDevice();
 254         addCapabilityToDevice(CapabilityDTO.TYPE_TEMPERATURESENSOR, c -> {
 255             c.setTemperatureSensorTemperatureState(21.5);
 256             c.setTemperatureSensorFrostWarningState(false);
 257         }, device);
 258
 259         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 260
 261         deviceHandler.onDeviceStateChanged(device);
 262         assertTrue(isChannelUpdated(CHANNEL_CURRENT_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
 263         assertTrue(isChannelUpdated(CHANNEL_FROST_WARNING, OnOffType.OFF));
 264     }
 265
 266     @Test
 267     public void testOnDeviceStateChanged_TemperatureSensor_EmptyState() {
 268         DeviceDTO device = createDevice();
 269         addCapabilityToDevice(CapabilityDTO.TYPE_TEMPERATURESENSOR, null, device);
 270
 271         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 272
 273         deviceHandler.onDeviceStateChanged(device);
 274         assertFalse(isChannelUpdated(CHANNEL_CURRENT_TEMPERATURE));
 275         assertFalse(isChannelUpdated(CHANNEL_FROST_WARNING));
 276     }
 277
 278     @Test
 279     public void testOnDeviceStateChanged_ThermostatActuator_WindowReduction_On() {
 280         DeviceDTO device = createDevice();
 281         addCapabilityToDevice(CapabilityDTO.TYPE_THERMOSTATACTUATOR, c -> {
 282             c.setThermostatActuatorPointTemperatureState(21.5);
 283             c.setThermostatActuatorOperationModeState(STATE_VALUE_OPERATION_MODE_AUTO);
 284             c.setThermostatActuatorWindowReductionActiveState(true);
 285         }, device);
 286
 287         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 288
 289         deviceHandler.onDeviceStateChanged(device);
 290         assertTrue(isChannelUpdated(CHANNEL_TARGET_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
 291         assertTrue(isChannelUpdated(CHANNEL_OPERATION_MODE, new StringType(STATE_VALUE_OPERATION_MODE_AUTO)));
 292         assertTrue(isChannelUpdated(CHANNEL_WINDOW_REDUCTION_ACTIVE, OnOffType.ON));
 293     }
 294
 295     @Test
 296     public void testOnDeviceStateChanged_ThermostatActuator_WindowReduction_Off() {
 297         DeviceDTO device = createDevice();
 298         addCapabilityToDevice(CapabilityDTO.TYPE_THERMOSTATACTUATOR, c -> {
 299             c.setThermostatActuatorPointTemperatureState(21.5);
 300             c.setThermostatActuatorOperationModeState(STATE_VALUE_OPERATION_MODE_MANUAL);
 301             c.setThermostatActuatorWindowReductionActiveState(false);
 302         }, device);
 303
 304         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 305
 306         deviceHandler.onDeviceStateChanged(device);
 307         assertTrue(isChannelUpdated(CHANNEL_TARGET_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
 308         assertTrue(isChannelUpdated(CHANNEL_OPERATION_MODE, new StringType(STATE_VALUE_OPERATION_MODE_MANUAL)));
 309         assertTrue(isChannelUpdated(CHANNEL_WINDOW_REDUCTION_ACTIVE, OnOffType.OFF));
 310     }
 311
 312     @Test
 313     public void testOnDeviceStateChanged_ThermostatActuator_EmptyState() {
 314         DeviceDTO device = createDevice();
 315         addCapabilityToDevice(CapabilityDTO.TYPE_THERMOSTATACTUATOR, null, device);
 316
 317         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 318
 319         deviceHandler.onDeviceStateChanged(device);
 320         assertFalse(isChannelUpdated(CHANNEL_TARGET_TEMPERATURE));
 321         assertFalse(isChannelUpdated(CHANNEL_OPERATION_MODE));
 322         assertFalse(isChannelUpdated(CHANNEL_WINDOW_REDUCTION_ACTIVE));
 323     }
 324
 325     @Test
 326     public void testOnDeviceStateChanged_HumiditySensor_MoldWarning_On() {
 327         DeviceDTO device = createDevice();
 328         addCapabilityToDevice(CapabilityDTO.TYPE_HUMIDITYSENSOR, c -> {
 329             c.setHumiditySensorHumidityState(35.5);
 330             c.setHumiditySensorMoldWarningState(true);
 331         }, device);
 332
 333         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 334
 335         deviceHandler.onDeviceStateChanged(device);
 336         assertTrue(isChannelUpdated(CHANNEL_HUMIDITY, QuantityType.valueOf(35.5, Units.PERCENT)));
 337         assertTrue(isChannelUpdated(CHANNEL_MOLD_WARNING, OnOffType.ON));
 338     }
 339
 340     @Test
 341     public void testOnDeviceStateChanged_HumiditySensor_MoldWarning_Off() {
 342         DeviceDTO device = createDevice();
 343         addCapabilityToDevice(CapabilityDTO.TYPE_HUMIDITYSENSOR, c -> {
 344             c.setHumiditySensorHumidityState(35.5);
 345             c.setHumiditySensorMoldWarningState(false);
 346         }, device);
 347
 348         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 349
 350         deviceHandler.onDeviceStateChanged(device);
 351         assertTrue(isChannelUpdated(CHANNEL_HUMIDITY, QuantityType.valueOf(35.5, Units.PERCENT)));
 352         assertTrue(isChannelUpdated(CHANNEL_MOLD_WARNING, OnOffType.OFF));
 353     }
 354
 355     @Test
 356     public void testOnDeviceStateChanged_HumiditySensor_EmptyState() {
 357         DeviceDTO device = createDevice();
 358         addCapabilityToDevice(CapabilityDTO.TYPE_HUMIDITYSENSOR, null, device);
 359
 360         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 361
 362         deviceHandler.onDeviceStateChanged(device);
 363         assertFalse(isChannelUpdated(CHANNEL_HUMIDITY));
 364         assertFalse(isChannelUpdated(CHANNEL_MOLD_WARNING));
 365     }
 366
 367     @Test
 368     public void testOnDeviceStateChanged_WindowDoorSensor_Open() {
 369         DeviceDTO device = createDevice();
 370         addCapabilityToDevice(CapabilityDTO.TYPE_WINDOWDOORSENSOR, c -> c.setWindowDoorSensorState(true), device);
 371
 372         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 373
 374         deviceHandler.onDeviceStateChanged(device);
 375         assertTrue(isChannelUpdated(CHANNEL_CONTACT, OpenClosedType.OPEN));
 376     }
 377
 378     @Test
 379     public void testOnDeviceStateChanged_WindowDoorSensor_Closed() {
 380         DeviceDTO device = createDevice();
 381         addCapabilityToDevice(CapabilityDTO.TYPE_WINDOWDOORSENSOR, c -> c.setWindowDoorSensorState(false), device);
 382
 383         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 384
 385         deviceHandler.onDeviceStateChanged(device);
 386         assertTrue(isChannelUpdated(CHANNEL_CONTACT, OpenClosedType.CLOSED));
 387     }
 388
 389     @Test
 390     public void testOnDeviceStateChanged_WindowDoorSensor_EmptyState() {
 391         DeviceDTO device = createDevice();
 392         addCapabilityToDevice(CapabilityDTO.TYPE_WINDOWDOORSENSOR, null, device);
 393
 394         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 395
 396         deviceHandler.onDeviceStateChanged(device);
 397         assertFalse(isChannelUpdated(CHANNEL_CONTACT));
 398     }
 399
 400     @Test
 401     public void testOnDeviceStateChanged_SmokeDetectorSensor_On() {
 402         DeviceDTO device = createDevice();
 403         addCapabilityToDevice(CapabilityDTO.TYPE_SMOKEDETECTORSENSOR, c -> c.setSmokeDetectorSensorState(true), device);
 404
 405         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 406
 407         deviceHandler.onDeviceStateChanged(device);
 408         assertTrue(isChannelUpdated(CHANNEL_SMOKE, OnOffType.ON));
 409     }
 410
 411     @Test
 412     public void testOnDeviceStateChanged_SmokeDetectorSensor_Off() {
 413         DeviceDTO device = createDevice();
 414         addCapabilityToDevice(CapabilityDTO.TYPE_SMOKEDETECTORSENSOR, c -> c.setSmokeDetectorSensorState(false),
 415                 device);
 416
 417         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 418
 419         deviceHandler.onDeviceStateChanged(device);
 420         assertTrue(isChannelUpdated(CHANNEL_SMOKE, OnOffType.OFF));
 421     }
 422
 423     @Test
 424     public void testOnDeviceStateChanged_SmokeDetectorSensor_EmptyState() {
 425         DeviceDTO device = createDevice();
 426         addCapabilityToDevice(CapabilityDTO.TYPE_SMOKEDETECTORSENSOR, null, device);
 427
 428         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 429
 430         deviceHandler.onDeviceStateChanged(device);
 431         assertFalse(isChannelUpdated(CHANNEL_SMOKE));
 432     }
 433
 434     @Test
 435     public void testOnDeviceStateChanged_AlarmActuator_On() {
 436         DeviceDTO device = createDevice();
 437         addCapabilityToDevice(CapabilityDTO.TYPE_ALARMACTUATOR, c -> c.setAlarmActuatorState(true), device);
 438
 439         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 440
 441         deviceHandler.onDeviceStateChanged(device);
 442         assertTrue(isChannelUpdated(CHANNEL_ALARM, OnOffType.ON));
 443     }
 444
 445     @Test
 446     public void testOnDeviceStateChanged_AlarmActuator_Off() {
 447         DeviceDTO device = createDevice();
 448         addCapabilityToDevice(CapabilityDTO.TYPE_ALARMACTUATOR, c -> c.setAlarmActuatorState(false), device);
 449
 450         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 451
 452         deviceHandler.onDeviceStateChanged(device);
 453         assertTrue(isChannelUpdated(CHANNEL_ALARM, OnOffType.OFF));
 454     }
 455
 456     @Test
 457     public void testOnDeviceStateChanged_AlarmActuator_EmptyState() {
 458         DeviceDTO device = createDevice();
 459         addCapabilityToDevice(CapabilityDTO.TYPE_ALARMACTUATOR, null, device);
 460
 461         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 462
 463         deviceHandler.onDeviceStateChanged(device);
 464         assertFalse(isChannelUpdated(CHANNEL_ALARM));
 465     }
 466
 467     @Test
 468     public void testOnDeviceStateChanged_SwitchActuator_On() {
 469         DeviceDTO device = createDevice();
 470         addCapabilityToDevice(CapabilityDTO.TYPE_SWITCHACTUATOR, c -> c.setSwitchActuatorState(true), device);
 471
 472         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 473
 474         deviceHandler.onDeviceStateChanged(device);
 475         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
 476     }
 477
 478     @Test
 479     public void testOnDeviceStateChanged_SwitchActuator_Off() {
 480         DeviceDTO device = createDevice();
 481         addCapabilityToDevice(CapabilityDTO.TYPE_SWITCHACTUATOR, c -> c.setSwitchActuatorState(false), device);
 482
 483         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 484
 485         deviceHandler.onDeviceStateChanged(device);
 486         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.OFF));
 487     }
 488
 489     @Test
 490     public void testOnDeviceStateChanged_SwitchActuator_EmptyState() {
 491         DeviceDTO device = createDevice();
 492         addCapabilityToDevice(CapabilityDTO.TYPE_SWITCHACTUATOR, null, device);
 493
 494         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 495
 496         deviceHandler.onDeviceStateChanged(device);
 497         assertFalse(isChannelUpdated(CHANNEL_SWITCH));
 498     }
 499
 500     @Test
 501     public void testOnDeviceStateChanged_DimmerActuator() {
 502         DeviceDTO device = createDevice();
 503         addCapabilityToDevice(CapabilityDTO.TYPE_DIMMERACTUATOR, c -> c.setDimmerActuatorState(50), device);
 504
 505         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 506
 507         deviceHandler.onDeviceStateChanged(device);
 508         assertTrue(isChannelUpdated(CHANNEL_DIMMER, new DecimalType(50)));
 509     }
 510
 511     @Test
 512     public void testOnDeviceStateChanged_DimmerActuator_EmptyState() {
 513         DeviceDTO device = createDevice();
 514         addCapabilityToDevice(CapabilityDTO.TYPE_DIMMERACTUATOR, null, device);
 515
 516         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 517
 518         deviceHandler.onDeviceStateChanged(device);
 519         assertFalse(isChannelUpdated(CHANNEL_DIMMER));
 520     }
 521
 522     @Test
 523     public void testOnDeviceStateChanged_RollerShutterActuator() {
 524         DeviceDTO device = createDevice();
 525         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, c -> c.setRollerShutterActuatorState(40),
 526                 device);
 527
 528         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 529
 530         deviceHandler.onDeviceStateChanged(device);
 531         assertTrue(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(40)));
 532     }
 533
 534     @Test
 535     public void testOnDeviceStateChanged_RollerShutterActuator_Invert_True() {
 536         DeviceDTO device = createDevice();
 537         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, c -> c.setRollerShutterActuatorState(40),
 538                 device);
 539
 540         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 541
 542         Channel rollerShutterChannelMock = createRollerShutterChannelMock(true);
 543
 544         Thing thingMock = deviceHandler.getThing();
 545         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
 546
 547         deviceHandler.onDeviceStateChanged(device);
 548         assertTrue(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(40)));
 549         assertFalse(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(60)));
 550     }
 551
 552     @Test
 553     public void testOnDeviceStateChanged_RollerShutterActuator_Invert_False() {
 554         DeviceDTO device = createDevice();
 555         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, c -> c.setRollerShutterActuatorState(40),
 556                 device);
 557
 558         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 559
 560         Channel rollerShutterChannelMock = createRollerShutterChannelMock(false);
 561
 562         Thing thingMock = deviceHandler.getThing();
 563         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
 564
 565         deviceHandler.onDeviceStateChanged(device);
 566         assertFalse(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(40)));
 567         assertTrue(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(60)));
 568     }
 569
 570     @Test
 571     public void testOnDeviceStateChanged_RollerShutterActuator_EmptyState() {
 572         DeviceDTO device = createDevice();
 573         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, null, device);
 574
 575         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 576
 577         deviceHandler.onDeviceStateChanged(device);
 578         assertFalse(isChannelUpdated(CHANNEL_ROLLERSHUTTER));
 579     }
 580
 581     @Test
 582     public void testOnDeviceStateChanged_MotionDetectionSensor() {
 583         DeviceDTO device = createDevice();
 584         addCapabilityToDevice(CapabilityDTO.TYPE_MOTIONDETECTIONSENSOR, c -> c.setMotionDetectionSensorState(50),
 585                 device);
 586
 587         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 588
 589         deviceHandler.onDeviceStateChanged(device);
 590         assertTrue(isChannelUpdated(CHANNEL_MOTION_COUNT, new DecimalType(50)));
 591     }
 592
 593     @Test
 594     public void testOnDeviceStateChanged_MotionDetectionSensor_EmptyState() {
 595         DeviceDTO device = createDevice();
 596         addCapabilityToDevice(CapabilityDTO.TYPE_MOTIONDETECTIONSENSOR, null, device);
 597
 598         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 599
 600         deviceHandler.onDeviceStateChanged(device);
 601         assertFalse(isChannelUpdated(CHANNEL_MOTION_COUNT));
 602     }
 603
 604     @Test
 605     public void testOnDeviceStateChanged_LuminanceSensor() {
 606         DeviceDTO device = createDevice();
 607         addCapabilityToDevice(CapabilityDTO.TYPE_LUMINANCESENSOR, c -> c.setLuminanceSensorState(50.1), device);
 608
 609         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 610
 611         deviceHandler.onDeviceStateChanged(device);
 612         assertTrue(isChannelUpdated(CHANNEL_LUMINANCE, QuantityType.valueOf(50.1, Units.PERCENT)));
 613     }
 614
 615     @Test
 616     public void testOnDeviceStateChanged_LuminanceSensor_EmptyState() {
 617         DeviceDTO device = createDevice();
 618         addCapabilityToDevice(CapabilityDTO.TYPE_LUMINANCESENSOR, null, device);
 619
 620         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 621
 622         deviceHandler.onDeviceStateChanged(device);
 623         assertFalse(isChannelUpdated(CHANNEL_LUMINANCE));
 624     }
 625
 626     @Test
 627     public void testOnDeviceStateChanged_EnergyConsumptionSensor() {
 628         DeviceDTO device = createDevice();
 629         addCapabilityToDevice(CapabilityDTO.TYPE_ENERGYCONSUMPTIONSENSOR, c -> {
 630             c.setEnergyConsumptionSensorEnergyConsumptionMonthKWhState(201.51);
 631             c.setEnergyConsumptionSensorAbsoluteEnergyConsumptionState(5500.51);
 632             c.setEnergyConsumptionSensorEnergyConsumptionMonthEuroState(80.32);
 633             c.setEnergyConsumptionSensorEnergyConsumptionDayEuroState(3.72);
 634             c.setEnergyConsumptionSensorEnergyConsumptionDayKWhState(8.71);
 635         }, device);
 636
 637         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 638
 639         deviceHandler.onDeviceStateChanged(device);
 640         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_KWH,
 641                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
 642         assertTrue(isChannelUpdated(CHANNEL_ABOLUTE_ENERGY_CONSUMPTION,
 643                 QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
 644         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_EURO, new DecimalType(80.32)));
 645         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_EURO, new DecimalType(3.72)));
 646         assertTrue(
 647                 isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
 648     }
 649
 650     @Test
 651     public void testOnDeviceStateChanged_EnergyConsumptionSensor_EmptyState() {
 652         DeviceDTO device = createDevice();
 653         addCapabilityToDevice(CapabilityDTO.TYPE_ENERGYCONSUMPTIONSENSOR, null, device);
 654
 655         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 656
 657         deviceHandler.onDeviceStateChanged(device);
 658         assertFalse(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_KWH));
 659         assertFalse(isChannelUpdated(CHANNEL_ABOLUTE_ENERGY_CONSUMPTION));
 660         assertFalse(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_EURO));
 661         assertFalse(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_EURO));
 662         assertFalse(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_KWH));
 663     }
 664
 665     @Test
 666     public void testOnDeviceStateChanged_PowerConsumptionSensor() {
 667         DeviceDTO device = createDevice();
 668         addCapabilityToDevice(CapabilityDTO.TYPE_POWERCONSUMPTIONSENSOR,
 669                 c -> c.setPowerConsumptionSensorPowerConsumptionWattState(350.5), device);
 670
 671         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 672
 673         deviceHandler.onDeviceStateChanged(device);
 674         assertTrue(isChannelUpdated(CHANNEL_POWER_CONSUMPTION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
 675     }
 676
 677     @Test
 678     public void testOnDeviceStateChanged_PowerConsumptionSensor_EmptyState() {
 679         DeviceDTO device = createDevice();
 680         addCapabilityToDevice(CapabilityDTO.TYPE_POWERCONSUMPTIONSENSOR, null, device);
 681
 682         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 683
 684         deviceHandler.onDeviceStateChanged(device);
 685         assertFalse(isChannelUpdated(CHANNEL_POWER_CONSUMPTION_WATT));
 686     }
 687
 688     @Test
 689     public void testOnDeviceStateChanged_GenerationMeterEnergySensor() {
 690         DeviceDTO device = createDevice();
 691         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERENERGYSENSOR, c -> {
 692             c.setGenerationMeterEnergySensorEnergyPerMonthInKWhState(201.51);
 693             c.setGenerationMeterEnergySensorTotalEnergyState(5500.51);
 694             c.setGenerationMeterEnergySensorEnergyPerMonthInEuroState(80.32);
 695             c.setGenerationMeterEnergySensorEnergyPerDayInEuroState(3.72);
 696             c.setGenerationMeterEnergySensorEnergyPerDayInKWhState(8.71);
 697         }, device);
 698
 699         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 700
 701         deviceHandler.onDeviceStateChanged(device);
 702         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_KWH,
 703                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
 704         assertTrue(
 705                 isChannelUpdated(CHANNEL_TOTAL_ENERGY_GENERATION, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
 706         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_EURO, new DecimalType(80.32)));
 707         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_EURO, new DecimalType(3.72)));
 708         assertTrue(
 709                 isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
 710     }
 711
 712     @Test
 713     public void testOnDeviceStateChanged_GenerationMeterEnergySensor_EmptyState() {
 714         DeviceDTO device = createDevice();
 715         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERENERGYSENSOR, null, device);
 716
 717         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 718
 719         deviceHandler.onDeviceStateChanged(device);
 720         assertFalse(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_KWH));
 721         assertFalse(isChannelUpdated(CHANNEL_TOTAL_ENERGY_GENERATION));
 722         assertFalse(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_EURO));
 723         assertFalse(isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_EURO));
 724         assertFalse(isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_KWH));
 725     }
 726
 727     @Test
 728     public void testOnDeviceStateChanged_GenerationMeterPowerConsumptionSensor() {
 729         DeviceDTO device = createDevice();
 730         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERPOWERCONSUMPTIONSENSOR,
 731                 c -> c.setGenerationMeterPowerConsumptionSensorPowerInWattState(350.5), device);
 732
 733         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 734
 735         deviceHandler.onDeviceStateChanged(device);
 736         assertTrue(isChannelUpdated(CHANNEL_POWER_GENERATION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
 737     }
 738
 739     @Test
 740     public void testOnDeviceStateChanged_GenerationMeterPowerConsumptionSensor_EmptyState() {
 741         DeviceDTO device = createDevice();
 742         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERPOWERCONSUMPTIONSENSOR, null, device);
 743
 744         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 745
 746         deviceHandler.onDeviceStateChanged(device);
 747         assertFalse(isChannelUpdated(CHANNEL_POWER_GENERATION_WATT));
 748     }
 749
 750     @Test
 751     public void testOnDeviceStateChanged_TwoWayMeterEnergyConsumptionSensor() {
 752         DeviceDTO device = createDevice();
 753         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYCONSUMPTIONSENSOR, c -> {
 754             c.setTwoWayMeterEnergyConsumptionSensorEnergyPerMonthInKWhState(201.51);
 755             c.setTwoWayMeterEnergyConsumptionSensorTotalEnergyState(5500.51);
 756             c.setTwoWayMeterEnergyConsumptionSensorEnergyPerMonthInEuroState(80.32);
 757             c.setTwoWayMeterEnergyConsumptionSensorEnergyPerDayInEuroState(3.72);
 758             c.setTwoWayMeterEnergyConsumptionSensorEnergyPerDayInKWhState(8.71);
 759         }, device);
 760
 761         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 762
 763         deviceHandler.onDeviceStateChanged(device);
 764         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
 765         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
 766         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_EURO, new DecimalType(80.32)));
 767         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_EURO, new DecimalType(3.72)));
 768         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
 769     }
 770
 771     @Test
 772     public void testOnDeviceStateChanged_TwoWayMeterEnergyConsumptionSensor_EmptyState() {
 773         DeviceDTO device = createDevice();
 774         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYCONSUMPTIONSENSOR, null, device);
 775
 776         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 777
 778         deviceHandler.onDeviceStateChanged(device);
 779         assertFalse(isChannelUpdated(CHANNEL_ENERGY_MONTH_KWH));
 780         assertFalse(isChannelUpdated(CHANNEL_TOTAL_ENERGY));
 781         assertFalse(isChannelUpdated(CHANNEL_ENERGY_MONTH_EURO));
 782         assertFalse(isChannelUpdated(CHANNEL_ENERGY_DAY_EURO));
 783         assertFalse(isChannelUpdated(CHANNEL_ENERGY_DAY_KWH));
 784     }
 785
 786     @Test
 787     public void testOnDeviceStateChanged_TwoWayMeterEnergyFeedSensor() {
 788         DeviceDTO device = createDevice();
 789         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYFEEDSENSOR, c -> {
 790             c.setTwoWayMeterEnergyFeedSensorEnergyPerMonthInKWhState(201.51);
 791             c.setTwoWayMeterEnergyFeedSensorTotalEnergyState(5500.51);
 792             c.setTwoWayMeterEnergyFeedSensorEnergyPerMonthInEuroState(80.32);
 793             c.setTwoWayMeterEnergyFeedSensorEnergyPerDayInEuroState(3.72);
 794             c.setTwoWayMeterEnergyFeedSensorEnergyPerDayInKWhState(8.71);
 795         }, device);
 796
 797         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 798
 799         deviceHandler.onDeviceStateChanged(device);
 800         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
 801         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY_FED, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
 802         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_EURO, new DecimalType(80.32)));
 803         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_EURO, new DecimalType(3.72)));
 804         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
 805     }
 806
 807     @Test
 808     public void testOnDeviceStateChanged_TwoWayMeterEnergyFeedSensor_EmptyState() {
 809         DeviceDTO device = createDevice();
 810         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYFEEDSENSOR, null, device);
 811
 812         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 813
 814         deviceHandler.onDeviceStateChanged(device);
 815         assertFalse(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_KWH));
 816         assertFalse(isChannelUpdated(CHANNEL_TOTAL_ENERGY_FED));
 817         assertFalse(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_EURO));
 818         assertFalse(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_EURO));
 819         assertFalse(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_KWH));
 820     }
 821
 822     @Test
 823     public void testOnDeviceStateChanged_TwoWayMeterPowerConsumptionSensor() {
 824         DeviceDTO device = createDevice();
 825         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERPOWERCONSUMPTIONSENSOR,
 826                 c -> c.setTwoWayMeterPowerConsumptionSensorPowerInWattState(350.5), device);
 827
 828         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 829
 830         deviceHandler.onDeviceStateChanged(device);
 831         assertTrue(isChannelUpdated(CHANNEL_POWER_WATT, QuantityType.valueOf(350.5, Units.WATT)));
 832     }
 833
 834     @Test
 835     public void testOnDeviceStateChanged_TwoWayMeterPowerConsumptionSensor_EmptyState() {
 836         DeviceDTO device = createDevice();
 837         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERPOWERCONSUMPTIONSENSOR, null, device);
 838
 839         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 840
 841         deviceHandler.onDeviceStateChanged(device);
 842         assertFalse(isChannelUpdated(CHANNEL_POWER_WATT));
 843     }
 844
 845     @Test
 846     public void testOnDeviceStateChanged_PushButtonSensor_Button1_ShortPress() {
 847         DeviceDTO device = createDevice();
 848         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 849             c.setPushButtonSensorCounterState(10);
 850             c.setPushButtonSensorButtonIndexState(0);
 851             c.setPushButtonSensorButtonIndexType("ShortPress");
 852         }, device);
 853
 854         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 855
 856         deviceHandler.onDeviceStateChanged(device);
 857         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
 858         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 859         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 860     }
 861
 862     @Test
 863     public void testOnDeviceStateChanged_PushButtonSensor_Button1_LongPress() {
 864         DeviceDTO device = createDevice();
 865         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 866             c.setPushButtonSensorCounterState(10);
 867             c.setPushButtonSensorButtonIndexState(0);
 868             c.setPushButtonSensorButtonIndexType("LongPress");
 869         }, device);
 870
 871         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 872
 873         deviceHandler.onDeviceStateChanged(device);
 874         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
 875         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 876         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 877     }
 878
 879     @Test
 880     public void testOnDeviceStateChanged_PushButtonSensor_Button2_ShortPress() {
 881         DeviceDTO device = createDevice();
 882         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 883             c.setPushButtonSensorCounterState(10);
 884             c.setPushButtonSensorButtonIndexState(1);
 885             c.setPushButtonSensorButtonIndexType("ShortPress");
 886         }, device);
 887
 888         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 889
 890         deviceHandler.onDeviceStateChanged(device);
 891         assertTrue(isChannelUpdated("button2Count", new DecimalType(10)));
 892         assertTrue(isChannelTriggered("button2", CommonTriggerEvents.SHORT_PRESSED));
 893         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.LONG_PRESSED));
 894     }
 895
 896     @Test
 897     public void testOnDeviceStateChanged_PushButtonSensor_Button2_LongPress() {
 898         DeviceDTO device = createDevice();
 899         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 900             c.setPushButtonSensorCounterState(10);
 901             c.setPushButtonSensorButtonIndexState(1);
 902             c.setPushButtonSensorButtonIndexType("LongPress");
 903         }, device);
 904
 905         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 906
 907         deviceHandler.onDeviceStateChanged(device);
 908         assertTrue(isChannelUpdated("button2Count", new DecimalType(10)));
 909         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.SHORT_PRESSED));
 910         assertTrue(isChannelTriggered("button2", CommonTriggerEvents.LONG_PRESSED));
 911     }
 912
 913     @Test
 914     public void testOnDeviceStateChanged_PushButtonSensor_EmptyState() {
 915         DeviceDTO device = createDevice();
 916         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
 917
 918         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 919
 920         deviceHandler.onDeviceStateChanged(device);
 921         assertFalse(isChannelUpdated(CHANNEL_BUTTON_COUNT));
 922         assertFalse(isChannelUpdated("button1Count"));
 923         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 924         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 925     }
 926
 927     @Test
 928     public void testOnDeviceStateChanged_Event_LinkedToDevice() {
 929         DeviceStateDTO deviceState = new DeviceStateDTO();
 930         deviceState.setReachable(true);
 931
 932         DeviceDTO device = createDevice();
 933         device.setDeviceState(deviceState);
 934
 935         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 936
 937         EventDTO event = new EventDTO();
 938         event.setSource(LINK_TYPE_DEVICE);
 939
 940         deviceHandler.onDeviceStateChanged(device, event);
 941         assertEquals(ThingStatus.ONLINE, deviceHandler.getThing().getStatus());
 942         assertEquals(ThingStatusDetail.NONE, deviceHandler.getThing().getStatusInfo().getStatusDetail());
 943     }
 944
 945     @Test
 946     public void testOnDeviceStateChanged_Event_LinkedToCapability_WithoutState() {
 947         DeviceDTO device = createDevice();
 948
 949         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
 950         capabilityConfig.setName("capabilityName");
 951
 952         final String capabilityId = "capabilityId";
 953         CapabilityDTO capability = new CapabilityDTO();
 954         capability.setId(capabilityId);
 955         capability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 956         capability.setConfig(capabilityConfig);
 957         device.getCapabilityMap().put(capabilityId, capability);
 958
 959         DeviceDTO refreshedDevice = createDevice();
 960
 961         CapabilityStateDTO capabilityState = new CapabilityStateDTO();
 962         capabilityState.setSwitchActuatorState(true);
 963
 964         CapabilityDTO refreshedCapability = new CapabilityDTO();
 965         refreshedCapability.setId(capabilityId);
 966         refreshedCapability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 967         refreshedCapability.setConfig(capabilityConfig);
 968         refreshedCapability.setCapabilityState(capabilityState);
 969         refreshedDevice.getCapabilityMap().put(capabilityId, refreshedCapability);
 970
 971         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 972         when(bridgeHandlerMock.refreshDevice(any())).thenReturn(Optional.of(refreshedDevice));
 973
 974         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
 975
 976         deviceHandler.onDeviceStateChanged(device, event);
 977         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
 978     }
 979
 980     @Test
 981     public void testOnDeviceStateChanged_Event_LinkedToCapability_WithoutStateAlsoAfterRefresh() {
 982         DeviceDTO device = createDevice();
 983
 984         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
 985         capabilityConfig.setName("capabilityName");
 986
 987         final String capabilityId = "capabilityId";
 988         CapabilityDTO capability = new CapabilityDTO();
 989         capability.setId(capabilityId);
 990         capability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 991         capability.setConfig(capabilityConfig);
 992         device.getCapabilityMap().put(capabilityId, capability);
 993
 994         DeviceDTO refreshedDevice = createDevice();
 995
 996         CapabilityDTO refreshedCapability = new CapabilityDTO();
 997         refreshedCapability.setId(capabilityId);
 998         refreshedCapability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 999         refreshedCapability.setConfig(capabilityConfig);
1000         refreshedDevice.getCapabilityMap().put(capabilityId, refreshedCapability);
1001
1002         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1003         when(bridgeHandlerMock.refreshDevice(any())).thenReturn(Optional.of(refreshedDevice));
1004
1005         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1006
1007         deviceHandler.onDeviceStateChanged(device, event);
1008         // Channels should only get updated when the device have a state.
1009         assertFalse(isChannelUpdated(CHANNEL_SWITCH));
1010     }
1011
1012     @Test
1013     public void testOnDeviceStateChanged_Event_VariableActuator() {
1014         DeviceDTO device = createDevice();
1015         addCapabilityToDevice(CapabilityDTO.TYPE_VARIABLEACTUATOR, null, device);
1016
1017         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1018
1019         EventDTO event = createCapabilityEvent(c -> c.setValue(true));
1020
1021         deviceHandler.onDeviceStateChanged(device, event);
1022         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
1023     }
1024
1025     @Test
1026     public void testOnDeviceStateChanged_Event_SwitchActuator() {
1027         DeviceDTO device = createDevice();
1028         addCapabilityToDevice(CapabilityDTO.TYPE_SWITCHACTUATOR, null, device);
1029
1030         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1031
1032         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1033
1034         deviceHandler.onDeviceStateChanged(device, event);
1035         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
1036     }
1037
1038     @Test
1039     public void testOnDeviceStateChanged_Event_DimmerActuator() {
1040         DeviceDTO device = createDevice();
1041         addCapabilityToDevice(CapabilityDTO.TYPE_DIMMERACTUATOR, null, device);
1042
1043         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1044
1045         EventDTO event = createCapabilityEvent(c -> c.setDimLevel(50));
1046
1047         deviceHandler.onDeviceStateChanged(device, event);
1048         assertTrue(isChannelUpdated(CHANNEL_DIMMER, new DecimalType(50)));
1049     }
1050
1051     @Test
1052     public void testOnDeviceStateChanged_Event_RollerShutterActuator() {
1053         DeviceDTO device = createDevice();
1054         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, null, device);
1055
1056         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1057
1058         EventDTO event = createCapabilityEvent(c -> c.setShutterLevel(50));
1059
1060         deviceHandler.onDeviceStateChanged(device, event);
1061         assertTrue(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(50)));
1062     }
1063
1064     @Test
1065     public void testOnDeviceStateChanged_Event_RollerShutter_PushButtonSensor() {
1066         DeviceDTO device = createDevice();
1067         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, null, device);
1068         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1069
1070         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1071
1072         EventDTO event = createCapabilityEvent(c -> {
1073             c.setKeyPressCounter(10);
1074             c.setKeyPressButtonIndex(0);
1075             c.setKeyPressType("ShortPress");
1076         });
1077         event.setType("ButtonPressed");
1078         event.setNamespace("CosipDevices.RWE");
1079
1080         deviceHandler.onDeviceStateChanged(device, event);
1081         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
1082         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1083         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1084     }
1085
1086     @Test
1087     public void testOnDeviceStateChanged_Event_TemperatureSensor() {
1088         DeviceDTO device = createDevice();
1089         addCapabilityToDevice(CapabilityDTO.TYPE_TEMPERATURESENSOR, null, device);
1090
1091         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1092
1093         EventDTO event = createCapabilityEvent(c -> {
1094             c.setTemperature(21.5);
1095             c.setFrostWarning(true);
1096         });
1097
1098         deviceHandler.onDeviceStateChanged(device, event);
1099         assertTrue(isChannelUpdated(CHANNEL_CURRENT_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
1100         assertTrue(isChannelUpdated(CHANNEL_FROST_WARNING, OnOffType.ON));
1101     }
1102
1103     @Test
1104     public void testOnDeviceStateChanged_Event_ThermostatSensor() {
1105         DeviceDTO device = createDevice();
1106         addCapabilityToDevice(CapabilityDTO.TYPE_THERMOSTATACTUATOR, null, device);
1107
1108         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1109
1110         EventDTO event = createCapabilityEvent(c -> {
1111             c.setPointTemperature(21.5);
1112             c.setOperationMode(STATE_VALUE_OPERATION_MODE_AUTO);
1113             c.setWindowReductionActive(true);
1114         });
1115
1116         deviceHandler.onDeviceStateChanged(device, event);
1117         assertTrue(isChannelUpdated(CHANNEL_TARGET_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
1118         assertTrue(isChannelUpdated(CHANNEL_OPERATION_MODE, new StringType(STATE_VALUE_OPERATION_MODE_AUTO)));
1119         assertTrue(isChannelUpdated(CHANNEL_WINDOW_REDUCTION_ACTIVE, OnOffType.ON));
1120     }
1121
1122     @Test
1123     public void testOnDeviceStateChanged_Event_HumiditySensor() {
1124         DeviceDTO device = createDevice();
1125         addCapabilityToDevice(CapabilityDTO.TYPE_HUMIDITYSENSOR, null, device);
1126
1127         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1128
1129         EventDTO event = createCapabilityEvent(c -> {
1130             c.setHumidity(35.5);
1131             c.setMoldWarning(true);
1132         });
1133
1134         deviceHandler.onDeviceStateChanged(device, event);
1135         assertTrue(isChannelUpdated(CHANNEL_HUMIDITY, QuantityType.valueOf(35.5, Units.PERCENT)));
1136         assertTrue(isChannelUpdated(CHANNEL_MOLD_WARNING, OnOffType.ON));
1137     }
1138
1139     @Test
1140     public void testOnDeviceStateChanged_Event_WindowDoorSensor() {
1141         DeviceDTO device = createDevice();
1142         addCapabilityToDevice(CapabilityDTO.TYPE_WINDOWDOORSENSOR, null, device);
1143
1144         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1145
1146         EventDTO event = createCapabilityEvent(c -> c.setIsOpen(true));
1147
1148         deviceHandler.onDeviceStateChanged(device, event);
1149         assertTrue(isChannelUpdated(CHANNEL_CONTACT, OpenClosedType.OPEN));
1150     }
1151
1152     @Test
1153     public void testOnDeviceStateChanged_Event_SmokeDetectorSensor() {
1154         DeviceDTO device = createDevice();
1155         addCapabilityToDevice(CapabilityDTO.TYPE_SMOKEDETECTORSENSOR, null, device);
1156
1157         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1158
1159         EventDTO event = createCapabilityEvent(c -> c.setIsSmokeAlarm(true));
1160
1161         deviceHandler.onDeviceStateChanged(device, event);
1162         assertTrue(isChannelUpdated(CHANNEL_SMOKE, OnOffType.ON));
1163     }
1164
1165     @Test
1166     public void testOnDeviceStateChanged_Event_AlarmActuator() {
1167         DeviceDTO device = createDevice();
1168         addCapabilityToDevice(CapabilityDTO.TYPE_ALARMACTUATOR, null, device);
1169
1170         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1171
1172         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1173
1174         deviceHandler.onDeviceStateChanged(device, event);
1175         assertTrue(isChannelUpdated(CHANNEL_ALARM, OnOffType.ON));
1176     }
1177
1178     @Test
1179     public void testOnDeviceStateChanged_Event_MotionDetectionSensor() {
1180         DeviceDTO device = createDevice();
1181         addCapabilityToDevice(CapabilityDTO.TYPE_MOTIONDETECTIONSENSOR, null, device);
1182
1183         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1184
1185         EventDTO event = createCapabilityEvent(c -> c.setMotionDetectedCount(50));
1186
1187         deviceHandler.onDeviceStateChanged(device, event);
1188         assertTrue(isChannelUpdated(CHANNEL_MOTION_COUNT, new DecimalType(50)));
1189     }
1190
1191     @Test
1192     public void testOnDeviceStateChanged_Event_LuminanceSensor() {
1193         DeviceDTO device = createDevice();
1194         addCapabilityToDevice(CapabilityDTO.TYPE_LUMINANCESENSOR, null, device);
1195
1196         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1197
1198         EventDTO event = createCapabilityEvent(c -> c.setLuminance(50.1));
1199
1200         deviceHandler.onDeviceStateChanged(device, event);
1201         assertTrue(isChannelUpdated(CHANNEL_LUMINANCE, QuantityType.valueOf(50.1, Units.PERCENT)));
1202     }
1203
1204     @Test
1205     public void testOnDeviceStateChanged_Event_PushButtonSensor() {
1206         DeviceDTO device = createDevice();
1207         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1208
1209         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1210
1211         EventDTO event = createCapabilityEvent(c -> {
1212             c.setKeyPressCounter(10);
1213             c.setKeyPressButtonIndex(0);
1214             c.setKeyPressType("ShortPress");
1215         });
1216
1217         deviceHandler.onDeviceStateChanged(device, event);
1218         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
1219         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1220         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1221         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1222         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1223     }
1224
1225     @Test
1226     public void testOnDeviceStateChanged_StateChangedEvent_PushButtonSensor_SHC_Classic() {
1227         when(bridgeHandlerMock.isSHCClassic()).thenReturn(true);
1228
1229         DeviceDTO device = createDevice();
1230         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1231
1232         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1233
1234         // SHC Classic sends only StateChanged events with this information
1235         EventDTO event = createCapabilityEvent(c -> {
1236             c.setLastKeyPressButtonIndex(0);
1237             c.setLastKeyPressCounter(10);
1238         });
1239
1240         // Nothing should get processed, because it should only react on the more detailed ButtonPressed events
1241         deviceHandler.onDeviceStateChanged(device, event);
1242         assertFalse(isChannelUpdated("button1Count", new DecimalType(10)));
1243         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1244         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED)); // not available for SHC Classic
1245         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED)); // not available for SHC Classic
1246         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1247     }
1248
1249     @Test
1250     public void testOnDeviceStateChanged_StateChangedEvent_PushButtonSensor_SHCA() {
1251         when(bridgeHandlerMock.isSHCClassic()).thenReturn(false);
1252
1253         DeviceDTO device = createDevice();
1254         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1255
1256         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1257
1258         // StateChanged events only have with this information
1259         EventDTO event = createCapabilityEvent(c -> {
1260             c.setLastKeyPressButtonIndex(0);
1261             c.setLastKeyPressCounter(10);
1262         });
1263
1264         // Nothing should get processed, because it should only react on the more detailed ButtonPressed events
1265         deviceHandler.onDeviceStateChanged(device, event);
1266         assertFalse(isChannelUpdated("button1Count", new DecimalType(10)));
1267         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1268         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1269         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1270         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1271     }
1272
1273     @Test
1274     public void testOnDeviceStateChanged_Event_EnergyConsumptionSensor() {
1275         DeviceDTO device = createDevice();
1276         addCapabilityToDevice(CapabilityDTO.TYPE_ENERGYCONSUMPTIONSENSOR, null, device);
1277
1278         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1279
1280         EventDTO event = createCapabilityEvent(c -> {
1281             c.setEnergyConsumptionMonthKWh(201.51);
1282             c.setAbsoluteEnergyConsumption(5500.51);
1283             c.setEnergyConsumptionMonthEuro(80.32);
1284             c.setEnergyConsumptionDayEuro(3.72);
1285             c.setEnergyConsumptionDayKWh(8.71);
1286         });
1287
1288         deviceHandler.onDeviceStateChanged(device, event);
1289         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_KWH,
1290                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1291         assertTrue(isChannelUpdated(CHANNEL_ABOLUTE_ENERGY_CONSUMPTION,
1292                 QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1293         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_EURO, new DecimalType(80.32)));
1294         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_EURO, new DecimalType(3.72)));
1295         assertTrue(
1296                 isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1297     }
1298
1299     @Test
1300     public void testOnDeviceStateChanged_Event_PowerConsumptionSensor() {
1301         DeviceDTO device = createDevice();
1302         addCapabilityToDevice(CapabilityDTO.TYPE_POWERCONSUMPTIONSENSOR, null, device);
1303
1304         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1305
1306         EventDTO event = createCapabilityEvent(c -> c.setPowerConsumptionWatt(350.5));
1307
1308         deviceHandler.onDeviceStateChanged(device, event);
1309         assertTrue(isChannelUpdated(CHANNEL_POWER_CONSUMPTION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1310     }
1311
1312     @Test
1313     public void testOnDeviceStateChanged_Event_GenerationMeterEnergySensor() {
1314         DeviceDTO device = createDevice();
1315         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERENERGYSENSOR, null, device);
1316
1317         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1318
1319         EventDTO event = createCapabilityEvent(c -> {
1320             c.setEnergyPerMonthInKWh(201.51);
1321             c.setTotalEnergy(5500.51);
1322             c.setEnergyPerMonthInEuro(80.32);
1323             c.setEnergyPerDayInEuro(3.72);
1324             c.setEnergyPerDayInKWh(8.71);
1325         });
1326
1327         deviceHandler.onDeviceStateChanged(device, event);
1328         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_KWH,
1329                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1330         assertTrue(
1331                 isChannelUpdated(CHANNEL_TOTAL_ENERGY_GENERATION, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1332         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_EURO, new DecimalType(80.32)));
1333         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_EURO, new DecimalType(3.72)));
1334         assertTrue(
1335                 isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1336     }
1337
1338     @Test
1339     public void testOnDeviceStateChanged_Event_GenerationMeterPowerConsumptionSensor() {
1340         DeviceDTO device = createDevice();
1341         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERPOWERCONSUMPTIONSENSOR, null, device);
1342
1343         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1344
1345         EventDTO event = createCapabilityEvent(c -> c.setPowerInWatt(350.5));
1346
1347         deviceHandler.onDeviceStateChanged(device, event);
1348         assertTrue(isChannelUpdated(CHANNEL_POWER_GENERATION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1349     }
1350
1351     @Test
1352     public void testOnDeviceStateChanged_Event_TwoWayMeterEnergyConsumptionSensor() {
1353         DeviceDTO device = createDevice();
1354         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYCONSUMPTIONSENSOR, null, device);
1355
1356         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1357
1358         EventDTO event = createCapabilityEvent(c -> {
1359             c.setEnergyPerMonthInKWh(201.51);
1360             c.setTotalEnergy(5500.51);
1361             c.setEnergyPerMonthInEuro(80.32);
1362             c.setEnergyPerDayInEuro(3.72);
1363             c.setEnergyPerDayInKWh(8.71);
1364         });
1365
1366         deviceHandler.onDeviceStateChanged(device, event);
1367         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1368         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1369         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_EURO, new DecimalType(80.32)));
1370         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_EURO, new DecimalType(3.72)));
1371         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1372     }
1373
1374     @Test
1375     public void testOnDeviceStateChanged_Event_TwoWayMeterEnergyFeedSensor() {
1376         DeviceDTO device = createDevice();
1377         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYFEEDSENSOR, null, device);
1378
1379         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1380
1381         EventDTO event = createCapabilityEvent(c -> {
1382             c.setEnergyPerMonthInKWh(201.51);
1383             c.setTotalEnergy(5500.51);
1384             c.setEnergyPerMonthInEuro(80.32);
1385             c.setEnergyPerDayInEuro(3.72);
1386             c.setEnergyPerDayInKWh(8.71);
1387         });
1388
1389         deviceHandler.onDeviceStateChanged(device, event);
1390         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1391         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY_FED, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1392         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_EURO, new DecimalType(80.32)));
1393         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_EURO, new DecimalType(3.72)));
1394         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1395     }
1396
1397     @Test
1398     public void testOnDeviceStateChanged_Event_TwoWayMeterPowerConsumptionSensor() {
1399         DeviceDTO device = createDevice();
1400         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERPOWERCONSUMPTIONSENSOR, null, device);
1401
1402         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1403
1404         EventDTO event = createCapabilityEvent(c -> c.setPowerInWatt(350.5));
1405
1406         deviceHandler.onDeviceStateChanged(device, event);
1407         assertTrue(isChannelUpdated(CHANNEL_POWER_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1408     }
1409
1410     @Test
1411     public void testHandleCommand_UnsupportedChannel() {
1412         DeviceDTO device = createDevice();
1413
1414         ChannelUID channelMock = createChannel(CHANNEL_CONTACT);
1415
1416         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1417
1418         deviceHandler.handleCommand(channelMock, OpenClosedType.OPEN);
1419
1420         verify(bridgeHandlerMock, never()).commandSetRollerShutterLevel(any(), anyInt());
1421         verify(bridgeHandlerMock, never()).commandSwitchDevice(any(), anyBoolean());
1422         verify(bridgeHandlerMock, never()).commandUpdatePointTemperature(any(), anyDouble());
1423         verify(bridgeHandlerMock, never()).commandSwitchAlarm(any(), anyBoolean());
1424         verify(bridgeHandlerMock, never()).commandSetOperationMode(any(), anyBoolean());
1425         verify(bridgeHandlerMock, never()).commandSetDimLevel(any(), anyInt());
1426         verify(bridgeHandlerMock, never()).commandSetRollerShutterLevel(any(), anyInt());
1427         verify(bridgeHandlerMock, never()).commandSetRollerShutterStop(any(), any());
1428     }
1429
1430     @Test
1431     public void testHandleCommand_CommandSwitchDevice_On() {
1432         DeviceDTO device = createDevice();
1433
1434         ChannelUID channelMock = createChannel(CHANNEL_SWITCH);
1435
1436         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1437         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1438
1439         verify(bridgeHandlerMock).commandSwitchDevice(device.getId(), true);
1440     }
1441
1442     @Test
1443     public void testHandleCommand_CommandSwitchDevice_Off() {
1444         DeviceDTO device = createDevice();
1445
1446         ChannelUID channelMock = createChannel(CHANNEL_SWITCH);
1447
1448         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1449         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1450
1451         verify(bridgeHandlerMock).commandSwitchDevice(device.getId(), false);
1452     }
1453
1454     @Test
1455     public void testHandleCommand_CommandSwitchAlarm_On() {
1456         DeviceDTO device = createDevice();
1457
1458         ChannelUID channelMock = createChannel(CHANNEL_ALARM);
1459
1460         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1461         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1462
1463         verify(bridgeHandlerMock).commandSwitchAlarm(device.getId(), true);
1464     }
1465
1466     @Test
1467     public void testHandleCommand_CommandSwitchAlarm_Off() {
1468         DeviceDTO device = createDevice();
1469
1470         ChannelUID channelMock = createChannel(CHANNEL_ALARM);
1471
1472         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1473         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1474
1475         verify(bridgeHandlerMock).commandSwitchAlarm(device.getId(), false);
1476     }
1477
1478     @Test
1479     public void testHandleCommand_CommandSetDimLevel_On() {
1480         DeviceDTO device = createDevice();
1481
1482         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1483
1484         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1485         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1486
1487         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 100);
1488     }
1489
1490     @Test
1491     public void testHandleCommand_CommandSetDimLevel_Off() {
1492         DeviceDTO device = createDevice();
1493
1494         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1495
1496         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1497         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1498
1499         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 0);
1500     }
1501
1502     @Test
1503     public void testHandleCommand_CommandSetDimLevel_DecimalType() {
1504         DeviceDTO device = createDevice();
1505
1506         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1507
1508         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1509         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1510
1511         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 30);
1512     }
1513
1514     @Test
1515     public void testHandleCommand_CommandSetOperationMode_Auto() {
1516         DeviceDTO device = createDevice();
1517
1518         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1519
1520         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1521         deviceHandler.handleCommand(channelMock, StringType.valueOf(STATE_VALUE_OPERATION_MODE_AUTO));
1522
1523         verify(bridgeHandlerMock).commandSetOperationMode(device.getId(), true);
1524     }
1525
1526     @Test
1527     public void testHandleCommand_CommandSetOperationMode_Manual() {
1528         DeviceDTO device = createDevice();
1529
1530         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1531
1532         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1533         deviceHandler.handleCommand(channelMock, StringType.valueOf(STATE_VALUE_OPERATION_MODE_MANUAL));
1534
1535         verify(bridgeHandlerMock).commandSetOperationMode(device.getId(), false);
1536     }
1537
1538     @Test
1539     public void testHandleCommand_CommandSetOperationMode_Unknown() {
1540         DeviceDTO device = createDevice();
1541
1542         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1543
1544         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1545         deviceHandler.handleCommand(channelMock, StringType.valueOf("Unknown"));
1546
1547         verify(bridgeHandlerMock, never()).commandSetOperationMode(any(), anyBoolean());
1548     }
1549
1550     @Test
1551     public void testHandleCommand_CommandUpdatePointTemperature_QuantityType() {
1552         DeviceDTO device = createDevice();
1553
1554         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1555
1556         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1557         deviceHandler.handleCommand(channelMock, QuantityType.valueOf(20.0, SIUnits.CELSIUS));
1558
1559         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 20.0);
1560     }
1561
1562     @Test
1563     public void testHandleCommand_CommandUpdatePointTemperature_DecimalType() {
1564         DeviceDTO device = createDevice();
1565
1566         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1567
1568         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1569         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("20"));
1570
1571         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 20.0);
1572     }
1573
1574     @Test
1575     public void testHandleCommand_CommandUpdatePointTemperature_MinTemperature() {
1576         DeviceDTO device = createDevice();
1577
1578         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1579
1580         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1581         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("0"));
1582
1583         // 0 (and everything below the min temperature 6.0 should be set to the min temperature 6.0)
1584         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 6.0);
1585     }
1586
1587     @Test
1588     public void testHandleCommand_CommandUpdatePointTemperature_MaxTemperature() {
1589         DeviceDTO device = createDevice();
1590
1591         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1592
1593         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1594         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("40"));
1595
1596         // 0 (and everything below the min temperature 30.0 should be set to the min temperature 30.0)
1597         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 30.0);
1598     }
1599
1600     @Test
1601     public void testHandleCommand_CommandRollerShutter_Up() {
1602         DeviceDTO device = createDevice();
1603
1604         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1605
1606         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1607         deviceHandler.handleCommand(channelMock, UpDownType.UP);
1608
1609         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.UP);
1610     }
1611
1612     @Test
1613     public void testHandleCommand_CommandRollerShutter_Down() {
1614         DeviceDTO device = createDevice();
1615
1616         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1617
1618         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1619         deviceHandler.handleCommand(channelMock, UpDownType.DOWN);
1620
1621         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.DOWN);
1622     }
1623
1624     @Test
1625     public void testHandleCommand_CommandRollerShutter_On() {
1626         DeviceDTO device = createDevice();
1627
1628         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1629
1630         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1631         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1632
1633         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.DOWN);
1634     }
1635
1636     @Test
1637     public void testHandleCommand_CommandRollerShutter_Off() {
1638         DeviceDTO device = createDevice();
1639
1640         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1641
1642         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1643         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1644
1645         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.UP);
1646     }
1647
1648     @Test
1649     public void testHandleCommand_CommandRollerShutter_Stop() {
1650         DeviceDTO device = createDevice();
1651
1652         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1653
1654         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1655         deviceHandler.handleCommand(channelMock, StopMoveType.STOP);
1656
1657         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.STOP);
1658     }
1659
1660     @Test
1661     public void testHandleCommand_CommandRollerShutter_DecimalType() {
1662         DeviceDTO device = createDevice();
1663
1664         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1665
1666         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1667         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1668
1669         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 30);
1670     }
1671
1672     @Test
1673     public void testHandleCommand_CommandRollerShutter_DecimalType_Inverted() {
1674         DeviceDTO device = createDevice();
1675
1676         Channel rollerShutterChannelMock = createRollerShutterChannelMock(true);
1677
1678         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1679
1680         Thing thingMock = deviceHandler.getThing();
1681         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
1682
1683         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1684
1685         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1686
1687         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 30);
1688     }
1689
1690     @Test
1691     public void testHandleCommand_CommandRollerShutter_DecimalType_NotInverted() {
1692         DeviceDTO device = createDevice();
1693
1694         Channel rollerShutterChannelMock = createRollerShutterChannelMock(false);
1695
1696         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1697
1698         Thing thingMock = deviceHandler.getThing();
1699         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
1700
1701         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1702
1703         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1704
1705         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 70);
1706     }
1707
1708     private LivisiDeviceHandler createDeviceHandler(DeviceDTO device) {
1709         when(bridgeHandlerMock.getDeviceById(any())).thenReturn(Optional.of(device));
1710
1711         ThingUID bridgeThingUID = new ThingUID(THING_TYPE_BRIDGE, "bridgeId");
1712         Bridge bridgeMock = mock(Bridge.class);
1713         when(bridgeMock.getHandler()).thenReturn(bridgeHandlerMock);
1714         when(bridgeMock.getStatus()).thenReturn(ThingStatus.ONLINE);
1715         when(bridgeMock.getStatusInfo())
1716                 .thenReturn(new ThingStatusInfo(ThingStatus.ONLINE, ThingStatusDetail.NONE, null));
1717
1718         ThingTypeUID thingTypeUID = THING_TYPE_RST2;
1719         ThingUID thingUID = new ThingUID(thingTypeUID, device.getId());
1720
1721         Configuration thingConfiguration = new Configuration();
1722         thingConfiguration.setProperties(Collections.singletonMap(PROPERTY_ID, device.getId()));
1723
1724         Thing thingMock = mock(Thing.class);
1725         when(thingMock.getBridgeUID()).thenReturn(bridgeThingUID);
1726         when(thingMock.getConfiguration()).thenReturn(thingConfiguration);
1727         when(thingMock.getUID()).thenReturn(thingUID);
1728         when(thingMock.getThingTypeUID()).thenReturn(thingTypeUID);
1729         doAnswer(invocation -> {
1730             thingStatusInfo = invocation.getArgument(0, ThingStatusInfo.class);
1731             return null;
1732         }).when(thingMock).setStatusInfo(any());
1733         when(thingMock.getStatusInfo()).thenAnswer(invocation -> thingStatusInfo);
1734         when(thingMock.getStatus()).thenAnswer(invocation -> thingStatusInfo.getStatus());
1735
1736         LivisiDeviceHandler deviceHandler = new LivisiDeviceHandler(thingMock);
1737         ThingHandlerCallback callbackMock = createCallbackMock(bridgeMock);
1738         deviceHandler.setCallback(callbackMock);
1739
1740         deviceHandler.initialize();
1741
1742         return deviceHandler;
1743     }
1744
1745     private static DeviceDTO createDevice() {
1746         DeviceDTO device = new DeviceDTO();
1747         device.setId("id");
1748         device.setConfig(new DeviceConfigDTO());
1749         device.setCapabilityMap(new HashMap<>());
1750         return device;
1751     }
1752
1753     private static ChannelUID createChannel(String channelId) {
1754         ChannelUID channelMock = mock(ChannelUID.class);
1755         when(channelMock.getId()).thenReturn(channelId);
1756         return channelMock;
1757     }
1758
1759     private static void addCapabilityToDevice(String capabilityType,
1760             @Nullable Consumer<CapabilityStateDTO> capabilityStateConsumer, DeviceDTO device) {
1761         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
1762         capabilityConfig.setName("capabilityName");
1763
1764         CapabilityStateDTO capabilityState = new CapabilityStateDTO();
1765         if (capabilityStateConsumer != null) {
1766             capabilityStateConsumer.accept(capabilityState);
1767         }
1768
1769         final String capabilityId = "capabilityId";
1770         CapabilityDTO capability = new CapabilityDTO();
1771         capability.setId(capabilityId);
1772         capability.setType(capabilityType);
1773         capability.setConfig(capabilityConfig);
1774         capability.setCapabilityState(capabilityState);
1775         device.getCapabilityMap().put(capabilityId, capability);
1776     }
1777
1778     private static EventDTO createCapabilityEvent(Consumer<EventPropertiesDTO> eventPropertiesConsumer) {
1779         EventPropertiesDTO eventProperties = new EventPropertiesDTO();
1780         eventPropertiesConsumer.accept(eventProperties);
1781
1782         EventDTO event = new EventDTO();
1783         event.setSource(LINK_TYPE_CAPABILITY + "capabilityId");
1784         event.setProperties(eventProperties);
1785         return event;
1786     }
1787
1788     private ThingHandlerCallback createCallbackMock(Bridge bridge) {
1789         ThingHandlerCallback callback = mock(ThingHandlerCallback.class);
1790         when(callback.getBridge(any())).thenReturn(bridge);
1791         when(callback.createChannelBuilders(any(), any())).thenReturn(Collections.emptyList());
1792
1793         doAnswer(invocation -> {
1794             ChannelUID channelUID = invocation.getArgument(0, ChannelUID.class);
1795             State state = invocation.getArgument(1, State.class);
1796             updatedChannels.put(channelUID.getId(), state);
1797             return null;
1798         }).when(callback).stateUpdated(any(), any());
1799
1800         doAnswer(invocation -> {
1801             Thing thing = invocation.getArgument(0, Thing.class);
1802             ThingStatusInfo thingStatusInfo = invocation.getArgument(1, ThingStatusInfo.class);
1803             thing.setStatusInfo(thingStatusInfo);
1804             return null;
1805         }).when(callback).statusUpdated(any(), any());
1806
1807         doAnswer(invocation -> {
1808             ChannelUID channelUID = invocation.getArgument(1, ChannelUID.class);
1809             String value = invocation.getArgument(2, String.class);
1810             triggeredChannels.add(new TriggeredEvent(channelUID.getId(), value));
1811             return null;
1812         }).when(callback).channelTriggered(any(), any(), any());
1813
1814         doAnswer(invocation -> {
1815             ChannelUID channelUID = invocation.getArgument(0, ChannelUID.class);
1816             return ChannelBuilder.create(channelUID);
1817         }).when(callback).createChannelBuilder(any(), any());
1818
1819         doAnswer(invocation -> {
1820             ChannelUID channelUID = invocation.getArgument(1, ChannelUID.class);
1821             return ChannelBuilder.create(channelUID);
1822         }).when(callback).editChannel(any(), any());
1823
1824         return callback;
1825     }
1826
1827     private boolean isChannelUpdated(String channelUID) {
1828         return updatedChannels.containsKey(channelUID);
1829     }
1830
1831     private boolean isChannelUpdated(String channelUID, State expectedState) {
1832         State state = updatedChannels.get(channelUID);
1833         return expectedState.equals(state);
1834     }
1835
1836     private boolean isChannelTriggered(String channelUID, String expectedTriggerValue) {
1837         return triggeredChannels.contains(new TriggeredEvent(channelUID, expectedTriggerValue));
1838     }
1839
1840     private static Channel createRollerShutterChannelMock(boolean isInvert) {
1841         Map<String, Object> rollerShutterChannelProperties = new HashMap<>();
1842         rollerShutterChannelProperties.put(INVERT_CHANNEL_PARAMETER, isInvert);
1843         Configuration rollerShutterChannelConfiguration = new Configuration(rollerShutterChannelProperties);
1844
1845         Channel rollerShutterChannelMock = mock(Channel.class);
1846         when(rollerShutterChannelMock.getConfiguration()).thenReturn(rollerShutterChannelConfiguration);
1847         return rollerShutterChannelMock;
1848     }
1849
1850     private static class TriggeredEvent {
1851
1852         private final String channelUID;
1853         private final String triggerValue;
1854
1855         public TriggeredEvent(String channelUID, String triggerValue) {
1856             this.channelUID = channelUID;
1857             this.triggerValue = triggerValue;
1858         }
1859
1860         @Override
1861         public boolean equals(@Nullable Object o) {
1862             if (this == o)
1863                 return true;
1864             if (o == null || getClass() != o.getClass())
1865                 return false;
1866             TriggeredEvent that = (TriggeredEvent) o;
1867             return channelUID.equals(that.channelUID) && triggerValue.equals(that.triggerValue);
1868         }
1869
1870         @Override
1871         public int hashCode() {
1872             return Objects.hash(channelUID, triggerValue);
1873         }
1874     }
1875 }