Code Review / openflowplugin.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
Migrate openflowplugim-impl tests to uint types
[openflowplugin.git] / openflowplugin-impl / src / test / java / org / opendaylight / openflowplugin / impl / device / DeviceManagerImplTest.java
diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java
index fbb1165834b90131d4708b36381d46b107dbe106..f64100a67d801844b3c55d88fb3cbc9315a678b2 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/device/DeviceManagerImplTest.java
@@ -5,39 +5,37 @@
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
  * and is available at http://www.eclipse.org/legal/epl-v10.html
  */
-
 package org.opendaylight.openflowplugin.impl.device;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.FluentFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import io.netty.util.HashedWheelTimer;
 import java.lang.reflect.Field;
-import java.math.BigInteger;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.NotificationPublishService;
+import org.opendaylight.mdsal.binding.api.TransactionChain;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
@@ -59,20 +57,23 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint16Type;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.NonZeroUint32Type;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfigBuilder;
+import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
 
 @RunWith(MockitoJUnitRunner.class)
 public class DeviceManagerImplTest {
 
-    private static final long TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA = 2000L;
-    private static final int BARRIER_COUNT_LIMIT = 25600;
-    private static final long BARRIER_INTERVAL_NANOS = 500;
+    private static final Uint32 TEST_VALUE_GLOBAL_NOTIFICATION_QUOTA = Uint32.valueOf(2000);
+    private static final Uint16 BARRIER_COUNT_LIMIT = Uint16.valueOf(25600);
+    private static final Uint32 BARRIER_INTERVAL_NANOS = Uint32.valueOf(500);
     private static final NodeId DUMMY_NODE_ID = new NodeId("dummyNodeId");
     private static final KeyedInstanceIdentifier<Node, NodeKey> DUMMY_IDENTIFIER  = DeviceStateUtil
             .createNodeInstanceIdentifier(DUMMY_NODE_ID);
 
     @Mock
-    private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
+    private FluentFuture<CommitInfo> mockedFuture;
     @Mock
     private FeaturesReply mockFeatures;
     @Mock
@@ -92,7 +93,7 @@ public class DeviceManagerImplTest {
     @Mock
     private WriteTransaction writeTransaction;
     @Mock
-    private BindingTransactionChain transactionChain;
+    private TransactionChain transactionChain;
     @Mock
     private Capabilities capabilities;
     @Mock
@@ -101,27 +102,21 @@ public class DeviceManagerImplTest {
     private NotificationPublishService notificationPublishService;
     @Mock
     private TranslatorLibrary translatorLibrary;
+    @Mock
+    private ExecutorService executorService;
 
     private DeviceManagerImpl deviceManager;
 
     @Before
-    public void setUp() throws Exception {
-        when(mockConnectionContext.getNodeId()).thenReturn(DUMMY_NODE_ID);
+    public void setUp() {
         when(mockConnectionContext.getFeatures()).thenReturn(mockFeatures);
         when(mockConnectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
         when(mockConnectionContext.getDeviceInfo()).thenReturn(deviceInfo);
-        when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockConnectionContext);
         when(deviceInfo.getNodeInstanceIdentifier()).thenReturn(DUMMY_IDENTIFIER);
         when(deviceInfo.getNodeId()).thenReturn(DUMMY_NODE_ID);
 
-        when(mockFeatures.getCapabilities()).thenReturn(capabilities);
-        when(mockFeatures.getCapabilitiesV10()).thenReturn(capabilitiesV10);
-        when(mockFeatures.getDatapathId()).thenReturn(BigInteger.valueOf(21L));
-
         when(mockedFuture.isDone()).thenReturn(true);
-        when(writeTransaction.submit()).thenReturn(mockedFuture);
-        when(transactionChain.newWriteOnlyTransaction()).thenReturn(writeTransaction);
-        when(dataBroker.createTransactionChain(any(TransactionChainListener.class))).thenReturn(transactionChain);
+        doReturn(mockedFuture).when(writeTransaction).commit();
         when(dataBroker.newWriteOnlyTransaction()).thenReturn(writeTransaction);
 
         deviceManager = new DeviceManagerImpl(
@@ -133,22 +128,24 @@ public class DeviceManagerImplTest {
                         .setEnableFlowRemovedNotification(true)
                         .setSkipTableFeatures(false)
                         .setUseSingleLayerSerialization(true)
+                        .setIsStatisticsPollingOn(false)
                         .build(),
                 dataBroker,
                 messageIntelligenceAgency,
                 notificationPublishService,
                 new HashedWheelTimer(),
                 convertorExecutor,
-                DeviceInitializerProviderFactory.createDefaultProvider());
+                DeviceInitializerProviderFactory.createDefaultProvider(),
+                executorService);
 
         deviceManager.setTranslatorLibrary(translatorLibrary);
         verify(dataBroker).newWriteOnlyTransaction();
         verify(writeTransaction).merge(eq(LogicalDatastoreType.OPERATIONAL), any(), any());
-        verify(writeTransaction).submit();
+        verify(writeTransaction).commit();
     }
 
     @Test
-    public void createContext() throws Exception {
+    public void createContext() {
         final DeviceContext context = deviceManager.createContext(mockConnectionContext);
         assertEquals(deviceInfo, context.getDeviceInfo());
 
@@ -156,7 +153,7 @@ public class DeviceManagerImplTest {
 
     @Test
     public void removeDeviceFromOperationalDS() throws Exception {
-        final ListenableFuture<Void> future = deviceManager
+        final ListenableFuture<?> future = deviceManager
                 .removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
 
         future.get();
@@ -166,19 +163,17 @@ public class DeviceManagerImplTest {
 
     @Test(expected = ExecutionException.class)
     public void removeDeviceFromOperationalDSException() throws Exception {
-        final CheckedFuture<Void, TransactionCommitFailedException> failedFuture =
-                Futures.immediateFailedCheckedFuture(
-                        new TransactionCommitFailedException("Test failed transaction", null, null));
-        Mockito.when(writeTransaction.submit()).thenReturn(failedFuture);
-        final ListenableFuture<Void> future = deviceManager
-                .removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
+        final FluentFuture<?> failedFuture = FluentFutures.immediateFailedFluentFuture(
+                        new ExecutionException(new Throwable("Test failed transaction")));
+        Mockito.doReturn(failedFuture).when(writeTransaction).commit();
+        final ListenableFuture<?> future = deviceManager.removeDeviceFromOperationalDS(DUMMY_IDENTIFIER);
         future.get();
         assertTrue(future.isDone());
         verify(writeTransaction).delete(LogicalDatastoreType.OPERATIONAL, DUMMY_IDENTIFIER);
     }
 
     @Test
-    public void sendNodeAddedNotification() throws Exception {
+    public void sendNodeAddedNotification() {
         deviceManager.sendNodeAddedNotification(DUMMY_IDENTIFIER);
         deviceManager.sendNodeAddedNotification(DUMMY_IDENTIFIER);
         verify(notificationPublishService).offerNotification(new NodeUpdatedBuilder()
@@ -188,7 +183,7 @@ public class DeviceManagerImplTest {
     }
 
     @Test
-    public void sendNodeRemovedNotification() throws Exception {
+    public void sendNodeRemovedNotification() {
         deviceManager.sendNodeAddedNotification(DUMMY_IDENTIFIER);
         deviceManager.sendNodeRemovedNotification(DUMMY_IDENTIFIER);
         deviceManager.sendNodeRemovedNotification(DUMMY_IDENTIFIER);
OpenFlow Plugin