JUnit for IdManager

Signed-off-by: Dimple Jain <dimple.jain@ericsson.com>
Change-Id: Iefd165f9a23359a443edfa4994687fe0dd3aab77

diff --git a/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java b/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
index 7eb3bd3a0ad1e16b3132303a7f6c942af5dbd7a0..a57086a42cab68bf2dbe15c6c5061c7414b09ac5 100644 (file)
--- a/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
+++ b/idmanager/idmanager-impl/src/main/java/org/opendaylight/idmanager/IdManager.java
@@ -72,14 +72,14 @@ public class IdManager implements IdManagerService, AutoCloseable{
         return result;
     }
 
-    private <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
+    protected  <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
                                                    InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
         WriteTransaction tx = broker.newWriteOnlyTransaction();
         tx.put(datastoreType, path, data, true);
         Futures.addCallback(tx.submit(), callback);
     }
 
-    private <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
+    protected  <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
                                                     InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
         WriteTransaction tx = broker.newWriteOnlyTransaction();
         tx.merge(datastoreType, path, data, true);
@@ -95,7 +95,7 @@ public class IdManager implements IdManagerService, AutoCloseable{
         long poolSize = input.getPoolSize().longValue();
         RpcResultBuilder<Void> rpcResultBuilder;
 
-        LOG.debug("poolName: %s, startIndx: %d , poolSize: %d ", poolName, startIndx,  poolSize);
+        LOG.debug("poolName: {}, startIndx: {} , poolSize: {} ", poolName, startIndx,  poolSize);
 
         try {
             InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
@@ -146,9 +146,9 @@ public class IdManager implements IdManagerService, AutoCloseable{
                     generatedIds = new ArrayList<GeneratedIds>();
                 }
                 if (!generatedIds.isEmpty()) {
-                    for (GeneratedIds gen_id : generatedIds) {
-                        if (gen_id.getIdKey().equals(idKey)) {
-                            newIdValue = gen_id.getIdValue();
+                    for (GeneratedIds genId : generatedIds) {
+                        if (genId.getIdKey().equals(idKey)) {
+                            newIdValue = genId.getIdValue();
                             LOG.debug("Existing id {} for the key {} ", idKey, newIdValue);
                         }
 
@@ -197,7 +197,6 @@ public class IdManager implements IdManagerService, AutoCloseable{
 
             public void onFailure(Throwable error) {
                 LOG.error("Error in Datastore write operation", error);
-            };
+            }
         };
-
 }

diff --git a/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java b/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java
new file mode 100644 (file)
index 0000000..7002c7b
--- /dev/null
+++ b/idmanager/idmanager-impl/src/test/java/org/opendaylight/idmanager/test/IdManagerTest.java
@@ -0,0 +1,146 @@
+package org.opendaylight.idmanager.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.when;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.idmanager.IdManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.*;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPool;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.IdPoolKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.idmanager.rev150403.pools.id.pool.GeneratedIds;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.math.BigInteger;
+import java.util.*;
+import java.util.concurrent.Future;
+
+
+@RunWith(MockitoJUnitRunner.class)
+public class IdManagerTest {
+    private static final Logger LOG = LoggerFactory.getLogger(IdManagerTest.class);
+    Map<InstanceIdentifier<?>,DataObject> written = new HashMap<>();
+    Map<InstanceIdentifier<?>,DataObject> updated = new HashMap<>();
+    @Mock DataBroker dataBroker;
+    @Mock ReadOnlyTransaction mockReadTx;
+    @Mock WriteTransaction mockWriteTx;
+    CreateIdPoolInput createPoolTest;
+    GetUniqueIdInput  getIdInputTest;
+    IdManager idManager;
+    IdPool idPoolTest;
+    InstanceIdentifier<IdPool> identifier;
+
+    @Before
+    public void setUp() throws Exception {
+
+        idManager = new IdManager(dataBroker) {
+            protected  <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
+                                                             InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
+                written.put(path, data);
+            }
+            protected  <T extends DataObject> void asyncUpdate(LogicalDatastoreType datastoreType,
+                                                              InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
+                updated.put(path, data);
+            }
+
+        };
+        setupMocks();
+    }
+
+    private void setupMocks() {
+        createPoolTest = buildCreateIdPool("vpn", 100, 100);
+        getIdInputTest = buildUniqueId("vpn", "vpn1");
+        idPoolTest = buildIdPool("vpn", 100, 100);
+        identifier = buildInstanceIdentifier("vpn");
+        when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
+        when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
+    }
+
+    @Test
+    public void testCreateIdPool()
+    {
+        doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(
+                LogicalDatastoreType.OPERATIONAL, identifier);
+
+        Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
+        Collection<DataObject> idPoolVal  = new ArrayList< >();
+        idPoolVal = written.values();
+        assertEquals(1,written.size());
+            for (DataObject poolData: idPoolVal) {
+                IdPool pool = null;
+                if (poolData instanceof IdPool) {
+                    pool = (IdPool) poolData;
+                    assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
+                    assertEquals(createPoolTest.getIdStart(), pool.getIdStart());
+                    assertEquals(createPoolTest.getPoolSize(), pool.getPoolSize());
+                }
+            }
+    }
+
+    @Test
+    public void testUniqueId()
+    {
+        Optional<IdPool> expected = Optional.of(idPoolTest);
+        doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
+                LogicalDatastoreType.OPERATIONAL, identifier);
+
+        idManager.getUniqueId(getIdInputTest);
+        Collection<DataObject> idPoolVal  = new ArrayList< >();
+        idPoolVal = updated.values();
+        assertEquals(1,updated.size());
+            for (DataObject poolData: idPoolVal) {
+                IdPool pool = null;
+                if (poolData instanceof IdPool) {
+                    pool = (IdPool) poolData;
+                    assertEquals(getIdInputTest.getPoolName(), pool.getPoolName());
+                    List <GeneratedIds> genIds = pool.getGeneratedIds();
+                    assertEquals(1,genIds.size());
+                }
+            }
+    }
+
+    private CreateIdPoolInput buildCreateIdPool(String poolName, long idStart, long poolSize) {
+        CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
+                .setIdStart(idStart)
+                .setPoolSize(BigInteger.valueOf(poolSize))
+                .build();
+        return createPool;
+    }
+
+    private IdPool buildIdPool(String poolName, long idStart, long poolSize) {
+        IdPool idPool = new IdPoolBuilder().setPoolName(poolName)
+                .setIdStart(idStart)
+                .setPoolSize(BigInteger.valueOf(poolSize))
+                .build();
+        return idPool;
+    }
+
+    private GetUniqueIdInput buildUniqueId(String poolName, String idKey) {
+        GetUniqueIdInput getIdInput = new GetUniqueIdInputBuilder().setPoolName(poolName)
+                .setIdKey(idKey).build();
+        return getIdInput;
+    }
+
+    private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName){
+        InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
+                InstanceIdentifier.builder(Pools.class).child(IdPool.class, new IdPoolKey(poolName));
+        InstanceIdentifier<IdPool> id = idBuilder.build();
+        return id;
+    }
+}
+