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.internal.actions;
  14
  15 import static org.hamcrest.MatcherAssert.assertThat;
  16 import static org.hamcrest.Matchers.is;
  17 import static org.junit.jupiter.api.Assertions.assertThrows;
  18 import static org.mockito.Mockito.*;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.junit.jupiter.api.BeforeEach;
  23 import org.junit.jupiter.api.Test;
  24 import org.openhab.binding.enigma2.internal.Enigma2BindingConstants;
  25 import org.openhab.binding.enigma2.internal.handler.Enigma2Handler;
  26
  27 /**
  28  * The {@link Enigma2ActionsTest} class is responsible for testing {@link Enigma2Actions}.
  29  *
  30  * @author Guido Dolfen - Initial contribution
  31  */
  32 @SuppressWarnings("null")
  33 @NonNullByDefault
  34 public class Enigma2ActionsTest {
  35     @Nullable
  36     private Enigma2Actions enigma2Actions;
  37     @Nullable
  38     private Enigma2Handler enigma2Handler;
  39     public static final String SOME_TEXT = "some Text";
  40
  41     @BeforeEach
  42     public void setUp() {
  43         enigma2Handler = mock(Enigma2Handler.class);
  44         enigma2Actions = new Enigma2Actions();
  45         enigma2Actions.setThingHandler(enigma2Handler);
  46     }
  47
  48     @Test
  49     public void testGetThingHandler() {
  50         assertThat(enigma2Actions.getThingHandler(), is(enigma2Handler));
  51     }
  52
  53     @Test
  54     public void testSendRcCommand() {
  55         enigma2Actions.sendRcCommand("KEY_1");
  56         verify(enigma2Handler).sendRcCommand("KEY_1");
  57     }
  58
  59     @Test
  60     public void testSendInfo() {
  61         enigma2Actions.sendInfo(SOME_TEXT);
  62         verify(enigma2Handler).sendInfo(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  63     }
  64
  65     @Test
  66     public void testSendInfoTimeout() {
  67         enigma2Actions.sendInfo(SOME_TEXT, 10);
  68         verify(enigma2Handler).sendInfo(10, SOME_TEXT);
  69     }
  70
  71     @Test
  72     public void testSendError() {
  73         enigma2Actions.sendError(SOME_TEXT);
  74         verify(enigma2Handler).sendError(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  75     }
  76
  77     @Test
  78     public void testSendErrorTimeout() {
  79         enigma2Actions.sendError(SOME_TEXT, 10);
  80         verify(enigma2Handler).sendError(10, SOME_TEXT);
  81     }
  82
  83     @Test
  84     public void testSendWarning() {
  85         enigma2Actions.sendWarning(SOME_TEXT);
  86         verify(enigma2Handler).sendWarning(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  87     }
  88
  89     @Test
  90     public void testSendWarningTimeout() {
  91         enigma2Actions.sendWarning(SOME_TEXT, 10);
  92         verify(enigma2Handler).sendWarning(10, SOME_TEXT);
  93     }
  94
  95     @Test
  96     public void testSendQuestion() {
  97         enigma2Actions.sendQuestion(SOME_TEXT);
  98         verify(enigma2Handler).sendQuestion(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
  99     }
 100
 101     @Test
 102     public void testSendQuestionTimeout() {
 103         enigma2Actions.sendQuestion(SOME_TEXT, 10);
 104         verify(enigma2Handler).sendQuestion(10, SOME_TEXT);
 105     }
 106
 107     @Test
 108     public void testSendRcCommandStatic() {
 109         Enigma2Actions.sendRcCommand(enigma2Actions, "KEY_1");
 110         verify(enigma2Handler).sendRcCommand("KEY_1");
 111     }
 112
 113     @Test
 114     public void testSendRcCommandStaticWithException() {
 115         assertThrows(IllegalArgumentException.class, () -> Enigma2Actions.sendRcCommand(null, "KEY_1"));
 116     }
 117
 118     @Test
 119     public void testSendInfoStatic() {
 120         Enigma2Actions.sendInfo(enigma2Actions, SOME_TEXT);
 121         verify(enigma2Handler).sendInfo(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 122     }
 123
 124     @Test
 125     public void testSendInfoTimeoutStatic() {
 126         Enigma2Actions.sendInfo(enigma2Actions, SOME_TEXT, 10);
 127         verify(enigma2Handler).sendInfo(10, SOME_TEXT);
 128     }
 129
 130     @Test
 131     public void testSendInfoStaticWithException() {
 132         assertThrows(IllegalArgumentException.class, () -> Enigma2Actions.sendInfo(null, SOME_TEXT));
 133     }
 134
 135     @Test
 136     public void testSendErrorStatic() {
 137         Enigma2Actions.sendError(enigma2Actions, SOME_TEXT);
 138         verify(enigma2Handler).sendError(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 139     }
 140
 141     @Test
 142     public void testSendErrorTimeoutStatic() {
 143         Enigma2Actions.sendError(enigma2Actions, SOME_TEXT, 10);
 144         verify(enigma2Handler).sendError(10, SOME_TEXT);
 145     }
 146
 147     @Test
 148     public void testSendErrorStaticWithException() {
 149         assertThrows(IllegalArgumentException.class, () -> Enigma2Actions.sendError(null, SOME_TEXT));
 150     }
 151
 152     @Test
 153     public void testSendWarningStatic() {
 154         Enigma2Actions.sendWarning(enigma2Actions, SOME_TEXT);
 155         verify(enigma2Handler).sendWarning(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 156     }
 157
 158     @Test
 159     public void testSendWarningTimeoutStatic() {
 160         Enigma2Actions.sendWarning(enigma2Actions, SOME_TEXT, 10);
 161         verify(enigma2Handler).sendWarning(10, SOME_TEXT);
 162     }
 163
 164     @Test
 165     public void testSendWarningStaticWithException() {
 166         assertThrows(IllegalArgumentException.class, () -> Enigma2Actions.sendWarning(null, SOME_TEXT));
 167     }
 168
 169     @Test
 170     public void testSendQuestionStatic() {
 171         Enigma2Actions.sendQuestion(enigma2Actions, SOME_TEXT);
 172         verify(enigma2Handler).sendQuestion(Enigma2BindingConstants.MESSAGE_TIMEOUT, SOME_TEXT);
 173     }
 174
 175     @Test
 176     public void testSendQuestionTimeoutStatic() {
 177         Enigma2Actions.sendQuestion(enigma2Actions, SOME_TEXT, 10);
 178         verify(enigma2Handler).sendQuestion(10, SOME_TEXT);
 179     }
 180
 181     @Test
 182     public void testSendQuestionStaticWithException() {
 183         assertThrows(IllegalArgumentException.class, () -> Enigma2Actions.sendQuestion(null, SOME_TEXT));
 184     }
 185 }