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

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