dom/mdsal-dom-inmemory-datastore/src/test/java/org/opendaylight/mdsal/dom/store/inmemory/WriteableNodeOperationTest.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.mdsal.dom.store.inmemory;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.mockito.Mockito.doNothing;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.mockito.Mockito.verify;
  14 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.DOM_DATA_TREE_WRITE_CURSOR;
  15 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.NORMALIZED_NODE;
  16 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.NORMALIZED_NODE_CONTAINER;
  17 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.PATH_ARGUMENT;
  18 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.WRITEABLE_MODIFICATION_NODE;
  19 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.WRITE_CURSOR_STRATEGY;
  20 import static org.opendaylight.mdsal.dom.store.inmemory.TestUtils.resetMocks;
  21
  22 import com.google.common.base.Optional;
  23 import java.util.Collection;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.Map;
  27 import org.junit.After;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  31 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  32 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
  33
  34 public class WriteableNodeOperationTest extends WriteableNodeOperation {
  35
  36     @Test
  37     public void enterTest() throws Exception {
  38         assertEquals(DOM_DATA_TREE_WRITE_CURSOR, this.getCursor());
  39
  40         returnNull();
  41         assertEquals(DOM_DATA_TREE_WRITE_CURSOR.toString(), this.enter(PATH_ARGUMENT).toString());
  42         verify(DOM_DATA_TREE_WRITE_CURSOR).enter(PATH_ARGUMENT);
  43         verify(WRITEABLE_MODIFICATION_NODE).getChild(PATH_ARGUMENT);
  44
  45         returnNoNull();
  46         this.enter(PATH_ARGUMENT);
  47         verify(WRITEABLE_MODIFICATION_NODE).createOperation(DOM_DATA_TREE_WRITE_CURSOR);
  48     }
  49
  50     @Test
  51     public void writeTest() throws Exception {
  52         returnNull();
  53         this.write(PATH_ARGUMENT, NORMALIZED_NODE);
  54         verify(DOM_DATA_TREE_WRITE_CURSOR).write(PATH_ARGUMENT, NORMALIZED_NODE);
  55
  56         returnNoNull(NORMALIZED_NODE_CONTAINER);
  57         this.write(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
  58         verify(WRITE_CURSOR_STRATEGY).writeToCurrent(NORMALIZED_NODE_CONTAINER);
  59     }
  60
  61     @Test
  62     public void writeToCurrentTest() throws Exception {
  63         returnNull();
  64         Map<PathArgument, WriteableModificationNode> childrenWithSubShards = new HashMap<>();
  65         childrenWithSubShards.put(PATH_ARGUMENT, WRITEABLE_MODIFICATION_NODE);
  66         doReturn(childrenWithSubShards).when(WRITEABLE_MODIFICATION_NODE).getChildrenWithSubshards();
  67         doReturn(Optional.of(NORMALIZED_NODE)).when(NORMALIZED_NODE_CONTAINER).getChild(PATH_ARGUMENT);
  68         this.writeToCurrent(NORMALIZED_NODE_CONTAINER);
  69         verify(DOM_DATA_TREE_WRITE_CURSOR).delete(PATH_ARGUMENT);
  70         verify(DOM_DATA_TREE_WRITE_CURSOR).exit();
  71     }
  72
  73     @Test
  74     public void mergeTest() throws Exception {
  75         returnNull();
  76         this.merge(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
  77         verify(DOM_DATA_TREE_WRITE_CURSOR).merge(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
  78
  79         returnNoNull(NORMALIZED_NODE_CONTAINER);
  80         this.merge(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
  81         verify(WRITE_CURSOR_STRATEGY).mergeToCurrent(NORMALIZED_NODE_CONTAINER);
  82     }
  83
  84     @Test
  85     public void deleteTest() throws Exception {
  86         returnNoNull();
  87         this.delete(PATH_ARGUMENT);
  88         verify(DOM_DATA_TREE_WRITE_CURSOR).delete(PATH_ARGUMENT);
  89         verify(WRITEABLE_MODIFICATION_NODE).markDeleted();
  90     }
  91
  92     @Test(expected = UnsupportedOperationException.class)
  93     public void mergeToCurrentTestWithException() throws Exception {
  94         returnNoNull();
  95         this.mergeToCurrent(NORMALIZED_NODE_CONTAINER);
  96     }
  97
  98     @Test
  99     public void mergeToCurrentTest() throws Exception {
 100         returnNull();
 101         this.mergeToCurrent(NORMALIZED_NODE_CONTAINER);
 102         verify(DOM_DATA_TREE_WRITE_CURSOR).merge(PATH_ARGUMENT, NORMALIZED_NODE);
 103     }
 104
 105     private static void returnNull() {
 106         doReturn(null).when(WRITEABLE_MODIFICATION_NODE).getChild(PATH_ARGUMENT);
 107         doReturn(null).when(WRITEABLE_MODIFICATION_NODE).createOperation(DOM_DATA_TREE_WRITE_CURSOR);
 108     }
 109
 110     private static void returnNoNull() {
 111         returnNoNull(null);
 112     }
 113
 114     private static void returnNoNull(NormalizedNodeContainer normalizedNode) {
 115         if (normalizedNode != null) {
 116             doNothing().when(WRITE_CURSOR_STRATEGY).writeToCurrent(normalizedNode);
 117             doNothing().when(WRITE_CURSOR_STRATEGY).mergeToCurrent(normalizedNode);
 118             doReturn(WRITE_CURSOR_STRATEGY)
 119                     .when(WRITEABLE_MODIFICATION_NODE).createOperation(DOM_DATA_TREE_WRITE_CURSOR);
 120         }
 121
 122         doReturn(WRITEABLE_MODIFICATION_NODE).when(WRITEABLE_MODIFICATION_NODE).getChild(PATH_ARGUMENT);
 123         doNothing().when(WRITEABLE_MODIFICATION_NODE).markDeleted();
 124     }
 125
 126     @Before
 127     public void setUp() {
 128         final Collection<NormalizedNode> collectionNodes = new HashSet<>();
 129         doReturn("testArgument").when(PATH_ARGUMENT).toString();
 130         doReturn("testCursor").when(DOM_DATA_TREE_WRITE_CURSOR).toString();
 131         doReturn("testNode").when(NORMALIZED_NODE).toString();
 132         doReturn("testNodeContainer").when(NORMALIZED_NODE_CONTAINER).toString();
 133         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).enter(PATH_ARGUMENT);
 134         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).write(PATH_ARGUMENT, NORMALIZED_NODE);
 135         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).write(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
 136         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).merge(PATH_ARGUMENT, NORMALIZED_NODE);
 137         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).merge(PATH_ARGUMENT, NORMALIZED_NODE_CONTAINER);
 138         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).delete(PATH_ARGUMENT);
 139         doNothing().when(DOM_DATA_TREE_WRITE_CURSOR).exit();
 140
 141         collectionNodes.add(NORMALIZED_NODE);
 142         doReturn(collectionNodes).when(NORMALIZED_NODE_CONTAINER).getValue();
 143         doReturn(PATH_ARGUMENT).when(NORMALIZED_NODE_CONTAINER).getIdentifier();
 144         doReturn(PATH_ARGUMENT).when(NORMALIZED_NODE).getIdentifier();
 145     }
 146
 147     @After
 148     public void reset() {
 149         resetMocks();
 150     }
 151
 152     public WriteableNodeOperationTest(){
 153         super(WRITEABLE_MODIFICATION_NODE, DOM_DATA_TREE_WRITE_CURSOR);
 154     }
 155
 156     @Override
 157     public void exit() {
 158         // NOOP
 159     }
 160 }