gerrit.onap Code Review - appc.git/blob

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