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

   1 /**
   2  * Copyright (c) 2010-2021 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.bsblan.internal.helper;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.openhab.binding.bsblan.internal.BsbLanBindingConstants.*;
  17
  18 import org.eclipse.jdt.annotation.NonNullByDefault;
  19 import org.junit.jupiter.api.Test;
  20 import org.openhab.binding.bsblan.internal.api.dto.BsbLanApiParameterDTO;
  21 import org.openhab.core.library.types.DecimalType;
  22 import org.openhab.core.library.types.OnOffType;
  23 import org.openhab.core.library.types.StringType;
  24 import org.openhab.core.types.State;
  25
  26 /**
  27  * The {@link BsbLanParameterConverterTests} class implements tests
  28  * for {@link BsbLanParameterConverter}.
  29  *
  30  * @author Peter Schraffl - Initial contribution
  31  */
  32 @NonNullByDefault
  33 public class BsbLanParameterConverterTests {
  34
  35     @Test
  36     public void testGetStatesForStringParameter() {
  37         BsbLanApiParameterDTO parameter = new BsbLanApiParameterDTO();
  38         parameter.dataType = BsbLanApiParameterDTO.DataType.DT_STRN;
  39         parameter.description = "Test-Description";
  40         parameter.name = "Test-Name";
  41         parameter.unit = "Test-Unit";
  42         parameter.value = "Test-Value";
  43
  44         State state = null;
  45
  46         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DATATYPE, parameter);
  47         assertNotNull(state);
  48         assertEquals(new DecimalType(BsbLanApiParameterDTO.DataType.DT_STRN.getValue()), state.as(DecimalType.class));
  49
  50         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DESCRIPTION, parameter);
  51         assertNotNull(state);
  52         assertEquals(new StringType("Test-Description"), state.as(StringType.class));
  53
  54         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NAME, parameter);
  55         assertNotNull(state);
  56         assertEquals(new StringType("Test-Name"), state.as(StringType.class));
  57
  58         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_UNIT, parameter);
  59         assertNotNull(state);
  60         assertEquals(new StringType("Test-Unit"), state.as(StringType.class));
  61
  62         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NUMBER_VALUE, parameter);
  63         assertNull(state);
  64
  65         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_STRING_VALUE, parameter);
  66         assertNotNull(state);
  67         assertEquals(new StringType("Test-Value"), state.as(StringType.class));
  68
  69         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_SWITCH_VALUE, parameter);
  70         assertNotNull(state);
  71         assertEquals(OnOffType.ON, state);
  72     }
  73
  74     @Test
  75     public void testGetStatesForEnumParameterValue1() {
  76         BsbLanApiParameterDTO parameter = new BsbLanApiParameterDTO();
  77         parameter.dataType = BsbLanApiParameterDTO.DataType.DT_ENUM;
  78         parameter.description = "Test-Description";
  79         parameter.name = "Test-Name";
  80         parameter.unit = "Test-Unit";
  81         parameter.value = "1";
  82
  83         State state = null;
  84
  85         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DATATYPE, parameter);
  86         assertNotNull(state);
  87         assertEquals(new DecimalType(BsbLanApiParameterDTO.DataType.DT_ENUM.getValue()), state.as(DecimalType.class));
  88
  89         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DESCRIPTION, parameter);
  90         assertNotNull(state);
  91         assertEquals(new StringType("Test-Description"), state.as(StringType.class));
  92
  93         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NAME, parameter);
  94         assertNotNull(state);
  95         assertEquals(new StringType("Test-Name"), state.as(StringType.class));
  96
  97         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_UNIT, parameter);
  98         assertNotNull(state);
  99         assertEquals(new StringType("Test-Unit"), state.as(StringType.class));
 100
 101         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NUMBER_VALUE, parameter);
 102         assertNotNull(state);
 103         assertEquals(new DecimalType(1), state.as(DecimalType.class));
 104
 105         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_STRING_VALUE, parameter);
 106         assertNotNull(state);
 107         assertEquals(new StringType("1"), state.as(StringType.class));
 108
 109         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_SWITCH_VALUE, parameter);
 110         assertNotNull(state);
 111         assertEquals(OnOffType.ON, state);
 112     }
 113
 114     @Test
 115     public void testGetStatesForEnumParameterValue0() {
 116         BsbLanApiParameterDTO parameter = new BsbLanApiParameterDTO();
 117         parameter.dataType = BsbLanApiParameterDTO.DataType.DT_ENUM;
 118         parameter.description = "Test-Description";
 119         parameter.name = "Test-Name";
 120         parameter.unit = "Test-Unit";
 121         parameter.value = "0";
 122
 123         State state = null;
 124
 125         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DATATYPE, parameter);
 126         assertNotNull(state);
 127         assertEquals(new DecimalType(BsbLanApiParameterDTO.DataType.DT_ENUM.getValue()), state.as(DecimalType.class));
 128
 129         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DESCRIPTION, parameter);
 130         assertNotNull(state);
 131         assertEquals(new StringType("Test-Description"), state.as(StringType.class));
 132
 133         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NAME, parameter);
 134         assertNotNull(state);
 135         assertEquals(new StringType("Test-Name"), state.as(StringType.class));
 136
 137         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_UNIT, parameter);
 138         assertNotNull(state);
 139         assertEquals(new StringType("Test-Unit"), state.as(StringType.class));
 140
 141         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NUMBER_VALUE, parameter);
 142         assertNotNull(state);
 143         assertEquals(new DecimalType(0), state.as(DecimalType.class));
 144
 145         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_STRING_VALUE, parameter);
 146         assertNotNull(state);
 147         assertEquals(new StringType("0"), state.as(StringType.class));
 148
 149         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_SWITCH_VALUE, parameter);
 150         assertNotNull(state);
 151         assertEquals(OnOffType.OFF, state);
 152     }
 153
 154     @Test
 155     public void testGetStatesForValueParameterValue() {
 156         BsbLanApiParameterDTO parameter = new BsbLanApiParameterDTO();
 157         parameter.dataType = BsbLanApiParameterDTO.DataType.DT_VALS;
 158         parameter.description = "Test-Description";
 159         parameter.name = "Test-Name";
 160         parameter.unit = "Test-Unit";
 161         parameter.value = "22.5";
 162
 163         State state = null;
 164
 165         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DATATYPE, parameter);
 166         assertNotNull(state);
 167         assertEquals(new DecimalType(BsbLanApiParameterDTO.DataType.DT_VALS.getValue()), state.as(DecimalType.class));
 168
 169         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_DESCRIPTION, parameter);
 170         assertNotNull(state);
 171         assertEquals(new StringType("Test-Description"), state.as(StringType.class));
 172
 173         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NAME, parameter);
 174         assertNotNull(state);
 175         assertEquals(new StringType("Test-Name"), state.as(StringType.class));
 176
 177         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_UNIT, parameter);
 178         assertNotNull(state);
 179         assertEquals(new StringType("Test-Unit"), state.as(StringType.class));
 180
 181         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_NUMBER_VALUE, parameter);
 182         assertNotNull(state);
 183         assertEquals(new DecimalType(22.5), state.as(DecimalType.class));
 184
 185         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_STRING_VALUE, parameter);
 186         assertNotNull(state);
 187         assertEquals(new StringType("22.5"), state.as(StringType.class));
 188
 189         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_SWITCH_VALUE, parameter);
 190         assertNotNull(state);
 191         assertEquals(OnOffType.ON, state);
 192     }
 193
 194     @Test
 195     public void testGetStatesEscapesHtml() {
 196         BsbLanApiParameterDTO parameter = new BsbLanApiParameterDTO();
 197         parameter.dataType = BsbLanApiParameterDTO.DataType.DT_VALS;
 198         parameter.description = "Test-Description";
 199         parameter.name = "Test-Name";
 200         parameter.unit = "&deg;C";
 201         parameter.value = "22.5";
 202
 203         State state = null;
 204
 205         state = BsbLanParameterConverter.getState(PARAMETER_CHANNEL_UNIT, parameter);
 206         assertNotNull(state);
 207         assertEquals(new StringType("°C"), state.as(StringType.class));
 208     }
 209
 210     @Test
 211     public void testGetValueForReadonlyChannels() {
 212         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_DATATYPE, OnOffType.ON));
 213         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_DESCRIPTION, OnOffType.ON));
 214         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NAME, OnOffType.ON));
 215         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_UNIT, OnOffType.ON));
 216     }
 217
 218     @Test
 219     public void testGetValueForNumberValueChannel() {
 220         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE, OnOffType.ON), "1");
 221         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE, OnOffType.OFF), "0");
 222         assertEquals(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE, new DecimalType(42)), "42");
 223         assertEquals(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE, new DecimalType(22.5)), "22.5");
 224         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE,
 225                 new StringType("Not a number value")));
 226         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_NUMBER_VALUE, new StringType("")));
 227     }
 228
 229     @Test
 230     public void testGetValueForSwitchValueChannel() {
 231         assertEquals("1", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, OnOffType.ON));
 232         assertEquals("0", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, OnOffType.OFF));
 233         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, new DecimalType(1)));
 234         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, new DecimalType(0)));
 235         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, new DecimalType(42)));
 236         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, new DecimalType(22.5)));
 237         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE,
 238                 new StringType("Not a number value")));
 239         assertNull(BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_SWITCH_VALUE, new StringType("")));
 240     }
 241
 242     @Test
 243     public void testGetValueForStringValueChannel() {
 244         assertEquals("1", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, OnOffType.ON));
 245         assertEquals("0", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, OnOffType.OFF));
 246         assertEquals("42", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, new DecimalType(42)));
 247         assertEquals("22.5", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, new DecimalType(22.5)));
 248         assertEquals("A string value",
 249                 BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, new StringType("A string value")));
 250         assertEquals("", BsbLanParameterConverter.getValue(PARAMETER_CHANNEL_STRING_VALUE, new StringType("")));
 251     }
 252 }