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