appc-dispatcher/appc-dispatcher-common/lock-manager-lib/lock-manager-impl/src/test/java/org/openecomp/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 }