add no locking feature

It provides an interface to applications for locking
purposes that always succeeds.  It does not deny
acquiring resource locks.

Issue-ID: POLICY-3114
Signed-off-by: jhh <jorge.hernandez-herrero@att.com>
Change-Id: I6aebb5f40e4176e0ff7b0e6c6d4042a79dd0b7a3
Signed-off-by: jhh <jorge.hernandez-herrero@att.com>

4 files changed, 208 insertions, 57 deletions

diff --git a/policy-core/src/main/java/org/onap/policy/drools/core/lock/AlwaysSuccessLock.java b/policy-core/src/main/java/org/onap/policy/drools/core/lock/AlwaysSuccessLock.java
new file mode 100644
index 00000000..6b1e1494
--- /dev/null
+++ b/policy-core/src/main/java/org/onap/policy/drools/core/lock/AlwaysSuccessLock.java
@@ -0,0 +1,64 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2021 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 lombok.NonNull;
+
+/**
+ * Lock implementation whose operations always succeed.
+ */
+public class AlwaysSuccessLock extends LockImpl {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Overrides parent constructor.
+     */
+    public AlwaysSuccessLock() {
+        setState(LockState.ACTIVE);
+    }
+
+    /**
+     * Overrides parent constructor.
+     */
+    public AlwaysSuccessLock(@NonNull LockState state, @NonNull String resourceId,
+            @NonNull String ownerKey, int holdSec, @NonNull LockCallback callback) {
+        super(state, resourceId, ownerKey, holdSec, callback);
+        if (!isActive()) {
+            throw new IllegalArgumentException("AlwaysSuccessLock can only be created in the active state");
+        }
+    }
+
+    /**
+     * Constructs the object.
+     */
+    public AlwaysSuccessLock(@NonNull String resourceId, @NonNull String ownerKey,
+            int holdSec, @NonNull LockCallback callback) {
+        super(LockState.ACTIVE, resourceId, ownerKey, holdSec, callback);
+    }
+
+    /**
+     * Always returns true.
+     */
+    @Override
+    public synchronized boolean free() {
+        return true;
+    }
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysFailLockTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysFailLockTest.java
index 06489a5c..178ef0af 100644
--- a/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysFailLockTest.java
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysFailLockTest.java
@@ -2,7 +2,7 @@
  * ============LICENSE_START=======================================================
  * ONAP
  * ================================================================================
- * Copyright (C) 2019-2020 AT&T Intellectual Property. All rights reserved.
+ * Copyright (C) 2021 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.
@@ -21,73 +21,29 @@
 package org.onap.policy.drools.core.lock;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
-import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
 import org.junit.Before;
 import org.junit.Test;
 
-public class AlwaysFailLockTest {
-    private static final String RESOURCE = "hello";
-    private static final String OWNER_KEY = "world";
-    private static final int HOLD_SEC = 10;
-    private static final int HOLD_SEC2 = 10;
+public class AlwaysFailLockTest extends AlwaysLockBaseTest<AlwaysFailLock> {
 
-    private LockCallback callback;
-    private AlwaysFailLock lock;
-
-    /**
-     * Populates {@link #lock}.
-     */
     @Before
     public void setUp() {
         callback = mock(LockCallback.class);
-
         lock = new AlwaysFailLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback);
     }
 
     @Test
-    public void testSerializable() throws Exception {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
-            oos.writeObject(lock);
-        }
-
-        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
-        try (ObjectInputStream ois = new ObjectInputStream(bais)) {
-            lock = (AlwaysFailLock) ois.readObject();
-        }
-
-        assertEquals(LockState.UNAVAILABLE, lock.getState());
-        assertEquals(RESOURCE, lock.getResourceId());
-        assertEquals(OWNER_KEY, lock.getOwnerKey());
-        assertEquals(HOLD_SEC, lock.getHoldSec());
-
-        // these fields are transient
-        assertNull(lock.getCallback());
-    }
-
-    @Test
     public void testAlwaysFailLockNoArgs() {
-        // verify that no-arg constructor doesn't throw an exception
-        assertThatCode(() -> new AlwaysFailLock()).doesNotThrowAnyException();
+        assertThatCode(AlwaysFailLock::new).doesNotThrowAnyException();
     }
 
     @Test
-    public void testAlwaysFailLock() {
+    public void testUnavailableLock() {
         assertTrue(lock.isUnavailable());
-        assertEquals(RESOURCE, lock.getResourceId());
-        assertEquals(OWNER_KEY, lock.getOwnerKey());
-        assertEquals(HOLD_SEC, lock.getHoldSec());
-        assertSame(callback, lock.getCallback());
     }
 
     @Test
@@ -95,13 +51,4 @@ public class AlwaysFailLockTest {
         assertFalse(lock.free());
         assertTrue(lock.isUnavailable());
     }
-
-    @Test
-    public void testExtend() {
-        LockCallback callback2 = mock(LockCallback.class);
-        lock.extend(HOLD_SEC2, callback2);
-
-        assertEquals(HOLD_SEC2, lock.getHoldSec());
-        assertSame(callback2, lock.getCallback());
-    }
 }
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysLockBaseTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysLockBaseTest.java
new file mode 100644
index 00000000..1091b260
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysLockBaseTest.java
@@ -0,0 +1,71 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2021 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.assertNull;
+import static org.junit.Assert.assertSame;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import org.junit.Test;
+
+public abstract class AlwaysLockBaseTest<T extends LockImpl> {
+    protected static final String RESOURCE = "hello";
+    protected static final String OWNER_KEY = "world";
+    protected static final int HOLD_SEC = 10;
+    protected static final int HOLD_SEC2 = 10;
+
+    protected LockCallback callback;
+    protected T lock;
+
+    @Test
+    public void testSerializable() throws Exception {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
+            oos.writeObject(lock);
+        }
+
+        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
+        T lock2;
+        try (ObjectInputStream ois = new ObjectInputStream(bais)) {
+            lock2 = (T) ois.readObject();
+        }
+
+        assertEquals(lock.getState(), lock2.getState());
+        assertEquals(lock.getResourceId(), lock2.getResourceId());
+        assertEquals(lock.getOwnerKey(), lock2.getOwnerKey());
+        assertEquals(lock.getHoldSec(), lock2.getHoldSec());
+
+        // these fields are transient
+        assertNull(lock2.getCallback());
+    }
+
+    @Test
+    public void testAlwaysLockData() {
+        assertEquals(RESOURCE, lock.getResourceId());
+        assertEquals(OWNER_KEY, lock.getOwnerKey());
+        assertEquals(HOLD_SEC, lock.getHoldSec());
+        assertSame(callback, lock.getCallback());
+    }
+}
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysSuccessLockTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysSuccessLockTest.java
new file mode 100644
index 00000000..32889484
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/lock/AlwaysSuccessLockTest.java
@@ -0,0 +1,69 @@
+/*
+ * ============LICENSE_START=======================================================
+ * ONAP
+ * ================================================================================
+ * Copyright (C) 2021 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.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class AlwaysSuccessLockTest extends AlwaysLockBaseTest<AlwaysSuccessLock> {
+
+    @Before
+    public void setUp() {
+        callback = mock(LockCallback.class);
+        lock = new AlwaysSuccessLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback);
+    }
+
+    @Test
+    public void testAlwaysSuccessLockConstructors() {
+        assertThatCode(AlwaysSuccessLock::new).doesNotThrowAnyException();
+        assertThatCode(() -> new AlwaysSuccessLock(LockState.ACTIVE, RESOURCE, OWNER_KEY, HOLD_SEC, callback))
+            .doesNotThrowAnyException();
+        assertThatIllegalArgumentException()
+            .isThrownBy(() -> new AlwaysSuccessLock(LockState.UNAVAILABLE, RESOURCE, OWNER_KEY, HOLD_SEC, callback));
+    }
+
+    @Test
+    public void testActiveLock() {
+        assertTrue(lock.isActive());
+    }
+
+    @Test
+    public void testFree() {
+        assertTrue(lock.free());
+        assertTrue(lock.isActive());
+    }
+
+    @Test
+    public void testExtend() {
+        LockCallback callback2 = mock(LockCallback.class);
+        lock.extend(HOLD_SEC2, callback2);
+
+        assertEquals(HOLD_SEC2, lock.getHoldSec());
+        assertSame(callback2, lock.getCallback());
+    }
+}