data/yang-data-tree-ri/src/test/java/org/opendaylight/yangtools/yang/data/tree/impl/YT1276Test.java

   1 /*
   2  * Copyright (c) 2021 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.yangtools.yang.data.tree.impl;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertThrows;
  12
  13 import java.util.function.Consumer;
  14 import org.junit.jupiter.api.BeforeAll;
  15 import org.junit.jupiter.api.Test;
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  18 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  19 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  20 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  21 import org.opendaylight.yangtools.yang.data.tree.api.DataTree;
  22 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeConfiguration;
  23 import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
  24 import org.opendaylight.yangtools.yang.data.tree.api.DataValidationFailedException;
  25 import org.opendaylight.yangtools.yang.data.tree.impl.di.InMemoryDataTreeFactory;
  26 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  27 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  28
  29 class YT1276Test {
  30     private static final QName FOO = QName.create("foo", "foo");
  31     private static final QName BAR = QName.create(FOO, "bar");
  32     private static final QName BAZ = QName.create(FOO, "baz");
  33     private static final QName XYZZY_LEAF = QName.create(FOO, "xyzzy-leaf");
  34     private static final QName XYZZY_AUGMENT = QName.create(FOO, "xyzzy-augment");
  35     private static final QName XYZZY_AUGMENT_CONT = QName.create(FOO, "xyzzy-augment-container");
  36     private static final QName XYZZY_AUGMENT_CONT_INNER = QName.create(FOO, "xyzzy-augment-container-inner");
  37     private static final QName XYZZY_AUGMENT_CONT_LEAF = QName.create(FOO, "xyzzy-augment-container-leaf");
  38     private static final QName BAZ_AUG_CASE_MANDAT_LEAF = QName.create(FOO, "augmented-case-mandatory");
  39     private static final QName BAZ_AUG_CASE_NON_MANDAT_LEAF = QName.create(FOO, "augmented-case-non-mandatory");
  40     private static final QName NESTED_BAZ_CHOICE = QName.create(FOO, "nested-baz");
  41     private static final QName NESTED_BAZ_XYZ_CASE_MANDATORY = QName.create(FOO, "nested-xyz-mandatory");
  42     private static final QName NESTED_BAZ_XYZ_CASE_NON_MANDATORY = QName.create(FOO, "nested-xyz-non-mandatory");
  43
  44     private static EffectiveModelContext MODEL;
  45
  46     private final DataTree tree = new InMemoryDataTreeFactory()
  47         .create(DataTreeConfiguration.DEFAULT_CONFIGURATION, MODEL);
  48
  49     @BeforeAll
  50     static void beforeClass() {
  51         MODEL = YangParserTestUtils.parseYangResource("/yt1276.yang");
  52     }
  53
  54     @Test
  55     void testFooWithBar() throws DataValidationFailedException {
  56         applyOperation(mod -> {
  57             mod.write(YangInstanceIdentifier.of(FOO), Builders.containerBuilder()
  58                 .withNodeIdentifier(new NodeIdentifier(FOO))
  59                 .withChild(ImmutableNodes.leafNode(BAR, "xyzzy"))
  60                 .build());
  61         });
  62     }
  63
  64     @Test
  65     @Deprecated
  66     void testFooWithBarLegacy() throws DataValidationFailedException {
  67         applyOperation(mod -> {
  68             mod.write(YangInstanceIdentifier.of(FOO), Builders.containerBuilder()
  69                 .withNodeIdentifier(new NodeIdentifier(FOO))
  70                 .withChild(ImmutableNodes.leafNode(BAR, "xyzzy"))
  71                 .build());
  72         });
  73     }
  74
  75     @Test
  76     void testFooWithoutBar() {
  77         final IllegalArgumentException ex = assertFailsReady(mod -> {
  78             mod.write(YangInstanceIdentifier.of(FOO), Builders.containerBuilder()
  79                 .withNodeIdentifier(new NodeIdentifier(FOO))
  80                 .build());
  81         });
  82         assertEquals("Node (foo)foo is missing mandatory descendant /(foo)bar", ex.getMessage());
  83     }
  84
  85     @Test
  86     void testBarWithXyzzyWithSubtree() throws DataValidationFailedException {
  87         applyOperation(mod -> {
  88             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
  89                 .withNodeIdentifier(new NodeIdentifier(BAR))
  90                 .withChild(Builders.choiceBuilder()
  91                     .withNodeIdentifier(new NodeIdentifier(BAZ))
  92                     .withChild(ImmutableNodes.leafNode(XYZZY_LEAF, "xyzzy"))
  93                     .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
  94                     .withChild(Builders.containerBuilder()
  95                         .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT))
  96                         .withChild(Builders.containerBuilder()
  97                             .withNodeIdentifier(new NodeIdentifier(XYZZY_AUGMENT_CONT_INNER))
  98                             .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
  99                             .build())
 100                         .build())
 101                     .build())
 102                 .build());
 103         });
 104     }
 105
 106     @Test
 107     void testBazWithAugmentedCaseWithMandatoryLeaf() throws DataValidationFailedException {
 108         applyOperation(mod -> {
 109             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 110                 .withNodeIdentifier(new NodeIdentifier(BAR))
 111                 .withChild(Builders.choiceBuilder()
 112                     .withNodeIdentifier(new NodeIdentifier(BAZ))
 113                     .withChild(ImmutableNodes.leafNode(BAZ_AUG_CASE_MANDAT_LEAF, "augmentedCaseMandatory"))
 114                     .withChild(ImmutableNodes.leafNode(BAZ_AUG_CASE_NON_MANDAT_LEAF, "augmentedCaseNonMandatory"))
 115                     .build())
 116                 .build());
 117         });
 118     }
 119
 120     @Test
 121     void testBazWithAugmentedCaseWithoutMandatoryLeaf() throws DataValidationFailedException {
 122         assertThrows(IllegalArgumentException.class, () -> {
 123             applyOperation(mod -> {
 124                 mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 125                     .withNodeIdentifier(new NodeIdentifier(BAR))
 126                     .withChild(Builders.choiceBuilder()
 127                         .withNodeIdentifier(new NodeIdentifier(BAZ))
 128                         .withChild(ImmutableNodes.leafNode(BAZ_AUG_CASE_NON_MANDAT_LEAF, "augmentedCaseNonMandatory"))
 129                         .build())
 130                     .build());
 131             });
 132         });
 133     }
 134
 135     @Test
 136     void testWithAugmentedNestedBazWithMandatoryLeaf() throws DataValidationFailedException {
 137         applyOperation(mod -> {
 138             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 139                 .withNodeIdentifier(new NodeIdentifier(BAR))
 140                 .withChild(Builders.choiceBuilder()
 141                     .withNodeIdentifier(new NodeIdentifier(BAZ))
 142                     .withChild(Builders.choiceBuilder()
 143                         .withNodeIdentifier(new NodeIdentifier(NESTED_BAZ_CHOICE))
 144                         .withChild(ImmutableNodes.leafNode(NESTED_BAZ_XYZ_CASE_MANDATORY, "nestedMandatory"))
 145                         .withChild(ImmutableNodes.leafNode(NESTED_BAZ_XYZ_CASE_NON_MANDATORY, "nestedNonMandatory"))
 146                     .build())
 147                     .build())
 148                 .build());
 149         });
 150     }
 151
 152     @Test
 153     void testWithAugmentedNestedBazWithhoutMandatoryLeaf() throws DataValidationFailedException {
 154         assertThrows(IllegalArgumentException.class, () -> {
 155             applyOperation(mod -> {
 156                 mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 157                     .withNodeIdentifier(new NodeIdentifier(BAR))
 158                     .withChild(Builders.choiceBuilder()
 159                         .withNodeIdentifier(new NodeIdentifier(BAZ))
 160                         .withChild(Builders.choiceBuilder()
 161                             .withNodeIdentifier(new NodeIdentifier(NESTED_BAZ_CHOICE))
 162                             .withChild(ImmutableNodes.leafNode(NESTED_BAZ_XYZ_CASE_NON_MANDATORY, "nestedNonMandatory"))
 163                             .build())
 164                         .build())
 165                     .build());
 166             });
 167         });
 168     }
 169
 170     @Test
 171     @Deprecated
 172     void testBarWithXyzzyLegacy() throws DataValidationFailedException {
 173         applyOperation(mod -> {
 174             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 175                 .withNodeIdentifier(new NodeIdentifier(BAR))
 176                 .withChild(Builders.choiceBuilder()
 177                     .withNodeIdentifier(new NodeIdentifier(BAZ))
 178                     .withChild(ImmutableNodes.leafNode(XYZZY_LEAF, "xyzzy"))
 179                     .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
 180                     .withChild(Builders.containerBuilder()
 181                         .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT))
 182                         .withChild(Builders.containerBuilder()
 183                             .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT_INNER))
 184                             .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
 185                             .build())
 186                         .build())
 187                     .build())
 188                 .build());
 189         });
 190     }
 191
 192     @Test
 193     void testBarWithoutXyzzyLeaf() {
 194         final var ex = assertFailsReady(mod -> {
 195             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 196                 .withNodeIdentifier(new NodeIdentifier(BAR))
 197                 .withChild(Builders.choiceBuilder()
 198                     .withNodeIdentifier(new NodeIdentifier(BAZ))
 199                     .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT, "xyzzy"))
 200                     .withChild(Builders.containerBuilder()
 201                         .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT))
 202                         .withChild(Builders.containerBuilder()
 203                             .withNodeIdentifier(NodeIdentifier.create(XYZZY_AUGMENT_CONT_INNER))
 204                             .withChild(ImmutableNodes.leafNode(XYZZY_AUGMENT_CONT_LEAF, "aug-cont-leaf"))
 205                             .build())
 206                         .build())
 207                     .build())
 208                 .build());
 209         });
 210         assertEquals(
 211             "Node (foo)baz is missing mandatory descendant /(foo)xyzzy-leaf",
 212             ex.getMessage());
 213     }
 214
 215     @Test
 216     void testBarWithoutXyzzyAugment() {
 217         final var ex = assertFailsReady(mod -> {
 218             mod.write(YangInstanceIdentifier.of(BAR), Builders.containerBuilder()
 219                 .withNodeIdentifier(new NodeIdentifier(BAR))
 220                 .withChild(Builders.choiceBuilder()
 221                     .withNodeIdentifier(new NodeIdentifier(BAZ))
 222                     .withChild(ImmutableNodes.leafNode(XYZZY_LEAF, "xyzzy"))
 223                     .build())
 224                 .build());
 225         });
 226         assertEquals("Node (foo)baz is missing mandatory descendant /(foo)xyzzy-augment", ex.getMessage());
 227
 228     }
 229
 230     private IllegalArgumentException assertFailsReady(final Consumer<DataTreeModification> operation) {
 231         return assertThrows(IllegalArgumentException.class, () -> applyOperation(operation));
 232     }
 233
 234     private void applyOperation(final Consumer<DataTreeModification> operation)
 235             throws DataValidationFailedException {
 236         final var mod = tree.takeSnapshot().newModification();
 237         operation.accept(mod);
 238         mod.ready();
 239         tree.commit(tree.prepare(mod));
 240     }
 241 }