policy-management/src/test/java/org/onap/policy/drools/system/internal/LockManagerTest.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2024 Nordix Foundation.
   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.onap.policy.drools.system.internal;
  23
  24 import static org.junit.jupiter.api.Assertions.assertFalse;
  25 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
  26 import static org.junit.jupiter.api.Assertions.assertNotNull;
  27 import static org.junit.jupiter.api.Assertions.assertTrue;
  28 import static org.mockito.ArgumentMatchers.any;
  29 import static org.mockito.Mockito.doAnswer;
  30 import static org.mockito.Mockito.mock;
  31 import static org.mockito.Mockito.never;
  32 import static org.mockito.Mockito.spy;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35
  36 import java.io.Serial;
  37 import java.util.concurrent.ScheduledExecutorService;
  38 import org.junit.jupiter.api.AfterEach;
  39 import org.junit.jupiter.api.BeforeEach;
  40 import org.junit.jupiter.api.Test;
  41 import org.mockito.Mock;
  42 import org.mockito.MockitoAnnotations;
  43 import org.onap.policy.drools.core.lock.AlwaysFailLock;
  44 import org.onap.policy.drools.core.lock.Lock;
  45 import org.onap.policy.drools.core.lock.LockCallback;
  46 import org.onap.policy.drools.core.lock.LockState;
  47
  48 class LockManagerTest {
  49     private static final String OWNER_KEY = "my key";
  50     private static final String RESOURCE = "my resource";
  51     private static final String RESOURCE2 = "my resource #2";
  52     private static final int HOLD_SEC = 100;
  53
  54     @Mock
  55     private LockCallback callback;
  56
  57     @Mock
  58     private ScheduledExecutorService exsvc;
  59
  60     private MyManager mgr;
  61
  62     private AutoCloseable closeable;
  63
  64     /**
  65      * Resets fields and creates {@link #mgr}.
  66      */
  67     @BeforeEach
  68     public void setUp() {
  69         closeable = MockitoAnnotations.openMocks(this);
  70
  71         doAnswer(args -> {
  72             args.getArgument(0, Runnable.class).run();
  73             return null;
  74         }).when(exsvc).execute(any());
  75
  76         mgr = new MyManager();
  77     }
  78
  79     @AfterEach
  80     public void tearDown() throws Exception {
  81         closeable.close();
  82     }
  83
  84     @Test
  85     void testIsAlive() {
  86         assertFalse(mgr.isAlive());
  87         assertFalse(mgr.isLocked());
  88
  89         mgr.start();
  90         assertTrue(mgr.isAlive());
  91         assertFalse(mgr.isLocked());
  92
  93         mgr.stop();
  94         assertFalse(mgr.isAlive());
  95     }
  96
  97     @Test
  98     void testStart() {
  99         assertTrue(mgr.start());
 100         assertTrue(mgr.isAlive());
 101
 102         assertFalse(mgr.start());
 103         assertTrue(mgr.isAlive());
 104
 105         mgr.stop();
 106         assertTrue(mgr.start());
 107         assertTrue(mgr.isAlive());
 108     }
 109
 110     @Test
 111     void testStop() {
 112         assertFalse(mgr.stop());
 113
 114         mgr.start();
 115         assertTrue(mgr.stop());
 116         assertFalse(mgr.isAlive());
 117     }
 118
 119     @Test
 120     void testShutdown() {
 121         mgr.start();
 122         mgr.shutdown();
 123         assertFalse(mgr.isAlive());
 124
 125         mgr.shutdown();
 126         assertFalse(mgr.isAlive());
 127     }
 128
 129     @Test
 130     void testIsLocked() {
 131         assertFalse(mgr.isLocked());
 132         assertFalse(mgr.isAlive());
 133
 134         mgr.lock();
 135         assertTrue(mgr.isLocked());
 136         assertFalse(mgr.isAlive());
 137
 138         mgr.unlock();
 139         assertFalse(mgr.isLocked());
 140     }
 141
 142     @Test
 143     void testLock() {
 144         assertTrue(mgr.lock());
 145         assertTrue(mgr.isLocked());
 146
 147         assertFalse(mgr.lock());
 148         assertTrue(mgr.isLocked());
 149
 150         mgr.unlock();
 151         assertTrue(mgr.lock());
 152         assertTrue(mgr.isLocked());
 153     }
 154
 155     @Test
 156     void testUnlock() {
 157         assertFalse(mgr.unlock());
 158
 159         mgr.lock();
 160         assertTrue(mgr.unlock());
 161         assertFalse(mgr.isLocked());
 162     }
 163
 164     @Test
 165     void testCreateLock() {
 166         Lock lock = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
 167         assertTrue(lock.isActive());
 168         verify(callback).lockAvailable(lock);
 169         verify(callback, never()).lockUnavailable(lock);
 170
 171         // should not be able to lock it again
 172         LockCallback callback2 = mock(LockCallback.class);
 173         Lock lock2 = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback2, false);
 174         assertTrue(lock2.isUnavailable());
 175         verify(callback2, never()).lockAvailable(lock2);
 176         verify(callback2).lockUnavailable(lock2);
 177
 178         // should be able to lock another resource
 179         LockCallback callback3 = mock(LockCallback.class);
 180         Lock lock3 = mgr.createLock(RESOURCE2, OWNER_KEY, HOLD_SEC, callback3, false);
 181         assertTrue(lock3.isActive());
 182         verify(callback3).lockAvailable(lock3);
 183         verify(callback3, never()).lockUnavailable(lock3);
 184     }
 185
 186     /**
 187      * Tests createLock() when the feature instance has changed.
 188      */
 189     @Test
 190     void testCreateLockInstanceChanged() {
 191         mgr = spy(mgr);
 192         when(mgr.hasInstanceChanged()).thenReturn(true);
 193
 194         Lock lock = mgr.createLock(RESOURCE, OWNER_KEY, HOLD_SEC, callback, false);
 195         assertInstanceOf(AlwaysFailLock.class, lock);
 196         assertTrue(lock.isUnavailable());
 197
 198         verify(callback, never()).lockAvailable(lock);
 199         verify(callback).lockUnavailable(lock);
 200     }
 201
 202     @Test
 203     void testGetResource2lock() {
 204         assertNotNull(mgr.getResource2lock());
 205     }
 206
 207     private class MyManager extends LockManager<MyLock> {
 208
 209         @Override
 210         protected boolean hasInstanceChanged() {
 211             return false;
 212         }
 213
 214         @Override
 215         protected void finishLock(MyLock lock) {
 216             lock.grant();
 217         }
 218
 219         @Override
 220         protected MyLock makeLock(LockState waiting, String resourceId, String ownerKey, int holdSec,
 221                         LockCallback callback) {
 222             return new MyLock(waiting, resourceId, ownerKey, holdSec, callback);
 223         }
 224
 225     }
 226
 227     private class MyLock extends FeatureLockImpl {
 228         @Serial
 229         private static final long serialVersionUID = 1L;
 230
 231         public MyLock(LockState waiting, String resourceId, String ownerKey, int holdSec, LockCallback callback) {
 232             super(waiting, resourceId, ownerKey, holdSec, callback);
 233         }
 234
 235         @Override
 236         public boolean free() {
 237             return false;
 238         }
 239
 240         @Override
 241         public void extend(int holdSec, LockCallback callback) {
 242             // do nothing
 243         }
 244
 245         @Override
 246         protected boolean addToFeature() {
 247             return false;
 248         }
 249
 250         @Override
 251         public void notifyAvailable() {
 252             getCallback().lockAvailable(this);
 253         }
 254
 255         @Override
 256         public void notifyUnavailable() {
 257             getCallback().lockUnavailable(this);
 258         }
 259
 260         @Override
 261         protected ScheduledExecutorService getThreadPool() {
 262             return exsvc;
 263         }
 264     }
 265 }