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.Influx1FilterCriteriaQueryCreatorImpl;
  40 import org.openhab.persistence.influxdb.internal.influx2.Influx2FilterCriteriaQueryCreatorImpl;
  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 Influx1FilterCriteriaQueryCreatorImpl instanceV1;
  58     private Influx2FilterCriteriaQueryCreatorImpl instanceV2;
  59
  60     @BeforeEach
  61     public void before() {
  62         instanceV1 = new Influx1FilterCriteriaQueryCreatorImpl(influxDBConfiguration, metadataRegistry);
  63         instanceV2 = new Influx2FilterCriteriaQueryCreatorImpl(influxDBConfiguration, metadataRegistry);
  64     }
  65
  66     @AfterEach
  67     public void after() {
  68         instanceV1 = null;
  69         instanceV2 = null;
  70         influxDBConfiguration = null;
  71         metadataRegistry = null;
  72     }
  73
  74     @Test
  75     public void testSimpleItemQueryWithoutParams() {
  76         FilterCriteria criteria = createBaseCriteria();
  77
  78         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
  79         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\";"));
  80
  81         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
  82         assertThat(queryV2,
  83                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
  84                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
  85                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])"));
  86     }
  87
  88     @Test
  89     public void testSimpleUnboundedItemWithoutParams() {
  90         FilterCriteria criteria = new FilterCriteria();
  91         criteria.setOrdering(null);
  92
  93         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
  94         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\"./.*/;"));
  95
  96         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
  97         assertThat(queryV2, equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)"));
  98     }
  99
 100     @Test
 101     public void testRangeCriteria() {
 102         FilterCriteria criteria = createBaseCriteria();
 103         ZonedDateTime now = ZonedDateTime.now();
 104         ZonedDateTime tomorrow = now.plus(1, ChronoUnit.DAYS);
 105         criteria.setBeginDate(now);
 106         criteria.setEndDate(tomorrow);
 107
 108         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 109         String expectedQueryV1 = String.format(
 110                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE time >= '%s' AND time <= '%s';",
 111                 now.toInstant(), tomorrow.toInstant());
 112         assertThat(queryV1, equalTo(expectedQueryV1));
 113
 114         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 115         String expectedQueryV2 = String.format(
 116                 "from(bucket:\"origin\")\n\t" + "|> range(start:%s, stop:%s)\n\t"
 117                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 118                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])",
 119                 INFLUX2_DATE_FORMATTER.format(now.toInstant()), INFLUX2_DATE_FORMATTER.format(tomorrow.toInstant()));
 120         assertThat(queryV2, equalTo(expectedQueryV2));
 121     }
 122
 123     @Test
 124     public void testValueOperator() {
 125         FilterCriteria criteria = createBaseCriteria();
 126         criteria.setOperator(FilterCriteria.Operator.LTE);
 127         criteria.setState(new PercentType(90));
 128
 129         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 130         assertThat(query,
 131                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" WHERE value <= 90;"));
 132
 133         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 134         assertThat(queryV2,
 135                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 136                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 137                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])\n\t"
 138                         + "|> filter(fn: (r) => (r[\"_field\"] == \"value\" and r[\"_value\"] <= 90))"));
 139     }
 140
 141     @Test
 142     public void testPagination() {
 143         FilterCriteria criteria = createBaseCriteria();
 144         criteria.setPageNumber(2);
 145         criteria.setPageSize(10);
 146
 147         String query = instanceV1.createQuery(criteria, RETENTION_POLICY);
 148         assertThat(query,
 149                 equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\" LIMIT 10 OFFSET 20;"));
 150
 151         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 152         assertThat(queryV2, equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 153                 + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 154                 + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])\n\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,
 168                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 169                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 170                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])\n\t"
 171                         + "|> sort(desc:false, columns:[\"_time\"])"));
 172     }
 173
 174     @Test
 175     public void testPreviousState() {
 176         FilterCriteria criteria = createBaseCriteria();
 177         criteria.setOrdering(FilterCriteria.Ordering.DESCENDING);
 178         criteria.setPageSize(1);
 179         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 180         assertThat(queryV2,
 181                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 182                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 183                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])\n\t" + "|> last()"));
 184     }
 185
 186     private FilterCriteria createBaseCriteria() {
 187         return createBaseCriteria(ITEM_NAME);
 188     }
 189
 190     private FilterCriteria createBaseCriteria(String sampleItem) {
 191         FilterCriteria criteria = new FilterCriteria();
 192         criteria.setItemName(sampleItem);
 193         criteria.setOrdering(null);
 194         return criteria;
 195     }
 196
 197     @Test
 198     public void testMeasurementNameFromMetadata() {
 199         FilterCriteria criteria = createBaseCriteria();
 200         MetadataKey metadataKey = new MetadataKey(InfluxDBPersistenceService.SERVICE_NAME, "sampleItem");
 201
 202         when(metadataRegistry.get(metadataKey))
 203                 .thenReturn(new Metadata(metadataKey, "measurementName", Map.of("key1", "val1", "key2", "val2")));
 204
 205         String queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 206         assertThat(queryV1, equalTo(
 207                 "SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"measurementName\" WHERE item = 'sampleItem';"));
 208
 209         String queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 210         assertThat(queryV2,
 211                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 212                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"measurementName\")\n\t"
 213                         + "|> filter(fn: (r) => r[\"item\"] == \"sampleItem\")\n\t"
 214                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\", \"item\"])"));
 215
 216         when(metadataRegistry.get(metadataKey))
 217                 .thenReturn(new Metadata(metadataKey, "", Map.of("key1", "val1", "key2", "val2")));
 218
 219         queryV1 = instanceV1.createQuery(criteria, RETENTION_POLICY);
 220         assertThat(queryV1, equalTo("SELECT \"value\"::field,\"item\"::tag FROM \"origin\".\"sampleItem\";"));
 221
 222         queryV2 = instanceV2.createQuery(criteria, RETENTION_POLICY);
 223         assertThat(queryV2,
 224                 equalTo("from(bucket:\"origin\")\n\t" + "|> range(start:-100y)\n\t"
 225                         + "|> filter(fn: (r) => r[\"_measurement\"] == \"sampleItem\")\n\t"
 226                         + "|> keep(columns:[\"_measurement\", \"_time\", \"_value\"])"));
 227     }
 228 }