aboutsummaryrefslogtreecommitdiffstats
path: root/policy-core/src/test/java
diff options
context:
space:
mode:
authorJim Hahn <jrh3@att.com>2018-03-29 15:07:36 -0400
committerJim Hahn <jrh3@att.com>2018-04-03 10:55:19 -0400
commit3a80de9806cbdd0461716e814f5e674e259d42b3 (patch)
treee48400fcfee10f363538bad7efa177911b0c316c /policy-core/src/test/java
parentca3efc7d2ee9522f995adc55baa6fff3279bba70 (diff)
Add api-resource-locks feature
Added ResourceLockFeatureAPI, to provide an interface for PolicyGuard to use to access other locking mechanisms. Move lock API to policy-core. Changed the interface and added Callback support. Added a class to invoke the API implementers. Changed to set a future instead of expecting the callback to implement the future interface. Also refactored, creating "lock" sub-package. Add junit tests. Increase junit coverage. IsLocked & isLockedBy should check all arguments. Make ImplFuture protected instead of public. Simplify locking - move callback support to an optional feature. Move Reference class to policy-utils. Return plain Future instead of LockRequestFuture. Change-Id: I65154d33833914b4332e02d1ef2512f4c5f09b16 Issue-ID: POLICY-577 Signed-off-by: Jim Hahn <jrh3@att.com>
Diffstat (limited to 'policy-core/src/test/java')
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java431
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java131
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java76
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java509
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java280
-rw-r--r--policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java59
6 files changed, 1486 insertions, 0 deletions
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java
new file mode 100644
index 00000000..883778eb
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockRequestFutureTest.java
@@ -0,0 +1,431 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.onap.policy.drools.core.lock.TestUtils.expectException;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.drools.core.lock.PolicyResourceLockFeatureAPI.Callback;
+
+public class LockRequestFutureTest {
+
+ private static final int WAIT_SEC = 1;
+ private static final String RESOURCE = "my.resource";
+ private static final String OWNER = "my.owner";
+ private static final String EXPECTED_EXCEPTION = "expected exception";
+
+ private Callback callback;
+ private LockRequestFuture fut;
+
+ @Before
+ public void setUp() {
+ callback = mock(Callback.class);
+ fut = new LockRequestFuture(RESOURCE, OWNER, callback);
+ }
+
+ @Test
+ public void testLockRequestFutureStringStringBoolean_False() throws Exception {
+ fut = new LockRequestFuture(RESOURCE, OWNER, false);
+
+ assertTrue(fut.isDone());
+ assertEquals(RESOURCE, fut.getResourceId());
+ assertEquals(OWNER, fut.getOwner());
+
+ assertFalse(fut.isLocked());
+ assertFalse(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testLockRequestFutureStringStringBoolean_True() throws Exception {
+ fut = new LockRequestFuture(RESOURCE, OWNER, true);
+
+ assertTrue(fut.isDone());
+ assertEquals(RESOURCE, fut.getResourceId());
+ assertEquals(OWNER, fut.getOwner());
+
+ assertTrue(fut.isLocked());
+ assertTrue(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testLockRequestFutureStringStringBoolean_ArgEx() throws Exception {
+
+ // null resource id
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class,
+ xxx -> new LockRequestFuture(null, OWNER, true));
+ assertEquals("null resourceId", ex.getMessage());
+
+
+ // null owner
+ ex = expectException(IllegalArgumentException.class, xxx -> new LockRequestFuture(RESOURCE, null, true));
+ assertEquals("null owner", ex.getMessage());
+ }
+
+ @Test
+ public void testLockRequestFutureStringStringCallback() throws Exception {
+ assertFalse(fut.isDone());
+ assertEquals(RESOURCE, fut.getResourceId());
+ assertEquals(OWNER, fut.getOwner());
+
+ fut.setLocked(true);
+ fut.invokeCallback();
+
+ // ensure it invoked the callback
+ verify(callback).set(true);
+ }
+
+ @Test
+ public void testLockRequestFutureStringStringCallback_ArgEx() throws Exception {
+
+ // null resource id
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class,
+ xxx -> new LockRequestFuture(null, OWNER, callback));
+ assertEquals("null resourceId", ex.getMessage());
+
+
+ // null owner
+ ex = expectException(IllegalArgumentException.class, xxx -> new LockRequestFuture(RESOURCE, null, callback));
+ assertEquals("null owner", ex.getMessage());
+
+
+ // null callback is OK
+ new LockRequestFuture(RESOURCE, OWNER, null);
+ }
+
+ @Test
+ public void testGetResourceId() {
+ assertEquals(RESOURCE, fut.getResourceId());
+ }
+
+ @Test
+ public void testGetOwner() {
+ assertEquals(OWNER, fut.getOwner());
+ }
+
+ @Test
+ public void testCancel() throws Exception {
+ // not cancelled yet
+ assertFalse(fut.isDone());
+
+ // cancel it
+ assertTrue(fut.cancel(false));
+ assertTrue(fut.isDone());
+
+ // should not block now
+ expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS));
+
+ }
+
+ @Test
+ public void testCancel_AlreadyCancelled() throws Exception {
+
+ fut.cancel(true);
+
+ assertFalse(fut.cancel(true));
+ assertTrue(fut.isDone());
+
+ expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testCancel_AlreadyAcquired() throws Exception {
+
+ fut.setLocked(true);
+
+ assertFalse(fut.cancel(true));
+ assertTrue(fut.isDone());
+ assertTrue(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testCancel_AlreadyDenied() throws Exception {
+
+ fut.setLocked(false);
+
+ assertFalse(fut.cancel(true));
+ assertTrue(fut.isDone());
+ assertFalse(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testSetLocked_True() throws Exception {
+ assertTrue(fut.setLocked(true));
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testSetLocked_False() throws Exception {
+ assertTrue(fut.setLocked(false));
+
+ assertTrue(fut.isDone());
+ assertFalse(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testSetLocked_AlreadyCancelled() {
+
+ fut.cancel(true);
+
+ assertFalse(fut.setLocked(true));
+ assertFalse(fut.setLocked(false));
+
+ assertTrue(fut.isDone());
+ expectException(CancellationException.class, xxx -> fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testSetLocked_AlreadyAcquired() throws Exception {
+ fut.setLocked(true);
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get(0, TimeUnit.SECONDS));
+
+ assertFalse(fut.cancel(true));
+ assertFalse(fut.setLocked(true));
+ assertFalse(fut.setLocked(false));
+ }
+
+ @Test
+ public void testSetLocked_AlreadyDenied() throws Exception {
+ fut.setLocked(false);
+
+ assertTrue(fut.isDone());
+ assertFalse(fut.get(0, TimeUnit.SECONDS));
+
+ assertFalse(fut.cancel(true));
+ assertFalse(fut.setLocked(true));
+ assertFalse(fut.setLocked(false));
+ }
+
+ @Test
+ public void testIsCancelled() {
+ assertFalse(fut.isCancelled());
+
+ fut.cancel(false);
+ assertTrue(fut.isCancelled());
+ }
+
+ @Test
+ public void testIsCancelled_Acquired() {
+ fut.setLocked(true);
+ assertFalse(fut.isCancelled());
+ }
+
+ @Test
+ public void testIsCancelled_Denied() {
+ fut.setLocked(false);
+ assertFalse(fut.isCancelled());
+ }
+
+ @Test
+ public void testIsDone_Cancelled() {
+ fut.cancel(false);
+ assertTrue(fut.isDone());
+ }
+
+ @Test
+ public void testIsDone_Acquired() {
+ fut.setLocked(true);
+ assertTrue(fut.isDone());
+ }
+
+ @Test
+ public void testIsDone_Denied() {
+ fut.setLocked(false);
+ assertTrue(fut.isDone());
+ }
+
+ @Test
+ public void testIsDone_Waiting() {
+ assertFalse(fut.isDone());
+ }
+
+ @Test
+ public void testIsLocked_Cancelled() {
+ fut.cancel(false);
+ assertFalse(fut.isLocked());
+ }
+
+ @Test
+ public void testIsLocked_Acquired() {
+ fut.setLocked(true);
+ assertTrue(fut.isLocked());
+ }
+
+ @Test
+ public void testIsLocked_Denied() {
+ fut.setLocked(false);
+ assertFalse(fut.isLocked());
+ }
+
+ @Test
+ public void testIsLocked_Waiting() {
+ assertFalse(fut.isLocked());
+ }
+
+ @Test
+ public void testGet_Cancelled() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.cancel(false);
+ }
+ }.start();
+
+ expectException(CancellationException.class, xxx -> fut.get());
+ }
+
+ @Test
+ public void testGet_Acquired() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.setLocked(true);
+ }
+ }.start();
+
+ assertTrue(fut.get());
+ }
+
+ @Test
+ public void testGet_Denied() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.setLocked(false);
+ }
+ }.start();
+
+ assertFalse(fut.get());
+ }
+
+ @Test
+ public void testGetLongTimeUnit() throws Exception {
+ expectException(TimeoutException.class, xxx -> fut.get(0, TimeUnit.SECONDS));
+
+ fut.setLocked(true);
+ assertTrue(fut.get(0, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testGetLongTimeUnit_Timeout() throws Exception {
+ expectException(TimeoutException.class, xxx -> fut.get(0, TimeUnit.SECONDS));
+ expectException(TimeoutException.class, xxx -> fut.get(2, TimeUnit.MILLISECONDS));
+ }
+
+ @Test
+ public void testGetLongTimeUnit_Cancelled() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.cancel(false);
+ }
+ }.start();
+
+ expectException(CancellationException.class, xxx -> fut.get(WAIT_SEC, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testGetLongTimeUnit_Acquired() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.setLocked(true);
+ }
+ }.start();
+
+ assertTrue(fut.get(WAIT_SEC, TimeUnit.SECONDS));
+ }
+
+ @Test
+ public void testGetLongTimeUnit_Denied() throws Exception {
+ new Thread() {
+ @Override
+ public void run() {
+ fut.setLocked(false);
+ }
+ }.start();
+
+ assertFalse(fut.get(WAIT_SEC, TimeUnit.SECONDS));
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testInvokeCallback() {
+ fut.setLocked(true);
+ fut.invokeCallback();
+
+ // re-invoke - should throw an exception
+ fut.invokeCallback();
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testInvokeCallback_Cancelled() {
+ fut.cancel(false);
+
+ // invoke after cancel - should throw an exception
+ fut.invokeCallback();
+ }
+
+ @Test
+ public void testInvokeCallback_Acquired() {
+ fut.setLocked(true);
+ fut.invokeCallback();
+
+ verify(callback).set(true);
+ verify(callback, never()).set(false);
+ }
+
+ @Test
+ public void testInvokeCallback_Denied() {
+ fut.setLocked(false);
+ fut.invokeCallback();
+
+ verify(callback).set(false);
+ verify(callback, never()).set(true);
+ }
+
+ @Test
+ public void testInvokeCallback_Ex() {
+ doThrow(new RuntimeException(EXPECTED_EXCEPTION)).when(callback).set(anyBoolean());
+
+ fut.setLocked(false);
+ fut.invokeCallback();
+ }
+
+ @Test
+ public void testMakeNullArgException() {
+ IllegalArgumentException ex = LockRequestFuture.makeNullArgException(EXPECTED_EXCEPTION);
+ assertEquals(EXPECTED_EXCEPTION, ex.getMessage());
+ }
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java
new file mode 100644
index 00000000..bd11dcf9
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/LockTest.java
@@ -0,0 +1,131 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.policy.drools.core.lock.Lock.RemoveResult;
+import org.onap.policy.drools.utils.Pair;
+
+public class LockTest {
+
+ private static final String OWNER = "my.owner";
+ private static final String OWNER2 = "another.owner";
+ private static final String OWNER3 = "third.owner";
+
+ private static final Integer ITEM2 = 10;
+ private static final Integer ITEM3 = 20;
+
+ private Lock<Integer> lock;
+ private Pair<String, Integer> newOwner;
+
+ @Before
+ public void setUp() {
+ lock = new Lock<>(OWNER);
+ newOwner = new Pair<>(null, null);
+ }
+
+
+ @Test
+ public void testLock() {
+ assertEquals(OWNER, lock.getOwner());
+ }
+
+ @Test
+ public void testGetOwner() {
+ assertEquals(OWNER, lock.getOwner());
+ }
+
+ @Test
+ public void testAdd() {
+ assertTrue(lock.add(OWNER2, ITEM2));
+ assertTrue(lock.add(OWNER3, ITEM3));
+
+ // attempt to re-add owner2 with the same item - should fail
+ assertFalse(lock.add(OWNER2, ITEM2));
+
+ // attempt to re-add owner2 with a different item - should fail
+ assertFalse(lock.add(OWNER2, ITEM3));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testAdd_ArgEx() {
+ lock.add(OWNER2, null);
+ }
+
+ @Test
+ public void testAdd_AlreadyOwner() {
+ assertFalse(lock.add(OWNER, ITEM2));
+ }
+
+ @Test
+ public void testAdd_AlreadyInQueue() {
+ lock.add(OWNER2, ITEM2);
+
+ assertFalse(lock.add(OWNER2, ITEM2));
+ }
+
+ @Test
+ public void testRemoveRequester_Owner_QueueEmpty() {
+ assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER, newOwner));
+ }
+
+ @Test
+ public void testRemoveRequester_Owner_QueueHasOneItem() {
+ lock.add(OWNER2, ITEM2);
+
+ assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER, newOwner));
+ assertEquals(OWNER2, newOwner.first());
+ assertEquals(ITEM2, newOwner.second());
+
+ assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER2, newOwner));
+ }
+
+ @Test
+ public void testRemoveRequester_Owner_QueueHasMultipleItems() {
+ lock.add(OWNER2, ITEM2);
+ lock.add(OWNER3, ITEM3);
+
+ assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER, newOwner));
+ assertEquals(OWNER2, newOwner.first());
+ assertEquals(ITEM2, newOwner.second());
+
+ assertEquals(RemoveResult.RELOCKED, lock.removeRequester(OWNER2, newOwner));
+ assertEquals(OWNER3, newOwner.first());
+ assertEquals(ITEM3, newOwner.second());
+
+ assertEquals(RemoveResult.UNLOCKED, lock.removeRequester(OWNER3, newOwner));
+ }
+
+ @Test
+ public void testRemoveRequester_InQueue() {
+ lock.add(OWNER2, ITEM2);
+
+ assertEquals(RemoveResult.REMOVED, lock.removeRequester(OWNER2, newOwner));
+ }
+
+ @Test
+ public void testRemoveRequester_NeitherOwnerNorInQueue() {
+ assertEquals(RemoveResult.NOT_FOUND, lock.removeRequester(OWNER2, newOwner));
+ }
+
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java
new file mode 100644
index 00000000..5a826bb7
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockFeatureAPITest.java
@@ -0,0 +1,76 @@
+/*
+ * ============LICENSE_START=======================================================
+ * api-resource-locks
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PolicyResourceLockFeatureAPITest {
+
+ private static final String RESOURCE_ID = "the resource";
+ private static final String OWNER = "the owner";
+
+ private PolicyResourceLockFeatureAPI api;
+
+ @Before
+ public void setUp() {
+ api = new PolicyResourceLockFeatureAPI() {
+ @Override
+ public int getSequenceNumber() {
+ return 0;
+ }
+ };
+ }
+
+ @Test
+ public void testBeforeLock() {
+ assertNull(api.beforeLock(RESOURCE_ID, OWNER, null));
+ }
+
+ @Test
+ public void testAfterLock() {
+ assertFalse(api.afterLock(RESOURCE_ID, OWNER, true));
+ assertFalse(api.afterLock(RESOURCE_ID, OWNER, false));
+ }
+
+ @Test
+ public void testBeforeUnlock() {
+ assertNull(api.beforeUnlock(RESOURCE_ID, OWNER));
+ }
+
+ @Test
+ public void testAfterUnlock() {
+ assertFalse(api.afterUnlock(RESOURCE_ID, OWNER, true));
+ assertFalse(api.afterUnlock(RESOURCE_ID, OWNER, false));
+ }
+
+ @Test
+ public void testBeforeIsLocked() {
+ assertNull(api.beforeIsLocked(RESOURCE_ID));
+ }
+
+ @Test
+ public void testBeforeIsLockedBy() {
+ assertNull(api.beforeIsLockedBy(RESOURCE_ID, OWNER));
+ }
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java
new file mode 100644
index 00000000..2f8b5f83
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/PolicyResourceLockManagerTest.java
@@ -0,0 +1,509 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyBoolean;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.onap.policy.drools.core.lock.TestUtils.expectException;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.Future;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.onap.policy.drools.core.lock.PolicyResourceLockFeatureAPI.Callback;
+import org.onap.policy.drools.core.lock.PolicyResourceLockManager.Factory;
+
+public class PolicyResourceLockManagerTest {
+
+ private static final String NULL_RESOURCE_ID = "null resourceId";
+ private static final String NULL_OWNER = "null owner";
+
+ private static final String RESOURCE_A = "resource.a";
+ private static final String RESOURCE_B = "resource.b";
+ private static final String RESOURCE_C = "resource.c";
+
+ private static final String OWNER1 = "owner.one";
+ private static final String OWNER2 = "owner.two";
+ private static final String OWNER3 = "owner.three";
+
+ /**
+ * Saved at the start of the tests and restored once all tests complete.
+ */
+ private static Factory saveFactory;
+
+ private Callback callback1;
+ private PolicyResourceLockFeatureAPI impl1;
+ private PolicyResourceLockFeatureAPI impl2;
+ private List<PolicyResourceLockFeatureAPI> implList;
+
+ private Future<Boolean> fut;
+
+ private PolicyResourceLockManager mgr;
+
+ @BeforeClass
+ public static void setUpBeforeClass() {
+ saveFactory = PolicyResourceLockManager.getFactory();
+ }
+
+ @AfterClass
+ public static void tearDownAfterClass() {
+ PolicyResourceLockManager.setFactory(saveFactory);
+ }
+
+ @Before
+ public void setUp() {
+ callback1 = mock(Callback.class);
+ impl1 = mock(PolicyResourceLockFeatureAPI.class);
+ impl2 = mock(PolicyResourceLockFeatureAPI.class);
+
+ initImplementer(impl1);
+ initImplementer(impl2);
+
+ // list of feature API implementers
+ implList = new LinkedList<>(Arrays.asList(impl1, impl2));
+
+ PolicyResourceLockManager.setFactory(new Factory() {
+
+ @Override
+ public List<PolicyResourceLockFeatureAPI> getImplementers() {
+ return implList;
+ }
+ });
+
+ mgr = new PolicyResourceLockManager();
+ }
+
+ /**
+ * Initializes an implementer so it always returns {@code null}.
+ *
+ * @param impl
+ */
+ private void initImplementer(PolicyResourceLockFeatureAPI impl) {
+ when(impl.beforeLock(anyString(), anyString(), any(Callback.class))).thenReturn(null);
+ when(impl.beforeUnlock(anyString(), anyString())).thenReturn(null);
+ when(impl.beforeIsLocked(anyString())).thenReturn(null);
+ when(impl.beforeIsLockedBy(anyString(), anyString())).thenReturn(null);
+ }
+
+ @Test
+ public void testLock() throws Exception {
+ fut = mgr.lock(RESOURCE_A, OWNER1, callback1);
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ verify(impl1).beforeLock(RESOURCE_A, OWNER1, callback1);
+ verify(impl2).beforeLock(RESOURCE_A, OWNER1, callback1);
+ verify(impl1).afterLock(RESOURCE_A, OWNER1, true);
+ verify(impl2).afterLock(RESOURCE_A, OWNER1, true);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+ assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
+ assertFalse(mgr.isLocked(RESOURCE_B));
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
+
+ // null callback - not locked yet
+ fut = mgr.lock(RESOURCE_C, OWNER3, null);
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ // null callback - already locked
+ fut = mgr.lock(RESOURCE_A, OWNER3, null);
+ assertTrue(fut.isDone());
+ assertFalse(fut.get());
+ }
+
+ @Test
+ public void testLock_ArgEx() {
+ IllegalArgumentException ex =
+ expectException(IllegalArgumentException.class, xxx -> mgr.lock(null, OWNER1, callback1));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.lock(RESOURCE_A, null, callback1));
+ assertEquals(NULL_OWNER, ex.getMessage());
+
+ // this should not throw an exception
+ mgr.lock(RESOURCE_A, OWNER1, null);
+ }
+
+ @Test
+ public void testLock_BeforeIntercepted() {
+ fut = mock(LockRequestFuture.class);
+
+ // NOT async
+ when(fut.isDone()).thenReturn(true);
+
+ // have impl1 intercept
+ when(impl1.beforeLock(RESOURCE_A, OWNER1, callback1)).thenReturn(fut);
+
+ assertEquals(fut, mgr.lock(RESOURCE_A, OWNER1, callback1));
+
+ verify(impl1).beforeLock(RESOURCE_A, OWNER1, callback1);
+ verify(impl2, never()).beforeLock(anyString(), anyString(), any(Callback.class));
+
+ verify(impl1, never()).afterLock(anyString(), anyString(), anyBoolean());
+ verify(impl2, never()).afterLock(anyString(), anyString(), anyBoolean());
+ }
+
+ @Test
+ public void testLock_Acquired_AfterIntercepted() throws Exception {
+
+ // impl1 intercepts during afterLock()
+ when(impl1.afterLock(RESOURCE_A, OWNER1, true)).thenReturn(true);
+
+ fut = mgr.lock(RESOURCE_A, OWNER1, callback1);
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ // impl1 sees it, but impl2 does not
+ verify(impl1).afterLock(RESOURCE_A, OWNER1, true);
+ verify(impl2, never()).afterLock(anyString(), anyString(), anyBoolean());
+ }
+
+ @Test
+ public void testLock_Acquired() throws Exception {
+ fut = mgr.lock(RESOURCE_A, OWNER1, callback1);
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ verify(impl1).afterLock(RESOURCE_A, OWNER1, true);
+ verify(impl2).afterLock(RESOURCE_A, OWNER1, true);
+ }
+
+ @Test
+ public void testLock_Denied_AfterIntercepted() throws Exception {
+
+ mgr.lock(RESOURCE_A, OWNER1, callback1);
+
+ // impl1 intercepts during afterLock()
+ when(impl1.afterLock(RESOURCE_A, OWNER2, false)).thenReturn(true);
+
+ // owner2 tries to lock
+ fut = mgr.lock(RESOURCE_A, OWNER2, null);
+
+ assertTrue(fut.isDone());
+ assertFalse(fut.get());
+
+ // impl1 sees it, but impl2 does not
+ verify(impl1).afterLock(RESOURCE_A, OWNER2, false);
+ verify(impl2, never()).afterLock(RESOURCE_A, OWNER2, false);
+ }
+
+ @Test
+ public void testLock_Denied() {
+
+ mgr.lock(RESOURCE_A, OWNER1, callback1);
+
+ // owner2 tries to lock
+ fut = mgr.lock(RESOURCE_A, OWNER2, null);
+
+ verify(impl1).afterLock(RESOURCE_A, OWNER2, false);
+ verify(impl2).afterLock(RESOURCE_A, OWNER2, false);
+ }
+
+ @Test
+ public void testUnlock() throws Exception {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+ mgr.lock(RESOURCE_B, OWNER1, null);
+
+ assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2).beforeUnlock(RESOURCE_A, OWNER1);
+
+ verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true);
+ verify(impl2).afterUnlock(RESOURCE_A, OWNER1, true);
+ }
+
+ @Test
+ public void testUnlock_ArgEx() {
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(null, OWNER1));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(RESOURCE_A, null));
+ assertEquals(NULL_OWNER, ex.getMessage());
+ }
+
+ @Test
+ public void testUnlock_BeforeInterceptedTrue() {
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // have impl1 intercept
+ when(impl1.beforeUnlock(RESOURCE_A, OWNER1)).thenReturn(true);
+
+ assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2, never()).beforeUnlock(anyString(), anyString());
+
+ verify(impl1, never()).afterUnlock(anyString(), anyString(), anyBoolean());
+ verify(impl2, never()).afterUnlock(anyString(), anyString(), anyBoolean());
+ }
+
+ @Test
+ public void testUnlock_BeforeInterceptedFalse() {
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // have impl1 intercept
+ when(impl1.beforeUnlock(RESOURCE_A, OWNER1)).thenReturn(false);
+
+ assertFalse(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2, never()).beforeUnlock(anyString(), anyString());
+
+ verify(impl1, never()).afterUnlock(anyString(), anyString(), anyBoolean());
+ verify(impl2, never()).afterUnlock(anyString(), anyString(), anyBoolean());
+ }
+
+ @Test
+ public void testUnlock_Unlocked() {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2).beforeUnlock(RESOURCE_A, OWNER1);
+
+ verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true);
+ verify(impl2).afterUnlock(RESOURCE_A, OWNER1, true);
+ }
+
+ @Test
+ public void testUnlock_Unlocked_AfterIntercepted() {
+ // have impl1 intercept
+ when(impl1.afterUnlock(RESOURCE_A, OWNER1, true)).thenReturn(true);
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2).beforeUnlock(RESOURCE_A, OWNER1);
+
+ verify(impl1).afterUnlock(RESOURCE_A, OWNER1, true);
+ verify(impl2, never()).afterUnlock(RESOURCE_A, OWNER1, true);
+ }
+
+ @Test
+ public void testUnlock_NotUnlocked() {
+ assertFalse(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2).beforeUnlock(RESOURCE_A, OWNER1);
+
+ verify(impl1).afterUnlock(RESOURCE_A, OWNER1, false);
+ verify(impl2).afterUnlock(RESOURCE_A, OWNER1, false);
+ }
+
+ @Test
+ public void testUnlock_NotUnlocked_AfterIntercepted() {
+ // have impl1 intercept
+ when(impl1.afterUnlock(RESOURCE_A, OWNER1, false)).thenReturn(true);
+
+ assertFalse(mgr.unlock(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeUnlock(RESOURCE_A, OWNER1);
+ verify(impl2).beforeUnlock(RESOURCE_A, OWNER1);
+
+ verify(impl1).afterUnlock(RESOURCE_A, OWNER1, false);
+ verify(impl2, never()).afterUnlock(RESOURCE_A, OWNER1, false);
+ }
+
+ @Test
+ public void testIsLocked_True() {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2).beforeIsLocked(RESOURCE_A);
+ }
+
+ @Test
+ public void testIsLocked_False() {
+ assertFalse(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2).beforeIsLocked(RESOURCE_A);
+ }
+
+ @Test
+ public void testIsLocked_ArgEx() {
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLocked(null));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+ }
+
+ @Test
+ public void testIsLocked_BeforeIntercepted_True() {
+
+ // have impl1 intercept
+ when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(true);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2, never()).beforeIsLocked(RESOURCE_A);
+ }
+
+ @Test
+ public void testIsLocked_BeforeIntercepted_False() {
+
+ // lock it so we can verify that impl1 overrides the superclass isLocker()
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // have impl1 intercept
+ when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(false);
+
+ assertFalse(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2, never()).beforeIsLocked(RESOURCE_A);
+ }
+
+ @Test
+ public void testIsLockedBy_True() {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ verify(impl2).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ }
+
+ @Test
+ public void testIsLockedBy_False() {
+ // different owner
+ mgr.lock(RESOURCE_A, OWNER2, null);
+
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ verify(impl2).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ }
+
+ @Test
+ public void testIsLockedBy_ArgEx() {
+ IllegalArgumentException ex =
+ expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(null, OWNER1));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(RESOURCE_A, null));
+ assertEquals(NULL_OWNER, ex.getMessage());
+ }
+
+ @Test
+ public void testIsLockedBy_BeforeIntercepted_True() {
+
+ // have impl1 intercept
+ when(impl1.beforeIsLockedBy(RESOURCE_A, OWNER1)).thenReturn(true);
+
+ assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ verify(impl2, never()).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ }
+
+ @Test
+ public void testIsLockedBy_BeforeIntercepted_False() {
+
+ // lock it so we can verify that impl1 overrides the superclass isLocker()
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // have impl1 intercept
+ when(impl1.beforeIsLockedBy(RESOURCE_A, OWNER1)).thenReturn(false);
+
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
+
+ verify(impl1).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ verify(impl2, never()).beforeIsLockedBy(RESOURCE_A, OWNER1);
+ }
+
+ @Test
+ public void testGetInstance() {
+ PolicyResourceLockManager inst = PolicyResourceLockManager.getInstance();
+ assertNotNull(inst);
+
+ // should return the same instance each time
+ assertEquals(inst, PolicyResourceLockManager.getInstance());
+ assertEquals(inst, PolicyResourceLockManager.getInstance());
+ }
+
+ @Test
+ public void testDoIntercept_Empty() {
+ // clear the implementer list
+ implList.clear();
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+ assertFalse(mgr.isLocked(RESOURCE_B));
+
+ verify(impl1, never()).beforeIsLocked(anyString());
+ }
+
+ @Test
+ public void testDoIntercept_Impl1() {
+ when(impl1.beforeIsLocked(RESOURCE_A)).thenReturn(true);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2, never()).beforeIsLocked(anyString());
+ }
+
+ @Test
+ public void testDoIntercept_Impl2() {
+ when(impl2.beforeIsLocked(RESOURCE_A)).thenReturn(true);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2).beforeIsLocked(RESOURCE_A);
+ }
+
+ @Test
+ public void testDoIntercept_Ex() {
+ doThrow(new RuntimeException("expected exception")).when(impl1).beforeIsLocked(RESOURCE_A);
+
+ assertFalse(mgr.isLocked(RESOURCE_A));
+
+ verify(impl1).beforeIsLocked(RESOURCE_A);
+ verify(impl2).beforeIsLocked(RESOURCE_A);
+ }
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java
new file mode 100644
index 00000000..6abc5bf9
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/SimpleLockManagerTest.java
@@ -0,0 +1,280 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.onap.policy.drools.core.lock.TestUtils.expectException;
+import java.util.LinkedList;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SimpleLockManagerTest {
+
+ private static final String NULL_RESOURCE_ID = "null resourceId";
+ private static final String NULL_OWNER = "null owner";
+
+ private static final String RESOURCE_A = "resource.a";
+ private static final String RESOURCE_B = "resource.b";
+ private static final String RESOURCE_C = "resource.c";
+
+ private static final String OWNER1 = "owner.one";
+ private static final String OWNER2 = "owner.two";
+ private static final String OWNER3 = "owner.three";
+
+ private Future<Boolean> fut;
+ private SimpleLockManager mgr;
+
+ @Before
+ public void setUp() {
+ mgr = new SimpleLockManager();
+ }
+
+ @Test
+ public void testLock() throws Exception {
+ fut = mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+ assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
+ assertFalse(mgr.isLocked(RESOURCE_B));
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
+
+ // null callback - not locked yet
+ fut = mgr.lock(RESOURCE_C, OWNER3, null);
+ assertTrue(fut.isDone());
+ assertTrue(fut.get());
+
+ // null callback - already locked
+ fut = mgr.lock(RESOURCE_A, OWNER3, null);
+ assertTrue(fut.isDone());
+ assertFalse(fut.get());
+ }
+
+ @Test
+ public void testLock_AlreadyLocked() throws Exception {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ fut = mgr.lock(RESOURCE_A, OWNER2, null);
+ assertTrue(fut.isDone());
+ assertFalse(fut.get());
+ }
+
+ @Test(expected = IllegalStateException.class)
+ public void testLock_SameOwner() throws Exception {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // should throw an exception
+ mgr.lock(RESOURCE_A, OWNER1, null);
+ }
+
+ @Test
+ public void testLock_ArgEx() {
+ IllegalArgumentException ex =
+ expectException(IllegalArgumentException.class, xxx -> mgr.lock(null, OWNER1, null));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.lock(RESOURCE_A, null, null));
+ assertEquals(NULL_OWNER, ex.getMessage());
+
+ // this should not throw an exception
+ mgr.lock(RESOURCE_A, OWNER1, null);
+ }
+
+ @Test
+ public void testUnlock() throws Exception {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // unlock it
+ assertTrue(mgr.unlock(RESOURCE_A, OWNER1));
+ }
+
+ @Test
+ public void testUnlock_ArgEx() {
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(null, OWNER1));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.unlock(RESOURCE_A, null));
+ assertEquals(NULL_OWNER, ex.getMessage());
+ }
+
+ @Test
+ public void testUnlock_NotLocked() {
+ assertFalse(mgr.unlock(RESOURCE_A, OWNER1));
+ }
+
+ @Test
+ public void testIsLocked() {
+ assertFalse(mgr.isLocked(RESOURCE_A));
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+ mgr.lock(RESOURCE_B, OWNER1, null);
+
+ assertTrue(mgr.isLocked(RESOURCE_A));
+ assertTrue(mgr.isLocked(RESOURCE_B));
+ assertFalse(mgr.isLocked(RESOURCE_C));
+
+ // unlock from first resource
+ mgr.unlock(RESOURCE_A, OWNER1);
+ assertFalse(mgr.isLocked(RESOURCE_A));
+ assertTrue(mgr.isLocked(RESOURCE_B));
+ assertFalse(mgr.isLocked(RESOURCE_C));
+
+ // unlock from second resource
+ mgr.unlock(RESOURCE_B, OWNER1);
+ assertFalse(mgr.isLocked(RESOURCE_A));
+ assertFalse(mgr.isLocked(RESOURCE_B));
+ assertFalse(mgr.isLocked(RESOURCE_C));
+ }
+
+ @Test
+ public void testIsLocked_ArgEx() {
+ IllegalArgumentException ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLocked(null));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+ }
+
+ @Test
+ public void testIsLockedBy() {
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
+
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1));
+
+ assertTrue(mgr.isLockedBy(RESOURCE_A, OWNER1));
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
+
+ // unlock from the resource
+ mgr.unlock(RESOURCE_A, OWNER1);
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER1));
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
+ assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1));
+ }
+
+ @Test
+ public void testIsLockedBy_ArgEx() {
+ IllegalArgumentException ex =
+ expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(null, OWNER1));
+ assertEquals(NULL_RESOURCE_ID, ex.getMessage());
+
+ ex = expectException(IllegalArgumentException.class, xxx -> mgr.isLockedBy(RESOURCE_A, null));
+ assertEquals(NULL_OWNER, ex.getMessage());
+ }
+
+ @Test
+ public void testIsLockedBy_NotLocked() {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // different resource, thus no lock
+ assertFalse(mgr.isLockedBy(RESOURCE_B, OWNER1));
+ }
+
+ @Test
+ public void testIsLockedBy_LockedButNotOwner() {
+ mgr.lock(RESOURCE_A, OWNER1, null);
+
+ // different owner
+ assertFalse(mgr.isLockedBy(RESOURCE_A, OWNER2));
+ }
+
+ @Test
+ public void testMultiThreaded() throws InterruptedException {
+ int nthreads = 10;
+ int nlocks = 100;
+
+ LinkedList<Thread> threads = new LinkedList<>();
+
+ String[] resources = {RESOURCE_A, RESOURCE_B};
+
+ AtomicInteger nfail = new AtomicInteger(0);
+
+ CountDownLatch stopper = new CountDownLatch(1);
+ CountDownLatch completed = new CountDownLatch(nthreads);
+
+ for (int x = 0; x < nthreads; ++x) {
+ String owner = "owner." + x;
+
+ Thread t = new Thread() {
+ @Override
+ public void run() {
+
+ for (int y = 0; y < nlocks; ++y) {
+ String res = resources[y % resources.length];
+
+ try {
+ // some locks will be acquired, some denied
+ mgr.lock(res, owner, null).get();
+
+ // do some "work"
+ stopper.await(1L, TimeUnit.MILLISECONDS);
+
+ mgr.unlock(res, owner);
+
+ } catch (CancellationException | ExecutionException e) {
+ nfail.incrementAndGet();
+
+ } catch (InterruptedException expected) {
+ Thread.currentThread().interrupt();
+ break;
+ }
+ }
+
+ completed.countDown();
+ }
+ };
+
+ t.setDaemon(true);
+ threads.add(t);
+ }
+
+ // start the threads
+ for (Thread t : threads) {
+ t.start();
+ }
+
+ // wait for them to complete
+ completed.await(5000L, TimeUnit.SECONDS);
+
+ // stop the threads from sleeping
+ stopper.countDown();
+
+ completed.await(1L, TimeUnit.SECONDS);
+
+ // interrupt those that are still alive
+ for (Thread t : threads) {
+ if (t.isAlive()) {
+ t.interrupt();
+ }
+ }
+
+ assertEquals(0, nfail.get());
+ }
+
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java
new file mode 100644
index 00000000..2e353936
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/TestUtils.java
@@ -0,0 +1,59 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.drools.core.lock;
+
+public class TestUtils {
+
+ /**
+ * Invokes a function that is expected to throw an exception.
+ *
+ * @param clazz class of exception that is expected
+ * @param func
+ * @return
+ */
+ public static <T> T expectException(Class<T> clazz, VoidFunction func) {
+ try {
+ func.apply(null);
+ throw new AssertionError("missing exception");
+
+ } catch (Exception e) {
+ try {
+ return clazz.cast(e);
+
+ } catch (ClassCastException e2) {
+ throw new AssertionError("incorrect exception type", e2);
+ }
+ }
+ }
+
+ /**
+ * Void function that may throw an exception.
+ */
+ @FunctionalInterface
+ public static interface VoidFunction {
+
+ /**
+ *
+ * @param arg always {@code null}
+ */
+ public void apply(Void arg) throws Exception;
+ }
+}