Increase code coverage in policy-core and policy-utils

Issue-ID: POLICY-5068
Change-Id: I598b674fd623ff56c2e7b0316c114e7c270c2b3f
Signed-off-by: adheli.tavares <adheli.tavares@est.tech>

6 files changed, 387 insertions, 52 deletions

diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/DroolsContainerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/DroolsContainerTest.java
index abed9727..d6804b60 100644
--- a/policy-core/src/test/java/org/onap/policy/drools/core/DroolsContainerTest.java
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/DroolsContainerTest.java
@@ -79,44 +79,7 @@ public class DroolsContainerTest {
      */
     @Test
     void createAndUpdate() throws Exception {
-        // make sure feature log starts out clean
-        PolicySessionFeatureApiMock.getLog();
-
-        // run 'globalInit', and verify expected feature hook fired
-        PolicyContainer.globalInit(new String[0]);
-        assertEquals(List.of("globalInit"),
-                PolicySessionFeatureApiMock.getLog());
-
-        // initial conditions -- there should be no containers
-        assertEquals(0, PolicyContainer.getPolicyContainers().size());
-
-        // create the container, and start it
-        PolicyContainer container =
-                new PolicyContainer("org.onap.policy.drools-pdp",
-                        "drools-artifact1", "17.1.0-SNAPSHOT");
-        container.start();
-        assertTrue(container.isAlive());
-
-        // verify expected feature hooks fired
-        assertEquals(Arrays.asList("activatePolicySession",
-                "newPolicySession",
-                "selectThreadModel"),
-                PolicySessionFeatureApiMock.getLog());
-
-        // this container should be on the list
-        {
-            Collection<PolicyContainer> containers =
-                    PolicyContainer.getPolicyContainers();
-            assertEquals(1, containers.size());
-            assertTrue(containers.contains(container));
-        }
-
-        // verify initial container attributes
-        assertEquals("org.onap.policy.drools-pdp:drools-artifact1:17.1.0-SNAPSHOT",
-                container.getName());
-        assertEquals("org.onap.policy.drools-pdp", container.getGroupId());
-        assertEquals("drools-artifact1", container.getArtifactId());
-        assertEquals("17.1.0-SNAPSHOT", container.getVersion());
+        PolicyContainer container = validateCreatedContainer();
 
         try {
             // fetch the session, and verify that it exists
@@ -225,20 +188,17 @@ public class DroolsContainerTest {
 
         // run 'globalInit', and verify expected feature hook fired
         PolicyContainer.globalInit(new String[0]);
-        assertEquals(List.of("globalInit-exception"),
-                PolicySessionFeatureApiMock.getLog());
+        assertEquals(List.of("globalInit-exception"), PolicySessionFeatureApiMock.getLog());
 
         // initial conditions -- there should be no containers
         assertEquals(0, PolicyContainer.getPolicyContainers().size());
 
-        String versionList =
-                "17.3.0-SNAPSHOT,17.1.0-SNAPSHOT,17.2.0-SNAPSHOT";
+        String versionList = "17.3.0-SNAPSHOT,17.1.0-SNAPSHOT,17.2.0-SNAPSHOT";
 
         // versions should be tried in order -- the 17.1.0-SNAPSHOT should "win",
         // given the fact that '17.3.0-SNAPSHOT' doesn't exist
         PolicyContainer container =
-                new PolicyContainer("org.onap.policy.drools-pdp",
-                        "drools-artifact1", versionList);
+                new PolicyContainer("org.onap.policy.drools-pdp", "drools-artifact1", versionList);
         // the following should be equivalent to 'container.start()'
         PolicyContainer.activate();
         assertTrue(container.isAlive());
@@ -251,15 +211,12 @@ public class DroolsContainerTest {
 
         // this container should be on the list
         {
-            Collection<PolicyContainer> containers =
-                    PolicyContainer.getPolicyContainers();
-            assertEquals(1, containers.size());
-            assertTrue(containers.contains(container));
+            Collection<PolicyContainer> containers = PolicyContainer.getPolicyContainers();
+            assertTrue(containers.contains(container) && (containers.size() == 1));
         }
 
         // verify initial container attributes
-        assertEquals("org.onap.policy.drools-pdp:drools-artifact1:17.1.0-SNAPSHOT",
-                container.getName());
+        assertEquals("org.onap.policy.drools-pdp:drools-artifact1:17.1.0-SNAPSHOT", container.getName());
         assertEquals("org.onap.policy.drools-pdp", container.getGroupId());
         assertEquals("drools-artifact1", container.getArtifactId());
         assertEquals("17.1.0-SNAPSHOT", container.getVersion());
@@ -288,8 +245,7 @@ public class DroolsContainerTest {
             // get all sessions, and verify that this one is the only one
             {
                 Collection<PolicySession> sessions = container.getPolicySessions();
-                assertEquals(1, sessions.size());
-                assertTrue(sessions.contains(session));
+                assertTrue(sessions.contains(session) && (1 == sessions.size()));
             }
 
             // verify session attributes
@@ -341,4 +297,50 @@ public class DroolsContainerTest {
         // final conditions -- there should be no containers
         assertEquals(0, PolicyContainer.getPolicyContainers().size());
     }
+
+    /**
+     * Creates a policy container.
+     * @return a container used on create and update test
+     */
+    private static PolicyContainer validateCreatedContainer() {
+        // make sure feature log starts out clean
+        PolicySessionFeatureApiMock.getLog();
+
+        // run 'globalInit', and verify expected feature hook fired
+        PolicyContainer.globalInit(new String[0]);
+        assertEquals(List.of("globalInit"),
+            PolicySessionFeatureApiMock.getLog());
+
+        // initial conditions -- there should be no containers
+        assertEquals(0, PolicyContainer.getPolicyContainers().size());
+
+        // create the container, and start it
+        PolicyContainer container =
+            new PolicyContainer("org.onap.policy.drools-pdp",
+                "drools-artifact1", "17.1.0-SNAPSHOT");
+        container.start();
+        assertTrue(container.isAlive());
+
+        // verify expected feature hooks fired
+        assertEquals(Arrays.asList("activatePolicySession",
+                "newPolicySession",
+                "selectThreadModel"),
+            PolicySessionFeatureApiMock.getLog());
+
+        // this container should be on the list
+        {
+            Collection<PolicyContainer> containers =
+                PolicyContainer.getPolicyContainers();
+            assertEquals(1, containers.size());
+            assertTrue(containers.contains(container));
+        }
+
+        // verify initial container attributes
+        assertEquals("org.onap.policy.drools-pdp:drools-artifact1:17.1.0-SNAPSHOT",
+            container.getName());
+        assertEquals("org.onap.policy.drools-pdp", container.getGroupId());
+        assertEquals("drools-artifact1", container.getArtifactId());
+        assertEquals("17.1.0-SNAPSHOT", container.getVersion());
+        return container;
+    }
 }
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/PolicyContainerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/PolicyContainerTest.java
new file mode 100644
index 00000000..72c8d2d3
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/PolicyContainerTest.java
@@ -0,0 +1,230 @@
+/*-
+ * ============LICENSE_START================================================
+ * policy-core
+ * =========================================================================
+ * Copyright (C) 2024 Nordix Foundation.
+ * =========================================================================
+ * 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;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.doCallRealMethod;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.kie.api.KieBase;
+import org.kie.api.KieServices;
+import org.kie.api.builder.KieScanner;
+import org.kie.api.builder.ReleaseId;
+import org.kie.api.event.rule.AgendaEventListener;
+import org.kie.api.event.rule.RuleRuntimeEventListener;
+import org.kie.api.runtime.KieContainer;
+import org.kie.api.runtime.KieSession;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.springframework.test.util.ReflectionTestUtils;
+
+class PolicyContainerTest {
+
+    private static final String VERSION = "1.0.0";
+
+    @Test
+    void adoptKieSession_Exceptions() {
+        var mockKieSession = mock(KieSession.class);
+        var policyContainer = mock(PolicyContainer.class);
+
+        when(policyContainer.getName()).thenReturn("kieReleaseName");
+        when(policyContainer.adoptKieSession(any(), eq(mockKieSession))).thenCallRealMethod();
+        when(policyContainer.adoptKieSession("name", null)).thenCallRealMethod();
+
+        assertThatThrownBy(() -> policyContainer.adoptKieSession("", mockKieSession))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("KieSession input name is null kieReleaseName");
+
+        assertThatThrownBy(() -> policyContainer.adoptKieSession(null, mockKieSession))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("KieSession input name is null kieReleaseName");
+
+        assertThatThrownBy(() -> policyContainer.adoptKieSession("name", null))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("KieSession 'name' is null kieReleaseName");
+    }
+
+    @Test
+    void testAdoptKieSession() {
+        var mockKieSession = mock(KieSession.class);
+        doNothing().when(mockKieSession).addEventListener(any(AgendaEventListener.class));
+        doNothing().when(mockKieSession).addEventListener(any(RuleRuntimeEventListener.class));
+
+        var policyContainer = mock(PolicyContainer.class);
+        when(policyContainer.adoptKieSession("name", mockKieSession)).thenCallRealMethod();
+        when(policyContainer.getName()).thenReturn("kieReleaseName");
+
+        var mockKieBase = mock(KieBase.class);
+        when(mockKieSession.getKieBase()).thenReturn(mockKieBase);
+
+        var mockKieContainer = mock(KieContainer.class);
+        when(policyContainer.getKieContainer()).thenReturn(mockKieContainer);
+        when(mockKieContainer.getKieBase("baseName")).thenReturn(mockKieBase);
+        when(mockKieContainer.getKieBaseNames()).thenReturn(List.of("baseName"));
+        when(mockKieContainer.getKieBase()).thenReturn(mockKieBase);
+
+        HashMap<String, PolicySession> sessions = new HashMap<>();
+        ReflectionTestUtils.setField(policyContainer, "sessions", sessions);
+        ReflectionTestUtils.setField(policyContainer, "kieContainer", mockKieContainer);
+
+        assertNotNull(policyContainer.adoptKieSession("name", mockKieSession));
+        assertThatThrownBy(() -> policyContainer.adoptKieSession("name", mockKieSession))
+            .isInstanceOf(IllegalStateException.class)
+            .hasMessageContaining("PolicySession 'name' already exists");
+    }
+
+    @Test
+    void testAdoptKieSession_KieBaseDoesntMatch() {
+        var mockKieSession = mock(KieSession.class);
+
+        var policyContainer = mock(PolicyContainer.class);
+        when(policyContainer.adoptKieSession("name", mockKieSession)).thenCallRealMethod();
+        when(policyContainer.getName()).thenReturn("kieReleaseName");
+
+        var mockKieBase = mock(KieBase.class);
+        when(mockKieSession.getKieBase()).thenReturn(mockKieBase);
+        var mockKieBase2 = mock(KieBase.class);
+
+        var mockKieContainer = mock(KieContainer.class);
+        when(policyContainer.getKieContainer()).thenReturn(mockKieContainer);
+        when(mockKieContainer.getKieBase("baseName")).thenReturn(mockKieBase2);
+        when(mockKieContainer.getKieBaseNames()).thenReturn(List.of("baseName"));
+        when(mockKieContainer.getKieBase()).thenReturn(mockKieBase2);
+
+        ReflectionTestUtils.setField(policyContainer, "kieContainer", mockKieContainer);
+
+        assertThatThrownBy(() -> policyContainer.adoptKieSession("name", mockKieSession))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("KieSession 'name' does not reside within container kieReleaseName");
+    }
+
+    @Test
+    void startScanner_Exceptions() {
+        var policyContainer = mock(PolicyContainer.class);
+        doCallRealMethod().when(policyContainer).startScanner(any(ReleaseId.class));
+        doCallRealMethod().when(policyContainer).startScanner(isNull());
+        when(policyContainer.isScannerStarted()).thenCallRealMethod();
+
+        assertThatThrownBy(() -> policyContainer.startScanner(null))
+            .hasMessageContaining("releaseId is marked non-null but is null");
+        assertFalse(policyContainer.isScannerStarted());
+
+        // shouldn't throw exception, but won't start scanner as version is null
+        var mockVersionNull = mock(ReleaseId.class);
+        when(mockVersionNull.getVersion()).thenReturn(null);
+        when(policyContainer.isValidVersion(isNull())).thenCallRealMethod();
+        assertDoesNotThrow(() -> policyContainer.startScanner(mockVersionNull));
+        assertFalse(policyContainer.isScannerStarted());
+
+        var mockVersionSnapshot = mock(ReleaseId.class);
+        when(mockVersionSnapshot.getVersion()).thenReturn(VERSION);
+        when(policyContainer.isValidVersion(VERSION)).thenCallRealMethod();
+        assertDoesNotThrow(() -> policyContainer.startScanner(mockVersionSnapshot));
+        assertFalse(policyContainer.isScannerStarted());
+    }
+
+    @Test
+    void startScanner_SnapshotVersion() {
+        var policyContainer = mock(PolicyContainer.class);
+        when(policyContainer.isScannerStarted()).thenCallRealMethod();
+        when(policyContainer.isValidVersion(VERSION + "-SNAPSHOT")).thenCallRealMethod();
+
+        var mockVersionSnapshot = mock(ReleaseId.class);
+        when(mockVersionSnapshot.getVersion()).thenReturn(VERSION + "-SNAPSHOT");
+
+        doCallRealMethod().when(policyContainer).startScanner(mockVersionSnapshot);
+
+        assertDoesNotThrow(() -> policyContainer.startScanner(mockVersionSnapshot));
+        assertTrue(policyContainer.isScannerStarted());
+    }
+
+    @Test
+    void startScanner_LatestVersion() {
+        var policyContainer = mock(PolicyContainer.class);
+        when(policyContainer.isScannerStarted()).thenCallRealMethod();
+        when(policyContainer.isValidVersion(anyString())).thenCallRealMethod();
+
+        var mockLatestVersion = mock(ReleaseId.class);
+        when(mockLatestVersion.getVersion()).thenReturn(VERSION + "LATEST");
+
+        doCallRealMethod().when(policyContainer).startScanner(mockLatestVersion);
+
+        assertDoesNotThrow(() -> policyContainer.startScanner(mockLatestVersion));
+        assertTrue(policyContainer.isScannerStarted());
+    }
+
+    @Test
+    void startScanner_ReleaseVersion() {
+        var mockKieServices = mock(KieServices.class);
+        when(mockKieServices.newKieScanner(any(KieContainer.class))).thenReturn(mock(KieScanner.class));
+
+        try (MockedStatic<KieServices.Factory> factory = Mockito.mockStatic(KieServices.Factory.class)) {
+            factory.when(KieServices.Factory::get).thenReturn(mockKieServices);
+            assertEquals(mockKieServices, KieServices.Factory.get());
+
+            var policyContainer = mock(PolicyContainer.class);
+            when(policyContainer.isScannerStarted()).thenCallRealMethod();
+            when(policyContainer.isValidVersion(VERSION + "RELEASE")).thenCallRealMethod();
+
+            var mockLatestVersion = mock(ReleaseId.class);
+            when(mockLatestVersion.getVersion()).thenReturn(VERSION + "RELEASE");
+
+            doCallRealMethod().when(policyContainer).startScanner(mockLatestVersion);
+
+            assertDoesNotThrow(() -> policyContainer.startScanner(mockLatestVersion));
+            assertTrue(policyContainer.isScannerStarted());
+
+            // try again, but should come out at checking if scanner is already started.
+            assertDoesNotThrow(() -> policyContainer.startScanner(mockLatestVersion));
+        }
+    }
+
+    @Test
+    void insert() {
+        var policyContainer = mock(PolicyContainer.class);
+        var object = new Object();
+        when(policyContainer.insert("name", object)).thenCallRealMethod();
+
+        HashMap<String, PolicySession> sessions = new HashMap<>();
+        ReflectionTestUtils.setField(policyContainer, "sessions", sessions);
+
+        assertFalse(policyContainer.insert("name", object));
+    }
+
+    @Test
+    void deactivate() {
+        assertDoesNotThrow(PolicyContainer::deactivate);
+    }
+}
\ No newline at end of file
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/PolicySessionFeatureApiMock.java b/policy-core/src/test/java/org/onap/policy/drools/core/PolicySessionFeatureApiMock.java
index d8257067..f0e5b516 100644
--- a/policy-core/src/test/java/org/onap/policy/drools/core/PolicySessionFeatureApiMock.java
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/PolicySessionFeatureApiMock.java
@@ -86,6 +86,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public void globalInit(String[] args, String configDir) {
         addLog("globalInit");
     }
@@ -93,6 +94,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public KieSession activatePolicySession(PolicyContainer policyContainer, String name, String kieBaseName) {
         addLog("activatePolicySession");
         return null;
@@ -101,6 +103,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public void newPolicySession(PolicySession policySession) {
         addLog("newPolicySession");
     }
@@ -108,6 +111,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public PolicySession.ThreadModel selectThreadModel(PolicySession session) {
         addLog("selectThreadModel");
         return null;
@@ -116,6 +120,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public void disposeKieSession(PolicySession policySession) {
         addLog("disposeKieSession");
     }
@@ -123,6 +128,7 @@ public class PolicySessionFeatureApiMock implements PolicySessionFeatureApi {
     /**
      * {@inheritDoc}.
      */
+    @Override
     public void destroyKieSession(PolicySession policySession) {
         addLog("destroyKieSession");
     }
diff --git a/policy-core/src/test/java/org/onap/policy/drools/core/jmx/PdpJmxListenerTest.java b/policy-core/src/test/java/org/onap/policy/drools/core/jmx/PdpJmxListenerTest.java
new file mode 100644
index 00000000..d81dc3e9
--- /dev/null
+++ b/policy-core/src/test/java/org/onap/policy/drools/core/jmx/PdpJmxListenerTest.java
@@ -0,0 +1,66 @@
+/*-
+ * ============LICENSE_START===============================================
+ * ONAP
+ * ========================================================================
+ * Copyright (C) 2024 Nordix Foundation.
+ * ========================================================================
+ * 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.jmx;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.management.ManagementFactory;
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanRegistrationException;
+import javax.management.MBeanServer;
+import javax.management.MalformedObjectNameException;
+import javax.management.NotCompliantMBeanException;
+import javax.management.ObjectName;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+class PdpJmxListenerTest {
+
+    @Test
+    void test() {
+        Assertions.assertDoesNotThrow(PdpJmxListener::start);
+        Assertions.assertDoesNotThrow(PdpJmxListener::stop);
+    }
+
+    @Test
+    void testExceptions()
+        throws MalformedObjectNameException, NotCompliantMBeanException, InstanceAlreadyExistsException,
+        MBeanRegistrationException, InstanceNotFoundException {
+
+        var mockMBean = Mockito.mock(MBeanServer.class);
+        Mockito.doThrow(MBeanRegistrationException.class).when(mockMBean)
+            .registerMBean(PdpJmx.getInstance(), new ObjectName("PolicyEngine:type=PdpJmx"));
+        Mockito.doThrow(MBeanRegistrationException.class).when(mockMBean)
+            .unregisterMBean(new ObjectName("PolicyEngine:type=PdpJmx"));
+
+        // trying to reach exception catch clause, but can't validate if exception was thrown
+        try (MockedStatic<ManagementFactory> factory = Mockito.mockStatic(ManagementFactory.class)) {
+            factory.when(ManagementFactory::getPlatformMBeanServer).thenReturn(mockMBean);
+            assertEquals(mockMBean, ManagementFactory.getPlatformMBeanServer());
+
+            Assertions.assertDoesNotThrow(PdpJmxListener::start);
+            Assertions.assertDoesNotThrow(PdpJmxListener::stop);
+        }
+    }
+}
\ No newline at end of file
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 51273d7d..02c3fead 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
@@ -22,6 +22,7 @@
 package org.onap.policy.drools.core.lock;
 
 import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
@@ -52,4 +53,9 @@ class AlwaysFailLockTest extends AlwaysLockBaseTest<AlwaysFailLock> {
         assertFalse(lock.free());
         assertTrue(lock.isUnavailable());
     }
+
+    @Test
+    void testExtend() {
+        assertDoesNotThrow(() -> lock.extend(10, callback));
+    }
 }
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
index 80f81f92..0104d0a8 100644
--- 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
@@ -25,6 +25,7 @@ import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.Mockito.mock;
 
@@ -67,4 +68,28 @@ class AlwaysSuccessLockTest extends AlwaysLockBaseTest<AlwaysSuccessLock> {
         assertEquals(HOLD_SEC2, lock.getHoldSec());
         assertSame(callback2, lock.getCallback());
     }
+
+    @Test
+    void testNullArgs() {
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(null, RESOURCE, OWNER_KEY, HOLD_SEC, callback));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(LockState.WAITING, null, OWNER_KEY, HOLD_SEC, callback));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(LockState.WAITING, RESOURCE, null, HOLD_SEC, callback));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(LockState.WAITING, RESOURCE, OWNER_KEY, HOLD_SEC, null));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(null, OWNER_KEY, HOLD_SEC, callback));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(RESOURCE, null, HOLD_SEC, callback));
+
+        assertThrows(NullPointerException.class,
+            () -> new AlwaysSuccessLock(RESOURCE, OWNER_KEY, HOLD_SEC, null));
+    }
 }