restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/rfc8040/utils/parser/NetconfFieldsTranslatorTest.java

   1 /*
   2  * Copyright © 2020 FRINX s.r.o. and others.  All rights reserved.
   3  * Copyright © 2021 PANTHEON.tech, s.r.o.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   7  * and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9 package org.opendaylight.restconf.nb.rfc8040.utils.parser;
  10
  11 import static org.hamcrest.CoreMatchers.instanceOf;
  12 import static org.hamcrest.MatcherAssert.assertThat;
  13 import static org.junit.Assert.assertEquals;
  14
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.stream.Collectors;
  18 import org.junit.runner.RunWith;
  19 import org.mockito.junit.MockitoJUnitRunner;
  20 import org.opendaylight.restconf.api.query.FieldsParam;
  21 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
  22 import org.opendaylight.yangtools.yang.common.QName;
  23 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  24 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
  25 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  26 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
  27
  28 /**
  29  * Unit test for {@link NetconfFieldsTranslator}.
  30  */
  31 @RunWith(MockitoJUnitRunner.class)
  32 public class NetconfFieldsTranslatorTest extends AbstractFieldsTranslatorTest<YangInstanceIdentifier> {
  33     @Override
  34     protected List<YangInstanceIdentifier> translateFields(final InstanceIdentifierContext context,
  35             final FieldsParam fields) {
  36         return NetconfFieldsTranslator.translate(context, fields);
  37     }
  38
  39     @Override
  40     protected void assertSimplePath(final List<YangInstanceIdentifier> result) {
  41         assertEquals(1, result.size());
  42         final var pathArguments = result.get(0).getPathArguments();
  43         assertEquals(1, pathArguments.size());
  44         assertEquals(LIBRARY_Q_NAME, pathArguments.get(0).getNodeType());
  45     }
  46
  47     @Override
  48     protected void assertKeyedList(List<YangInstanceIdentifier> result) {
  49         assertEquals(1, result.size());
  50     }
  51
  52     @Override
  53     protected void assertDoublePath(final List<YangInstanceIdentifier> result) {
  54         assertEquals(2, result.size());
  55
  56         final var libraryPath = assertPath(result, LIBRARY_Q_NAME);
  57         assertEquals(1, libraryPath.getPathArguments().size());
  58
  59         final var playerPath = assertPath(result, PLAYER_Q_NAME);
  60         assertEquals(1, playerPath.getPathArguments().size());
  61     }
  62
  63     @Override
  64     protected void assertSubPath(final List<YangInstanceIdentifier> result) {
  65         assertEquals(1, result.size());
  66         final var pathArguments = result.get(0).getPathArguments();
  67         assertEquals(6, pathArguments.size());
  68         assertEquals(LIBRARY_Q_NAME, pathArguments.get(0).getNodeType());
  69         assertEquals(ARTIST_Q_NAME, pathArguments.get(1).getNodeType());
  70         assertEquals(ARTIST_Q_NAME, pathArguments.get(2).getNodeType());
  71         assertEquals(ALBUM_Q_NAME, pathArguments.get(3).getNodeType());
  72         assertEquals(ALBUM_Q_NAME, pathArguments.get(4).getNodeType());
  73         assertEquals(NAME_Q_NAME, pathArguments.get(5).getNodeType());
  74     }
  75
  76     @Override
  77     protected void assertChildrenPath(final List<YangInstanceIdentifier> result) {
  78         assertEquals(1, result.size());
  79         final var pathArguments = result.get(0).getPathArguments();
  80         assertEquals(6, pathArguments.size());
  81         assertEquals(LIBRARY_Q_NAME, pathArguments.get(0).getNodeType());
  82         assertEquals(ARTIST_Q_NAME, pathArguments.get(1).getNodeType());
  83         assertEquals(ARTIST_Q_NAME, pathArguments.get(2).getNodeType());
  84         assertEquals(ALBUM_Q_NAME, pathArguments.get(3).getNodeType());
  85         assertEquals(ALBUM_Q_NAME, pathArguments.get(4).getNodeType());
  86         assertEquals(NAME_Q_NAME, pathArguments.get(5).getNodeType());
  87     }
  88
  89     @Override
  90     protected void assertNamespace(final List<YangInstanceIdentifier> result) {
  91         assertEquals(1, result.size());
  92         final var augmentedLibraryPath = assertPath(result, AUGMENTED_LIBRARY_Q_NAME);
  93         assertEquals(2, augmentedLibraryPath.getPathArguments().size());
  94     }
  95
  96     @Override
  97     protected void assertMultipleChildren1(final List<YangInstanceIdentifier> result) {
  98         assertEquals(3, result.size());
  99
 100         final var tosPath = assertPath(result, TYPE_OF_SERVICE_Q_NAME);
 101         assertEquals(3, tosPath.getPathArguments().size());
 102
 103         final var instanceNamePath = assertPath(result, INSTANCE_NAME_Q_NAME);
 104         assertEquals(5, instanceNamePath.getPathArguments().size());
 105
 106         final var providerPath = assertPath(result, PROVIDER_Q_NAME);
 107         assertEquals(5, providerPath.getPathArguments().size());
 108     }
 109
 110     @Override
 111     protected void assertMultipleChildren2(final List<YangInstanceIdentifier> result) {
 112         assertEquals(3, result.size());
 113
 114         final var tosPath = assertPath(result, TYPE_OF_SERVICE_Q_NAME);
 115         assertEquals(3, tosPath.getPathArguments().size());
 116
 117         final var instanceNamePath = assertPath(result, INSTANCE_NAME_Q_NAME);
 118         assertEquals(5, instanceNamePath.getPathArguments().size());
 119
 120         final var providerPath = assertPath(result, PROVIDER_Q_NAME);
 121         assertEquals(5, providerPath.getPathArguments().size());
 122     }
 123
 124     @Override
 125     protected void assertMultipleChildren3(final List<YangInstanceIdentifier> result) {
 126         assertEquals(3, result.size());
 127
 128         final var instanceNamePath = assertPath(result, INSTANCE_NAME_Q_NAME);
 129         assertEquals(5, instanceNamePath.getPathArguments().size());
 130
 131         final var tosPath = assertPath(result, TYPE_OF_SERVICE_Q_NAME);
 132         assertEquals(3, tosPath.getPathArguments().size());
 133
 134         final var nextServicePath = assertPath(result, NEXT_SERVICE_Q_NAME);
 135         assertEquals(4, nextServicePath.getPathArguments().size());
 136     }
 137
 138     @Override
 139     protected void assertMultipleChildren4(final List<YangInstanceIdentifier> result) {
 140         assertEquals(4, result.size());
 141
 142         final var instanceNamePath = assertPath(result, INSTANCE_NAME_Q_NAME);
 143         assertEquals(5, instanceNamePath.getPathArguments().size());
 144
 145         final var tosPath = assertPath(result, TYPE_OF_SERVICE_Q_NAME);
 146         assertEquals(3, tosPath.getPathArguments().size());
 147
 148         final var nextServicePath = assertPath(result, NEXT_SERVICE_Q_NAME);
 149         assertEquals(4, nextServicePath.getPathArguments().size());
 150
 151         final var providerPath = assertPath(result, PROVIDER_Q_NAME);
 152         assertEquals(5, providerPath.getPathArguments().size());
 153     }
 154
 155     @Override
 156     protected void assertMultipleChildren5(final List<YangInstanceIdentifier> result) {
 157         assertEquals(4, result.size());
 158
 159         final var instanceNamePath = assertPath(result, INSTANCE_NAME_Q_NAME);
 160         assertEquals(5, instanceNamePath.getPathArguments().size());
 161
 162         final var tosPath = assertPath(result, TYPE_OF_SERVICE_Q_NAME);
 163         assertEquals(3, tosPath.getPathArguments().size());
 164
 165         final var nextServicePath = assertPath(result, NEXT_SERVICE_Q_NAME);
 166         assertEquals(4, nextServicePath.getPathArguments().size());
 167
 168         final var providerPath = assertPath(result, PROVIDER_Q_NAME);
 169         assertEquals(5, providerPath.getPathArguments().size());
 170     }
 171
 172     @Override
 173     protected void assertAugmentedChild(final List<YangInstanceIdentifier> result) {
 174         assertEquals(1, result.size());
 175         final var pathArguments = result.get(0).getPathArguments();
 176
 177         assertEquals(3, pathArguments.size());
 178         assertEquals(PLAYER_Q_NAME, pathArguments.get(0).getNodeType());
 179         assertThat(pathArguments.get(1), instanceOf(AugmentationIdentifier.class));
 180         assertEquals(SPEED_Q_NAME, pathArguments.get(2).getNodeType());
 181     }
 182
 183     @Override
 184     protected void assertListFieldUnderList(final List<YangInstanceIdentifier> result) {
 185         assertEquals(1, result.size());
 186         assertEquals(List.of(
 187             NodeIdentifier.create(SERVICES_Q_NAME),
 188             NodeIdentifierWithPredicates.of(SERVICES_Q_NAME),
 189             NodeIdentifier.create(INSTANCE_Q_NAME),
 190             NodeIdentifierWithPredicates.of(INSTANCE_Q_NAME)),
 191             result.get(0).getPathArguments());
 192     }
 193
 194     @Override
 195     protected void assertLeafList(final List<YangInstanceIdentifier> parsedFields) {
 196         assertEquals(1, parsedFields.size());
 197         assertEquals(List.of(new NodeIdentifier(PROTOCOLS_Q_NAME)), parsedFields.get(0).getPathArguments());
 198     }
 199
 200     @Override
 201     protected void assertDuplicateNodes1(final List<YangInstanceIdentifier> parsedFields) {
 202         assertEquals(4, parsedFields.size());
 203         assertEquals(
 204             Set.of(List.of(NodeIdentifier.create(BAR_Q_NAME), NodeIdentifier.create(ALPHA_Q_NAME)),
 205                 List.of(NodeIdentifier.create(BAR_Q_NAME), NodeIdentifier.create(BETA_Q_NAME),
 206                     NodeIdentifier.create(GAMMA_Q_NAME)),
 207                 List.of(NodeIdentifier.create(BAZ_Q_NAME), NodeIdentifierWithPredicates.of(BAZ_Q_NAME),
 208                     NodeIdentifier.create(ALPHA_Q_NAME)),
 209                 List.of(NodeIdentifier.create(BAZ_Q_NAME), NodeIdentifierWithPredicates.of(BAZ_Q_NAME),
 210                     NodeIdentifier.create(BETA_Q_NAME), NodeIdentifier.create(GAMMA_Q_NAME))),
 211             parsedFields.stream().map(YangInstanceIdentifier::getPathArguments).collect(Collectors.toSet()));
 212     }
 213
 214     @Override
 215     protected void assertDuplicateNodes2(final List<YangInstanceIdentifier> parsedFields) {
 216         assertEquals(4, parsedFields.size());
 217         assertEquals(
 218             Set.of(List.of(NodeIdentifier.create(BAR_Q_NAME), NodeIdentifier.create(ALPHA_Q_NAME)),
 219                 List.of(NodeIdentifier.create(BAR_Q_NAME), NodeIdentifier.create(BETA_Q_NAME),
 220                     NodeIdentifier.create(DELTA_Q_NAME)),
 221                 List.of(NodeIdentifier.create(BAZ_Q_NAME), NodeIdentifierWithPredicates.of(BAZ_Q_NAME),
 222                     NodeIdentifier.create(ALPHA_Q_NAME)),
 223                 List.of(NodeIdentifier.create(BAZ_Q_NAME), NodeIdentifierWithPredicates.of(BAZ_Q_NAME),
 224                     NodeIdentifier.create(BETA_Q_NAME), NodeIdentifier.create(EPSILON_Q_NAME))),
 225             parsedFields.stream().map(YangInstanceIdentifier::getPathArguments).collect(Collectors.toSet()));
 226     }
 227
 228     private static YangInstanceIdentifier assertPath(final List<YangInstanceIdentifier> paths, final QName lastArg) {
 229         return paths.stream()
 230             .filter(path -> lastArg.equals(path.getLastPathArgument().getNodeType()))
 231             .findAny()
 232             .orElseThrow(() -> new AssertionError("Path ending with " + lastArg + " not found"));
 233     }
 234 }