idmanager/idmanager-impl/src/test/java/org/opendaylight/genius/idmanager/test/IdManagerTest.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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.genius.idmanager.test;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.mockito.Matchers.any;
  13 import static org.mockito.Matchers.anyObject;
  14 import static org.mockito.Matchers.eq;
  15 import static org.mockito.Mockito.doAnswer;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.when;
  18
  19 import com.google.common.base.Optional;
  20 import com.google.common.util.concurrent.Futures;
  21 import java.net.UnknownHostException;
  22 import java.util.ArrayList;
  23 import java.util.Arrays;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.concurrent.Future;
  28 import org.junit.Before;
  29 import org.junit.Ignore;
  30 import org.junit.Test;
  31 import org.junit.runner.RunWith;
  32 import org.mockito.Matchers;
  33 import org.mockito.Mock;
  34 import org.mockito.runners.MockitoJUnitRunner;
  35 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  36 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  37 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  38 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  39 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  40 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  41 import org.opendaylight.genius.idmanager.IdManager;
  42 import org.opendaylight.genius.idmanager.IdUtils;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInput;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.CreateIdPoolInputBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.DeleteIdPoolInputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPoolsBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.AvailableIdsHolderBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPools;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ChildPoolsKey;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntries;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.IdEntriesKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.id.pool.ReleasedIdsHolderBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntries;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.released.ids.DelayedIdEntriesBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockInput;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
  72 import org.opendaylight.yangtools.yang.binding.DataObject;
  73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
  75 import org.opendaylight.yangtools.yang.common.RpcResult;
  76 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  77
  78 @RunWith(MockitoJUnitRunner.class)
  79 public class IdManagerTest {
  80
  81     Map<InstanceIdentifier<?>, DataObject> configDataStore = new HashMap<>();
  82     @Mock DataBroker dataBroker;
  83     @Mock ReadOnlyTransaction mockReadTx;
  84     @Mock WriteTransaction mockWriteTx;
  85     @Mock LockManagerService lockManager;
  86     Future<RpcResult<Void>> rpcResult;
  87     IdUtils idUtils;
  88     IdManager idManager;
  89     IdPool globalIdPool;
  90     String allocateIdPoolName = "allocateIdTest";
  91     InstanceIdentifier<IdPool> parentPoolIdentifier;
  92     InstanceIdentifier<IdPool> localPoolIdentifier;
  93     InstanceIdentifier<ChildPools> childPoolIdentifier;
  94     final String poolName = "test-pool";
  95     int idStart = 100;
  96     int idEnd = 200;
  97     int blockSize = 2;
  98     String idKey = "test-key";
  99     String localPoolName;
 100     long idValue = 2;
 101
 102     @Before
 103     public void setUp() throws Exception {
 104         idUtils = new IdUtils();
 105         localPoolName = idUtils.getLocalPoolName(poolName);
 106
 107         parentPoolIdentifier = buildInstanceIdentifier(poolName);
 108         localPoolIdentifier = buildInstanceIdentifier(localPoolName);
 109         childPoolIdentifier = buildChildPoolInstanceIdentifier(poolName, localPoolName);
 110     }
 111
 112     private void setupMocks(List<IdPool> idPools) throws ReadFailedException, UnknownHostException {
 113         when(dataBroker.newReadOnlyTransaction()).thenReturn(mockReadTx);
 114         when(dataBroker.newWriteOnlyTransaction()).thenReturn(mockWriteTx);
 115         when(lockManager.lock(any(LockInput.class)))
 116                 .thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 117         when(lockManager.unlock(any(UnlockInput.class)))
 118                 .thenReturn(Futures.immediateFuture(RpcResultBuilder.<Void>success().build()));
 119         doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
 120         doAnswer(invocation -> {
 121             configDataStore.put(invocation.getArgumentAt(1, KeyedInstanceIdentifier.class),
 122                     invocation.getArgumentAt(2, IdPool.class));
 123             return null;
 124         }).when(mockWriteTx).put(eq(LogicalDatastoreType.CONFIGURATION), Matchers.any(), any(IdPool.class), eq(true));
 125         doAnswer(invocation -> {
 126             configDataStore.put(invocation.getArgumentAt(1, KeyedInstanceIdentifier.class),
 127                     invocation.getArgumentAt(2, IdPool.class));
 128             return null;
 129         }).when(mockWriteTx).merge(eq(LogicalDatastoreType.CONFIGURATION), Matchers.any(), any(ChildPools.class),
 130                 eq(true));
 131         doAnswer(invocation -> {
 132             configDataStore.put(invocation.getArgumentAt(1, KeyedInstanceIdentifier.class),
 133                     invocation.getArgumentAt(2, IdPool.class));
 134             return null;
 135         }).when(mockWriteTx).merge(eq(LogicalDatastoreType.CONFIGURATION), Matchers.any(), any(IdPool.class), eq(true));
 136         doAnswer(invocation -> {
 137             configDataStore.put(invocation.getArgumentAt(1, KeyedInstanceIdentifier.class), null);
 138             return null;
 139         }).when(mockWriteTx).delete(eq(LogicalDatastoreType.CONFIGURATION), Matchers.<InstanceIdentifier<IdPool>>any());
 140
 141         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx)
 142                 .read(eq(LogicalDatastoreType.CONFIGURATION), anyObject());
 143         if (idPools != null && !idPools.isEmpty()) {
 144             Optional<IdPools> optionalIdPools = Optional.of(new IdPoolsBuilder().setIdPool(idPools).build());
 145             doReturn(Futures.immediateCheckedFuture(optionalIdPools)).when(mockReadTx)
 146                     .read(LogicalDatastoreType.CONFIGURATION, idUtils.getIdPools());
 147         }
 148         idManager = new IdManager(dataBroker, new SingleTransactionDataBroker(dataBroker), lockManager, idUtils);
 149     }
 150
 151     @Test
 152     public void testCreateIdPool() throws Exception {
 153         setupMocks(null);
 154         CreateIdPoolInput createPoolTest = buildCreateIdPool(poolName, idStart, idEnd);
 155         long expectedBlockSize = idUtils.computeBlockSize(idStart, idEnd);
 156
 157         Future<RpcResult<Void>> result = idManager.createIdPool(createPoolTest);
 158         IdPool pool;
 159         assertTrue(result.get().isSuccessful());
 160         // Just to ensure the local pool is also written. Even if it is not triggered Test case will pass.
 161         Thread.sleep(100);
 162         assertTrue(configDataStore.size() > 0);
 163         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 164         if (dataObject instanceof IdPool) {
 165             pool = (IdPool) dataObject;
 166             assertEquals(localPoolName, pool.getPoolName());
 167             assertEquals(createPoolTest.getPoolName(), pool.getParentPoolName());
 168             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 169             assertEquals(idStart + expectedBlockSize - 1, pool.getAvailableIdsHolder().getEnd().intValue());
 170             assertEquals(idStart - 1, pool.getAvailableIdsHolder().getCursor().intValue());
 171             assertEquals(30, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 172             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 173             assertEquals(expectedBlockSize, pool.getBlockSize().longValue());
 174         }
 175         dataObject = configDataStore.get(parentPoolIdentifier);
 176         if (dataObject instanceof IdPool) {
 177             pool = (IdPool) dataObject;
 178             assertEquals(createPoolTest.getPoolName(), pool.getPoolName());
 179             assertEquals(0, pool.getReleasedIdsHolder().getDelayedTimeSec().longValue());
 180             assertEquals(0, pool.getReleasedIdsHolder().getAvailableIdCount().longValue());
 181             assertEquals(createPoolTest.getLow(), pool.getAvailableIdsHolder().getStart());
 182             assertEquals(createPoolTest.getHigh(), pool.getAvailableIdsHolder().getEnd());
 183             assertEquals(createPoolTest.getLow() - 1, pool.getAvailableIdsHolder().getCursor().intValue());
 184             assertEquals(expectedBlockSize, pool.getBlockSize().longValue());
 185         }
 186         dataObject = configDataStore.get(childPoolIdentifier);
 187         if (dataObject instanceof ChildPools) {
 188             ChildPools childPool = (ChildPools) dataObject;
 189             assertEquals(localPoolName, childPool.getChildPoolName());
 190         }
 191     }
 192
 193     @Test
 194     public void testAllocateId() throws Exception {
 195         List<IdPool> listOfIdPool = new ArrayList<>();
 196         IdPool localIdPool = buildLocalIdPool(blockSize, idStart, idStart + blockSize - 1, idStart - 1, localPoolName,
 197                 poolName).build();
 198         listOfIdPool.add(localIdPool);
 199         IdPool globalIdPool = buildGlobalIdPool(poolName, idStart, idEnd, idStart + blockSize,
 200                 buildChildPool(localPoolName)).build();
 201         listOfIdPool.add(globalIdPool);
 202         setupMocks(listOfIdPool);
 203         doReturn(Futures.immediateCheckedFuture(Optional.of(globalIdPool))).when(mockReadTx).read(
 204                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 205
 206         AllocateIdInput allocateIdInput = buildAllocateId(poolName, idKey);
 207         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 208         assertTrue(result.get().isSuccessful());
 209         Thread.sleep(100);
 210         assertTrue(configDataStore.size() > 0);
 211         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 212         if (dataObject instanceof IdPool) {
 213             IdPool pool = (IdPool) dataObject;
 214             assertEquals(localPoolName, pool.getPoolName());
 215             assertEquals(idStart, pool.getAvailableIdsHolder().getStart().intValue());
 216             assertEquals(idStart + blockSize - 1 , pool.getAvailableIdsHolder().getEnd().intValue());
 217             assertEquals(idStart, pool.getAvailableIdsHolder().getCursor().intValue());
 218         }
 219         dataObject = configDataStore.get(parentPoolIdentifier);
 220         if (dataObject instanceof IdPool) {
 221             IdPool parentPool = (IdPool) dataObject;
 222             assertEquals(1, parentPool.getIdEntries().size());
 223         }
 224         dataObject = configDataStore.get(childPoolIdentifier);
 225         if (dataObject instanceof ChildPools) {
 226             ChildPools childPool = (ChildPools) dataObject;
 227             assertEquals(localPoolName, childPool.getChildPoolName());
 228         }
 229     }
 230
 231     @Test
 232     public void testReleaseId() throws Exception {
 233         List<IdEntries> idEntries = new ArrayList<>();
 234         List<Long> idValuesList = new ArrayList<>();
 235         idValuesList.add(idValue);
 236
 237         List<IdPool> listOfIdPool = new ArrayList<>();
 238         IdPool expectedLocalPool = buildLocalIdPool(blockSize, idStart, idStart + blockSize - 1, idStart - 1,
 239                 localPoolName, poolName).build();
 240         IdPool globalIdPool = buildGlobalIdPool(poolName, idStart, idEnd, blockSize, buildChildPool(localPoolName))
 241                 .setIdEntries(idEntries).build();
 242         listOfIdPool.add(expectedLocalPool);
 243         listOfIdPool.add(globalIdPool);
 244         setupMocks(listOfIdPool);
 245         doReturn(Futures.immediateCheckedFuture(Optional.of(globalIdPool))).when(mockReadTx).read(
 246                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 247
 248         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(parentPoolIdentifier, idKey);
 249         Optional<IdEntries> expectedIdEntry = Optional.of(buildIdEntry(idKey, idValuesList));
 250         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 251                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 252
 253         ReleaseIdInput releaseIdInput = createReleaseIdInput(poolName, idKey);
 254         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 255         assertTrue(result.get().isSuccessful());
 256         Thread.sleep(100);
 257         assertTrue(configDataStore.size() > 0);
 258         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 259         if (dataObject instanceof IdPool) {
 260             IdPool pool = (IdPool) dataObject;
 261             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 262             assertEquals(idValue, pool.getReleasedIdsHolder().getDelayedIdEntries().get(0).getId().intValue());
 263         }
 264         dataObject = configDataStore.get(parentPoolIdentifier);
 265         if (dataObject instanceof IdPool) {
 266             IdPool parentPool = (IdPool) dataObject;
 267             assertEquals(0, parentPool.getIdEntries().size());
 268         }
 269         dataObject = configDataStore.get(childPoolIdentifier);
 270         if (dataObject instanceof ChildPools) {
 271             ChildPools childPool = (ChildPools) dataObject;
 272             assertEquals(localPoolName, childPool.getChildPoolName());
 273         }
 274     }
 275
 276     /**
 277      * Ignoring this test case since cleanup task gets scheduled only after 30
 278      * seconds. Therefore in order to validate the pool state the test has to
 279      * wait for at least 30 seconds.
 280      */
 281     @Ignore
 282     public void testCleanupReleasedIds() throws Exception {
 283         List<Long> idValues = Arrays.asList(1L, 2L, 3L, 4L, 5L);
 284         IdEntries idEntry = buildIdEntry(idKey, idValues);
 285         List<IdEntries> listOfIdEntries = new ArrayList<>();
 286         listOfIdEntries.add(idEntry);
 287
 288         IdPool globalIdPool = buildGlobalIdPool(poolName, idStart, idEnd, blockSize, buildChildPool(localPoolName))
 289                 .setIdEntries(listOfIdEntries).build();
 290         IdPool expectedLocalPool = buildLocalIdPool(blockSize, idStart, idStart + blockSize - 1, idStart - 1,
 291                 localPoolName, poolName).build();
 292         List<IdPool> listOfIdPool = new ArrayList<>();
 293
 294         listOfIdPool.add(expectedLocalPool);
 295         listOfIdPool.add(globalIdPool);
 296         setupMocks(listOfIdPool);
 297
 298         Optional<IdPool> expectedGlobalPool = Optional.of(globalIdPool);
 299         doReturn(Futures.immediateCheckedFuture(expectedGlobalPool)).when(mockReadTx).read(
 300                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 301
 302         InstanceIdentifier<IdEntries> idEntriesIdentifier = buildIdEntriesIdentifier(parentPoolIdentifier, idKey);
 303         Optional<IdEntries> expectedIdEntry = Optional.of(idEntry);
 304         doReturn(Futures.immediateCheckedFuture(expectedIdEntry)).when(mockReadTx).read(
 305                 LogicalDatastoreType.CONFIGURATION, idEntriesIdentifier);
 306
 307         ReleasedIdsHolder releaseIdsHolder = createReleasedIdsHolder(0, new ArrayList<>(), 0);
 308         InstanceIdentifier<ReleasedIdsHolder> releaseHolderIdentifier = buildReleaseIdsIdentifier(poolName);
 309         doReturn(Futures.immediateCheckedFuture(Optional.of(releaseIdsHolder))).when(mockReadTx).read(
 310                 LogicalDatastoreType.CONFIGURATION, releaseHolderIdentifier);
 311
 312         ReleaseIdInput releaseIdInput = createReleaseIdInput(poolName, idKey);
 313         Future<RpcResult<Void>> result = idManager.releaseId(releaseIdInput);
 314         Thread.sleep(40000);
 315         assertTrue(result.get().isSuccessful());
 316         assertTrue(configDataStore.size() > 0);
 317
 318         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 319         if (dataObject instanceof IdPool) {
 320             IdPool pool = (IdPool) dataObject;
 321             assertEquals(2, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 322         }
 323
 324         dataObject = configDataStore.get(parentPoolIdentifier);
 325         if (dataObject instanceof IdPool) {
 326             IdPool parentPool = (IdPool) dataObject;
 327             assertEquals(0, parentPool.getIdEntries().size());
 328         }
 329
 330         dataObject = configDataStore.get(childPoolIdentifier);
 331         if (dataObject instanceof ChildPools) {
 332             ChildPools childPool = (ChildPools) dataObject;
 333             assertEquals(localPoolName, childPool.getChildPoolName());
 334         }
 335
 336         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(poolName);
 337         dataObject = configDataStore.get(releaseIdsIdentifier);
 338         if (dataObject instanceof ReleasedIdsHolder) {
 339             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 340             assertEquals(3, releasedIds.getAvailableIdCount().intValue());
 341             assertEquals(3, releasedIds.getDelayedIdEntries().size());
 342         }
 343     }
 344
 345     @Test
 346     public void testAllocateIdBlockFromReleasedIds() throws Exception {
 347         List<DelayedIdEntries> delayedIdEntries = buildDelayedIdEntries(new long[] {150, 151, 152});
 348         ReleasedIdsHolder expectedReleasedIds = createReleasedIdsHolder(3, delayedIdEntries , 0);
 349         IdPool globalIdPool = buildGlobalIdPool(poolName, idStart, idEnd, blockSize, buildChildPool(localPoolName))
 350                 .setReleasedIdsHolder(expectedReleasedIds).build();
 351         IdPool localPool = buildLocalIdPool(blockSize, idStart, idStart + blockSize - 1, idStart + blockSize - 1,
 352                 localPoolName, poolName).build();
 353         Optional<IdPool> expected = Optional.of(globalIdPool);
 354         List<IdPool> listOfIdPool = new ArrayList<>();
 355         listOfIdPool.add(localPool);
 356         listOfIdPool.add(globalIdPool);
 357         InstanceIdentifier<IdPool> parentPoolIdentifier = buildInstanceIdentifier(poolName);
 358         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 359                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 360
 361         setupMocks(listOfIdPool);
 362         doReturn(Futures.immediateCheckedFuture(Optional.of(globalIdPool))).when(mockReadTx).read(
 363                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 364
 365         AllocateIdInput allocateIdInput = buildAllocateId(poolName, idKey);
 366         Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(allocateIdInput);
 367         assertTrue(result.get().isSuccessful());
 368         Thread.sleep(3);
 369         assertTrue(configDataStore.size() > 0);
 370         InstanceIdentifier<IdPool> localPoolIdentifier = buildInstanceIdentifier(localPoolName);
 371         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 372         if (dataObject instanceof IdPool) {
 373             IdPool pool = (IdPool) dataObject;
 374             assertEquals(localPoolName, pool.getPoolName());
 375             assertEquals(1, pool.getReleasedIdsHolder().getDelayedIdEntries().size());
 376             assertEquals(1, pool.getReleasedIdsHolder().getAvailableIdCount().intValue());
 377         }
 378
 379         InstanceIdentifier<ReleasedIdsHolder> releaseIdsIdentifier = buildReleaseIdsIdentifier(poolName);
 380         dataObject = configDataStore.get(releaseIdsIdentifier);
 381         if (dataObject instanceof ReleasedIdsHolder) {
 382             ReleasedIdsHolder releasedIds = (ReleasedIdsHolder) dataObject;
 383             assertEquals(1, releasedIds.getAvailableIdCount().intValue());
 384             assertEquals(1, releasedIds.getDelayedIdEntries().size());
 385         }
 386
 387         InstanceIdentifier<ChildPools> childPoolIdentifier = buildChildPoolInstanceIdentifier(poolName, localPoolName);
 388         dataObject = configDataStore.get(childPoolIdentifier);
 389         if (dataObject instanceof ChildPools) {
 390             ChildPools childPool = (ChildPools) dataObject;
 391             assertEquals(localPoolName, childPool.getChildPoolName());
 392         }
 393     }
 394
 395     @Test
 396     public void testDeletePool() throws Exception {
 397         IdPool globalIdPool = buildGlobalIdPool(poolName, idStart, idEnd, blockSize, buildChildPool(localPoolName))
 398                 .build();
 399         IdPool localPool = buildLocalIdPool(blockSize, idStart, idStart + blockSize - 1, idStart + blockSize - 1,
 400                 localPoolName, poolName).build();
 401         List<IdPool> listOfIdPool = new ArrayList<>();
 402         listOfIdPool.add(localPool);
 403         listOfIdPool.add(globalIdPool);
 404         setupMocks(listOfIdPool);
 405         Optional<IdPool> expected = Optional.of(globalIdPool);
 406         doReturn(Futures.immediateCheckedFuture(expected)).when(mockReadTx).read(
 407                 LogicalDatastoreType.CONFIGURATION, parentPoolIdentifier);
 408         DeleteIdPoolInput deleteIdPoolInput = createDeleteIdPoolInput(poolName);
 409         Future<RpcResult<Void>> result = idManager.deleteIdPool(deleteIdPoolInput);
 410         Thread.sleep(3);
 411         assertTrue(result.get().isSuccessful());
 412         assertTrue(configDataStore.size() > 0);
 413         DataObject dataObject = configDataStore.get(localPoolIdentifier);
 414         assertEquals(dataObject, null);
 415         dataObject = configDataStore.get(parentPoolIdentifier);
 416         assertEquals(dataObject, null);
 417     }
 418
 419     private InstanceIdentifier<ReleasedIdsHolder> buildReleaseIdsIdentifier(
 420             String poolName) {
 421         InstanceIdentifier<ReleasedIdsHolder> releasedIds = InstanceIdentifier
 422                 .builder(IdPools.class).child(IdPool.class,
 423                         new IdPoolKey(poolName)).child(ReleasedIdsHolder.class).build();
 424         return releasedIds;
 425     }
 426
 427     private InstanceIdentifier<ChildPools> buildChildPoolInstanceIdentifier(String poolName, String childPoolName) {
 428         InstanceIdentifier<ChildPools> childPool = InstanceIdentifier
 429                 .builder(IdPools.class).child(IdPool.class,
 430                         new IdPoolKey(poolName)).child(ChildPools.class, new ChildPoolsKey(childPoolName)).build();
 431         return childPool;
 432     }
 433
 434     private ReleaseIdInput createReleaseIdInput(String poolName, String idKey) {
 435         return new ReleaseIdInputBuilder().setIdKey(idKey).setPoolName(poolName).build();
 436     }
 437
 438     private IdEntries buildIdEntry(String idKey, List<Long> idValuesList) {
 439         return new IdEntriesBuilder().setIdKey(idKey).setIdValue(idValuesList).build();
 440     }
 441
 442     private InstanceIdentifier<IdEntries> buildIdEntriesIdentifier(InstanceIdentifier<IdPool> identifier,
 443             String idKey) {
 444         InstanceIdentifier.InstanceIdentifierBuilder<IdEntries> idEntriesBuilder = identifier
 445                 .builder().child(IdEntries.class, new IdEntriesKey(idKey));
 446         InstanceIdentifier<IdEntries> idEntry = idEntriesBuilder.build();
 447         return idEntry;
 448     }
 449
 450     private CreateIdPoolInput buildCreateIdPool(String poolName, long low, long high) {
 451         CreateIdPoolInput createPool = new CreateIdPoolInputBuilder().setPoolName(poolName)
 452                 .setLow(low)
 453                 .setHigh(high)
 454                 .build();
 455         return createPool;
 456     }
 457
 458     private IdPoolBuilder buildGlobalIdPool(String poolName, long idStart, long poolSize, int blockSize,
 459             List<ChildPools> childPools) {
 460         AvailableIdsHolder availableIdsHolder = createAvailableIdsHolder(idStart, poolSize, idStart - 1);
 461         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 0);
 462         return new IdPoolBuilder().setKey(new IdPoolKey(poolName))
 463                 .setPoolName(poolName)
 464                 .setBlockSize(blockSize)
 465                 .setChildPools(childPools)
 466                 .setAvailableIdsHolder(availableIdsHolder)
 467                 .setReleasedIdsHolder(releasedIdsHolder);
 468     }
 469
 470     private IdPoolBuilder buildLocalIdPool(int blockSize, int start, int end, int cursor, String localPoolName,
 471             String parentPoolName) {
 472         ReleasedIdsHolder releasedIdsHolder = createReleasedIdsHolder(0, null, 30);
 473         return new IdPoolBuilder().setBlockSize(blockSize)
 474                 .setKey(new IdPoolKey(localPoolName))
 475                 .setParentPoolName(parentPoolName)
 476                 .setReleasedIdsHolder(releasedIdsHolder)
 477                 .setAvailableIdsHolder(createAvailableIdsHolder(start, end, cursor));
 478     }
 479
 480     private AllocateIdInput buildAllocateId(String poolName, String idKey) {
 481         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName)
 482                 .setIdKey(idKey).build();
 483         return getIdInput;
 484     }
 485
 486     private InstanceIdentifier<IdPool> buildInstanceIdentifier(String poolName) {
 487         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 488                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 489         InstanceIdentifier<IdPool> id = idBuilder.build();
 490         return id;
 491     }
 492
 493     private AvailableIdsHolder createAvailableIdsHolder(long low, long high, long cursor) {
 494         AvailableIdsHolder availableIdsHolder = new AvailableIdsHolderBuilder()
 495                 .setStart(low).setEnd(high).setCursor(cursor).build();
 496         return availableIdsHolder;
 497     }
 498
 499     private ReleasedIdsHolder createReleasedIdsHolder(long availableIdCount, List<DelayedIdEntries> delayedIdEntries,
 500             long delayTime) {
 501         ReleasedIdsHolder releasedIdsHolder = new ReleasedIdsHolderBuilder()
 502                 .setAvailableIdCount(availableIdCount)
 503                 .setDelayedIdEntries(delayedIdEntries)
 504                 .setDelayedTimeSec(delayTime).build();
 505         return releasedIdsHolder;
 506     }
 507
 508     private DeleteIdPoolInput createDeleteIdPoolInput(String poolName) {
 509         return new DeleteIdPoolInputBuilder().setPoolName(poolName).build();
 510     }
 511
 512     private List<DelayedIdEntries> buildDelayedIdEntries(long[] idValues) {
 513         List<DelayedIdEntries> delayedIdEntriesList = new ArrayList<>();
 514         for (long idValue : idValues) {
 515             DelayedIdEntries delayedIdEntries = new DelayedIdEntriesBuilder().setId(idValue).setReadyTimeSec(0L)
 516                     .build();
 517             delayedIdEntriesList.add(delayedIdEntries);
 518         }
 519         return delayedIdEntriesList;
 520     }
 521
 522     private List<ChildPools> buildChildPool(String childPoolName) {
 523         ChildPools childPools = new ChildPoolsBuilder().setChildPoolName(childPoolName).build();
 524         List<ChildPools> childPoolsList = new ArrayList<>();
 525         childPoolsList.add(childPools);
 526         return childPoolsList;
 527     }
 528 }