appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/test/java/org/onap/appc/lockmanager/api/LockManagerBaseTests.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * =============================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  * ECOMP is a trademark and service mark of AT&T Intellectual Property.
  22  * ============LICENSE_END=========================================================
  23  */
  24
  25 package org.onap.appc.lockmanager.api;
  26
  27 import org.junit.Assert;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.onap.appc.lockmanager.api.LockException;
  31 import org.onap.appc.lockmanager.api.LockManager;
  32
  33 public abstract class LockManagerBaseTests {
  34
  35     protected enum Resource {Resource1, Resource2};
  36     protected enum Owner {A, B};
  37
  38     protected LockManager lockManager;
  39
  40     @Before
  41     public void beforeTest() {
  42         lockManager = createLockManager();
  43     }
  44
  45     protected abstract LockManager createLockManager();
  46
  47     @Test
  48     public void testAcquireLock() throws LockException {
  49         boolean lockRes = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  50         try {
  51             Assert.assertTrue(lockRes);
  52         } finally {
  53             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
  54         }
  55     }
  56
  57     @Test
  58     public void testAcquireLock_AlreadyLockedBySameOwner() throws LockException {
  59         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  60         try {
  61             Assert.assertTrue(lockRes1);
  62             boolean lockRes2 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  63             Assert.assertFalse(lockRes2);
  64         } finally {
  65             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
  66         }
  67     }
  68
  69     @Test(expected = LockException.class)
  70     public void testAcquireLock_AlreadyLockedByOtherOwner() throws LockException {
  71         String owner2 = "B";
  72         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  73         try {
  74             Assert.assertTrue(lockRes1);
  75             boolean lockRes2 = lockManager.acquireLock(Resource.Resource1.name(), owner2);
  76             Assert.assertFalse(lockRes2);
  77         } finally {
  78             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
  79         }
  80     }
  81
  82     @Test
  83     public void testAcquireLock_LockDifferentResources() throws LockException {
  84         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
  85         try {
  86             Assert.assertTrue(lockRes1);
  87             boolean lockRes2 = lockManager.acquireLock(Resource.Resource2.name(), Owner.B.name());
  88             try {
  89                 Assert.assertTrue(lockRes2);
  90             } finally {
  91                 lockManager.releaseLock(Resource.Resource2.name(), Owner.B.name());
  92             }
  93         } finally {
  94             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
  95         }
  96     }
  97
  98     @Test(expected = LockException.class)
  99     public void testReleaseLock_NotLockedResource() throws LockException {
 100         lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 101     }
 102
 103     @Test(expected = LockException.class)
 104     public void testReleaseLock_LockedByOtherOwnerResource() throws LockException {
 105         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name());
 106         try {
 107             Assert.assertTrue(lockRes1);
 108             lockManager.releaseLock(Resource.Resource1.name(), Owner.B.name());
 109         } finally {
 110             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 111         }
 112     }
 113
 114     @Test(expected = LockException.class)
 115     public void testAcquireLock_LockExpired() throws LockException, InterruptedException {
 116         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name(), 50);
 117         Assert.assertTrue(lockRes1);
 118         Thread.sleep(1000);
 119         lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 120     }
 121
 122     @Test
 123     public void testAcquireLock_OtherLockExpired() throws LockException, InterruptedException {
 124         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name(), 50);
 125         Assert.assertTrue(lockRes1);
 126         Thread.sleep(1000);
 127         boolean lockRes2 = lockManager.acquireLock(Resource.Resource1.name(), Owner.B.name());
 128         try {
 129             Assert.assertTrue(lockRes2);
 130         }finally {
 131             lockManager.releaseLock(Resource.Resource1.name(), Owner.B.name());
 132         }
 133     }
 134
 135     @Test
 136     public void testIsLocked_WhenLocked() throws LockException, InterruptedException {
 137         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name(), 50);
 138         try {
 139         Assert.assertTrue(lockManager.isLocked(Resource.Resource1.name()));
 140         }finally {
 141             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 142         }
 143     }
 144
 145
 146     @Test(expected = LockException.class)
 147     public void testIsLocked_LockExpired() throws LockException, InterruptedException {
 148         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name(), 50);
 149         Assert.assertTrue(lockRes1);
 150         Assert.assertTrue(lockManager.isLocked(Resource.Resource1.name()));
 151         Thread.sleep(1000);
 152         try {
 153             Assert.assertFalse(lockManager.isLocked(Resource.Resource1.name()));
 154         }finally {
 155             lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 156         }
 157     }
 158
 159     @Test
 160     public void testIsLocked_LockReleased() throws LockException, InterruptedException {
 161         boolean lockRes1 = lockManager.acquireLock(Resource.Resource1.name(), Owner.A.name(), 50);
 162         lockManager.releaseLock(Resource.Resource1.name(), Owner.A.name());
 163         Assert.assertFalse(lockManager.isLocked(Resource.Resource1.name()));
 164     }
 165
 166     @Test
 167     public void testIsLocked_NoLock() throws LockException, InterruptedException {
 168         Assert.assertFalse(lockManager.isLocked(Resource.Resource1.name()));
 169     }
 170 }