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.persistence.influxdb.internal;
  14
  15 import static org.hamcrest.CoreMatchers.equalTo;
  16 import static org.hamcrest.MatcherAssert.assertThat;
  17 import static org.mockito.Mockito.when;
  18
  19 import java.time.ZoneId;
  20 import java.time.ZonedDateTime;
  21 import java.time.format.DateTimeFormatter;
  22 import java.time.temporal.ChronoUnit;
  23 import java.util.Map;
  24
  25 import org.eclipse.jdt.annotation.DefaultLocation;
  26 import org.eclipse.jdt.annotation.NonNullByDefault;
  27 import org.junit.jupiter.api.AfterEach;
  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.junit.jupiter.MockitoExtension;
  33 import org.openhab.core.items.Metadata;
  34 import org.openhab.core.items.MetadataKey;
  35 import org.openhab.core.items.MetadataRegistry;
  36 import org.openhab.core.library.types.PercentType;
  37 import org.openhab.core.persistence.FilterCriteria;
  38 import org.openhab.persistence.influxdb.InfluxDBPersistenceService;
  39 import org.openhab.persistence.influxdb.internal.influx1.InfluxDB1FilterCriteriaQueryCreatorImpl;
  40 import org.openhab.persistence.influxdb.internal.influx2.InfluxDB2FilterCriteriaQueryCreatorImpl;
  41
  42 /**
  43  * @author Joan Pujol Espinar - Initial contribution
  44  */
  45 @ExtendWith(MockitoExtension.class)
  46 @NonNullByDefault({ DefaultLocation.RETURN_TYPE, DefaultLocation.PARAMETER })
  47 public class InfluxFilterCriteriaQueryCreatorImplTest {
  48     private static final String RETENTION_POLICY = "origin";
  49     public static final String ITEM_NAME = "sampleItem";
  50
  51     private static final DateTimeFormatter INFLUX2_DATE_FORMATTER = DateTimeFormatter
  52             .ofPattern("yyyy-MM-dd'T'HH:mm:ss.nnnnnnnnn'Z'").withZone(ZoneId.of("UTC"));
  53
  54     private @Mock InfluxDBConfiguration influxDBConfiguration;
  55     private @Mock MetadataRegistry metadataRegistry;
  56
  57     private InfluxDB1FilterCriteriaQueryCreatorImpl instanceV1;
  58     private InfluxDB2FilterCriteriaQueryCreatorImpl instanceV2;
  59
  60     @BeforeEach
  61     public void before() {
  62         InfluxDBMetadataService influxDBMetadataService = new InfluxDBMetadataService(metadataRegistry);
  63         instanceV1 = new InfluxDB1FilterCriteriaQueryCreatorImpl(influxDBConfiguration, influxDBMetadataService);
  64         instanceV2 = new InfluxDB2FilterCriteriaQueryCreatorImpl(influxDBConfiguration, influxDBMetadataService);
  65     }
  66
  67     @AfterEach
  68     public void after() {
  69         instanceV1 = null;
  70         instanceV2 = null;
  71         influxDBConfiguration = null;
  72         metadataRegistry = null;
  73     }
  74
  75     @Test
  76     public void testSimpleItemQueryWithoutParams() {
  77         FilterCriteria criteria = createBaseCriteria();
  78
  79         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
  80         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\";"));
  81
  82         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
  83         assertThat(queryV2, equalTo("""
  84                 from(bucket:"origin")
  85                 \t|> range(start:-100y)
  86                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
  87                 \t|> keep(columns:["_measurement", "_time", "_value"])"""));
  88     }
  89
  90     @Test
  91     public void testSimpleUnboundedItemWithoutParams() {
  92         FilterCriteria criteria = new FilterCriteria();
  93         criteria.setOrdering(null);
  94
  95         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
  96         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\"./.*/;"));
  97
  98         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
  99         assertThat(queryV2, equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)"));
 100     }
 101
 102     @Test
 103     public void testRangeCriteria() {
 104         FilterCriteria criteria = createBaseCriteria();
 105         ZonedDateTime now = ZonedDateTime.now();
 106         ZonedDateTime tomorrow = now.plus(1, ChronoUnit.DAYS);
 107         criteria.setBeginDate(now);
 108         criteria.setEndDate(tomorrow);
 109
 110         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 111         String expectedQueryV1 = String.format(
 112                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE time >= '%s' AND time <= '%s';",
 113                 now.toInstant(), tomorrow.toInstant());
 114         assertThat(queryV1, equalTo(expectedQueryV1));
 115
 116         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 117         String expectedQueryV2 = String.format("""
 118                 from(bucket:"origin")
 119                 \t|> range(start:%s, stop:%s)
 120                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 121                 \t|> keep(columns:["_measurement", "_time", "_value"])""",
 122                 INFLUX2_DATE_FORMATTER.format(now.toInstant()), INFLUX2_DATE_FORMATTER.format(tomorrow.toInstant()));
 123         assertThat(queryV2, equalTo(expectedQueryV2));
 124     }
 125
 126     @Test
 127     public void testValueOperator() {
 128         FilterCriteria criteria = createBaseCriteria();
 129         criteria.setOperator(FilterCriteria.Operator.LTE);
 130         criteria.setState(new PercentType(90));
 131
 132         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 133         assertThat(query,
 134                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE value <= 90;"));
 135
 136         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 137         assertThat(queryV2, equalTo("""
 138                 from(bucket:"origin")
 139                 \t|> range(start:-100y)
 140                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 141                 \t|> keep(columns:["_measurement", "_time", "_value"])
 142                 \t|> filter(fn: (r) => (r["_field"] == "value" and r["_value"] <= 90))"""));
 143     }
 144
 145     @Test
 146     public void testPagination() {
 147         FilterCriteria criteria = createBaseCriteria();
 148         criteria.setPageNumber(2);
 149         criteria.setPageSize(10);
 150
 151         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 152         assertThat(query,
 153                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" LIMIT 10 OFFSET 20;"));
 154
 155         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 156         assertThat(queryV2, equalTo("""
 157                 from(bucket:"origin")
 158                 \t|> range(start:-100y)
 159                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 160                 \t|> keep(columns:["_measurement", "_time", "_value"])
 161                 \t|> limit(n:10, offset:20)"""));
 162     }
 163
 164     @Test
 165     public void testOrdering() {
 166         FilterCriteria criteria = createBaseCriteria();
 167         criteria.setOrdering(FilterCriteria.Ordering.ASCENDING);
 168
 169         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 170         assertThat(query,
 171                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" ORDER BY time ASC;"));
 172
 173         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 174         assertThat(queryV2, equalTo("""
 175                 from(bucket:"origin")
 176                 \t|> range(start:-100y)
 177                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 178                 \t|> keep(columns:["_measurement", "_time", "_value"])
 179                 \t|> sort(desc:false, columns:["_time"])"""));
 180     }
 181
 182     @Test
 183     public void testPreviousState() {
 184         FilterCriteria criteria = createBaseCriteria();
 185         criteria.setOrdering(FilterCriteria.Ordering.DESCENDING);
 186         criteria.setPageSize(1);
 187         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 188         assertThat(queryV2, equalTo("""
 189                 from(bucket:"origin")
 190                 \t|> range(start:-100y)
 191                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 192                 \t|> keep(columns:["_measurement", "_time", "_value"])
 193                 \t|> last()"""));
 194     }
 195
 196     private FilterCriteria createBaseCriteria() {
 197         FilterCriteria criteria = new FilterCriteria();
 198         criteria.setItemName(ITEM_NAME);
 199         criteria.setOrdering(null);
 200         return criteria;
 201     }
 202
 203     @Test
 204     public void testMeasurementNameFromMetadata() {
 205         FilterCriteria criteria = createBaseCriteria();
 206         MetadataKey metadataKey = new MetadataKey(InfluxDBPersistenceService.SERVICE_NAME, "sampleItem");
 207
 208         when(metadataRegistry.get(metadataKey))
 209                 .thenReturn(new Metadata(metadataKey, "measurementName", Map.of("key1", "val1", "key2", "val2")));
 210
 211         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 212         assertThat(queryV1, equalTo(
 213                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"measurementName\" WHERE item = 'sampleItem';"));
 214
 215         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 216         assertThat(queryV2, equalTo("""
 217                 from(bucket:"origin")
 218                 \t|> range(start:-100y)
 219                 \t|> filter(fn: (r) => r["_measurement"] == "measurementName")
 220                 \t|> filter(fn: (r) => r["item"] == "sampleItem")
 221                 \t|> keep(columns:["_measurement", "_time", "_value", "item"])"""));
 222         when(metadataRegistry.get(metadataKey))
 223                 .thenReturn(new Metadata(metadataKey, "", Map.of("key1", "val1", "key2", "val2")));
 224
 225         queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 226         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\";"));
 227
 228         queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 229         assertThat(queryV2, equalTo("""
 230                 from(bucket:"origin")
 231                 \t|> range(start:-100y)
 232                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 233                 \t|> keep(columns:["_measurement", "_time", "_value"])"""));
 234     }
 235 }