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