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,
  81                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" ORDER BY time DESC;"));
  82
  83         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
  84         assertThat(queryV2, equalTo("""
  85                 from(bucket:"origin")
  86                 \t|> range(start:-100y, stop:100y)
  87                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
  88                 \t|> keep(columns:["_measurement", "_time", "_value"])
  89                 \t|> sort(desc:true, columns:["_time"])"""));
  90     }
  91
  92     @Test
  93     public void testRangeCriteria() {
  94         FilterCriteria criteria = createBaseCriteria();
  95         ZonedDateTime now = ZonedDateTime.now();
  96         ZonedDateTime tomorrow = now.plus(1, ChronoUnit.DAYS);
  97         criteria.setBeginDate(now);
  98         criteria.setEndDate(tomorrow);
  99
 100         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 101         String expectedQueryV1 = String.format(
 102                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE time >= '%s' AND time <= '%s' ORDER BY time DESC;",
 103                 now.toInstant(), tomorrow.toInstant());
 104         assertThat(queryV1, equalTo(expectedQueryV1));
 105
 106         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 107         String expectedQueryV2 = String.format("""
 108                 from(bucket:"origin")
 109                 \t|> range(start:%s, stop:%s)
 110                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 111                 \t|> keep(columns:["_measurement", "_time", "_value"])
 112                 \t|> sort(desc:true, columns:["_time"])""", INFLUX2_DATE_FORMATTER.format(now.toInstant()),
 113                 INFLUX2_DATE_FORMATTER.format(tomorrow.toInstant()));
 114         assertThat(queryV2, equalTo(expectedQueryV2));
 115     }
 116
 117     @Test
 118     public void testValueOperator() {
 119         FilterCriteria criteria = createBaseCriteria();
 120         criteria.setOperator(FilterCriteria.Operator.LTE);
 121         criteria.setState(new PercentType(90));
 122
 123         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 124         assertThat(query, equalTo(
 125                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE value <= 90 ORDER BY time DESC;"));
 126
 127         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 128         assertThat(queryV2, equalTo("""
 129                 from(bucket:"origin")
 130                 \t|> range(start:-100y, stop:100y)
 131                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 132                 \t|> keep(columns:["_measurement", "_time", "_value"])
 133                 \t|> filter(fn: (r) => (r["_field"] == "value" and r["_value"] <= 90))
 134                 \t|> sort(desc:true, columns:["_time"])"""));
 135     }
 136
 137     @Test
 138     public void testPagination() {
 139         FilterCriteria criteria = createBaseCriteria();
 140         criteria.setPageNumber(2);
 141         criteria.setPageSize(10);
 142
 143         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 144         assertThat(query, equalTo(
 145                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" ORDER BY time DESC LIMIT 10 OFFSET 20;"));
 146
 147         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 148         assertThat(queryV2, equalTo("""
 149                 from(bucket:"origin")
 150                 \t|> range(start:-100y, stop:100y)
 151                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 152                 \t|> keep(columns:["_measurement", "_time", "_value"])
 153                 \t|> sort(desc:true, columns:["_time"])
 154                 \t|> limit(n:10, offset:20)"""));
 155     }
 156
 157     @Test
 158     public void testOrdering() {
 159         FilterCriteria criteria = createBaseCriteria();
 160         criteria.setOrdering(FilterCriteria.Ordering.ASCENDING);
 161
 162         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 163         assertThat(query,
 164                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" ORDER BY time ASC;"));
 165
 166         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 167         assertThat(queryV2, equalTo("""
 168                 from(bucket:"origin")
 169                 \t|> range(start:-100y, stop:100y)
 170                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 171                 \t|> keep(columns:["_measurement", "_time", "_value"])
 172                 \t|> sort(desc:false, columns:["_time"])"""));
 173     }
 174
 175     @Test
 176     public void testPreviousState() {
 177         FilterCriteria criteria = createBaseCriteria();
 178         criteria.setOrdering(FilterCriteria.Ordering.DESCENDING);
 179         criteria.setPageSize(1);
 180         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 181         assertThat(queryV2, equalTo("""
 182                 from(bucket:"origin")
 183                 \t|> range(start:-100y, stop:100y)
 184                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 185                 \t|> keep(columns:["_measurement", "_time", "_value"])
 186                 \t|> last()"""));
 187     }
 188
 189     private FilterCriteria createBaseCriteria() {
 190         FilterCriteria criteria = new FilterCriteria();
 191         criteria.setItemName(ITEM_NAME);
 192         return criteria;
 193     }
 194
 195     @Test
 196     public void testMeasurementNameFromMetadata() {
 197         FilterCriteria criteria = createBaseCriteria();
 198         MetadataKey metadataKey = new MetadataKey(InfluxDBPersistenceService.SERVICE_NAME, "sampleItem");
 199
 200         when(metadataRegistry.get(metadataKey))
 201                 .thenReturn(new Metadata(metadataKey, "measurementName", Map.of("key1", "val1", "key2", "val2")));
 202
 203         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 204         assertThat(queryV1, equalTo(
 205                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"measurementName\" WHERE item = 'sampleItem' ORDER BY time DESC;"));
 206
 207         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 208         assertThat(queryV2, equalTo("""
 209                 from(bucket:"origin")
 210                 \t|> range(start:-100y, stop:100y)
 211                 \t|> filter(fn: (r) => r["_measurement"] == "measurementName")
 212                 \t|> filter(fn: (r) => r["item"] == "sampleItem")
 213                 \t|> keep(columns:["_measurement", "_time", "_value", "item"])
 214                 \t|> sort(desc:true, columns:["_time"])"""));
 215         when(metadataRegistry.get(metadataKey))
 216                 .thenReturn(new Metadata(metadataKey, "", Map.of("key1", "val1", "key2", "val2")));
 217
 218         queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 219         assertThat(queryV1,
 220                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" ORDER BY time DESC;"));
 221
 222         queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 223         assertThat(queryV2, equalTo("""
 224                 from(bucket:"origin")
 225                 \t|> range(start:-100y, stop:100y)
 226                 \t|> filter(fn: (r) => r["_measurement"] == "sampleItem")
 227                 \t|> keep(columns:["_measurement", "_time", "_value"])
 228                 \t|> sort(desc:true, columns:["_time"])"""));
 229     }
 230 }