opendaylight/md-sal/sal-protocolbuffer-encoding/src/test/java/org/opendaylight/controller/cluster/datastore/util/TestModel.java

   1 package org.opendaylight.controller.cluster.datastore.util;
   2
   3 import org.opendaylight.yangtools.yang.common.QName;
   4 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
   5 import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
   6 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
   7 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
   8 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
   9 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  10 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  11 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  12 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  13 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  14 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
  15 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
  16 import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
  17 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableContainerNodeBuilder;
  18 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetEntryNodeBuilder;
  19 import org.opendaylight.yangtools.yang.data.impl.schema.builder.impl.ImmutableLeafSetNodeBuilder;
  20 import org.opendaylight.yangtools.yang.model.api.Module;
  21 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  22 import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
  23
  24 import java.io.InputStream;
  25 import java.util.ArrayList;
  26 import java.util.HashSet;
  27 import java.util.List;
  28 import java.util.Set;
  29
  30 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntry;
  31 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapEntryBuilder;
  32 import static org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes.mapNodeBuilder;
  33
  34 public class TestModel {
  35
  36   public static final QName TEST_QNAME = QName.create(
  37       "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test",
  38       "2014-03-13", "test");
  39
  40   public static final QName AUG_QNAME = QName.create(
  41       "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:aug",
  42       "2014-03-13", "name");
  43
  44   public static final QName DESC_QNAME = QName.create(TEST_QNAME, "desc");
  45   public static final QName OUTER_LIST_QNAME = QName.create(TEST_QNAME,
  46       "outer-list");
  47   public static final QName INNER_LIST_QNAME = QName.create(TEST_QNAME,
  48       "inner-list");
  49   public static final QName OUTER_CHOICE_QNAME = QName.create(TEST_QNAME,
  50       "outer-choice");
  51   public static final QName ID_QNAME = QName.create(TEST_QNAME, "id");
  52   public static final QName NAME_QNAME = QName.create(TEST_QNAME, "name");
  53   public static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
  54   private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
  55   private static final String DATASTORE_AUG_YANG =
  56       "/odl-datastore-augmentation.yang";
  57   private static final String DATASTORE_TEST_NOTIFICATION_YANG =
  58       "/odl-datastore-test-notification.yang";
  59
  60
  61   public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier
  62       .of(TEST_QNAME);
  63   public static final YangInstanceIdentifier DESC_PATH = YangInstanceIdentifier
  64       .builder(TEST_PATH).node(DESC_QNAME).build();
  65   public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier
  66       .builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
  67   public static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
  68   public static final QName THREE_QNAME = QName.create(TEST_QNAME, "three");
  69
  70   private static final Integer ONE_ID = 1;
  71   private static final Integer TWO_ID = 2;
  72   private static final String TWO_ONE_NAME = "one";
  73   private static final String TWO_TWO_NAME = "two";
  74   private static final String DESC = "Hello there";
  75
  76   // Family specific constants
  77   public static final QName FAMILY_QNAME =
  78       QName
  79           .create(
  80               "urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:notification-test",
  81               "2014-04-17", "family");
  82   public static final QName CHILDREN_QNAME = QName.create(FAMILY_QNAME,
  83       "children");
  84   public static final QName GRAND_CHILDREN_QNAME = QName.create(FAMILY_QNAME,
  85       "grand-children");
  86   public static final QName CHILD_NUMBER_QNAME = QName.create(FAMILY_QNAME,
  87       "child-number");
  88   public static final QName CHILD_NAME_QNAME = QName.create(FAMILY_QNAME,
  89       "child-name");
  90   public static final QName GRAND_CHILD_NUMBER_QNAME = QName.create(
  91       FAMILY_QNAME, "grand-child-number");
  92   public static final QName GRAND_CHILD_NAME_QNAME = QName.create(FAMILY_QNAME,
  93       "grand-child-name");
  94
  95   public static final YangInstanceIdentifier FAMILY_PATH = YangInstanceIdentifier
  96       .of(FAMILY_QNAME);
  97   public static final YangInstanceIdentifier FAMILY_DESC_PATH = YangInstanceIdentifier
  98       .builder(FAMILY_PATH).node(DESC_QNAME).build();
  99   public static final YangInstanceIdentifier CHILDREN_PATH = YangInstanceIdentifier
 100       .builder(FAMILY_PATH).node(CHILDREN_QNAME).build();
 101
 102   private static final Integer FIRST_CHILD_ID = 1;
 103   private static final Integer SECOND_CHILD_ID = 2;
 104
 105   private static final String FIRST_CHILD_NAME = "first child";
 106   private static final String SECOND_CHILD_NAME = "second child";
 107
 108   private static final Integer FIRST_GRAND_CHILD_ID = 1;
 109   private static final Integer SECOND_GRAND_CHILD_ID = 2;
 110
 111   private static final String FIRST_GRAND_CHILD_NAME = "first grand child";
 112   private static final String SECOND_GRAND_CHILD_NAME = "second grand child";
 113
 114   // first child
 115   private static final YangInstanceIdentifier CHILDREN_1_PATH = YangInstanceIdentifier
 116       .builder(CHILDREN_PATH)
 117       .nodeWithKey(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID) //
 118       .build();
 119   private static final YangInstanceIdentifier CHILDREN_1_NAME_PATH =
 120       YangInstanceIdentifier.builder(CHILDREN_PATH)
 121           .nodeWithKey(CHILDREN_QNAME, CHILD_NAME_QNAME, FIRST_CHILD_NAME) //
 122           .build();
 123
 124   private static final YangInstanceIdentifier CHILDREN_2_PATH = YangInstanceIdentifier
 125       .builder(CHILDREN_PATH)
 126       .nodeWithKey(CHILDREN_QNAME, CHILD_NUMBER_QNAME, SECOND_CHILD_ID) //
 127       .build();
 128   private static final YangInstanceIdentifier CHILDREN_2_NAME_PATH =
 129       YangInstanceIdentifier.builder(CHILDREN_PATH)
 130           .nodeWithKey(CHILDREN_QNAME, CHILD_NAME_QNAME, SECOND_CHILD_NAME) //
 131           .build();
 132
 133
 134   private static final YangInstanceIdentifier GRAND_CHILD_1_PATH =
 135       YangInstanceIdentifier.builder(CHILDREN_1_PATH)
 136           .node(GRAND_CHILDREN_QNAME)
 137           //
 138           .nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
 139               FIRST_GRAND_CHILD_ID) //
 140           .build();
 141
 142   private static final YangInstanceIdentifier GRAND_CHILD_1_NAME_PATH =
 143       YangInstanceIdentifier.builder(CHILDREN_1_PATH)
 144           .node(GRAND_CHILDREN_QNAME)
 145           //
 146           .nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NAME_QNAME,
 147               FIRST_GRAND_CHILD_NAME) //
 148           .build();
 149
 150   private static final YangInstanceIdentifier GRAND_CHILD_2_PATH =
 151       YangInstanceIdentifier.builder(CHILDREN_2_PATH)
 152           .node(GRAND_CHILDREN_QNAME)
 153           //
 154           .nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
 155               SECOND_GRAND_CHILD_ID) //
 156           .build();
 157
 158   private static final YangInstanceIdentifier GRAND_CHILD_2_NAME_PATH =
 159       YangInstanceIdentifier.builder(CHILDREN_2_PATH)
 160           .node(GRAND_CHILDREN_QNAME)
 161           //
 162           .nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NAME_QNAME,
 163               SECOND_GRAND_CHILD_NAME) //
 164           .build();
 165
 166   private static final YangInstanceIdentifier DESC_PATH_ID = YangInstanceIdentifier
 167       .builder(DESC_PATH).build();
 168   private static final YangInstanceIdentifier OUTER_LIST_1_PATH =
 169       YangInstanceIdentifier.builder(OUTER_LIST_PATH)
 170           .nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, ONE_ID) //
 171           .build();
 172
 173   private static final YangInstanceIdentifier OUTER_LIST_2_PATH =
 174       YangInstanceIdentifier.builder(OUTER_LIST_PATH)
 175           .nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, TWO_ID) //
 176           .build();
 177
 178   private static final YangInstanceIdentifier TWO_TWO_PATH = YangInstanceIdentifier
 179       .builder(OUTER_LIST_2_PATH).node(INNER_LIST_QNAME) //
 180       .nodeWithKey(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME) //
 181       .build();
 182
 183   private static final YangInstanceIdentifier TWO_TWO_VALUE_PATH =
 184       YangInstanceIdentifier.builder(TWO_TWO_PATH).node(VALUE_QNAME) //
 185           .build();
 186
 187   private static final MapEntryNode BAR_NODE = mapEntryBuilder(
 188       OUTER_LIST_QNAME, ID_QNAME, TWO_ID) //
 189       .withChild(mapNodeBuilder(INNER_LIST_QNAME) //
 190           .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_ONE_NAME)) //
 191           .withChild(mapEntry(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME)) //
 192           .build()) //
 193       .build();
 194
 195   public static final InputStream getDatastoreTestInputStream() {
 196     return getInputStream(DATASTORE_TEST_YANG);
 197   }
 198
 199   public static final InputStream getDatastoreAugInputStream() {
 200     return getInputStream(DATASTORE_AUG_YANG);
 201   }
 202
 203   public static final InputStream getDatastoreTestNotificationInputStream() {
 204     return getInputStream(DATASTORE_TEST_NOTIFICATION_YANG);
 205   }
 206
 207   private static InputStream getInputStream(final String resourceName) {
 208     return TestModel.class.getResourceAsStream(resourceName);
 209   }
 210
 211   public static SchemaContext createTestContext() {
 212     List<InputStream> inputStreams = new ArrayList<>();
 213     inputStreams.add(getDatastoreTestInputStream());
 214     inputStreams.add(getDatastoreAugInputStream());
 215     inputStreams.add(getDatastoreTestNotificationInputStream());
 216
 217     YangParserImpl parser = new YangParserImpl();
 218     Set<Module> modules = parser.parseYangModelsFromStreams(inputStreams);
 219     return parser.resolveSchemaContext(modules);
 220   }
 221
 222   /**
 223    * Returns a test document
 224    *
 225    * <pre>
 226    * test
 227    *     outer-list
 228    *          id 1
 229    *     outer-list
 230    *          id 2
 231    *          inner-list
 232    *                  name "one"
 233    *          inner-list
 234    *                  name "two"
 235    *
 236    * </pre>
 237    *
 238    * @return
 239    */
 240   public static NormalizedNode<?, ?> createDocumentOne(
 241       SchemaContext schemaContext) {
 242     return ImmutableContainerNodeBuilder
 243         .create()
 244         .withNodeIdentifier(
 245             new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
 246         .withChild(createTestContainer()).build();
 247
 248   }
 249
 250   public static ContainerNode createTestContainer() {
 251
 252
 253     final LeafSetEntryNode<Object> nike =
 254         ImmutableLeafSetEntryNodeBuilder
 255             .create()
 256             .withNodeIdentifier(
 257                 new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
 258                     "shoe"), "nike")).withValue("nike").build();
 259     final LeafSetEntryNode<Object> puma =
 260         ImmutableLeafSetEntryNodeBuilder
 261             .create()
 262             .withNodeIdentifier(
 263                 new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
 264                     "shoe"), "puma")).withValue("puma").build();
 265     final LeafSetNode<Object> shoes =
 266         ImmutableLeafSetNodeBuilder
 267             .create()
 268             .withNodeIdentifier(
 269                 new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
 270                     "shoe"))).withChild(nike).withChild(puma).build();
 271
 272
 273     final LeafSetEntryNode<Object> five =
 274         ImmutableLeafSetEntryNodeBuilder
 275             .create()
 276             .withNodeIdentifier(
 277                 (new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
 278                     "number"), 5))).withValue(5).build();
 279     final LeafSetEntryNode<Object> fifteen =
 280         ImmutableLeafSetEntryNodeBuilder
 281             .create()
 282             .withNodeIdentifier(
 283                 (new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
 284                     "number"), 15))).withValue(15).build();
 285     final LeafSetNode<Object> numbers =
 286         ImmutableLeafSetNodeBuilder
 287             .create()
 288             .withNodeIdentifier(
 289                 new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
 290                     "number"))).withChild(five).withChild(fifteen).build();
 291
 292
 293     Set<QName> childAugmentations = new HashSet<>();
 294     childAugmentations.add(AUG_QNAME);
 295     final YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
 296         new YangInstanceIdentifier.AugmentationIdentifier(null, childAugmentations);
 297     final AugmentationNode augmentationNode =
 298         Builders.augmentationBuilder()
 299             .withNodeIdentifier(augmentationIdentifier)
 300             .withChild(ImmutableNodes.leafNode(AUG_QNAME, "First Test"))
 301             .build();
 302     return ImmutableContainerNodeBuilder
 303         .create()
 304         .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
 305         .withChild(ImmutableNodes.leafNode(DESC_QNAME, DESC))
 306         .withChild(augmentationNode)
 307         .withChild(shoes)
 308         .withChild(numbers)
 309         .withChild(
 310             mapNodeBuilder(OUTER_LIST_QNAME)
 311                 .withChild(mapEntry(OUTER_LIST_QNAME, ID_QNAME, ONE_ID))
 312                 .withChild(BAR_NODE).build()).build();
 313
 314   }
 315
 316
 317   public static ContainerNode createFamily() {
 318     final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> familyContainerBuilder =
 319         ImmutableContainerNodeBuilder.create().withNodeIdentifier(
 320             new YangInstanceIdentifier.NodeIdentifier(FAMILY_QNAME));
 321
 322     final CollectionNodeBuilder<MapEntryNode, MapNode> childrenBuilder =
 323         mapNodeBuilder(CHILDREN_QNAME);
 324
 325     final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstChildBuilder =
 326         mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID);
 327     final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondChildBuilder =
 328         mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, SECOND_CHILD_ID);
 329
 330     final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstGrandChildBuilder =
 331         mapEntryBuilder(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
 332             FIRST_GRAND_CHILD_ID);
 333     final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondGrandChildBuilder =
 334         mapEntryBuilder(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
 335             SECOND_GRAND_CHILD_ID);
 336
 337     firstGrandChildBuilder
 338         .withChild(
 339             ImmutableNodes.leafNode(GRAND_CHILD_NUMBER_QNAME,
 340                 FIRST_GRAND_CHILD_ID)).withChild(
 341         ImmutableNodes.leafNode(GRAND_CHILD_NAME_QNAME,
 342             FIRST_GRAND_CHILD_NAME));
 343
 344     secondGrandChildBuilder.withChild(
 345         ImmutableNodes
 346             .leafNode(GRAND_CHILD_NUMBER_QNAME, SECOND_GRAND_CHILD_ID))
 347         .withChild(
 348             ImmutableNodes.leafNode(GRAND_CHILD_NAME_QNAME,
 349                 SECOND_GRAND_CHILD_NAME));
 350
 351     firstChildBuilder
 352         .withChild(ImmutableNodes.leafNode(CHILD_NUMBER_QNAME, FIRST_CHILD_ID))
 353         .withChild(ImmutableNodes.leafNode(CHILD_NAME_QNAME, FIRST_CHILD_NAME))
 354         .withChild(
 355             mapNodeBuilder(GRAND_CHILDREN_QNAME).withChild(
 356                 firstGrandChildBuilder.build()).build());
 357
 358
 359     secondChildBuilder
 360         .withChild(ImmutableNodes.leafNode(CHILD_NUMBER_QNAME, SECOND_CHILD_ID))
 361         .withChild(ImmutableNodes.leafNode(CHILD_NAME_QNAME, SECOND_CHILD_NAME))
 362         .withChild(
 363             mapNodeBuilder(GRAND_CHILDREN_QNAME).withChild(
 364                 firstGrandChildBuilder.build()).build());
 365
 366     childrenBuilder.withChild(firstChildBuilder.build());
 367     childrenBuilder.withChild(secondChildBuilder.build());
 368
 369     return familyContainerBuilder.withChild(childrenBuilder.build()).build();
 370   }
 371
 372 }