1 files changed, 27 insertions, 17 deletions

diff --git a/a1-policy-management/src/test/java/org/onap/ccsdk/oran/a1policymanagementservice/repository/LockTest.java b/a1-policy-management/src/test/java/org/onap/ccsdk/oran/a1policymanagementservice/repository/LockTest.java
index a63f15f1..79879446 100644
--- a/a1-policy-management/src/test/java/org/onap/ccsdk/oran/a1policymanagementservice/repository/LockTest.java
+++ b/a1-policy-management/src/test/java/org/onap/ccsdk/oran/a1policymanagementservice/repository/LockTest.java
@@ -21,21 +21,28 @@
 package org.onap.ccsdk.oran.a1policymanagementservice.repository;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.awaitility.Awaitility.await;
 
 import java.io.IOException;
+import java.lang.invoke.MethodHandles;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
 import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Lock.LockType;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
+import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 @ExtendWith(MockitoExtension.class)
 class LockTest {
 
+    private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
     @SuppressWarnings("squid:S2925") // "Thread.sleep" should not be used in tests.
     private void sleep() {
         try {
@@ -45,10 +52,13 @@ class LockTest {
         }
     }
 
-    private void asynchUnlock(Lock lock) {
+    private void asynchUnlock(Lock.Grant grant, Lock lock) {
+        logger.info("Lock {} cnt: {}, exclusive: {}, queue: {}", grant.getLabel(), lock.getLockCounter(),
+                lock.isExclusive, lock.lockRequestQueue.size());
+
         Thread thread = new Thread(() -> {
             sleep();
-            lock.unlockBlocking();
+            grant.unlockBlocking();
         });
         thread.start();
     }
@@ -56,14 +66,15 @@ class LockTest {
     @Test
     void testLock() throws IOException, ServiceException {
         Lock lock = new Lock();
-        lock.lockBlocking(LockType.SHARED);
-        lock.unlockBlocking();
+        Lock.Grant grant = lock.lockBlocking(LockType.SHARED, "test");
+        grant.unlockBlocking();
+        assertThat(grant.getLabel()).isEqualTo("test");
 
-        lock.lockBlocking(LockType.EXCLUSIVE);
-        asynchUnlock(lock);
+        grant = lock.lockBlocking(LockType.EXCLUSIVE, "");
+        asynchUnlock(grant, lock);
 
-        lock.lockBlocking(LockType.SHARED);
-        lock.unlockBlocking();
+        grant = lock.lockBlocking(LockType.SHARED, "");
+        grant.unlockBlocking();
 
         assertThat(lock.getLockCounter()).isZero();
     }
@@ -72,18 +83,17 @@ class LockTest {
     void testReactiveLock() {
         Lock lock = new Lock();
 
-        Mono<Lock> seq = lock.lock(LockType.EXCLUSIVE) //
-                .flatMap(l -> lock.lock(LockType.EXCLUSIVE)) //
-                .flatMap(l -> lock.unlock());
+        Mono<?> l0 = lock.lock(LockType.EXCLUSIVE, "1").doOnNext(grant -> asynchUnlock(grant, lock));
+        Mono<?> l1 = lock.lock(LockType.SHARED, "2").doOnNext(grant -> asynchUnlock(grant, lock));
+        Mono<?> l2 = lock.lock(LockType.SHARED, "3").doOnNext(grant -> asynchUnlock(grant, lock));
+        Mono<?> l3 = lock.lock(LockType.EXCLUSIVE, "4").doOnNext(grant -> asynchUnlock(grant, lock));
+        Mono<?> l4 = lock.lock(LockType.SHARED, "5").doOnNext(grant -> asynchUnlock(grant, lock));
 
-        asynchUnlock(lock);
-        StepVerifier.create(seq) //
+        StepVerifier.create(Flux.zip(l0, l1, l2, l3, l4)) //
                 .expectSubscription() //
-                .expectNext(lock) //
+                .expectNextCount(1) //
                 .verifyComplete();
 
-        assertThat(lock.getLockCounter()).isZero();
-
+        await().untilAsserted(() -> assertThat(lock.getLockCounter()).isZero());
     }
-
 }