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