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

   1 /**
   2  * Copyright (c) 2010-2023 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.mielecloud.internal.webservice.api;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.mockito.Mockito.*;
  17
  18 import java.util.Objects;
  19 import java.util.Optional;
  20
  21 import org.eclipse.jdt.annotation.NonNullByDefault;
  22 import org.eclipse.jdt.annotation.Nullable;
  23 import org.junit.jupiter.api.Test;
  24 import org.openhab.binding.mielecloud.internal.webservice.api.json.DeviceType;
  25
  26 /**
  27  * @author Björn Lange - Initial contribution
  28  */
  29 @NonNullByDefault
  30 public class WineStorageDeviceTemperatureStateTest {
  31     private static final Integer TEMPERATURE_0 = 8;
  32     private static final Integer TEMPERATURE_1 = 10;
  33     private static final Integer TEMPERATURE_2 = 12;
  34
  35     private static final Integer TARGET_TEMPERATURE_0 = 5;
  36     private static final Integer TARGET_TEMPERATURE_1 = 9;
  37     private static final Integer TARGET_TEMPERATURE_2 = 11;
  38
  39     @Nullable
  40     private DeviceState deviceState;
  41
  42     private DeviceState getDeviceState() {
  43         assertNotNull(deviceState);
  44         return Objects.requireNonNull(deviceState);
  45     }
  46
  47     private void setUpDeviceStateMock(int numberOfTemperatures) {
  48         deviceState = mock(DeviceState.class);
  49         if (numberOfTemperatures > 0) {
  50             when(getDeviceState().getTemperature(0)).thenReturn(Optional.of(TEMPERATURE_0));
  51             when(getDeviceState().getTargetTemperature(0)).thenReturn(Optional.of(TARGET_TEMPERATURE_0));
  52         } else {
  53             when(getDeviceState().getTemperature(0)).thenReturn(Optional.empty());
  54             when(getDeviceState().getTargetTemperature(0)).thenReturn(Optional.empty());
  55         }
  56         if (numberOfTemperatures > 1) {
  57             when(getDeviceState().getTemperature(1)).thenReturn(Optional.of(TEMPERATURE_1));
  58             when(getDeviceState().getTargetTemperature(1)).thenReturn(Optional.of(TARGET_TEMPERATURE_1));
  59         } else {
  60             when(getDeviceState().getTemperature(1)).thenReturn(Optional.empty());
  61             when(getDeviceState().getTargetTemperature(1)).thenReturn(Optional.empty());
  62         }
  63         if (numberOfTemperatures > 2) {
  64             when(getDeviceState().getTemperature(2)).thenReturn(Optional.of(TEMPERATURE_2));
  65             when(getDeviceState().getTargetTemperature(2)).thenReturn(Optional.of(TARGET_TEMPERATURE_2));
  66         } else {
  67             when(getDeviceState().getTemperature(2)).thenReturn(Optional.empty());
  68             when(getDeviceState().getTargetTemperature(2)).thenReturn(Optional.empty());
  69         }
  70     }
  71
  72     @Test
  73     public void testGetTemperaturesForWineCabinetWithThreeCompartments() {
  74         // given:
  75         setUpDeviceStateMock(3);
  76         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
  77         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
  78
  79         // when:
  80         Optional<Integer> temperature = state.getTemperature();
  81         Optional<Integer> targetTemperature = state.getTargetTemperature();
  82
  83         // then:
  84         assertFalse(temperature.isPresent());
  85         assertFalse(targetTemperature.isPresent());
  86     }
  87
  88     @Test
  89     public void testGetTemperaturesForWineCabinetWithTwoCompartments() {
  90         // given:
  91         setUpDeviceStateMock(2);
  92         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
  93         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
  94
  95         // when:
  96         Optional<Integer> temperature = state.getTemperature();
  97         Optional<Integer> targetTemperature = state.getTargetTemperature();
  98
  99         // then:
 100         assertFalse(temperature.isPresent());
 101         assertFalse(targetTemperature.isPresent());
 102     }
 103
 104     @Test
 105     public void testGetTemperaturesForWineCabinetWithOneCompartment() {
 106         // given:
 107         setUpDeviceStateMock(1);
 108         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 109         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 110
 111         // when:
 112         Integer temperature = state.getTemperature().get();
 113         Integer targetTemperature = state.getTargetTemperature().get();
 114
 115         // then:
 116         assertEquals(TEMPERATURE_0, temperature);
 117         assertEquals(TARGET_TEMPERATURE_0, targetTemperature);
 118     }
 119
 120     @Test
 121     public void testGetTemperaturesForWineCabinetFreezerCombination() {
 122         // given:
 123         setUpDeviceStateMock(2);
 124         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET_FREEZER_COMBINATION);
 125         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 126
 127         // when:
 128         Optional<Integer> temperature = state.getTemperature();
 129         Optional<Integer> targetTemperature = state.getTargetTemperature();
 130
 131         // then:
 132         assertFalse(temperature.isPresent());
 133         assertFalse(targetTemperature.isPresent());
 134     }
 135
 136     @Test
 137     public void testGetTemperaturesForOtherDeviceWithOneTemperature() {
 138         // given:
 139         setUpDeviceStateMock(1);
 140         when(getDeviceState().getRawType()).thenReturn(DeviceType.OVEN);
 141         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 142
 143         // when:
 144         Optional<Integer> temperature = state.getTemperature();
 145         Optional<Integer> targetTemperature = state.getTargetTemperature();
 146
 147         // then:
 148         assertFalse(temperature.isPresent());
 149         assertFalse(targetTemperature.isPresent());
 150     }
 151
 152     @Test
 153     public void testGetTemperaturesWhenNoTemperaturesAreAvailable() {
 154         // given:
 155         setUpDeviceStateMock(0);
 156         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 157         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 158
 159         // when:
 160         Optional<Integer> temperature = state.getTemperature();
 161         Optional<Integer> targetTemperature = state.getTargetTemperature();
 162
 163         // then:
 164         assertFalse(temperature.isPresent());
 165         assertFalse(targetTemperature.isPresent());
 166     }
 167
 168     @Test
 169     public void testGetTopTemperaturesForWineCabinetWithThreeCompartments() {
 170         // given:
 171         setUpDeviceStateMock(3);
 172         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 173         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 174
 175         // when:
 176         Integer temperature = state.getTopTemperature().get();
 177         Integer targetTemperature = state.getTopTargetTemperature().get();
 178
 179         // then:
 180         assertEquals(TEMPERATURE_0, temperature);
 181         assertEquals(TARGET_TEMPERATURE_0, targetTemperature);
 182     }
 183
 184     @Test
 185     public void testGetTopTemperaturesForWineCabinetWithTwoCompartments() {
 186         // given:
 187         setUpDeviceStateMock(2);
 188         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 189         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 190
 191         // when:
 192         Integer temperature = state.getTopTemperature().get();
 193         Integer targetTemperature = state.getTopTargetTemperature().get();
 194
 195         // then:
 196         assertEquals(TEMPERATURE_0, temperature);
 197         assertEquals(TARGET_TEMPERATURE_0, targetTemperature);
 198     }
 199
 200     @Test
 201     public void testGetTopTemperaturesForWineCabinetWithOneCompartment() {
 202         // given:
 203         setUpDeviceStateMock(1);
 204         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 205         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 206
 207         // when:
 208         Optional<Integer> temperature = state.getTopTemperature();
 209         Optional<Integer> targetTemperature = state.getTopTargetTemperature();
 210
 211         // then:
 212         assertFalse(temperature.isPresent());
 213         assertFalse(targetTemperature.isPresent());
 214     }
 215
 216     @Test
 217     public void testGetTopTemperaturesForWineCabinetFreezerCombination() {
 218         // given:
 219         setUpDeviceStateMock(2);
 220         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET_FREEZER_COMBINATION);
 221         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 222
 223         // when:
 224         Integer temperature = state.getTopTemperature().get();
 225         Integer targetTemperature = state.getTopTargetTemperature().get();
 226
 227         // then:
 228         assertEquals(TEMPERATURE_0, temperature);
 229         assertEquals(TARGET_TEMPERATURE_0, targetTemperature);
 230     }
 231
 232     @Test
 233     public void testGetTopTemperaturesForOtherDeviceWithTwoTemperatures() {
 234         // given:
 235         setUpDeviceStateMock(2);
 236         when(getDeviceState().getRawType()).thenReturn(DeviceType.OVEN);
 237         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 238
 239         // when:
 240         Optional<Integer> temperature = state.getTopTemperature();
 241         Optional<Integer> targetTemperature = state.getTopTargetTemperature();
 242
 243         // then:
 244         assertFalse(temperature.isPresent());
 245         assertFalse(targetTemperature.isPresent());
 246     }
 247
 248     @Test
 249     public void testGetTopTemperaturesWhenNoTemperaturesAreAvailable() {
 250         // given:
 251         setUpDeviceStateMock(0);
 252         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 253         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 254
 255         // when:
 256         Optional<Integer> temperature = state.getTopTemperature();
 257         Optional<Integer> targetTemperature = state.getTopTargetTemperature();
 258
 259         // then:
 260         assertFalse(temperature.isPresent());
 261         assertFalse(targetTemperature.isPresent());
 262     }
 263
 264     @Test
 265     public void testGetMiddleTemperaturesForWineCabinetWithThreeCompartments() {
 266         // given:
 267         setUpDeviceStateMock(3);
 268         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 269         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 270
 271         // when:
 272         Integer temperature = state.getMiddleTemperature().get();
 273         Integer targetTemperature = state.getMiddleTargetTemperature().get();
 274
 275         // then:
 276         assertEquals(TEMPERATURE_1, temperature);
 277         assertEquals(TARGET_TEMPERATURE_1, targetTemperature);
 278     }
 279
 280     @Test
 281     public void testGetMiddleTemperaturesForWineCabinetWithTwoCompartments() {
 282         // given:
 283         setUpDeviceStateMock(2);
 284         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 285         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 286
 287         // when:
 288         Optional<Integer> temperature = state.getMiddleTemperature();
 289         Optional<Integer> targetTemperature = state.getMiddleTargetTemperature();
 290
 291         // then:
 292         assertFalse(temperature.isPresent());
 293         assertFalse(targetTemperature.isPresent());
 294     }
 295
 296     @Test
 297     public void testGetMiddleTemperaturesForWineCabinetWithOneCompartment() {
 298         // given:
 299         setUpDeviceStateMock(1);
 300         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 301         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 302
 303         // when:
 304         Optional<Integer> temperature = state.getMiddleTemperature();
 305         Optional<Integer> targetTemperature = state.getMiddleTargetTemperature();
 306
 307         // then:
 308         assertFalse(temperature.isPresent());
 309         assertFalse(targetTemperature.isPresent());
 310     }
 311
 312     @Test
 313     public void testGetMiddleTemperaturesForWineCabinetFreezerCombination() {
 314         // given:
 315         setUpDeviceStateMock(2);
 316         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET_FREEZER_COMBINATION);
 317         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 318
 319         // when:
 320         Optional<Integer> temperature = state.getMiddleTemperature();
 321         Optional<Integer> targetTemperature = state.getMiddleTargetTemperature();
 322
 323         // then:
 324         assertFalse(temperature.isPresent());
 325         assertFalse(targetTemperature.isPresent());
 326     }
 327
 328     @Test
 329     public void testGetMiddleTemperaturesForOtherDeviceWithTwoTemperatures() {
 330         // given:
 331         setUpDeviceStateMock(2);
 332         when(getDeviceState().getRawType()).thenReturn(DeviceType.OVEN);
 333         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 334
 335         // when:
 336         Optional<Integer> temperature = state.getMiddleTemperature();
 337         Optional<Integer> targetTemperature = state.getMiddleTargetTemperature();
 338
 339         // then:
 340         assertFalse(temperature.isPresent());
 341         assertFalse(targetTemperature.isPresent());
 342     }
 343
 344     @Test
 345     public void testGetMiddleTemperaturesWhenNoTemperaturesAreAvailable() {
 346         // given:
 347         setUpDeviceStateMock(0);
 348         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 349         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 350
 351         // when:
 352         Optional<Integer> temperature = state.getMiddleTemperature();
 353         Optional<Integer> targetTemperature = state.getMiddleTargetTemperature();
 354
 355         // then:
 356         assertFalse(temperature.isPresent());
 357         assertFalse(targetTemperature.isPresent());
 358     }
 359
 360     @Test
 361     public void testGetBottomTemperaturesForWineCabinetWithThreeCompartments() {
 362         // given:
 363         setUpDeviceStateMock(3);
 364         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 365         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 366
 367         // when:
 368         Integer temperature = state.getBottomTemperature().get();
 369         Integer targetTemperature = state.getBottomTargetTemperature().get();
 370
 371         // then:
 372         assertEquals(TEMPERATURE_2, temperature);
 373         assertEquals(TARGET_TEMPERATURE_2, targetTemperature);
 374     }
 375
 376     @Test
 377     public void testGetBottomTemperaturesForWineCabinetWithTwoCompartments() {
 378         // given:
 379         setUpDeviceStateMock(2);
 380         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 381         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 382
 383         // when:
 384         Integer temperature = state.getBottomTemperature().get();
 385         Integer targetTemperature = state.getBottomTargetTemperature().get();
 386
 387         // then:
 388         assertEquals(TEMPERATURE_1, temperature);
 389         assertEquals(TARGET_TEMPERATURE_1, targetTemperature);
 390     }
 391
 392     @Test
 393     public void testGetBottomTemperaturesForWineCabinetWithOneCompartment() {
 394         // given:
 395         setUpDeviceStateMock(1);
 396         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 397         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 398
 399         // when:
 400         Optional<Integer> temperature = state.getBottomTemperature();
 401         Optional<Integer> targetTemperature = state.getBottomTargetTemperature();
 402
 403         // then:
 404         assertFalse(temperature.isPresent());
 405         assertFalse(targetTemperature.isPresent());
 406     }
 407
 408     @Test
 409     public void testGetBottomTemperaturesForWineCabinetFreezerCombination() {
 410         // given:
 411         setUpDeviceStateMock(2);
 412         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET_FREEZER_COMBINATION);
 413         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 414
 415         // when:
 416         Integer temperature = state.getBottomTemperature().get();
 417         Integer targetTemperature = state.getBottomTargetTemperature().get();
 418
 419         // then:
 420         assertEquals(TEMPERATURE_1, temperature);
 421         assertEquals(TARGET_TEMPERATURE_1, targetTemperature);
 422     }
 423
 424     @Test
 425     public void testGetBottomTemperaturesForOtherDeviceWithTwoTemperatures() {
 426         // given:
 427         setUpDeviceStateMock(2);
 428         when(getDeviceState().getRawType()).thenReturn(DeviceType.OVEN);
 429         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 430
 431         // when:
 432         Optional<Integer> temperature = state.getBottomTemperature();
 433         Optional<Integer> targetTemperature = state.getBottomTargetTemperature();
 434
 435         // then:
 436         assertFalse(temperature.isPresent());
 437         assertFalse(targetTemperature.isPresent());
 438     }
 439
 440     @Test
 441     public void testGetBottomTemperaturesWhenNoTemperaturesAreAvailable() {
 442         // given:
 443         setUpDeviceStateMock(0);
 444         when(getDeviceState().getRawType()).thenReturn(DeviceType.WINE_CABINET);
 445         WineStorageDeviceTemperatureState state = new WineStorageDeviceTemperatureState(getDeviceState());
 446
 447         // when:
 448         Optional<Integer> temperature = state.getBottomTemperature();
 449         Optional<Integer> targetTemperature = state.getBottomTargetTemperature();
 450
 451         // then:
 452         assertFalse(temperature.isPresent());
 453         assertFalse(targetTemperature.isPresent());
 454     }
 455 }