codec/yang-data-codec-xml/src/test/java/org/opendaylight/yangtools/yang/data/codec/xml/AnydataNormalizeContentTest.java

   1 /*
   2  * Copyright (c) 2023 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.codec.xml;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertNotNull;
  12 import static org.junit.jupiter.api.Assertions.assertTrue;
  13
  14 import java.util.stream.Stream;
  15 import javax.xml.stream.XMLStreamReader;
  16 import org.junit.jupiter.api.AfterAll;
  17 import org.junit.jupiter.api.BeforeAll;
  18 import org.junit.jupiter.params.ParameterizedTest;
  19 import org.junit.jupiter.params.provider.Arguments;
  20 import org.junit.jupiter.params.provider.MethodSource;
  21 import org.opendaylight.yangtools.util.xml.UntrustedXML;
  22 import org.opendaylight.yangtools.yang.common.Empty;
  23 import org.opendaylight.yangtools.yang.common.QName;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
  26 import org.opendaylight.yangtools.yang.data.api.schema.AnydataNode;
  27 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  28 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedAnydata;
  29 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  30 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
  31 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  32 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  33 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNormalizedNodeStreamWriter;
  34 import org.opendaylight.yangtools.yang.data.impl.schema.NormalizedNodeResult;
  35 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack.Inference;
  36
  37 class AnydataNormalizeContentTest extends AbstractAnydataTest {
  38
  39     private static final QName BAR_QNAME = QName.create(FOO_QNAME, "bar"); // container level 2
  40     private static final QName LIST_QNAME = QName.create(FOO_QNAME, "lst"); // list
  41     private static final QName LEAF_LIST_QNAME = QName.create(FOO_QNAME, "my-leafs"); // leaf-list of type string
  42     private static final QName LEAF_EMPTY_QNAME = QName.create(FOO_QNAME, "empty-leaf"); // leaf of type empty
  43     private static final NodeIdentifier BAR_NODEID = NodeIdentifier.create(BAR_QNAME);
  44     private static final NodeIdentifier LIST_NODEID = NodeIdentifier.create(LIST_QNAME);
  45     private static final NodeIdentifier LEAF_LIST_NODEID = NodeIdentifier.create(LEAF_LIST_QNAME);
  46     private static final NodeIdentifier LEAF_EMPTY_NODEID = NodeIdentifier.create(LEAF_EMPTY_QNAME);
  47     private static final LeafNode<String> LEAF_NODE = ImmutableNodes.leafNode(CONT_LEAF_NODEID, "test");
  48
  49     private static final String ANYDATA_XML = "<foo xmlns=\"test-anydata\"><cont-leaf>test</cont-leaf></foo>";
  50     private static final String ANYDATA_EMPTY_XML = "<foo xmlns=\"test-anydata\" />";
  51
  52     @BeforeAll
  53     static void beforeAll() throws Exception {
  54         beforeClass(); // junit 4
  55     }
  56
  57     @AfterAll
  58     static void afterAll() {
  59         afterClass(); // junit 4
  60     }
  61
  62     @ParameterizedTest(name = "Anydata normalize to {0}")
  63     @MethodSource("normalizeArgs")
  64     void anydataNormalize(final String testDesc, final String xml, final Inference inference,
  65             final NormalizedNode expectedData) throws Exception {
  66
  67         final XMLStreamReader reader = UntrustedXML.createXMLStreamReader(toInputStream(xml));
  68         final NormalizedNodeResult result = new NormalizedNodeResult();
  69         final NormalizedNodeStreamWriter streamWriter = ImmutableNormalizedNodeStreamWriter.from(result);
  70         final XmlParserStream xmlParser =
  71                 XmlParserStream.create(streamWriter, Inference.ofDataTreePath(SCHEMA_CONTEXT, FOO_QNAME));
  72         xmlParser.parse(reader);
  73
  74         final NormalizedNode normalizedNode = result.getResult();
  75         assertTrue(normalizedNode instanceof AnydataNode anydataNode
  76                 && anydataNode.body() instanceof DOMSourceAnydata);
  77         final AnydataNode<?> anydataNode = (AnydataNode<?>) normalizedNode;
  78         final DOMSourceAnydata domSourceAnydata = (DOMSourceAnydata) anydataNode.body();
  79
  80         final NormalizedAnydata normalizedAnydata = domSourceAnydata.normalizeTo(inference);
  81         assertNotNull(normalizedAnydata);
  82         assertEquals(expectedData, normalizedAnydata.getData());
  83     }
  84
  85     private static Stream<Arguments> normalizeArgs() {
  86         // test case descriptor, xml, inference, expected normalized data
  87         return Stream.of(
  88                 Arguments.of("container (root level)",
  89                         ANYDATA_XML,
  90                         Inference.ofDataTreePath(SCHEMA_CONTEXT, CONT_QNAME),
  91                         Builders.containerBuilder().withNodeIdentifier(CONT_NODEID).withChild(LEAF_NODE).build()),
  92                 Arguments.of("container (level 2)",
  93                         ANYDATA_XML,
  94                         Inference.ofDataTreePath(SCHEMA_CONTEXT, CONT_QNAME, BAR_QNAME),
  95                         Builders.containerBuilder().withNodeIdentifier(BAR_NODEID).withChild(LEAF_NODE).build()),
  96                 Arguments.of("empty container",
  97                         ANYDATA_EMPTY_XML,
  98                         Inference.ofDataTreePath(SCHEMA_CONTEXT, CONT_QNAME, BAR_QNAME),
  99                         ImmutableNodes.containerNode(BAR_NODEID)),
 100                 Arguments.of("single list element",
 101                         ANYDATA_XML,
 102                         Inference.ofDataTreePath(SCHEMA_CONTEXT, LIST_QNAME),
 103                         Builders.unkeyedListBuilder().withNodeIdentifier(LIST_NODEID).withChild(
 104                                 Builders.unkeyedListEntryBuilder().withNodeIdentifier(LIST_NODEID)
 105                                         .withChild(LEAF_NODE).build()).build()),
 106                 Arguments.of("single empty list element",
 107                         ANYDATA_EMPTY_XML,
 108                         Inference.ofDataTreePath(SCHEMA_CONTEXT, LIST_QNAME),
 109                         Builders.unkeyedListBuilder().withNodeIdentifier(LIST_NODEID).withChild(
 110                                 Builders.unkeyedListEntryBuilder().withNodeIdentifier(LIST_NODEID).build()).build()),
 111                 Arguments.of("single empty leaf-list element",
 112                         ANYDATA_EMPTY_XML,
 113                         Inference.ofDataTreePath(SCHEMA_CONTEXT, LIST_QNAME, LEAF_LIST_QNAME),
 114                         Builders.leafSetBuilder().withNodeIdentifier(LEAF_LIST_NODEID).withChild(
 115                                 Builders.leafSetEntryBuilder()
 116                                         .withNodeIdentifier(new NodeWithValue<>(LEAF_LIST_QNAME, ""))
 117                                         .withValue("").build()).build()),
 118                 Arguments.of("leaf of type empty",
 119                         ANYDATA_EMPTY_XML,
 120                         Inference.ofDataTreePath(SCHEMA_CONTEXT, CONT_QNAME, LEAF_EMPTY_QNAME),
 121                         ImmutableNodes.leafNode(LEAF_EMPTY_NODEID, Empty.value())));
 122     }
 123 }