binding/mdsal-binding-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/dom/adapter/query/QueryBuilderTest.java

   1 /*
   2  * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.mdsal.binding.dom.adapter.query;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12
  13 import com.google.common.base.Stopwatch;
  14 import java.util.List;
  15 import java.util.ServiceLoader;
  16 import java.util.stream.Collectors;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.junit.AfterClass;
  19 import org.junit.Before;
  20 import org.junit.BeforeClass;
  21 import org.junit.Test;
  22 import org.opendaylight.mdsal.binding.api.query.QueryExecutor;
  23 import org.opendaylight.mdsal.binding.api.query.QueryExpression;
  24 import org.opendaylight.mdsal.binding.api.query.QueryFactory;
  25 import org.opendaylight.mdsal.binding.api.query.QueryResult;
  26 import org.opendaylight.mdsal.binding.api.query.QueryResult.Item;
  27 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTree;
  28 import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeFactory;
  29 import org.opendaylight.mdsal.binding.runtime.spi.BindingRuntimeHelpers;
  30 import org.opendaylight.yang.gen.v1.mdsal.query.norev.Foo;
  31 import org.opendaylight.yang.gen.v1.mdsal.query.norev.FooBuilder;
  32 import org.opendaylight.yang.gen.v1.mdsal.query.norev.first.grp.System;
  33 import org.opendaylight.yang.gen.v1.mdsal.query.norev.first.grp.SystemBuilder;
  34 import org.opendaylight.yang.gen.v1.mdsal.query.norev.first.grp.SystemKey;
  35 import org.opendaylight.yang.gen.v1.mdsal.query.norev.second.grp.Alarms;
  36 import org.opendaylight.yang.gen.v1.mdsal.query.norev.second.grp.AlarmsBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.Top;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.TopLevelList;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.mdsal.test.binding.rev140701.two.level.list.top.level.list.NestedList;
  40 import org.opendaylight.yangtools.yang.binding.DataObject;
  41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.binding.util.BindingMap;
  43 import org.opendaylight.yangtools.yang.common.Empty;
  44 import org.opendaylight.yangtools.yang.common.Uint64;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 public class QueryBuilderTest {
  49     private static final Logger LOG = LoggerFactory.getLogger(QueryBuilderTest.class);
  50     private static BindingCodecTree CODEC;
  51
  52     private final QueryFactory factory = new DefaultQueryFactory(CODEC);
  53     private QueryExecutor executor;
  54
  55     @BeforeClass
  56     public static final void beforeClass() {
  57         CODEC = ServiceLoader.load(BindingCodecTreeFactory.class).findFirst().orElseThrow()
  58             .create(BindingRuntimeHelpers.createRuntimeContext());
  59     }
  60
  61     @AfterClass
  62     public static final void afterClass() {
  63         CODEC = null;
  64     }
  65
  66     @Before
  67     public void before() {
  68         executor = SimpleQueryExecutor.builder(CODEC)
  69             .add(new FooBuilder()
  70                 .setSystem(BindingMap.of(
  71                     new SystemBuilder().setName("first").setAlarms(BindingMap.of(
  72                         new AlarmsBuilder()
  73                             .setId(Uint64.ZERO)
  74                             .setCritical(Empty.value())
  75                             .setAffectedUsers(BindingMap.of(
  76                                 // TODO: fill
  77                             )).build(),
  78                         new AlarmsBuilder()
  79                             .setId(Uint64.ONE)
  80                             .setAffectedUsers(BindingMap.of(
  81                                 // TODO: fill
  82                             )).build(),
  83                         new AlarmsBuilder()
  84                             .setId(Uint64.TWO)
  85                             .setCritical(Empty.value())
  86                             .setAffectedUsers(BindingMap.of(
  87                                 // TODO: fill
  88                                 )).build())).build(),
  89                     new SystemBuilder().setName("second").setAlarms(BindingMap.of(
  90                         new AlarmsBuilder()
  91                         .setId(Uint64.ZERO)
  92                         .setCritical(Empty.value())
  93                         .setAffectedUsers(BindingMap.of(
  94                             // TODO: fill
  95                         )).build())).build()
  96                     ))
  97                 .build())
  98             .build();
  99     }
 100
 101     @Test
 102     public void bar() {
 103         final Stopwatch sw = Stopwatch.createStarted();
 104         final QueryExpression<TopLevelList> query = factory.querySubtree(InstanceIdentifier.create(Top.class))
 105                 .extractChild(TopLevelList.class)
 106                 .matching()
 107                     .childObject(NestedList.class)
 108                     .leaf(NestedList::getName).contains("foo")
 109                     .and().leaf(TopLevelList::getName).valueEquals("bar")
 110                 .build();
 111         LOG.info("Query built in {}", sw);
 112
 113         assertEquals(0, execute(query).getItems().size());
 114     }
 115
 116     @Test
 117     public void testFindCriticalAlarms() {
 118         final Stopwatch sw = Stopwatch.createStarted();
 119         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 120             .extractChild(System.class)
 121             .extractChild(Alarms.class)
 122                 .matching()
 123                     .leaf(Alarms::getCritical).nonNull()
 124                 .build();
 125         LOG.info("Query built in {}", sw);
 126
 127         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 128         assertEquals(3, items.size());
 129     }
 130
 131     @Test
 132     public void testFindNonCriticalAlarms() {
 133         final Stopwatch sw = Stopwatch.createStarted();
 134         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 135             .extractChild(System.class)
 136             .extractChild(Alarms.class)
 137                 .matching()
 138                     .leaf(Alarms::getCritical).isNull()
 139                 .build();
 140         LOG.info("Query built in {}", sw);
 141
 142         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 143         assertEquals(1, items.size());
 144     }
 145
 146     @Test
 147     public void testFindZeroAlarms() {
 148         final Stopwatch sw = Stopwatch.createStarted();
 149         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 150             .extractChild(System.class)
 151             .extractChild(Alarms.class)
 152                 .matching()
 153                     .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 154                 .build();
 155         LOG.info("Query built in {}", sw);
 156
 157         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 158         assertEquals(2, items.size());
 159
 160         List<Alarms> verifiedResult = items.stream()
 161             .map(Item::object)
 162             .filter(object -> object.getId().equals(Uint64.ZERO))
 163             .collect(Collectors.toList());
 164         assertNotNull(verifiedResult);
 165         assertEquals(2, verifiedResult.size());
 166     }
 167
 168     @Test
 169     public void testFindSystemFirstAlarmOne() {
 170         final Stopwatch sw = Stopwatch.createStarted();
 171         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 172             .extractChild(System.class, new SystemKey("first"))
 173             .extractChild(Alarms.class)
 174                 .matching()
 175                     .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 176                 .build();
 177         LOG.info("Query built in {}", sw);
 178
 179         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 180         assertEquals(1, items.size());
 181     }
 182
 183     @Test
 184     public void testFindGreaterThanAlarms() {
 185         final Stopwatch sw = Stopwatch.createStarted();
 186         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 187             .extractChild(System.class)
 188             .extractChild(Alarms.class)
 189             .matching()
 190             .leaf(Alarms::getId).greaterThan(Uint64.ONE)
 191             .build();
 192         LOG.info("Query built in {}", sw);
 193
 194         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 195         assertEquals(1, items.size());
 196     }
 197
 198     @Test
 199     public void testFindGreaterThanOrEqualsAlarms() {
 200         final Stopwatch sw = Stopwatch.createStarted();
 201         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 202             .extractChild(System.class)
 203             .extractChild(Alarms.class)
 204             .matching()
 205             .leaf(Alarms::getId).greaterThanOrEqual(Uint64.ONE)
 206             .build();
 207         LOG.info("Query built in {}", sw);
 208
 209         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 210         assertEquals(2, items.size());
 211     }
 212
 213     @Test
 214     public void testFindLessThanAlarms() {
 215         final Stopwatch sw = Stopwatch.createStarted();
 216         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 217             .extractChild(System.class)
 218             .extractChild(Alarms.class)
 219             .matching()
 220             .leaf(Alarms::getId).lessThan(Uint64.ONE)
 221             .build();
 222         LOG.info("Query built in {}", sw);
 223
 224         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 225         assertEquals(2, items.size());
 226     }
 227
 228     @Test
 229     public void testFindLessThanOrEqualsAlarms() {
 230         final Stopwatch sw = Stopwatch.createStarted();
 231         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 232             .extractChild(System.class)
 233             .extractChild(Alarms.class)
 234             .matching()
 235             .leaf(Alarms::getId).lessThanOrEqual(Uint64.ONE)
 236             .build();
 237         LOG.info("Query built in {}", sw);
 238
 239         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 240         assertEquals(3, items.size());
 241     }
 242
 243     @Test
 244     public void testFindSystemFirstWithAlarmOne() {
 245         final Stopwatch sw = Stopwatch.createStarted();
 246         final QueryExpression<System> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 247             .extractChild(System.class, new SystemKey("first"))
 248                 .matching()
 249                     .childObject(Alarms.class)
 250                         .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 251                 .build();
 252         LOG.info("Query built in {}", sw);
 253
 254         final List<? extends Item<@NonNull System>> items = execute(query).getItems();
 255         assertEquals(1, items.size());
 256     }
 257
 258
 259     private <T extends @NonNull DataObject> QueryResult<T> execute(final QueryExpression<T> query) {
 260         final Stopwatch sw = Stopwatch.createStarted();
 261         final QueryResult<T> result = executor.executeQuery(query);
 262         LOG.info("Query executed in {}", sw);
 263         return result;
 264     }
 265 }