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.Transformation;
  39 import org.openhab.core.transform.TransformationException;
  40 import org.openhab.core.transform.TransformationRegistry;
  41
  42 /**
  43  * @author Gaël L'hopital - Initial contribution
  44  * @author Jan N. Klug - Refactored to use {@link TransformationRegistry}
  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({}) TransformationRegistry transformationRegistry;
  62
  63     private @NonNullByDefault({}) MapTransformationService processor;
  64     private final Map<String, Transformation> 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                 Transformation transformation = new Transformation(uid, uid, "map",
  74                         Map.of(Transformation.FUNCTION, content));
  75                 configurationMap.put(uid, transformation);
  76             } catch (IOException ignored) {
  77             }
  78         });
  79
  80         Mockito.when(transformationRegistry.get(anyString(), eq(null)))
  81                 .thenAnswer((Answer<Transformation>) invocation -> {
  82                     Object[] args = invocation.getArguments();
  83                     return configurationMap.get(args[0]);
  84                 });
  85
  86         processor = new MapTransformationService(transformationRegistry);
  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 setTransformationIsRemoved() throws TransformationException {
 113         assertEquals("zu", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 114
 115         Transformation transformation = configurationMap.remove(NON_DEFAULTED_TRANSFORMATION_DE);
 116         processor.removed(Objects.requireNonNull(transformation));
 117
 118         assertThrows(TransformationException.class,
 119                 () -> processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 120     }
 121
 122     @Test
 123     public void setTransformationIsNotUpdatedIfOldElementMissing() throws TransformationException {
 124         // update configuration
 125         Transformation transformationDE = Objects.requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_DE));
 126         Transformation transformationFR = Objects.requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_FR));
 127         Transformation transformationModified = new Transformation(transformationDE.getUID(),
 128                 transformationDE.getLabel(), transformationDE.getType(), transformationDE.getConfiguration());
 129         processor.updated(transformationDE, transformationModified);
 130
 131         // assert there is no modified cached version
 132         assertEquals("zu", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 133     }
 134
 135     @Test
 136     public void setTransformationIsUpdatedIfOldElementPresent() throws TransformationException {
 137         // ensure old transformation is cached
 138         processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED);
 139
 140         // update configuration
 141         Transformation transformationDE = Objects.requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_DE));
 142         Transformation transformationFR = Objects.requireNonNull(configurationMap.get(NON_DEFAULTED_TRANSFORMATION_FR));
 143         Transformation transformationModified = new Transformation(transformationDE.getUID(),
 144                 transformationDE.getLabel(), transformationDE.getType(), transformationFR.getConfiguration());
 145         processor.updated(transformationDE, transformationModified);
 146
 147         // ensure modified configuration is applied
 148         assertEquals("fermé", processor.transform(NON_DEFAULTED_TRANSFORMATION_DE, SOURCE_CLOSED));
 149     }
 150 }