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