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.enigma2.internal.handler;
  14
  15 import static org.eclipse.jdt.annotation.Checks.requireNonNull;
  16 import static org.hamcrest.MatcherAssert.assertThat;
  17 import static org.hamcrest.Matchers.*;
  18 import static org.mockito.Mockito.*;
  19
  20 import java.time.LocalDateTime;
  21 import java.time.temporal.ChronoUnit;
  22 import java.util.Optional;
  23
  24 import org.eclipse.jdt.annotation.NonNullByDefault;
  25 import org.eclipse.jdt.annotation.Nullable;
  26 import org.junit.jupiter.api.BeforeEach;
  27 import org.junit.jupiter.api.Test;
  28 import org.openhab.binding.enigma2.internal.Enigma2BindingConstants;
  29 import org.openhab.binding.enigma2.internal.Enigma2Client;
  30 import org.openhab.binding.enigma2.internal.Enigma2Configuration;
  31 import org.openhab.binding.enigma2.internal.Enigma2RemoteKey;
  32 import org.openhab.binding.enigma2.internal.actions.Enigma2Actions;
  33 import org.openhab.core.config.core.Configuration;
  34 import org.openhab.core.library.types.DecimalType;
  35 import org.openhab.core.library.types.NextPreviousType;
  36 import org.openhab.core.library.types.OnOffType;
  37 import org.openhab.core.library.types.PercentType;
  38 import org.openhab.core.library.types.PlayPauseType;
  39 import org.openhab.core.library.types.StringType;
  40 import org.openhab.core.thing.ChannelUID;
  41 import org.openhab.core.thing.Thing;
  42 import org.openhab.core.thing.binding.ThingHandlerCallback;
  43 import org.openhab.core.types.RefreshType;
  44
  45 /**
  46  * The {@link Enigma2HandlerTest} class is responsible for testing {@link Enigma2Handler}.
  47  *
  48  * @author Guido Dolfen - Initial contribution
  49  */
  50 @SuppressWarnings({ "null", "unchecked" })
  51 @NonNullByDefault
  52 public class Enigma2HandlerTest {
  53     public static final String CHANNEL_UID_PREFIX = "enigma2:device:192_168_0_3:";
  54     public static final String SOME_TEXT = "some Text";
  55     @Nullable
  56     private Enigma2Handler enigma2Handler;
  57     @Nullable
  58     private Enigma2Client enigma2Client;
  59     @Nullable
  60     private Thing thing;
  61     @Nullable
  62     private Configuration configuration;
  63     @Nullable
  64     private ThingHandlerCallback callback;
  65
  66     @BeforeEach
  67     public void setUp() {
  68         enigma2Client = mock(Enigma2Client.class);
  69         thing = mock(Thing.class);
  70         callback = mock(ThingHandlerCallback.class);
  71         configuration = mock(Configuration.class);
  72         when(thing.getConfiguration()).thenReturn(requireNonNull(configuration));
  73         when(configuration.as(Enigma2Configuration.class)).thenReturn(new Enigma2Configuration());
  74         enigma2Handler = spy(new Enigma2Handler(requireNonNull(thing)));
  75         enigma2Handler.setCallback(callback);
  76         when(enigma2Handler.getEnigma2Client()).thenReturn(Optional.of(requireNonNull(enigma2Client)));
  77     }
  78
  79     @Test
  80     public void testSendRcCommand() {
  81         enigma2Handler.sendRcCommand("KEY_1");
  82         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.KEY_1.getValue());
  83     }
  84
  85     @Test
  86     public void testSendInfo() {
  87         enigma2Handler.sendInfo(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  88         verify(enigma2Client).sendInfo(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  89     }
  90
  91     @Test
  92     public void testSendWarning() {
  93         enigma2Handler.sendWarning(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  94         verify(enigma2Client).sendWarning(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  95     }
  96
  97     @Test
  98     public void testSendError() {
  99         enigma2Handler.sendError(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 100         verify(enigma2Client).sendError(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 101     }
 102
 103     @Test
 104     public void testSendQuestion() {
 105         enigma2Handler.sendQuestion(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 106         verify(enigma2Client).sendQuestion(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 107     }
 108
 109     @Test
 110     public void testGetEnigma2Client() {
 111         enigma2Handler = new Enigma2Handler(requireNonNull(thing));
 112         assertThat(enigma2Handler.getEnigma2Client(), is(Optional.empty()));
 113     }
 114
 115     @Test
 116     public void testGetServices() {
 117         enigma2Handler = new Enigma2Handler(requireNonNull(thing));
 118         assertThat(enigma2Handler.getServices(), contains(Enigma2Actions.class));
 119     }
 120
 121     @Test
 122     public void testSendRcCommandUnsupported() {
 123         enigma2Handler.sendRcCommand("KEY_X");
 124         verifyNoInteractions(enigma2Client);
 125     }
 126
 127     @Test
 128     public void testHandleCommandPowerRefreshFalse() {
 129         when(enigma2Client.isPower()).thenReturn(false);
 130         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_POWER);
 131         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 132         verify(enigma2Client).refreshPower();
 133         verify(callback).stateUpdated(channelUID, OnOffType.OFF);
 134     }
 135
 136     @Test
 137     public void testHandleCommandPowerRefreshTrue() {
 138         when(enigma2Client.isPower()).thenReturn(true);
 139         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_POWER);
 140         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 141         verify(enigma2Client).refreshPower();
 142         verify(callback).stateUpdated(channelUID, OnOffType.ON);
 143     }
 144
 145     @Test
 146     public void testHandleCommandPowerOn() {
 147         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_POWER);
 148         enigma2Handler.handleCommand(channelUID, OnOffType.ON);
 149         verify(enigma2Client).setPower(true);
 150     }
 151
 152     @Test
 153     public void testHandleCommandPowerOff() {
 154         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_POWER);
 155         enigma2Handler.handleCommand(channelUID, OnOffType.OFF);
 156         verify(enigma2Client).setPower(false);
 157     }
 158
 159     @Test
 160     public void testHandleCommandPowerUnsupported() {
 161         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_POWER);
 162         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 163         verifyNoInteractions(enigma2Client);
 164     }
 165
 166     @Test
 167     public void testHandleCommandChannelRefresh() {
 168         when(enigma2Client.getChannel()).thenReturn(SOME_TEXT);
 169         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_CHANNEL);
 170         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 171         verify(enigma2Client).refreshChannel();
 172         verify(callback).stateUpdated(channelUID, new StringType(SOME_TEXT));
 173     }
 174
 175     @Test
 176     public void testHandleCommandMuteRefreshFalse() {
 177         when(enigma2Client.isMute()).thenReturn(false);
 178         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MUTE);
 179         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 180         verify(enigma2Client).refreshVolume();
 181         verify(callback).stateUpdated(channelUID, OnOffType.OFF);
 182     }
 183
 184     @Test
 185     public void testHandleCommandMuteRefreshTrue() {
 186         when(enigma2Client.isMute()).thenReturn(true);
 187         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MUTE);
 188         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 189         verify(enigma2Client).refreshVolume();
 190         verify(callback).stateUpdated(channelUID, OnOffType.ON);
 191     }
 192
 193     @Test
 194     public void testHandleCommandMuteOn() {
 195         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MUTE);
 196         enigma2Handler.handleCommand(channelUID, OnOffType.ON);
 197         verify(enigma2Client).setMute(true);
 198     }
 199
 200     @Test
 201     public void testHandleCommandMuteOff() {
 202         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MUTE);
 203         enigma2Handler.handleCommand(channelUID, OnOffType.OFF);
 204         verify(enigma2Client).setMute(false);
 205     }
 206
 207     @Test
 208     public void testHandleCommandMuteUnsupported() {
 209         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MUTE);
 210         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 211         verifyNoInteractions(enigma2Client);
 212     }
 213
 214     @Test
 215     public void testHandleCommandChannelString() {
 216         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_CHANNEL);
 217         enigma2Handler.handleCommand(channelUID, new StringType(SOME_TEXT));
 218         verify(enigma2Client).setChannel(SOME_TEXT);
 219     }
 220
 221     @Test
 222     public void testHandleCommandChannelUnsupported() {
 223         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_CHANNEL);
 224         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 225         verifyNoInteractions(enigma2Client);
 226     }
 227
 228     @Test
 229     public void testHandleCommandMediaPlayerRefresh() {
 230         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 231         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 232         verifyNoInteractions(enigma2Client);
 233     }
 234
 235     @Test
 236     public void testHandleCommandMediaPlay() {
 237         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 238         enigma2Handler.handleCommand(channelUID, PlayPauseType.PLAY);
 239         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.PLAY.getValue());
 240     }
 241
 242     @Test
 243     public void testHandleCommandMediaPause() {
 244         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 245         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 246         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.PAUSE.getValue());
 247     }
 248
 249     @Test
 250     public void testHandleCommandMediaNext() {
 251         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 252         enigma2Handler.handleCommand(channelUID, NextPreviousType.NEXT);
 253         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.FAST_FORWARD.getValue());
 254     }
 255
 256     @Test
 257     public void testHandleCommandMediaPrevious() {
 258         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 259         enigma2Handler.handleCommand(channelUID, NextPreviousType.PREVIOUS);
 260         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.FAST_BACKWARD.getValue());
 261     }
 262
 263     @Test
 264     public void testHandleCommandMediaPlayerUnsupported() {
 265         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_PLAYER);
 266         enigma2Handler.handleCommand(channelUID, OnOffType.ON);
 267         verifyNoInteractions(enigma2Client);
 268     }
 269
 270     @Test
 271     public void testHandleCommandMediaStopRefresh() {
 272         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_STOP);
 273         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 274         verifyNoInteractions(enigma2Client);
 275     }
 276
 277     @Test
 278     public void testHandleCommandMediaStopOn() {
 279         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_STOP);
 280         enigma2Handler.handleCommand(channelUID, OnOffType.ON);
 281         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.STOP.getValue());
 282     }
 283
 284     @Test
 285     public void testHandleCommandMediaStopOff() {
 286         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_STOP);
 287         enigma2Handler.handleCommand(channelUID, OnOffType.OFF);
 288         verify(enigma2Client).sendRcCommand(Enigma2RemoteKey.STOP.getValue());
 289     }
 290
 291     @Test
 292     public void testHandleCommandMediaStopUnsupported() {
 293         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_MEDIA_STOP);
 294         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 295         verifyNoInteractions(enigma2Client);
 296     }
 297
 298     @Test
 299     public void testHandleCommandTitleUnsupported() {
 300         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_TITLE);
 301         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 302         verifyNoInteractions(enigma2Client);
 303     }
 304
 305     @Test
 306     public void testHandleCommandTitleRefresh() {
 307         when(enigma2Client.getTitle()).thenReturn(SOME_TEXT);
 308         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_TITLE);
 309         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 310         verify(enigma2Client).refreshEpg();
 311         verify(callback).stateUpdated(channelUID, new StringType(SOME_TEXT));
 312     }
 313
 314     @Test
 315     public void testHandleCommandAnswerUnsupported() {
 316         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_ANSWER);
 317         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 318         verifyNoInteractions(enigma2Client);
 319     }
 320
 321     @Test
 322     public void testHandleCommandAnswerRefresh() {
 323         when(enigma2Client.getAnswer()).thenReturn(SOME_TEXT);
 324         when(enigma2Client.getLastAnswerTime()).thenReturn(LocalDateTime.now().plus(1, ChronoUnit.SECONDS));
 325         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_ANSWER);
 326         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 327         verify(enigma2Client).refreshAnswer();
 328         verify(callback).stateUpdated(channelUID, new StringType(SOME_TEXT));
 329     }
 330
 331     @Test
 332     public void testHandleCommandAnswerRefreshFalse() {
 333         when(enigma2Client.getAnswer()).thenReturn(SOME_TEXT);
 334         when(enigma2Client.getLastAnswerTime()).thenReturn(LocalDateTime.of(2020, 1, 1, 0, 0));
 335         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_ANSWER);
 336         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 337         verify(enigma2Client).refreshAnswer();
 338         verifyNoInteractions(callback);
 339     }
 340
 341     @Test
 342     public void testHandleCommandDescriptionUnsupported() {
 343         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_DESCRIPTION);
 344         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 345         verifyNoInteractions(enigma2Client);
 346     }
 347
 348     @Test
 349     public void testHandleCommandDescriptionRefresh() {
 350         when(enigma2Client.getDescription()).thenReturn(SOME_TEXT);
 351         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_DESCRIPTION);
 352         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 353         verify(enigma2Client).refreshEpg();
 354         verify(callback).stateUpdated(channelUID, new StringType(SOME_TEXT));
 355     }
 356
 357     @Test
 358     public void testHandleCommandVolumeRefresh() {
 359         when(enigma2Client.getVolume()).thenReturn(35);
 360         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_VOLUME);
 361         enigma2Handler.handleCommand(channelUID, RefreshType.REFRESH);
 362         verify(enigma2Client).refreshVolume();
 363         verify(callback).stateUpdated(channelUID, new PercentType(35));
 364     }
 365
 366     @Test
 367     public void testHandleCommandVolumePercent() {
 368         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_VOLUME);
 369         enigma2Handler.handleCommand(channelUID, new PercentType(30));
 370         verify(enigma2Client).setVolume(30);
 371     }
 372
 373     @Test
 374     public void testHandleCommandVolumeDecimal() {
 375         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_VOLUME);
 376         enigma2Handler.handleCommand(channelUID, new DecimalType(40));
 377         verify(enigma2Client).setVolume(40);
 378     }
 379
 380     @Test
 381     public void testHandleCommandVolumeUnsupported() {
 382         ChannelUID channelUID = new ChannelUID(CHANNEL_UID_PREFIX + Enigma2BindingConstants.CHANNEL_VOLUME);
 383         enigma2Handler.handleCommand(channelUID, PlayPauseType.PAUSE);
 384         verifyNoInteractions(enigma2Client);
 385     }
 386 }