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
  12 import com.google.common.base.Stopwatch;
  13 import java.util.List;
  14 import org.eclipse.jdt.annotation.NonNull;
  15 import org.junit.AfterClass;
  16 import org.junit.Before;
  17 import org.junit.BeforeClass;
  18 import org.junit.Test;
  19 import org.opendaylight.mdsal.binding.api.query.QueryExecutor;
  20 import org.opendaylight.mdsal.binding.api.query.QueryExpression;
  21 import org.opendaylight.mdsal.binding.api.query.QueryFactory;
  22 import org.opendaylight.mdsal.binding.api.query.QueryResult;
  23 import org.opendaylight.mdsal.binding.api.query.QueryResult.Item;
  24 import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
  25 import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
  26 import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
  27 import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
  28 import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
  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.common.Empty;
  42 import org.opendaylight.yangtools.yang.common.Uint64;
  43 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  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 BindingNormalizedNodeCodecRegistry CODEC;
  50
  51     private final QueryFactory factory = new DefaultQueryFactory(CODEC);
  52     private QueryExecutor executor;
  53
  54     @BeforeClass
  55     public static void beforeClass() {
  56         ModuleInfoBackedContext ctx = ModuleInfoBackedContext.create();
  57         ctx.addModuleInfos(BindingReflections.loadModuleInfos());
  58         final SchemaContext schemaContext = ctx.tryToCreateSchemaContext().get();
  59
  60         CODEC = new BindingNormalizedNodeCodecRegistry(
  61             BindingRuntimeContext.create(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy(), schemaContext));
  62     }
  63
  64     @AfterClass
  65     public static final void afterClass() {
  66         CODEC = null;
  67     }
  68
  69     @Before
  70     public void before() {
  71         executor = SimpleQueryExecutor.builder(CODEC.getCodecContext())
  72             .add(new FooBuilder()
  73                 .setSystem(List.of(
  74                     new SystemBuilder().setName("first").setAlarms(List.of(
  75                         new AlarmsBuilder()
  76                             .setId(Uint64.ZERO)
  77                             .setCritical(Empty.getInstance())
  78                             .setAffectedUsers(List.of(
  79                                 // TODO: fill
  80                             )).build(),
  81                         new AlarmsBuilder()
  82                             .setId(Uint64.ONE)
  83                             .setAffectedUsers(List.of(
  84                                 // TODO: fill
  85                             )).build(),
  86                         new AlarmsBuilder()
  87                             .setId(Uint64.TWO)
  88                             .setCritical(Empty.getInstance())
  89                             .setAffectedUsers(List.of(
  90                                 // TODO: fill
  91                                 )).build())).build(),
  92                     new SystemBuilder().setName("second").setAlarms(List.of(
  93                         new AlarmsBuilder()
  94                         .setId(Uint64.ZERO)
  95                         .setCritical(Empty.getInstance())
  96                         .setAffectedUsers(List.of(
  97                             // TODO: fill
  98                         )).build())).build()
  99                     ))
 100                 .build())
 101             .build();
 102     }
 103
 104     @Test
 105     public void bar() {
 106         final Stopwatch sw = Stopwatch.createStarted();
 107         final QueryExpression<TopLevelList> query = factory.querySubtree(InstanceIdentifier.create(Top.class))
 108                 .extractChild(TopLevelList.class)
 109                 .matching()
 110                     .childObject(NestedList.class)
 111                     .leaf(NestedList::getName).contains("foo")
 112                     .and().leaf(TopLevelList::getName).valueEquals("bar")
 113                 .build();
 114         LOG.info("Query built in {}", sw);
 115
 116         assertEquals(0, execute(query).getItems().size());
 117     }
 118
 119     @Test
 120     public void testFindCriticalAlarms() {
 121         final Stopwatch sw = Stopwatch.createStarted();
 122         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 123             .extractChild(System.class)
 124             .extractChild(Alarms.class)
 125                 .matching()
 126                     .leaf(Alarms::getCritical).nonNull()
 127                 .build();
 128         LOG.info("Query built in {}", sw);
 129
 130         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 131         assertEquals(3, items.size());
 132     }
 133
 134     @Test
 135     public void testFindNonCriticalAlarms() {
 136         final Stopwatch sw = Stopwatch.createStarted();
 137         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 138             .extractChild(System.class)
 139             .extractChild(Alarms.class)
 140                 .matching()
 141                     .leaf(Alarms::getCritical).isNull()
 142                 .build();
 143         LOG.info("Query built in {}", sw);
 144
 145         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 146         assertEquals(1, items.size());
 147     }
 148
 149     @Test
 150     public void testFindZeroAlarms() {
 151         final Stopwatch sw = Stopwatch.createStarted();
 152         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 153             .extractChild(System.class)
 154             .extractChild(Alarms.class)
 155                 .matching()
 156                     .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 157                 .build();
 158         LOG.info("Query built in {}", sw);
 159
 160         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 161         assertEquals(2, items.size());
 162     }
 163
 164     @Test
 165     public void testFindSystemFirstAlarmOne() {
 166         final Stopwatch sw = Stopwatch.createStarted();
 167         final QueryExpression<Alarms> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 168             .extractChild(System.class, new SystemKey("first"))
 169             .extractChild(Alarms.class)
 170                 .matching()
 171                     .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 172                 .build();
 173         LOG.info("Query built in {}", sw);
 174
 175         final List<? extends Item<@NonNull Alarms>> items = execute(query).getItems();
 176         assertEquals(1, items.size());
 177     }
 178
 179     @Test
 180     public void testFindSystemFirstWithAlarmOne() {
 181         final Stopwatch sw = Stopwatch.createStarted();
 182         final QueryExpression<System> query = factory.querySubtree(InstanceIdentifier.create(Foo.class))
 183             .extractChild(System.class, new SystemKey("first"))
 184                 .matching()
 185                     .childObject(Alarms.class)
 186                         .leaf(Alarms::getId).valueEquals(Uint64.ZERO)
 187                 .build();
 188         LOG.info("Query built in {}", sw);
 189
 190         final List<? extends Item<@NonNull System>> items = execute(query).getItems();
 191         assertEquals(1, items.size());
 192     }
 193
 194
 195     private <T extends @NonNull DataObject> QueryResult<T> execute(final QueryExpression<T> query) {
 196         final Stopwatch sw = Stopwatch.createStarted();
 197         final QueryResult<T> result = executor.executeQuery(query);
 198         LOG.info("Query executed in {}", sw);
 199         return result;
 200     }
 201 }