codec/yang-data-codec-gson/src/test/java/org/opendaylight/yangtools/yang/data/codec/gson/Bug8083Test.java

   1 /*
   2  * Copyright (c) 2017 Cisco Systems, Inc. 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
   9 package org.opendaylight.yangtools.yang.data.codec.gson;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.ArgumentMatchers.any;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.verify;
  18 import static org.opendaylight.yangtools.yang.data.codec.gson.TestUtils.loadTextFile;
  19
  20 import com.google.common.collect.ImmutableMap;
  21 import com.google.gson.stream.JsonReader;
  22 import com.google.gson.stream.JsonWriter;
  23 import java.io.IOException;
  24 import java.io.StringReader;
  25 import java.net.URISyntaxException;
  26 import org.junit.AfterClass;
  27 import org.junit.BeforeClass;
  28 import org.junit.Test;
  29 import org.mockito.ArgumentCaptor;
  30 import org.opendaylight.yangtools.yang.common.QName;
  31 import org.opendaylight.yangtools.yang.common.QNameModule;
  32 import org.opendaylight.yangtools.yang.common.XMLNamespace;
  33 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  36 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  38 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  39 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizationResultHolder;
  40 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  41 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  42 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
  43 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
  44 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  45 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
  46 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  47
  48 public class Bug8083Test {
  49     private static final QNameModule FOOMOD = QNameModule.create(XMLNamespace.of("http://example.com/foomod"));
  50     private static final QNameModule BARMOD = QNameModule.create(XMLNamespace.of("http://example.com/barmod"));
  51
  52     private static final QName FOO_QNAME = QName.create(FOOMOD, "foo");
  53     private static final QName FOOLIST_QNAME = QName.create(FOOMOD, "foo-list");
  54     private static final QName NAME_QNAME = QName.create(FOOMOD, "name");
  55     private static final QName TOP_QNAME = QName.create(FOOMOD, "top");
  56     private static final QName BARCONTAINER_QNAME = QName.create(BARMOD, "bar-container");
  57
  58     private static final YangInstanceIdentifier TEST_IID = YangInstanceIdentifier.builder()
  59             .node(TOP_QNAME)
  60             .node(FOOLIST_QNAME)
  61             .node(NodeIdentifierWithPredicates.of(FOOLIST_QNAME, ImmutableMap.of(NAME_QNAME, "key-value")))
  62             .node(BARCONTAINER_QNAME)
  63             .node(QName.create(BARMOD, "bar-leaf"))
  64             .build();
  65     private static final String BAZ_YANG = """
  66         module baz {
  67           namespace baz-ns;
  68           prefix baz-prefix;
  69
  70           container top-cont {
  71             list keyed-list {
  72               key empty-key-leaf;
  73               leaf empty-key-leaf {
  74                 type empty;
  75               }
  76               leaf regular-leaf {
  77                 type int32;
  78               }
  79             }
  80             leaf iid-leaf {
  81               type instance-identifier;
  82             }
  83           }
  84         }""";
  85     private static final String FOOBAR_YANG = """
  86         module foobar {
  87           namespace foobar-ns;
  88           prefix foobar-prefix;
  89           container top-cont {
  90             list keyed-list {
  91               key iid-key-leaf;
  92               leaf iid-key-leaf {
  93                 type instance-identifier;
  94               }
  95               leaf regular-leaf {
  96                 type int32;
  97               }
  98             }
  99             leaf iid-leaf {
 100               type instance-identifier;
 101             }
 102             leaf leaf-b {
 103               type int32;
 104             }
 105           }
 106         }""";
 107     private static final String ZAB_YANG = """
 108         module zab {
 109           namespace zab-ns;
 110           prefix zab-prefix;
 111           identity base-id;
 112           identity derived-id {
 113             base base-id;
 114           }
 115           container top-cont {
 116             list keyed-list {
 117               key identityref-key-leaf;
 118               leaf identityref-key-leaf {
 119                 type identityref {
 120                   base base-id;
 121                 }
 122               }
 123               leaf regular-leaf {
 124                 type int32;
 125               }
 126             }
 127             leaf iid-leaf {
 128               type instance-identifier;
 129             }
 130           }
 131         }""";
 132
 133     private static EffectiveModelContext FULL_SCHEMA_CONTEXT;
 134
 135     @BeforeClass
 136     public static void init() {
 137         FULL_SCHEMA_CONTEXT = YangParserTestUtils.parseYang("""
 138             module example-barmod {
 139               namespace "http://example.com/barmod";
 140               prefix "barmod";
 141               import example-foomod {
 142                 prefix "foomod";
 143               }
 144               augment "/foomod:top/foomod:foo-list" {
 145                 container bar-container {
 146                   leaf bar-leaf {
 147                     type string;
 148                   }
 149                 }
 150               }
 151             }""", BAZ_YANG, """
 152             module example-foomod {
 153               namespace "http://example.com/foomod";
 154               prefix "foomod";
 155               container top {
 156                 leaf foo {
 157                   type instance-identifier;
 158                 }
 159                 list foo-list {
 160                   key name;
 161                   leaf name {
 162                     type string;
 163                   }
 164                 }
 165               }
 166             }""", FOOBAR_YANG, ZAB_YANG);
 167     }
 168
 169     @AfterClass
 170     public static void cleanup() {
 171         FULL_SCHEMA_CONTEXT = null;
 172     }
 173
 174     @Test
 175     public void testInstanceIdentifierSerializeNew() throws IOException {
 176         assertEquals("/example-foomod:top/foo-list[name='key-value']/example-barmod:bar-container/bar-leaf",
 177             writeInstanceIdentifier(JSONCodecFactorySupplier.RFC7951));
 178     }
 179
 180     @Test
 181     public void testInstanceIdentifierSerializeOld() throws IOException {
 182         assertEquals("/example-foomod:top/example-foomod:foo-list[example-foomod:name='key-value']"
 183                 + "/example-barmod:bar-container/example-barmod:bar-leaf",
 184             writeInstanceIdentifier(JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02));
 185     }
 186
 187     @Test
 188     public void testRFC7951InstanceIdentifierPath() throws IOException, URISyntaxException {
 189         final String inputJson = loadTextFile("/bug8083/json/foo.json");
 190
 191         // deserialization
 192         final var result = new NormalizationResultHolder();
 193         final var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 194         final var jsonParser = JsonParserStream.create(streamWriter,
 195             JSONCodecFactorySupplier.RFC7951.getShared(FULL_SCHEMA_CONTEXT));
 196         jsonParser.parse(new JsonReader(new StringReader(inputJson)));
 197         final var transformedInput = result.getResult().data();
 198
 199         assertTrue(transformedInput instanceof ContainerNode);
 200         final var container = (ContainerNode) transformedInput;
 201         final var child = container.childByArg(new NodeIdentifier(FOO_QNAME));
 202         assertTrue(child instanceof LeafNode);
 203         assertEquals(TEST_IID, child.body());
 204     }
 205
 206     @Test
 207     public void testInstanceIdentifierPathWithEmptyListKey() throws IOException, URISyntaxException {
 208         final var schemaContext = YangParserTestUtils.parseYang(BAZ_YANG);
 209         final String inputJson = loadTextFile("/bug8083/json/baz.json");
 210
 211         // deserialization
 212         final var result = new NormalizationResultHolder();
 213         final var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 214         final var jsonParser = JsonParserStream.create(streamWriter,
 215             JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext));
 216         jsonParser.parse(new JsonReader(new StringReader(inputJson)));
 217         final var transformedInput = result.getResult().data();
 218         assertNotNull(transformedInput);
 219     }
 220
 221     @Test
 222     public void testInstanceIdentifierPathWithIdentityrefListKey() throws IOException, URISyntaxException {
 223         final var schemaContext = YangParserTestUtils.parseYang(ZAB_YANG);
 224         final String inputJson = loadTextFile("/bug8083/json/zab.json");
 225
 226         // deserialization
 227         final var result = new NormalizationResultHolder();
 228         final var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 229         final var jsonParser = JsonParserStream.create(streamWriter,
 230             JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext));
 231         jsonParser.parse(new JsonReader(new StringReader(inputJson)));
 232         final var transformedInput = result.getResult().data();
 233         assertNotNull(transformedInput);
 234     }
 235
 236     @Test
 237     public void testInstanceIdentifierPathWithInstanceIdentifierListKey() throws IOException, URISyntaxException {
 238         final EffectiveModelContext schemaContext = YangParserTestUtils.parseYang(FOOBAR_YANG);
 239         final String inputJson = loadTextFile("/bug8083/json/foobar.json");
 240
 241         // deserialization
 242         final var result = new NormalizationResultHolder();
 243         final var streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
 244         final var jsonParser = JsonParserStream.create(streamWriter,
 245             JSONCodecFactorySupplier.DRAFT_LHOTKA_NETMOD_YANG_JSON_02.getShared(schemaContext));
 246         jsonParser.parse(new JsonReader(new StringReader(inputJson)));
 247         final var transformedInput = result.getResult().data();
 248         assertNotNull(transformedInput);
 249     }
 250
 251     private static JSONCodec<YangInstanceIdentifier> getCodec(final JSONCodecFactorySupplier supplier) {
 252         final DataSchemaNode top = FULL_SCHEMA_CONTEXT.getDataChildByName(TOP_QNAME);
 253         assertTrue(top instanceof ContainerSchemaNode);
 254         final DataSchemaNode foo = ((ContainerSchemaNode) top).getDataChildByName(FOO_QNAME);
 255         assertTrue(foo instanceof LeafSchemaNode);
 256         final TypeDefinition<? extends TypeDefinition<?>> type = ((LeafSchemaNode) foo).getType();
 257         assertTrue(type instanceof InstanceIdentifierTypeDefinition);
 258         return supplier.createSimple(FULL_SCHEMA_CONTEXT)
 259                 .instanceIdentifierCodec((InstanceIdentifierTypeDefinition) type);
 260     }
 261
 262     private static String writeInstanceIdentifier(final JSONCodecFactorySupplier supplier) throws IOException {
 263         final JsonWriter writer = mock(JsonWriter.class);
 264         ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
 265         doReturn(writer).when(writer).value(captor.capture());
 266
 267         getCodec(supplier).writeValue(writer, TEST_IID);
 268         verify(writer).value(any(String.class));
 269         return captor.getValue();
 270     }
 271 }