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 testOnDeviceStateChangedIsReachable() {
 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 testOnDeviceStateChangedIsNotReachable() {
 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 testOnDeviceStateChangedIsReachableVariableActuator() {
 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 testOnDeviceStateChangedLowBattery() {
 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 testOnDeviceStateChangedNoLowBattery() {
 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 testOnDeviceStateChangedNotBatteryPowered() {
 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 testOnDeviceStateChangedVariableActuatorOn() {
 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 testOnDeviceStateChangedVariableActuatorOff() {
 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 testOnDeviceStateChangedVariableActuatorEmptyState() {
 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 testOnDeviceStateChangedTemperatureSensorFrostWarningOn() {
 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 testOnDeviceStateChangedTemperatureSensorFrostWarningOff() {
 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 testOnDeviceStateChangedTemperatureSensorEmptyState() {
 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 testOnDeviceStateChangedThermostatActuatorWindowReductionOn() {
 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 testOnDeviceStateChangedThermostatActuatorWindowReductionOff() {
 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 testOnDeviceStateChangedThermostatActuatorEmptyState() {
 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 testOnDeviceStateChangedHumiditySensorMoldWarningOn() {
 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 testOnDeviceStateChangedHumiditySensorMoldWarningOff() {
 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 testOnDeviceStateChangedHumiditySensorEmptyState() {
 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 testOnDeviceStateChangedWindowDoorSensorOpen() {
 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 testOnDeviceStateChangedWindowDoorSensorClosed() {
 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 testOnDeviceStateChangedWindowDoorSensorEmptyState() {
 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 testOnDeviceStateChangedSmokeDetectorSensorOn() {
 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 testOnDeviceStateChangedSmokeDetectorSensorOff() {
 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 testOnDeviceStateChangedSmokeDetectorSensorEmptyState() {
 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 testOnDeviceStateChangedAlarmActuatorOn() {
 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 testOnDeviceStateChangedAlarmActuatorOff() {
 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 testOnDeviceStateChangedAlarmActuatorEmptyState() {
 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 testOnDeviceStateChangedSwitchActuatorOn() {
 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 testOnDeviceStateChangedSwitchActuatorOff() {
 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 testOnDeviceStateChangedSwitchActuatorEmptyState() {
 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 testOnDeviceStateChangedDimmerActuator() {
 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 testOnDeviceStateChangedDimmerActuatorEmptyState() {
 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 testOnDeviceStateChangedRollerShutterActuator() {
 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 testOnDeviceStateChangedRollerShutterActuatorInvertTrue() {
 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 testOnDeviceStateChangedRollerShutterActuatorInvertFalse() {
 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 testOnDeviceStateChangedRollerShutterActuatorEmptyState() {
 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 testOnDeviceStateChangedMotionDetectionSensor() {
 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 testOnDeviceStateChangedMotionDetectionSensorEmptyState() {
 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 testOnDeviceStateChangedLuminanceSensor() {
 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 testOnDeviceStateChangedLuminanceSensorEmptyState() {
 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 testOnDeviceStateChangedEnergyConsumptionSensor() {
 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 testOnDeviceStateChangedEnergyConsumptionSensorEmptyState() {
 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 testOnDeviceStateChangedPowerConsumptionSensor() {
 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 testOnDeviceStateChangedPowerConsumptionSensorEmptyState() {
 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 testOnDeviceStateChangedGenerationMeterEnergySensor() {
 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 testOnDeviceStateChangedGenerationMeterEnergySensorEmptyState() {
 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 testOnDeviceStateChangedGenerationMeterPowerConsumptionSensor() {
 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 testOnDeviceStateChangedGenerationMeterPowerConsumptionSensorEmptyState() {
 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 testOnDeviceStateChangedTwoWayMeterEnergyConsumptionSensor() {
 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 testOnDeviceStateChangedTwoWayMeterEnergyConsumptionSensorEmptyState() {
 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 testOnDeviceStateChangedTwoWayMeterEnergyFeedSensor() {
 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 testOnDeviceStateChangedTwoWayMeterEnergyFeedSensorEmptyState() {
 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 testOnDeviceStateChangedTwoWayMeterPowerConsumptionSensor() {
 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 testOnDeviceStateChangedTwoWayMeterPowerConsumptionSensorEmptyState() {
 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 testOnDeviceStateChangedPushButtonSensorButton1ShortPress() {
 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         // Trigger channels should only get triggered by events (onDeviceStateChanged(device, event), not
 859         // onDeviceStateChanged(device)).
 860         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
 861         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 862         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 863     }
 864
 865     @Test
 866     public void testOnDeviceStateChangedPushButtonSensorButton1LongPress() {
 867         DeviceDTO device = createDevice();
 868         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 869             c.setPushButtonSensorCounterState(10);
 870             c.setPushButtonSensorButtonIndexState(0);
 871             c.setPushButtonSensorButtonIndexType("LongPress");
 872         }, device);
 873
 874         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 875
 876         deviceHandler.onDeviceStateChanged(device);
 877         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
 878         // Trigger channels should only get triggered by events (onDeviceStateChanged(device, event), not
 879         // onDeviceStateChanged(device)).
 880         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
 881         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 882         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 883     }
 884
 885     @Test
 886     public void testOnDeviceStateChangedPushButtonSensorButton2ShortPress() {
 887         DeviceDTO device = createDevice();
 888         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 889             c.setPushButtonSensorCounterState(10);
 890             c.setPushButtonSensorButtonIndexState(1);
 891             c.setPushButtonSensorButtonIndexType("ShortPress");
 892         }, device);
 893
 894         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 895
 896         deviceHandler.onDeviceStateChanged(device);
 897         assertTrue(isChannelUpdated("button2Count", new DecimalType(10)));
 898         // Trigger channels should only get triggered by events (onDeviceStateChanged(device, event), not
 899         // onDeviceStateChanged(device)).
 900         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
 901         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.SHORT_PRESSED));
 902         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.LONG_PRESSED));
 903     }
 904
 905     @Test
 906     public void testOnDeviceStateChangedPushButtonSensorButton2LongPress() {
 907         DeviceDTO device = createDevice();
 908         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, c -> {
 909             c.setPushButtonSensorCounterState(10);
 910             c.setPushButtonSensorButtonIndexState(1);
 911             c.setPushButtonSensorButtonIndexType("LongPress");
 912         }, device);
 913
 914         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 915
 916         deviceHandler.onDeviceStateChanged(device);
 917         assertTrue(isChannelUpdated("button2Count", new DecimalType(10)));
 918         // Trigger channels should only get triggered by events (onDeviceStateChanged(device, event), not
 919         // onDeviceStateChanged(device)).
 920         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
 921         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.SHORT_PRESSED));
 922         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.LONG_PRESSED));
 923     }
 924
 925     @Test
 926     public void testOnDeviceStateChangedPushButtonSensorEmptyState() {
 927         DeviceDTO device = createDevice();
 928         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
 929
 930         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 931
 932         deviceHandler.onDeviceStateChanged(device);
 933         assertFalse(isChannelUpdated(CHANNEL_BUTTON_COUNT));
 934         assertFalse(isChannelUpdated("button1Count"));
 935         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
 936         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
 937         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
 938     }
 939
 940     @Test
 941     public void testOnDeviceStateChangedEventLinkedToDevice() {
 942         DeviceStateDTO deviceState = new DeviceStateDTO();
 943         deviceState.setReachable(true);
 944
 945         DeviceDTO device = createDevice();
 946         device.setDeviceState(deviceState);
 947
 948         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 949
 950         EventDTO event = new EventDTO();
 951         event.setSource(LINK_TYPE_DEVICE);
 952
 953         deviceHandler.onDeviceStateChanged(device, event);
 954         assertEquals(ThingStatus.ONLINE, deviceHandler.getThing().getStatus());
 955         assertEquals(ThingStatusDetail.NONE, deviceHandler.getThing().getStatusInfo().getStatusDetail());
 956     }
 957
 958     @Test
 959     public void testOnDeviceStateChangedEventLinkedToCapabilityWithoutState() {
 960         DeviceDTO device = createDevice();
 961
 962         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
 963         capabilityConfig.setName("capabilityName");
 964
 965         final String capabilityId = "capabilityId";
 966         CapabilityDTO capability = new CapabilityDTO();
 967         capability.setId(capabilityId);
 968         capability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 969         capability.setConfig(capabilityConfig);
 970         device.getCapabilityMap().put(capabilityId, capability);
 971
 972         DeviceDTO refreshedDevice = createDevice();
 973
 974         CapabilityStateDTO capabilityState = new CapabilityStateDTO();
 975         capabilityState.setSwitchActuatorState(true);
 976
 977         CapabilityDTO refreshedCapability = new CapabilityDTO();
 978         refreshedCapability.setId(capabilityId);
 979         refreshedCapability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
 980         refreshedCapability.setConfig(capabilityConfig);
 981         refreshedCapability.setCapabilityState(capabilityState);
 982         refreshedDevice.getCapabilityMap().put(capabilityId, refreshedCapability);
 983
 984         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
 985         when(bridgeHandlerMock.refreshDevice(any())).thenReturn(Optional.of(refreshedDevice));
 986
 987         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
 988
 989         deviceHandler.onDeviceStateChanged(device, event);
 990         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
 991     }
 992
 993     @Test
 994     public void testOnDeviceStateChangedEventLinkedToCapabilityWithoutStateAlsoAfterRefresh() {
 995         DeviceDTO device = createDevice();
 996
 997         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
 998         capabilityConfig.setName("capabilityName");
 999
1000         final String capabilityId = "capabilityId";
1001         CapabilityDTO capability = new CapabilityDTO();
1002         capability.setId(capabilityId);
1003         capability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
1004         capability.setConfig(capabilityConfig);
1005         device.getCapabilityMap().put(capabilityId, capability);
1006
1007         DeviceDTO refreshedDevice = createDevice();
1008
1009         CapabilityDTO refreshedCapability = new CapabilityDTO();
1010         refreshedCapability.setId(capabilityId);
1011         refreshedCapability.setType(CapabilityDTO.TYPE_SWITCHACTUATOR);
1012         refreshedCapability.setConfig(capabilityConfig);
1013         refreshedDevice.getCapabilityMap().put(capabilityId, refreshedCapability);
1014
1015         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1016         when(bridgeHandlerMock.refreshDevice(any())).thenReturn(Optional.of(refreshedDevice));
1017
1018         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1019
1020         deviceHandler.onDeviceStateChanged(device, event);
1021         // Channels should only get updated when the device have a state.
1022         assertFalse(isChannelUpdated(CHANNEL_SWITCH));
1023     }
1024
1025     @Test
1026     public void testOnDeviceStateChangedEventVariableActuator() {
1027         DeviceDTO device = createDevice();
1028         addCapabilityToDevice(CapabilityDTO.TYPE_VARIABLEACTUATOR, null, device);
1029
1030         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1031
1032         EventDTO event = createCapabilityEvent(c -> c.setValue(true));
1033
1034         deviceHandler.onDeviceStateChanged(device, event);
1035         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
1036     }
1037
1038     @Test
1039     public void testOnDeviceStateChangedEventSwitchActuator() {
1040         DeviceDTO device = createDevice();
1041         addCapabilityToDevice(CapabilityDTO.TYPE_SWITCHACTUATOR, null, device);
1042
1043         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1044
1045         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1046
1047         deviceHandler.onDeviceStateChanged(device, event);
1048         assertTrue(isChannelUpdated(CHANNEL_SWITCH, OnOffType.ON));
1049     }
1050
1051     @Test
1052     public void testOnDeviceStateChangedEventDimmerActuator() {
1053         DeviceDTO device = createDevice();
1054         addCapabilityToDevice(CapabilityDTO.TYPE_DIMMERACTUATOR, null, device);
1055
1056         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1057
1058         EventDTO event = createCapabilityEvent(c -> c.setDimLevel(50));
1059
1060         deviceHandler.onDeviceStateChanged(device, event);
1061         assertTrue(isChannelUpdated(CHANNEL_DIMMER, new DecimalType(50)));
1062     }
1063
1064     @Test
1065     public void testOnDeviceStateChangedEventRollerShutterActuator() {
1066         DeviceDTO device = createDevice();
1067         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, null, device);
1068
1069         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1070
1071         EventDTO event = createCapabilityEvent(c -> c.setShutterLevel(50));
1072
1073         deviceHandler.onDeviceStateChanged(device, event);
1074         assertTrue(isChannelUpdated(CHANNEL_ROLLERSHUTTER, new DecimalType(50)));
1075     }
1076
1077     @Test
1078     public void testOnDeviceStateChangedEventRollerShutterPushButtonSensor() {
1079         DeviceDTO device = createDevice();
1080         addCapabilityToDevice(CapabilityDTO.TYPE_ROLLERSHUTTERACTUATOR, null, device);
1081         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1082
1083         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1084
1085         EventDTO event = createCapabilityEvent(c -> {
1086             c.setKeyPressCounter(10);
1087             c.setKeyPressButtonIndex(0);
1088             c.setKeyPressType("ShortPress");
1089         });
1090         event.setType("ButtonPressed");
1091         event.setNamespace("CosipDevices.RWE");
1092
1093         deviceHandler.onDeviceStateChanged(device, event);
1094         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
1095         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1096         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1097         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1098     }
1099
1100     @Test
1101     public void testOnDeviceStateChangedEventTemperatureSensor() {
1102         DeviceDTO device = createDevice();
1103         addCapabilityToDevice(CapabilityDTO.TYPE_TEMPERATURESENSOR, null, device);
1104
1105         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1106
1107         EventDTO event = createCapabilityEvent(c -> {
1108             c.setTemperature(21.5);
1109             c.setFrostWarning(true);
1110         });
1111
1112         deviceHandler.onDeviceStateChanged(device, event);
1113         assertTrue(isChannelUpdated(CHANNEL_CURRENT_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
1114         assertTrue(isChannelUpdated(CHANNEL_FROST_WARNING, OnOffType.ON));
1115     }
1116
1117     @Test
1118     public void testOnDeviceStateChangedEventThermostatSensor() {
1119         DeviceDTO device = createDevice();
1120         addCapabilityToDevice(CapabilityDTO.TYPE_THERMOSTATACTUATOR, null, device);
1121
1122         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1123
1124         EventDTO event = createCapabilityEvent(c -> {
1125             c.setPointTemperature(21.5);
1126             c.setOperationMode(STATE_VALUE_OPERATION_MODE_AUTO);
1127             c.setWindowReductionActive(true);
1128         });
1129
1130         deviceHandler.onDeviceStateChanged(device, event);
1131         assertTrue(isChannelUpdated(CHANNEL_TARGET_TEMPERATURE, QuantityType.valueOf(21.5, SIUnits.CELSIUS)));
1132         assertTrue(isChannelUpdated(CHANNEL_OPERATION_MODE, new StringType(STATE_VALUE_OPERATION_MODE_AUTO)));
1133         assertTrue(isChannelUpdated(CHANNEL_WINDOW_REDUCTION_ACTIVE, OnOffType.ON));
1134     }
1135
1136     @Test
1137     public void testOnDeviceStateChangedEventHumiditySensor() {
1138         DeviceDTO device = createDevice();
1139         addCapabilityToDevice(CapabilityDTO.TYPE_HUMIDITYSENSOR, null, device);
1140
1141         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1142
1143         EventDTO event = createCapabilityEvent(c -> {
1144             c.setHumidity(35.5);
1145             c.setMoldWarning(true);
1146         });
1147
1148         deviceHandler.onDeviceStateChanged(device, event);
1149         assertTrue(isChannelUpdated(CHANNEL_HUMIDITY, QuantityType.valueOf(35.5, Units.PERCENT)));
1150         assertTrue(isChannelUpdated(CHANNEL_MOLD_WARNING, OnOffType.ON));
1151     }
1152
1153     @Test
1154     public void testOnDeviceStateChangedEventWindowDoorSensor() {
1155         DeviceDTO device = createDevice();
1156         addCapabilityToDevice(CapabilityDTO.TYPE_WINDOWDOORSENSOR, null, device);
1157
1158         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1159
1160         EventDTO event = createCapabilityEvent(c -> c.setIsOpen(true));
1161
1162         deviceHandler.onDeviceStateChanged(device, event);
1163         assertTrue(isChannelUpdated(CHANNEL_CONTACT, OpenClosedType.OPEN));
1164     }
1165
1166     @Test
1167     public void testOnDeviceStateChangedEventSmokeDetectorSensor() {
1168         DeviceDTO device = createDevice();
1169         addCapabilityToDevice(CapabilityDTO.TYPE_SMOKEDETECTORSENSOR, null, device);
1170
1171         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1172
1173         EventDTO event = createCapabilityEvent(c -> c.setIsSmokeAlarm(true));
1174
1175         deviceHandler.onDeviceStateChanged(device, event);
1176         assertTrue(isChannelUpdated(CHANNEL_SMOKE, OnOffType.ON));
1177     }
1178
1179     @Test
1180     public void testOnDeviceStateChangedEventAlarmActuator() {
1181         DeviceDTO device = createDevice();
1182         addCapabilityToDevice(CapabilityDTO.TYPE_ALARMACTUATOR, null, device);
1183
1184         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1185
1186         EventDTO event = createCapabilityEvent(c -> c.setOnState(true));
1187
1188         deviceHandler.onDeviceStateChanged(device, event);
1189         assertTrue(isChannelUpdated(CHANNEL_ALARM, OnOffType.ON));
1190     }
1191
1192     @Test
1193     public void testOnDeviceStateChangedEventMotionDetectionSensor() {
1194         DeviceDTO device = createDevice();
1195         addCapabilityToDevice(CapabilityDTO.TYPE_MOTIONDETECTIONSENSOR, null, device);
1196
1197         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1198
1199         EventDTO event = createCapabilityEvent(c -> c.setMotionDetectedCount(50));
1200
1201         deviceHandler.onDeviceStateChanged(device, event);
1202         assertTrue(isChannelUpdated(CHANNEL_MOTION_COUNT, new DecimalType(50)));
1203     }
1204
1205     @Test
1206     public void testOnDeviceStateChangedEventLuminanceSensor() {
1207         DeviceDTO device = createDevice();
1208         addCapabilityToDevice(CapabilityDTO.TYPE_LUMINANCESENSOR, null, device);
1209
1210         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1211
1212         EventDTO event = createCapabilityEvent(c -> c.setLuminance(50.1));
1213
1214         deviceHandler.onDeviceStateChanged(device, event);
1215         assertTrue(isChannelUpdated(CHANNEL_LUMINANCE, QuantityType.valueOf(50.1, Units.PERCENT)));
1216     }
1217
1218     @Test
1219     public void testOnDeviceStateChangedEventPushButtonSensorButton1ShortPress() {
1220         DeviceDTO device = createDevice();
1221         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1222
1223         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1224
1225         EventDTO event = createCapabilityEvent(c -> {
1226             c.setKeyPressCounter(10);
1227             c.setKeyPressButtonIndex(0);
1228             c.setKeyPressType("ShortPress");
1229         });
1230
1231         deviceHandler.onDeviceStateChanged(device, event);
1232         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
1233         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1234         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1235         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1236         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1237     }
1238
1239     @Test
1240     public void testOnDeviceStateChangedEventPushButtonSensorButton1LongPress() {
1241         DeviceDTO device = createDevice();
1242         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1243
1244         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1245
1246         EventDTO event = createCapabilityEvent(c -> {
1247             c.setKeyPressCounter(10);
1248             c.setKeyPressButtonIndex(0);
1249             c.setKeyPressType("LongPress");
1250         });
1251
1252         deviceHandler.onDeviceStateChanged(device, event);
1253         assertTrue(isChannelUpdated("button1Count", new DecimalType(10)));
1254         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1255         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1256         assertTrue(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1257         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1258     }
1259
1260     @Test
1261     public void testOnDeviceStateChangedStateChangedEventPushButtonSensorSHCClassic() {
1262         when(bridgeHandlerMock.isSHCClassic()).thenReturn(true);
1263
1264         DeviceDTO device = createDevice();
1265         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1266
1267         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1268
1269         // SHC Classic sends only StateChanged events with this information
1270         EventDTO event = createCapabilityEvent(c -> {
1271             c.setLastKeyPressButtonIndex(0);
1272             c.setLastKeyPressCounter(10);
1273         });
1274
1275         // Nothing should get processed, because it should only react on the more detailed ButtonPressed events
1276         deviceHandler.onDeviceStateChanged(device, event);
1277         assertFalse(isChannelUpdated("button1Count", new DecimalType(10)));
1278         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1279         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED)); // not available for SHC Classic
1280         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED)); // not available for SHC Classic
1281         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1282     }
1283
1284     @Test
1285     public void testOnDeviceStateChangedStateChangedEventPushButtonSensorSHCA() {
1286         when(bridgeHandlerMock.isSHCClassic()).thenReturn(false);
1287
1288         DeviceDTO device = createDevice();
1289         addCapabilityToDevice(CapabilityDTO.TYPE_PUSHBUTTONSENSOR, null, device);
1290
1291         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1292
1293         // StateChanged events only have with this information
1294         EventDTO event = createCapabilityEvent(c -> {
1295             c.setLastKeyPressButtonIndex(0);
1296             c.setLastKeyPressCounter(10);
1297         });
1298
1299         // Nothing should get processed, because it should only react on the more detailed ButtonPressed events
1300         deviceHandler.onDeviceStateChanged(device, event);
1301         assertFalse(isChannelUpdated("button1Count", new DecimalType(10)));
1302         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.PRESSED));
1303         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.SHORT_PRESSED));
1304         assertFalse(isChannelTriggered("button1", CommonTriggerEvents.LONG_PRESSED));
1305         assertFalse(isChannelTriggered("button2", CommonTriggerEvents.PRESSED));
1306     }
1307
1308     @Test
1309     public void testOnDeviceStateChangedEventEnergyConsumptionSensor() {
1310         DeviceDTO device = createDevice();
1311         addCapabilityToDevice(CapabilityDTO.TYPE_ENERGYCONSUMPTIONSENSOR, null, device);
1312
1313         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1314
1315         EventDTO event = createCapabilityEvent(c -> {
1316             c.setEnergyConsumptionMonthKWh(201.51);
1317             c.setAbsoluteEnergyConsumption(5500.51);
1318             c.setEnergyConsumptionMonthEuro(80.32);
1319             c.setEnergyConsumptionDayEuro(3.72);
1320             c.setEnergyConsumptionDayKWh(8.71);
1321         });
1322
1323         deviceHandler.onDeviceStateChanged(device, event);
1324         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_KWH,
1325                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1326         assertTrue(isChannelUpdated(CHANNEL_ABOLUTE_ENERGY_CONSUMPTION,
1327                 QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1328         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_MONTH_EURO, new DecimalType(80.32)));
1329         assertTrue(isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_EURO, new DecimalType(3.72)));
1330         assertTrue(
1331                 isChannelUpdated(CHANNEL_ENERGY_CONSUMPTION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1332     }
1333
1334     @Test
1335     public void testOnDeviceStateChangedEventPowerConsumptionSensor() {
1336         DeviceDTO device = createDevice();
1337         addCapabilityToDevice(CapabilityDTO.TYPE_POWERCONSUMPTIONSENSOR, null, device);
1338
1339         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1340
1341         EventDTO event = createCapabilityEvent(c -> c.setPowerConsumptionWatt(350.5));
1342
1343         deviceHandler.onDeviceStateChanged(device, event);
1344         assertTrue(isChannelUpdated(CHANNEL_POWER_CONSUMPTION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1345     }
1346
1347     @Test
1348     public void testOnDeviceStateChangedEventGenerationMeterEnergySensor() {
1349         DeviceDTO device = createDevice();
1350         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERENERGYSENSOR, null, device);
1351
1352         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1353
1354         EventDTO event = createCapabilityEvent(c -> {
1355             c.setEnergyPerMonthInKWh(201.51);
1356             c.setTotalEnergy(5500.51);
1357             c.setEnergyPerMonthInEuro(80.32);
1358             c.setEnergyPerDayInEuro(3.72);
1359             c.setEnergyPerDayInKWh(8.71);
1360         });
1361
1362         deviceHandler.onDeviceStateChanged(device, event);
1363         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_KWH,
1364                 QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1365         assertTrue(
1366                 isChannelUpdated(CHANNEL_TOTAL_ENERGY_GENERATION, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1367         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_MONTH_EURO, new DecimalType(80.32)));
1368         assertTrue(isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_EURO, new DecimalType(3.72)));
1369         assertTrue(
1370                 isChannelUpdated(CHANNEL_ENERGY_GENERATION_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1371     }
1372
1373     @Test
1374     public void testOnDeviceStateChangedEventGenerationMeterPowerConsumptionSensor() {
1375         DeviceDTO device = createDevice();
1376         addCapabilityToDevice(CapabilityDTO.TYPE_GENERATIONMETERPOWERCONSUMPTIONSENSOR, null, device);
1377
1378         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1379
1380         EventDTO event = createCapabilityEvent(c -> c.setPowerInWatt(350.5));
1381
1382         deviceHandler.onDeviceStateChanged(device, event);
1383         assertTrue(isChannelUpdated(CHANNEL_POWER_GENERATION_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1384     }
1385
1386     @Test
1387     public void testOnDeviceStateChangedEventTwoWayMeterEnergyConsumptionSensor() {
1388         DeviceDTO device = createDevice();
1389         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYCONSUMPTIONSENSOR, null, device);
1390
1391         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1392
1393         EventDTO event = createCapabilityEvent(c -> {
1394             c.setEnergyPerMonthInKWh(201.51);
1395             c.setTotalEnergy(5500.51);
1396             c.setEnergyPerMonthInEuro(80.32);
1397             c.setEnergyPerDayInEuro(3.72);
1398             c.setEnergyPerDayInKWh(8.71);
1399         });
1400
1401         deviceHandler.onDeviceStateChanged(device, event);
1402         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1403         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1404         assertTrue(isChannelUpdated(CHANNEL_ENERGY_MONTH_EURO, new DecimalType(80.32)));
1405         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_EURO, new DecimalType(3.72)));
1406         assertTrue(isChannelUpdated(CHANNEL_ENERGY_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1407     }
1408
1409     @Test
1410     public void testOnDeviceStateChangedEventTwoWayMeterEnergyFeedSensor() {
1411         DeviceDTO device = createDevice();
1412         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERENERGYFEEDSENSOR, null, device);
1413
1414         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1415
1416         EventDTO event = createCapabilityEvent(c -> {
1417             c.setEnergyPerMonthInKWh(201.51);
1418             c.setTotalEnergy(5500.51);
1419             c.setEnergyPerMonthInEuro(80.32);
1420             c.setEnergyPerDayInEuro(3.72);
1421             c.setEnergyPerDayInKWh(8.71);
1422         });
1423
1424         deviceHandler.onDeviceStateChanged(device, event);
1425         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_KWH, QuantityType.valueOf(201.51, Units.KILOWATT_HOUR)));
1426         assertTrue(isChannelUpdated(CHANNEL_TOTAL_ENERGY_FED, QuantityType.valueOf(5500.51, Units.KILOWATT_HOUR)));
1427         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_MONTH_EURO, new DecimalType(80.32)));
1428         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_EURO, new DecimalType(3.72)));
1429         assertTrue(isChannelUpdated(CHANNEL_ENERGY_FEED_DAY_KWH, QuantityType.valueOf(8.71, Units.KILOWATT_HOUR)));
1430     }
1431
1432     @Test
1433     public void testOnDeviceStateChangedEventTwoWayMeterPowerConsumptionSensor() {
1434         DeviceDTO device = createDevice();
1435         addCapabilityToDevice(CapabilityDTO.TYPE_TWOWAYMETERPOWERCONSUMPTIONSENSOR, null, device);
1436
1437         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1438
1439         EventDTO event = createCapabilityEvent(c -> c.setPowerInWatt(350.5));
1440
1441         deviceHandler.onDeviceStateChanged(device, event);
1442         assertTrue(isChannelUpdated(CHANNEL_POWER_WATT, QuantityType.valueOf(350.5, Units.WATT)));
1443     }
1444
1445     @Test
1446     public void testHandleCommandUnsupportedChannel() {
1447         DeviceDTO device = createDevice();
1448
1449         ChannelUID channelMock = createChannel(CHANNEL_CONTACT);
1450
1451         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1452
1453         deviceHandler.handleCommand(channelMock, OpenClosedType.OPEN);
1454
1455         verify(bridgeHandlerMock, never()).commandSetRollerShutterLevel(any(), anyInt());
1456         verify(bridgeHandlerMock, never()).commandSwitchDevice(any(), anyBoolean());
1457         verify(bridgeHandlerMock, never()).commandUpdatePointTemperature(any(), anyDouble());
1458         verify(bridgeHandlerMock, never()).commandSwitchAlarm(any(), anyBoolean());
1459         verify(bridgeHandlerMock, never()).commandSetOperationMode(any(), anyBoolean());
1460         verify(bridgeHandlerMock, never()).commandSetDimLevel(any(), anyInt());
1461         verify(bridgeHandlerMock, never()).commandSetRollerShutterLevel(any(), anyInt());
1462         verify(bridgeHandlerMock, never()).commandSetRollerShutterStop(any(), any());
1463     }
1464
1465     @Test
1466     public void testHandleCommandCommandSwitchDeviceOn() {
1467         DeviceDTO device = createDevice();
1468
1469         ChannelUID channelMock = createChannel(CHANNEL_SWITCH);
1470
1471         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1472         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1473
1474         verify(bridgeHandlerMock).commandSwitchDevice(device.getId(), true);
1475     }
1476
1477     @Test
1478     public void testHandleCommandCommandSwitchDeviceOff() {
1479         DeviceDTO device = createDevice();
1480
1481         ChannelUID channelMock = createChannel(CHANNEL_SWITCH);
1482
1483         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1484         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1485
1486         verify(bridgeHandlerMock).commandSwitchDevice(device.getId(), false);
1487     }
1488
1489     @Test
1490     public void testHandleCommandCommandSwitchAlarmOn() {
1491         DeviceDTO device = createDevice();
1492
1493         ChannelUID channelMock = createChannel(CHANNEL_ALARM);
1494
1495         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1496         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1497
1498         verify(bridgeHandlerMock).commandSwitchAlarm(device.getId(), true);
1499     }
1500
1501     @Test
1502     public void testHandleCommandCommandSwitchAlarmOff() {
1503         DeviceDTO device = createDevice();
1504
1505         ChannelUID channelMock = createChannel(CHANNEL_ALARM);
1506
1507         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1508         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1509
1510         verify(bridgeHandlerMock).commandSwitchAlarm(device.getId(), false);
1511     }
1512
1513     @Test
1514     public void testHandleCommandCommandSetDimLevelOn() {
1515         DeviceDTO device = createDevice();
1516
1517         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1518
1519         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1520         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1521
1522         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 100);
1523     }
1524
1525     @Test
1526     public void testHandleCommandCommandSetDimLevelOff() {
1527         DeviceDTO device = createDevice();
1528
1529         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1530
1531         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1532         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1533
1534         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 0);
1535     }
1536
1537     @Test
1538     public void testHandleCommandCommandSetDimLevelDecimalType() {
1539         DeviceDTO device = createDevice();
1540
1541         ChannelUID channelMock = createChannel(CHANNEL_DIMMER);
1542
1543         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1544         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1545
1546         verify(bridgeHandlerMock).commandSetDimLevel(device.getId(), 30);
1547     }
1548
1549     @Test
1550     public void testHandleCommandCommandSetOperationModeAuto() {
1551         DeviceDTO device = createDevice();
1552
1553         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1554
1555         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1556         deviceHandler.handleCommand(channelMock, StringType.valueOf(STATE_VALUE_OPERATION_MODE_AUTO));
1557
1558         verify(bridgeHandlerMock).commandSetOperationMode(device.getId(), true);
1559     }
1560
1561     @Test
1562     public void testHandleCommandCommandSetOperationModeManual() {
1563         DeviceDTO device = createDevice();
1564
1565         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1566
1567         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1568         deviceHandler.handleCommand(channelMock, StringType.valueOf(STATE_VALUE_OPERATION_MODE_MANUAL));
1569
1570         verify(bridgeHandlerMock).commandSetOperationMode(device.getId(), false);
1571     }
1572
1573     @Test
1574     public void testHandleCommandCommandSetOperationModeUnknown() {
1575         DeviceDTO device = createDevice();
1576
1577         ChannelUID channelMock = createChannel(CHANNEL_OPERATION_MODE);
1578
1579         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1580         deviceHandler.handleCommand(channelMock, StringType.valueOf("Unknown"));
1581
1582         verify(bridgeHandlerMock, never()).commandSetOperationMode(any(), anyBoolean());
1583     }
1584
1585     @Test
1586     public void testHandleCommandCommandUpdatePointTemperatureQuantityType() {
1587         DeviceDTO device = createDevice();
1588
1589         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1590
1591         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1592         deviceHandler.handleCommand(channelMock, QuantityType.valueOf(20.0, SIUnits.CELSIUS));
1593
1594         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 20.0);
1595     }
1596
1597     @Test
1598     public void testHandleCommandCommandUpdatePointTemperatureDecimalType() {
1599         DeviceDTO device = createDevice();
1600
1601         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1602
1603         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1604         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("20"));
1605
1606         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 20.0);
1607     }
1608
1609     @Test
1610     public void testHandleCommandCommandUpdatePointTemperatureMinTemperature() {
1611         DeviceDTO device = createDevice();
1612
1613         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1614
1615         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1616         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("0"));
1617
1618         // 0 (and everything below the min temperature 6.0 should be set to the min temperature 6.0)
1619         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 6.0);
1620     }
1621
1622     @Test
1623     public void testHandleCommandCommandUpdatePointTemperatureMaxTemperature() {
1624         DeviceDTO device = createDevice();
1625
1626         ChannelUID channelMock = createChannel(CHANNEL_TARGET_TEMPERATURE);
1627
1628         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1629         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("40"));
1630
1631         // 0 (and everything below the min temperature 30.0 should be set to the min temperature 30.0)
1632         verify(bridgeHandlerMock).commandUpdatePointTemperature(device.getId(), 30.0);
1633     }
1634
1635     @Test
1636     public void testHandleCommandCommandRollerShutterUp() {
1637         DeviceDTO device = createDevice();
1638
1639         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1640
1641         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1642         deviceHandler.handleCommand(channelMock, UpDownType.UP);
1643
1644         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.UP);
1645     }
1646
1647     @Test
1648     public void testHandleCommandCommandRollerShutterDown() {
1649         DeviceDTO device = createDevice();
1650
1651         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1652
1653         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1654         deviceHandler.handleCommand(channelMock, UpDownType.DOWN);
1655
1656         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.DOWN);
1657     }
1658
1659     @Test
1660     public void testHandleCommandCommandRollerShutterOn() {
1661         DeviceDTO device = createDevice();
1662
1663         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1664
1665         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1666         deviceHandler.handleCommand(channelMock, OnOffType.ON);
1667
1668         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.DOWN);
1669     }
1670
1671     @Test
1672     public void testHandleCommandCommandRollerShutterOff() {
1673         DeviceDTO device = createDevice();
1674
1675         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1676
1677         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1678         deviceHandler.handleCommand(channelMock, OnOffType.OFF);
1679
1680         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.UP);
1681     }
1682
1683     @Test
1684     public void testHandleCommandCommandRollerShutterStop() {
1685         DeviceDTO device = createDevice();
1686
1687         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1688
1689         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1690         deviceHandler.handleCommand(channelMock, StopMoveType.STOP);
1691
1692         verify(bridgeHandlerMock).commandSetRollerShutterStop(device.getId(), ShutterActionType.STOP);
1693     }
1694
1695     @Test
1696     public void testHandleCommandCommandRollerShutterDecimalType() {
1697         DeviceDTO device = createDevice();
1698
1699         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1700
1701         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1702         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1703
1704         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 30);
1705     }
1706
1707     @Test
1708     public void testHandleCommandCommandRollerShutterDecimalTypeInverted() {
1709         DeviceDTO device = createDevice();
1710
1711         Channel rollerShutterChannelMock = createRollerShutterChannelMock(true);
1712
1713         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1714
1715         Thing thingMock = deviceHandler.getThing();
1716         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
1717
1718         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1719
1720         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1721
1722         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 30);
1723     }
1724
1725     @Test
1726     public void testHandleCommandCommandRollerShutterDecimalTypeNotInverted() {
1727         DeviceDTO device = createDevice();
1728
1729         Channel rollerShutterChannelMock = createRollerShutterChannelMock(false);
1730
1731         LivisiDeviceHandler deviceHandler = createDeviceHandler(device);
1732
1733         Thing thingMock = deviceHandler.getThing();
1734         when(thingMock.getChannel(CHANNEL_ROLLERSHUTTER)).thenReturn(rollerShutterChannelMock);
1735
1736         ChannelUID channelMock = createChannel(CHANNEL_ROLLERSHUTTER);
1737
1738         deviceHandler.handleCommand(channelMock, DecimalType.valueOf("30"));
1739
1740         verify(bridgeHandlerMock).commandSetRollerShutterLevel(device.getId(), 70);
1741     }
1742
1743     private LivisiDeviceHandler createDeviceHandler(DeviceDTO device) {
1744         when(bridgeHandlerMock.getDeviceById(any())).thenReturn(Optional.of(device));
1745
1746         ThingUID bridgeThingUID = new ThingUID(THING_TYPE_BRIDGE, "bridgeId");
1747         Bridge bridgeMock = mock(Bridge.class);
1748         when(bridgeMock.getHandler()).thenReturn(bridgeHandlerMock);
1749         when(bridgeMock.getStatus()).thenReturn(ThingStatus.ONLINE);
1750         when(bridgeMock.getStatusInfo())
1751                 .thenReturn(new ThingStatusInfo(ThingStatus.ONLINE, ThingStatusDetail.NONE, null));
1752
1753         ThingTypeUID thingTypeUID = THING_TYPE_RST2;
1754         ThingUID thingUID = new ThingUID(thingTypeUID, device.getId());
1755
1756         Configuration thingConfiguration = new Configuration();
1757         thingConfiguration.setProperties(Collections.singletonMap(PROPERTY_ID, device.getId()));
1758
1759         Thing thingMock = mock(Thing.class);
1760         when(thingMock.getBridgeUID()).thenReturn(bridgeThingUID);
1761         when(thingMock.getConfiguration()).thenReturn(thingConfiguration);
1762         when(thingMock.getUID()).thenReturn(thingUID);
1763         when(thingMock.getThingTypeUID()).thenReturn(thingTypeUID);
1764         doAnswer(invocation -> {
1765             thingStatusInfo = invocation.getArgument(0, ThingStatusInfo.class);
1766             return null;
1767         }).when(thingMock).setStatusInfo(any());
1768         when(thingMock.getStatusInfo()).thenAnswer(invocation -> thingStatusInfo);
1769         when(thingMock.getStatus()).thenAnswer(invocation -> thingStatusInfo.getStatus());
1770
1771         LivisiDeviceHandler deviceHandler = new LivisiDeviceHandler(thingMock);
1772         ThingHandlerCallback callbackMock = createCallbackMock(bridgeMock);
1773         deviceHandler.setCallback(callbackMock);
1774
1775         deviceHandler.initialize();
1776
1777         return deviceHandler;
1778     }
1779
1780     private static DeviceDTO createDevice() {
1781         DeviceDTO device = new DeviceDTO();
1782         device.setId("id");
1783         device.setConfig(new DeviceConfigDTO());
1784         device.setCapabilityMap(new HashMap<>());
1785         return device;
1786     }
1787
1788     private static ChannelUID createChannel(String channelId) {
1789         ChannelUID channelMock = mock(ChannelUID.class);
1790         when(channelMock.getId()).thenReturn(channelId);
1791         return channelMock;
1792     }
1793
1794     private static void addCapabilityToDevice(String capabilityType,
1795             @Nullable Consumer<CapabilityStateDTO> capabilityStateConsumer, DeviceDTO device) {
1796         CapabilityConfigDTO capabilityConfig = new CapabilityConfigDTO();
1797         capabilityConfig.setName("capabilityName");
1798
1799         CapabilityStateDTO capabilityState = new CapabilityStateDTO();
1800         if (capabilityStateConsumer != null) {
1801             capabilityStateConsumer.accept(capabilityState);
1802         }
1803
1804         final String capabilityId = "capabilityId";
1805         CapabilityDTO capability = new CapabilityDTO();
1806         capability.setId(capabilityId);
1807         capability.setType(capabilityType);
1808         capability.setConfig(capabilityConfig);
1809         capability.setCapabilityState(capabilityState);
1810         device.getCapabilityMap().put(capabilityId, capability);
1811     }
1812
1813     private static EventDTO createCapabilityEvent(Consumer<EventPropertiesDTO> eventPropertiesConsumer) {
1814         EventPropertiesDTO eventProperties = new EventPropertiesDTO();
1815         eventPropertiesConsumer.accept(eventProperties);
1816
1817         EventDTO event = new EventDTO();
1818         event.setSource(LINK_TYPE_CAPABILITY + "capabilityId");
1819         event.setProperties(eventProperties);
1820         return event;
1821     }
1822
1823     private ThingHandlerCallback createCallbackMock(Bridge bridge) {
1824         ThingHandlerCallback callback = mock(ThingHandlerCallback.class);
1825         when(callback.getBridge(any())).thenReturn(bridge);
1826         when(callback.createChannelBuilders(any(), any())).thenReturn(Collections.emptyList());
1827
1828         doAnswer(invocation -> {
1829             ChannelUID channelUID = invocation.getArgument(0, ChannelUID.class);
1830             State state = invocation.getArgument(1, State.class);
1831             updatedChannels.put(channelUID.getId(), state);
1832             return null;
1833         }).when(callback).stateUpdated(any(), any());
1834
1835         doAnswer(invocation -> {
1836             Thing thing = invocation.getArgument(0, Thing.class);
1837             ThingStatusInfo thingStatusInfo = invocation.getArgument(1, ThingStatusInfo.class);
1838             thing.setStatusInfo(thingStatusInfo);
1839             return null;
1840         }).when(callback).statusUpdated(any(), any());
1841
1842         doAnswer(invocation -> {
1843             ChannelUID channelUID = invocation.getArgument(1, ChannelUID.class);
1844             String value = invocation.getArgument(2, String.class);
1845             triggeredChannels.add(new TriggeredEvent(channelUID.getId(), value));
1846             return null;
1847         }).when(callback).channelTriggered(any(), any(), any());
1848
1849         doAnswer(invocation -> {
1850             ChannelUID channelUID = invocation.getArgument(0, ChannelUID.class);
1851             return ChannelBuilder.create(channelUID);
1852         }).when(callback).createChannelBuilder(any(), any());
1853
1854         doAnswer(invocation -> {
1855             ChannelUID channelUID = invocation.getArgument(1, ChannelUID.class);
1856             return ChannelBuilder.create(channelUID);
1857         }).when(callback).editChannel(any(), any());
1858
1859         return callback;
1860     }
1861
1862     private boolean isChannelUpdated(String channelUID) {
1863         return updatedChannels.containsKey(channelUID);
1864     }
1865
1866     private boolean isChannelUpdated(String channelUID, State expectedState) {
1867         State state = updatedChannels.get(channelUID);
1868         return expectedState.equals(state);
1869     }
1870
1871     private boolean isChannelTriggered(String channelUID, String expectedTriggerValue) {
1872         return triggeredChannels.contains(new TriggeredEvent(channelUID, expectedTriggerValue));
1873     }
1874
1875     private static Channel createRollerShutterChannelMock(boolean isInvert) {
1876         Map<String, Object> rollerShutterChannelProperties = new HashMap<>();
1877         rollerShutterChannelProperties.put(INVERT_CHANNEL_PARAMETER, isInvert);
1878         Configuration rollerShutterChannelConfiguration = new Configuration(rollerShutterChannelProperties);
1879
1880         Channel rollerShutterChannelMock = mock(Channel.class);
1881         when(rollerShutterChannelMock.getConfiguration()).thenReturn(rollerShutterChannelConfiguration);
1882         return rollerShutterChannelMock;
1883     }
1884
1885     private static class TriggeredEvent {
1886
1887         private final String channelUID;
1888         private final String triggerValue;
1889
1890         public TriggeredEvent(String channelUID, String triggerValue) {
1891             this.channelUID = channelUID;
1892             this.triggerValue = triggerValue;
1893         }
1894
1895         @Override
1896         public boolean equals(@Nullable Object o) {
1897             if (this == o) {
1898                 return true;
1899             }
1900             if (o == null || getClass() != o.getClass()) {
1901                 return false;
1902             }
1903             TriggeredEvent that = (TriggeredEvent) o;
1904             return channelUID.equals(that.channelUID) && triggerValue.equals(that.triggerValue);
1905         }
1906
1907         @Override
1908         public int hashCode() {
1909             return Objects.hash(channelUID, triggerValue);
1910         }
1911     }
1912 }