Adopt odlparent-10.0.0/yangtools-8.0.0-SNAPSHOT

[mdsal.git] / dom / mdsal-dom-spi / src / test / java / org / opendaylight / mdsal / dom / spi / store / SnapshotBackedWriteTransactionTest.java

diff --git a/dom/mdsal-dom-spi/src/test/java/org/opendaylight/mdsal/dom/spi/store/SnapshotBackedWriteTransactionTest.java b/dom/mdsal-dom-spi/src/test/java/org/opendaylight/mdsal/dom/spi/store/SnapshotBackedWriteTransactionTest.java
index 3035fa2166883bde37d08dc41dcbbeeed352661b..ae8ce6c3f5603ab04326f529154fc55ccd0beddb 100644 (file)
--- a/dom/mdsal-dom-spi/src/test/java/org/opendaylight/mdsal/dom/spi/store/SnapshotBackedWriteTransactionTest.java
+++ b/dom/mdsal-dom-spi/src/test/java/org/opendaylight/mdsal/dom/spi/store/SnapshotBackedWriteTransactionTest.java
@@ -9,7 +9,10 @@ package org.opendaylight.mdsal.dom.spi.store;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.doThrow;
@@ -17,15 +20,15 @@ import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 
 import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
+import java.util.Optional;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.opendaylight.mdsal.dom.spi.store.SnapshotBackedWriteTransaction.TransactionReadyPrototype;
 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeModification;
-import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeModification;
+import org.opendaylight.yangtools.yang.data.tree.api.DataTreeSnapshot;
 
 public class SnapshotBackedWriteTransactionTest {
 
@@ -36,8 +39,8 @@ public class SnapshotBackedWriteTransactionTest {
     private static final DOMStoreThreePhaseCommitCohort DOM_STORE_THREE_PHASE_COMMIT_COHORT =
             mock(DOMStoreThreePhaseCommitCohort.class);
     private static final NormalizedNode NORMALIZED_NODE = mock(NormalizedNode.class);
-    private static final Optional NORMALIZED_NODE_OPTIONAL = Optional.of(NORMALIZED_NODE);
-    private static SnapshotBackedWriteTransaction snapshotBackedWriteTransaction;
+    private static final Optional<NormalizedNode> NORMALIZED_NODE_OPTIONAL = Optional.of(NORMALIZED_NODE);
+    private static SnapshotBackedWriteTransaction<Object> snapshotBackedWriteTransaction;
 
     @Before
     public void setUp() throws Exception {
@@ -49,25 +52,27 @@ public class SnapshotBackedWriteTransactionTest {
         doNothing().when(TRANSACTION_READY_PROTOTYPE).transactionAborted(any());
         doReturn("testDataTreeModification").when(DATA_TREE_MODIFICATION).toString();
         doReturn("testNormalizedNode").when(NORMALIZED_NODE).toString();
-        doReturn(DOM_STORE_THREE_PHASE_COMMIT_COHORT).when(TRANSACTION_READY_PROTOTYPE).transactionReady(any(),any());
-        doReturn(NORMALIZED_NODE_OPTIONAL).when(DATA_TREE_MODIFICATION).readNode(YangInstanceIdentifier.EMPTY);
+        doReturn(DOM_STORE_THREE_PHASE_COMMIT_COHORT)
+                .when(TRANSACTION_READY_PROTOTYPE)
+                .transactionReady(any(),any(), any());
+        doReturn(NORMALIZED_NODE_OPTIONAL).when(DATA_TREE_MODIFICATION).readNode(YangInstanceIdentifier.empty());
         snapshotBackedWriteTransaction = new SnapshotBackedWriteTransaction<>(new Object(), false, DATA_TREE_SNAPSHOT,
                 TRANSACTION_READY_PROTOTYPE);
     }
 
     @Test
     public void basicTest() throws Exception {
-        snapshotBackedWriteTransaction.write(YangInstanceIdentifier.EMPTY, NORMALIZED_NODE);
+        snapshotBackedWriteTransaction.write(YangInstanceIdentifier.empty(), NORMALIZED_NODE);
         verify(DATA_TREE_MODIFICATION).write(any(), any());
 
-        snapshotBackedWriteTransaction.merge(YangInstanceIdentifier.EMPTY, NORMALIZED_NODE);
+        snapshotBackedWriteTransaction.merge(YangInstanceIdentifier.empty(), NORMALIZED_NODE);
         verify(DATA_TREE_MODIFICATION).merge(any(), any());
 
-        snapshotBackedWriteTransaction.delete(YangInstanceIdentifier.EMPTY);
+        snapshotBackedWriteTransaction.delete(YangInstanceIdentifier.empty());
         verify(DATA_TREE_MODIFICATION).delete(any());
 
         assertEquals(NORMALIZED_NODE_OPTIONAL,
-                snapshotBackedWriteTransaction.readSnapshotNode(YangInstanceIdentifier.EMPTY));
+                snapshotBackedWriteTransaction.readSnapshotNode(YangInstanceIdentifier.empty()));
         verify(DATA_TREE_MODIFICATION).readNode(any());
 
         assertTrue(snapshotBackedWriteTransaction.addToStringAttributes(
@@ -77,30 +82,43 @@ public class SnapshotBackedWriteTransactionTest {
 
     @Test
     public void readyTest() throws Exception {
-        SnapshotBackedWriteTransaction snapshotBackedWriteTransaction =
-                new SnapshotBackedWriteTransaction<>(
-                        new Object(), false, DATA_TREE_SNAPSHOT, TRANSACTION_READY_PROTOTYPE);
+        SnapshotBackedWriteTransaction<Object> tx = new SnapshotBackedWriteTransaction<>(new Object(), false,
+                DATA_TREE_SNAPSHOT, TRANSACTION_READY_PROTOTYPE);
+        Assert.assertNotNull(tx.ready());
+        verify(TRANSACTION_READY_PROTOTYPE).transactionReady(any(), any(), eq(null));
+        tx.close();
+    }
+
+    @Test
+    public void readyWithException() {
+        Exception thrown = new RuntimeException();
+        doThrow(thrown).when(DATA_TREE_MODIFICATION).ready();
         Assert.assertNotNull(snapshotBackedWriteTransaction.ready());
-        verify(TRANSACTION_READY_PROTOTYPE).transactionReady(any(), any());
-        snapshotBackedWriteTransaction.close();
+        verify(TRANSACTION_READY_PROTOTYPE).transactionReady(any(), any(), same(thrown));
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void writeWithException() throws Exception {
-        doThrow(TestException.class).when(DATA_TREE_MODIFICATION).write(any(), any());
-        snapshotBackedWriteTransaction.write(YangInstanceIdentifier.EMPTY, NORMALIZED_NODE);
+        doAnswer(inv -> {
+            throw new TestException();
+        }).when(DATA_TREE_MODIFICATION).write(any(), any());
+        snapshotBackedWriteTransaction.write(YangInstanceIdentifier.empty(), NORMALIZED_NODE);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void mergeWithException() throws Exception {
-        doThrow(TestException.class).when(DATA_TREE_MODIFICATION).merge(any(), any());
-        snapshotBackedWriteTransaction.merge(YangInstanceIdentifier.EMPTY, NORMALIZED_NODE);
+        doAnswer(inv -> {
+            throw new TestException();
+        }).when(DATA_TREE_MODIFICATION).merge(any(), any());
+        snapshotBackedWriteTransaction.merge(YangInstanceIdentifier.empty(), NORMALIZED_NODE);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void deleteWithException() throws Exception {
-        doThrow(TestException.class).when(DATA_TREE_MODIFICATION).delete(any());
-        snapshotBackedWriteTransaction.delete(YangInstanceIdentifier.EMPTY);
+        doAnswer(inv -> {
+            throw new TestException();
+        }).when(DATA_TREE_MODIFICATION).delete(any());
+        snapshotBackedWriteTransaction.delete(YangInstanceIdentifier.empty());
     }
 
     private static final class TestException extends Exception {