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

   1 /**
   2  * Copyright (c) 2010-2022 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.transform.map.internal;
  14
  15 import static org.junit.jupiter.api.Assertions.*;
  16 import static org.mockito.ArgumentMatchers.anyString;
  17 import static org.mockito.ArgumentMatchers.eq;
  18
  19 import java.io.IOException;
  20 import java.nio.file.Files;
  21 import java.nio.file.Path;
  22 import java.util.HashMap;
  23 import java.util.Map;
  24 import java.util.Objects;
  25
  26 import org.eclipse.jdt.annotation.NonNullByDefault;
  27 import org.junit.jupiter.api.BeforeEach;
  28 import org.junit.jupiter.api.Test;
  29 import org.junit.jupiter.api.extension.ExtendWith;
  30 import org.mockito.Mock;
  31 import org.mockito.Mockito;
  32 import org.mockito.junit.jupiter.MockitoExtension;
  33 import org.mockito.junit.jupiter.MockitoSettings;
  34 import org.mockito.quality.Strictness;
  35 import org.mockito.stubbing.Answer;
  36 import org.openhab.core.test.java.JavaTest;
  37 import org.openhab.core.transform.TransformationConfiguration;
  38 import org.openhab.core.transform.TransformationConfigurationRegistry;
  39 import org.openhab.core.transform.TransformationException;
  40
  41 /**
  42  * @author Gaël L'hopital - Initial contribution
  43  * @author Jan N. Klug - Refactored to use {@link TransformationConfigurationRegistry}
  44  */
  45 @ExtendWith(MockitoExtension.class)
  46 @MockitoSettings(strictness = Strictness.LENIENT)
  47 @NonNullByDefault
  48 public class MapTransformationServiceTest extends JavaTest {
  49     private static final String SOURCE_CLOSED = "CLOSED";
  50     private static final String SOURCE_UNKNOWN = "UNKNOWN";
  51
  52     private static final String NON_DEFAULTED_TRANSFORMATION_DE = "map/doorstatus_de.map";
  53     private static final String NON_DEFAULTED_TRANSFORMATION_FR = "map/doorstatus_fr.map";
  54     private static final String DEFAULTED_TRANSFORMATION = "map/doorstatus_defaulted.map";
  55     private static final String UNKNOWN_TRANSFORMATION = "map/de.map";
  56
  57     private static final String SRC_FOLDER = "conf/transform";
  58
  59     @Mock
  60     private @NonNullByDefault({}) TransformationConfigurationRegistry transformationConfigurationRegistry;
  61
  62     private @NonNullByDefault({}) MapTransformationService processor;
  63     private final Map<String, TransformationConfiguration> configurationMap = new HashMap<>();
  64
  65     @BeforeEach
  66     public void setUp() throws IOException {
  67         configurationMap.clear();
  68         Files.walk(Path.of(SRC_FOLDER)).filter(Files::isRegularFile).forEach(file -> {
  69             try {
  70                 String content = new String(Files.readAllBytes(file));
  71                 String uid = Path.of(SRC_FOLDER).relativize(file).toString();
  72                 TransformationConfiguration transformationConfiguration = new TransformationConfiguration(uid, uid,
  73                         "map", null, content);
  74                 configurationMap.put(uid, transformationConfiguration);
  75             } catch (IOException ignored) {
  76             }
  77         });
  78
  79         Mockito.when(transformationConfigurationRegistry.get(anyString(), eq(null)))
  80                 .thenAnswer((Answer<TransformationConfiguration>) invocation -> {
  81                     Object[] args = invocation.getArguments();
  82                     return configurationMap.get((String) args[0]);
  83                 });
  84
  85         processor = new MapTransformationService(transformationConfigurationRegistry);
  86     }
  87
  88     @Test
  89     public void testTransformSucceeds() throws TransformationException {
  90         String transformedResponse = processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED);
  91         assertEquals("zu", transformedResponse);
  92     }
  93
  94     @Test
  95     public void testTransformFailsWithoutDefault() {
  96         assertThrows(TransformationException.class,
  97                 () -> processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_UNKNOWN));
  98     }
  99
 100     @Test
 101     public void testTransformSucceedsWithDefault() throws TransformationException {
 102         assertEquals("Default Value", processor.transform(DEFAULTED_TRANSFORMATION, SOURCE_UNKNOWN));
 103     }
 104
 105     @Test
 106     public void testTransformFailsOnUnknownTransformation() {
 107         assertThrows(TransformationException.class, () -> processor.transform(UNKNOWN_TRANSFORMATION, SOURCE_CLOSED));
 108     }
 109
 110     @Test
 111     public void setTransformationConfigurationIsRemoved() throws TransformationException {
 112         assertEquals("zu", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 113
 114         TransformationConfiguration transformationConfiguration = configurationMap
 115                 .remove(NON_DEFAULTED_TRANSFORMATION_DE);
 116         processor.removed(Objects.requireNonNull(transformationConfiguration));
 117
 118         assertThrows(TransformationException.class,
 119                 () -> processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 120     }
 121
 122     @Test
 123     public void setTransformationConfigurationIsNotUpdatedIfOldElementMissing() throws TransformationException {
 124         // update configuration
 125         TransformationConfiguration transformationConfigurationDE = Objects
 126                 .requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_DE));
 127         TransformationConfiguration transformationConfigurationFR = Objects
 128                 .requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_FR));
 129         TransformationConfiguration transformationConfigurationModified = new TransformationConfiguration(
 130                 transformationConfigurationDE.getUID(), transformationConfigurationDE.getLabel(),
 131                 transformationConfigurationDE.getType(), transformationConfigurationDE.getLanguage(),
 132                 transformationConfigurationFR.getContent());
 133         processor.updated(transformationConfigurationDE, transformationConfigurationModified);
 134
 135         // assert there is no modified cached version
 136         assertEquals("zu", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 137     }
 138
 139     @Test
 140     public void setTransformationConfigurationIsUpdatedIfOldElementPresent() throws TransformationException {
 141         // ensure old transformation is cached
 142         processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED);
 143
 144         // update configuration
 145         TransformationConfiguration transformationConfigurationDE = Objects
 146                 .requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_DE));
 147         TransformationConfiguration transformationConfigurationFR = Objects
 148                 .requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_FR));
 149         TransformationConfiguration transformationConfigurationModified = new TransformationConfiguration(
 150                 transformationConfigurationDE.getUID(), transformationConfigurationDE.getLabel(),
 151                 transformationConfigurationDE.getType(), transformationConfigurationDE.getLanguage(),
 152                 transformationConfigurationFR.getContent());
 153         processor.updated(transformationConfigurationDE, transformationConfigurationModified);
 154
 155         // ensure modified configuration is applied
 156         assertEquals("fermé", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 157     }
 158 }