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);
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 =
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);
}
public void onFailure(Throwable error) {
LOG.error("Error in Datastore write operation", error);
- };
+ }
};
-
}
--- /dev/null
+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;
+ }
+}
+