yang/yang-data-api/src/test/java/org/opendaylight/yangtools/yang/data/api/schema/tree/DataTreeCandidatesTest.java

   1 /*
   2  * Copyright (c) 2016 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.api.schema.tree;
  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.junit.Assert.fail;
  15 import static org.mockito.ArgumentMatchers.any;
  16 import static org.mockito.ArgumentMatchers.isNull;
  17 import static org.mockito.Mockito.doReturn;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21
  22 import com.google.common.collect.ImmutableList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.Optional;
  26 import org.junit.Test;
  27 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  28 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  29 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  30
  31 public class DataTreeCandidatesTest {
  32
  33     @Test
  34     public void testNewDataTreeCandidate() {
  35         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
  36         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
  37         final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.newDataTreeCandidate(mockedRootPath,
  38                 mockedDataTreeCandidateNode);
  39
  40         assertNotNull(dataTreeCandidate);
  41         assertTrue(dataTreeCandidate instanceof DefaultDataTreeCandidate);
  42         assertEquals(mockedRootPath, dataTreeCandidate.getRootPath());
  43         assertEquals(mockedDataTreeCandidateNode, dataTreeCandidate.getRootNode());
  44         assertTrue(dataTreeCandidate.toString().contains(
  45                 "DefaultDataTreeCandidate{rootPath=/, rootNode=Mock for DataTreeCandidateNode, hashCode: "));
  46     }
  47
  48     @Test
  49     public void testFromNormalizedNode() {
  50         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
  51         final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
  52         final DataTreeCandidate dataTreeCandidate = DataTreeCandidates.fromNormalizedNode(mockedRootPath,
  53                 mockedNormalizedNode);
  54
  55         assertNotNull(dataTreeCandidate);
  56         assertTrue(dataTreeCandidate instanceof DefaultDataTreeCandidate);
  57         assertEquals(mockedRootPath, dataTreeCandidate.getRootPath());
  58         assertTrue(dataTreeCandidate.getRootNode() instanceof NormalizedNodeDataTreeCandidateNode);
  59     }
  60
  61     @Test
  62     public void testApplyToCursor() {
  63         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
  64         final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
  65
  66         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
  67         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
  68         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
  69         DataTreeCandidates.applyToCursor(mockedCursor, mockedDataTreeCandidate);
  70         verify(mockedCursor, times(1)).delete(isNull());
  71     }
  72
  73     @Test
  74     public void testApplyToCursorAwareModification() {
  75         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
  76         final CursorAwareDataTreeModification mockedModification = mock(CursorAwareDataTreeModification.class);
  77
  78         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
  79         doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
  80         final DataTreeModificationCursor mockedCursor = mock(DataTreeModificationCursor.class);
  81         doReturn(Optional.of(mockedCursor)).when(mockedModification).openCursor(isNull());
  82         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
  83         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
  84
  85         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
  86
  87         DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
  88         verify(mockedModification, times(1)).openCursor(isNull());
  89         verify(mockedCursor, times(1)).delete(isNull());
  90
  91         doReturn(Boolean.TRUE).when(mockedRootPath).isEmpty();
  92         try {
  93             DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
  94             fail("An IllegalArgumentException should have been thrown!");
  95         } catch (IllegalArgumentException ex) {
  96             assertTrue(ex.getMessage().contains("Can not delete root"));
  97         }
  98     }
  99
 100     @Test
 101     public void testApplyToModificationWithDeleteModificationType() {
 102         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
 103         final DataTreeModification mockedModification = mock(DataTreeModification.class);
 104
 105         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
 106         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
 107         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
 108         doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
 109
 110         doReturn(ModificationType.DELETE).when(mockedDataTreeCandidateNode).getModificationType();
 111
 112         DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
 113         verify(mockedModification, times(1)).delete(any(YangInstanceIdentifier.class));
 114     }
 115
 116     @Test
 117     public void testApplyToModificationWithWriteModificationType() {
 118         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
 119         final DataTreeModification mockedModification = mock(DataTreeModification.class);
 120
 121         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
 122         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
 123         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
 124         doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
 125         final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
 126         doReturn(Optional.of(mockedNormalizedNode)).when(mockedDataTreeCandidateNode).getDataAfter();
 127
 128         doReturn(ModificationType.WRITE).when(mockedDataTreeCandidateNode).getModificationType();
 129
 130         DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
 131         verify(mockedModification, times(1)).write(any(YangInstanceIdentifier.class), any(NormalizedNode.class));
 132     }
 133
 134     @Test
 135     public void testApplyToModificationWithSubtreeModifiedModificationType() {
 136         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
 137         final DataTreeModification mockedModification = mock(DataTreeModification.class);
 138
 139         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
 140         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
 141         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
 142         doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
 143
 144         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedDataTreeCandidateNode).getModificationType();
 145
 146         final DataTreeCandidateNode mockedChildNode1 = mock(DataTreeCandidateNode.class);
 147         doReturn(ModificationType.DELETE).when(mockedChildNode1).getModificationType();
 148         final PathArgument mockedPathArgument1 = mock(PathArgument.class);
 149         doReturn(mockedPathArgument1).when(mockedChildNode1).getIdentifier();
 150
 151         final DataTreeCandidateNode mockedChildNode2 = mock(DataTreeCandidateNode.class);
 152         doReturn(ModificationType.WRITE).when(mockedChildNode2).getModificationType();
 153         final NormalizedNode<?, ?> mockedNormalizedNode = mock(NormalizedNode.class);
 154         doReturn(Optional.of(mockedNormalizedNode)).when(mockedChildNode2).getDataAfter();
 155         final PathArgument mockedPathArgument2 = mock(PathArgument.class);
 156         doReturn(mockedPathArgument2).when(mockedChildNode2).getIdentifier();
 157
 158         final DataTreeCandidateNode mockedChildNode3 = mock(DataTreeCandidateNode.class);
 159         doReturn(ModificationType.SUBTREE_MODIFIED).when(mockedChildNode3).getModificationType();
 160         final PathArgument mockedPathArgument3 = mock(PathArgument.class);
 161         doReturn(mockedPathArgument3).when(mockedChildNode3).getIdentifier();
 162         final DataTreeCandidateNode mockedChildNode3ChildNode = mock(DataTreeCandidateNode.class);
 163         doReturn(ModificationType.DELETE).when(mockedChildNode3ChildNode).getModificationType();
 164         final PathArgument mockedPathArgument31 = mock(PathArgument.class);
 165         doReturn(mockedPathArgument3).when(mockedChildNode3).getIdentifier();
 166         doReturn(mockedPathArgument31).when(mockedChildNode3ChildNode).getIdentifier();
 167         doReturn(Collections.singletonList(mockedChildNode3ChildNode)).when(mockedChildNode3).getChildNodes();
 168
 169         final Collection<DataTreeCandidateNode> childNodes = ImmutableList.of(mockedChildNode1, mockedChildNode2,
 170                 mockedChildNode3);
 171         doReturn(childNodes).when(mockedDataTreeCandidateNode).getChildNodes();
 172
 173         DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
 174         verify(mockedModification, times(2)).delete(any(YangInstanceIdentifier.class));
 175         verify(mockedModification, times(1)).write(any(YangInstanceIdentifier.class), any(NormalizedNode.class));
 176     }
 177
 178     @Test
 179     public void testApplyToModificationWithUnsupportedModificationType() {
 180         final DataTreeCandidate mockedDataTreeCandidate = mock(DataTreeCandidate.class);
 181         final DataTreeModification mockedModification = mock(DataTreeModification.class);
 182
 183         final DataTreeCandidateNode mockedDataTreeCandidateNode = mock(DataTreeCandidateNode.class);
 184         doReturn(mockedDataTreeCandidateNode).when(mockedDataTreeCandidate).getRootNode();
 185         final YangInstanceIdentifier mockedRootPath = mock(YangInstanceIdentifier.class);
 186         doReturn(mockedRootPath).when(mockedDataTreeCandidate).getRootPath();
 187
 188         doReturn(ModificationType.APPEARED).when(mockedDataTreeCandidateNode).getModificationType();
 189
 190         try {
 191             DataTreeCandidates.applyToModification(mockedModification, mockedDataTreeCandidate);
 192             fail("An IllegalArgumentException should have been thrown!");
 193         } catch (IllegalArgumentException ex) {
 194             assertTrue(ex.getMessage().contains("Unsupported modification"));
 195         }
 196     }
 197 }