policy-core/src/test/java/org/onap/policy/drools/core/lock/LockImplTest.java

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP
   4  * ================================================================================
   5  * Copyright (C) 2019-2020 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.core.lock;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatCode;
  26 import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException;
  27 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  28 import static org.junit.jupiter.api.Assertions.assertEquals;
  29 import static org.junit.jupiter.api.Assertions.assertFalse;
  30 import static org.junit.jupiter.api.Assertions.assertNotNull;
  31 import static org.junit.jupiter.api.Assertions.assertNull;
  32 import static org.junit.jupiter.api.Assertions.assertSame;
  33 import static org.junit.jupiter.api.Assertions.assertTrue;
  34 import static org.mockito.ArgumentMatchers.any;
  35 import static org.mockito.Mockito.doThrow;
  36 import static org.mockito.Mockito.mock;
  37 import static org.mockito.Mockito.never;
  38 import static org.mockito.Mockito.verify;
  39
  40 import java.io.ByteArrayInputStream;
  41 import java.io.ByteArrayOutputStream;
  42 import java.io.ObjectInputStream;
  43 import java.io.ObjectOutputStream;
  44 import org.junit.jupiter.api.BeforeEach;
  45 import org.junit.jupiter.api.Test;
  46
  47 class LockImplTest {
  48     private static final LockState STATE = LockState.WAITING;
  49     private static final String RESOURCE = "hello";
  50     private static final String OWNER_KEY = "world";
  51     private static final int HOLD_SEC = 10;
  52     private static final int HOLD_SEC2 = 20;
  53     private static final String EXPECTED_EXCEPTION = "expected exception";
  54
  55     private LockCallback callback;
  56     private LockImpl lock;
  57
  58     /**
  59      * Populates {@link #lock}.
  60      */
  61     @BeforeEach
  62     public void setUp() {
  63         callback = mock(LockCallback.class);
  64
  65         lock = new LockImpl(STATE, RESOURCE, OWNER_KEY, HOLD_SEC, callback);
  66     }
  67
  68     @Test
  69     void testSerializable() throws Exception {
  70         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  71         try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
  72             oos.writeObject(lock);
  73         }
  74
  75         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  76         try (ObjectInputStream ois = new ObjectInputStream(bais)) {
  77             lock = (LockImpl) ois.readObject();
  78         }
  79
  80         assertEquals(STATE, lock.getState());
  81         assertEquals(RESOURCE, lock.getResourceId());
  82         assertEquals(OWNER_KEY, lock.getOwnerKey());
  83         assertEquals(HOLD_SEC, lock.getHoldSec());
  84
  85         // these fields are transient
  86         assertNull(lock.getCallback());
  87     }
  88
  89     @Test
  90     void testLockImplNoArgs() {
  91         // use no-arg constructor
  92         lock = new LockImpl();
  93         assertEquals(LockState.UNAVAILABLE, lock.getState());
  94         assertNull(lock.getResourceId());
  95         assertNull(lock.getOwnerKey());
  96         assertNull(lock.getCallback());
  97         assertEquals(0, lock.getHoldSec());
  98     }
  99
 100     @Test
 101     void testLockImpl_testGetters() {
 102         assertEquals(STATE, lock.getState());
 103         assertEquals(RESOURCE, lock.getResourceId());
 104         assertEquals(OWNER_KEY, lock.getOwnerKey());
 105         assertSame(callback, lock.getCallback());
 106         assertEquals(HOLD_SEC, lock.getHoldSec());
 107
 108         // test illegal args
 109         assertThatThrownBy(() -> new LockImpl(null, RESOURCE, OWNER_KEY, HOLD_SEC, callback))
 110                         .hasMessageContaining("state");
 111         assertThatThrownBy(() -> new LockImpl(STATE, null, OWNER_KEY, HOLD_SEC, callback))
 112                         .hasMessageContaining("resourceId");
 113         assertThatThrownBy(() -> new LockImpl(STATE, RESOURCE, null, HOLD_SEC, callback))
 114                         .hasMessageContaining("ownerKey");
 115         assertThatIllegalArgumentException().isThrownBy(() -> new LockImpl(STATE, RESOURCE, OWNER_KEY, -1, callback))
 116                         .withMessageContaining("holdSec");
 117         assertThatThrownBy(() -> new LockImpl(STATE, RESOURCE, OWNER_KEY, HOLD_SEC, null))
 118                         .hasMessageContaining("callback");
 119     }
 120
 121     @Test
 122     void testFree() {
 123         assertTrue(lock.free());
 124         assertTrue(lock.isUnavailable());
 125
 126         // should fail this time
 127         assertFalse(lock.free());
 128         assertTrue(lock.isUnavailable());
 129
 130         // no call-backs should have been invoked
 131         verify(callback, never()).lockAvailable(any());
 132         verify(callback, never()).lockUnavailable(any());
 133     }
 134
 135     @Test
 136     void testExtend() {
 137         lock.setState(LockState.WAITING);
 138
 139         LockCallback callback2 = mock(LockCallback.class);
 140         lock.extend(HOLD_SEC2, callback2);
 141         assertTrue(lock.isActive());
 142         assertEquals(HOLD_SEC2, lock.getHoldSec());
 143         assertSame(callback2, lock.getCallback());
 144         verify(callback2).lockAvailable(lock);
 145         verify(callback2, never()).lockUnavailable(any());
 146
 147         // first call-back should never have been invoked
 148         verify(callback, never()).lockAvailable(any());
 149         verify(callback, never()).lockUnavailable(any());
 150
 151         // extend again
 152         LockCallback callback3 = mock(LockCallback.class);
 153         lock.extend(HOLD_SEC, callback3);
 154         assertEquals(HOLD_SEC, lock.getHoldSec());
 155         assertSame(callback3, lock.getCallback());
 156         assertTrue(lock.isActive());
 157         verify(callback3).lockAvailable(lock);
 158         verify(callback3, never()).lockUnavailable(any());
 159
 160         // other call-backs should not have been invoked again
 161         verify(callback, never()).lockAvailable(any());
 162         verify(callback, never()).lockUnavailable(any());
 163
 164         verify(callback2).lockAvailable(any());
 165         verify(callback2, never()).lockUnavailable(any());
 166
 167         assertTrue(lock.free());
 168
 169         // extend after free - should fail
 170         lock.extend(HOLD_SEC2, callback);
 171         assertTrue(lock.isUnavailable());
 172
 173         // call-backs should not have been invoked again
 174         verify(callback, never()).lockAvailable(any());
 175         verify(callback, never()).lockUnavailable(any());
 176
 177         verify(callback2).lockAvailable(any());
 178         verify(callback2, never()).lockUnavailable(any());
 179
 180         verify(callback3).lockAvailable(lock);
 181         verify(callback3, never()).lockUnavailable(any());
 182     }
 183
 184     @Test
 185     void testNotifyAvailable() {
 186         lock.notifyAvailable();
 187
 188         verify(callback).lockAvailable(any());
 189         verify(callback, never()).lockUnavailable(any());
 190     }
 191
 192     @Test
 193     void testNotifyAvailable_Ex() {
 194         doThrow(new IllegalArgumentException(EXPECTED_EXCEPTION)).when(callback).lockAvailable(any());
 195         doThrow(new IllegalArgumentException(EXPECTED_EXCEPTION)).when(callback).lockUnavailable(any());
 196
 197         // should not throw an exception
 198         assertThatCode(() -> lock.notifyAvailable()).doesNotThrowAnyException();
 199     }
 200
 201     @Test
 202     void testNotifyUnavailable() {
 203         lock.notifyUnavailable();
 204
 205         verify(callback, never()).lockAvailable(any());
 206         verify(callback).lockUnavailable(any());
 207     }
 208
 209     @Test
 210     void testNotifyUnavailable_Ex() {
 211         doThrow(new IllegalArgumentException(EXPECTED_EXCEPTION)).when(callback).lockAvailable(any());
 212         doThrow(new IllegalArgumentException(EXPECTED_EXCEPTION)).when(callback).lockUnavailable(any());
 213
 214         // should not throw an exception
 215         assertThatCode(() -> lock.notifyUnavailable()).doesNotThrowAnyException();
 216     }
 217
 218     @Test
 219     void testSetState_testIsActive_testIsWaiting_testIsUnavailable() {
 220         lock.setState(LockState.WAITING);
 221         assertEquals(LockState.WAITING, lock.getState());
 222         assertFalse(lock.isActive());
 223         assertFalse(lock.isUnavailable());
 224         assertTrue(lock.isWaiting());
 225
 226         lock.setState(LockState.ACTIVE);
 227         assertEquals(LockState.ACTIVE, lock.getState());
 228         assertTrue(lock.isActive());
 229         assertFalse(lock.isUnavailable());
 230         assertFalse(lock.isWaiting());
 231
 232         lock.setState(LockState.UNAVAILABLE);
 233         assertEquals(LockState.UNAVAILABLE, lock.getState());
 234         assertFalse(lock.isActive());
 235         assertTrue(lock.isUnavailable());
 236         assertFalse(lock.isWaiting());
 237     }
 238
 239     @Test
 240     void testSetHoldSec() {
 241         assertEquals(HOLD_SEC, lock.getHoldSec());
 242
 243         lock.setHoldSec(HOLD_SEC2);
 244         assertEquals(HOLD_SEC2, lock.getHoldSec());
 245     }
 246
 247     @Test
 248     void testSetCallback() {
 249         assertSame(callback, lock.getCallback());
 250
 251         LockCallback callback2 = mock(LockCallback.class);
 252         lock.setCallback(callback2);
 253         assertSame(callback2, lock.getCallback());
 254     }
 255
 256     @Test
 257     void testToString() {
 258         String text = lock.toString();
 259
 260         assertNotNull(text);
 261         assertThat(text).doesNotContain("ownerInfo").doesNotContain("callback").doesNotContain("succeed");
 262     }
 263 }