Improved notification on item archive/restore

Addressed code review comments, added unit-tests.

Change-Id: I2a74e9969540cb636658aa012f82a81e0fd2eac2
Issue-ID: SDC-1667
Signed-off-by: vempo <vitaliy.emporopulo@amdocs.com>

2 files changed, 116 insertions, 9 deletions

diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/AsyncNotifierTest.java b/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/AsyncNotifierTest.java
index 900fc940ee..6bfa8b24b5 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/AsyncNotifierTest.java
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/AsyncNotifierTest.java
@@ -17,18 +17,29 @@
 package org.openecomp.sdcrests.item.rest.services.catalog.notification;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.openecomp.sdcrests.item.rest.services.catalog.notification.AsyncNotifier.NextAction.DONE;
 import static org.openecomp.sdcrests.item.rest.services.catalog.notification.AsyncNotifier.NextAction.RETRY;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.UUID;
 import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.function.BiFunction;
 import org.apache.commons.lang.mutable.MutableInt;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.mockito.Mockito;
 import org.mockito.stubbing.Answer;
+import org.openecomp.sdcrests.item.types.ItemAction;
 
 /**
  * @author evitaliy
@@ -36,6 +47,50 @@ import org.mockito.stubbing.Answer;
  */
 public class AsyncNotifierTest {
 
+    private static final String NUMBER_OF_RETRIES_MESSAGE = "Number of retries must be positive";
+    private static final String DELAY_MESSAGE = "Delay must be positive";
+
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
+    @Test(expected = NullPointerException.class)
+    public void errorWhenWorkerNull() {
+        new AsyncNotifier.RetryingTask(null, 10, 10, Mockito.mock(ScheduledExecutorService.class));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void errorWhenSchedulerServiceNull() {
+        new AsyncNotifier.RetryingTask(() -> DONE, 10, 10, null);
+    }
+
+    @Test
+    public void errorWhenNumberOfRetriesNegative() {
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(NUMBER_OF_RETRIES_MESSAGE);
+        new AsyncNotifier.RetryingTask(() -> DONE, -12, 10, Mockito.mock(ScheduledExecutorService.class));
+    }
+
+    @Test
+    public void errorWhenNumberOfRetriesZero() {
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(NUMBER_OF_RETRIES_MESSAGE);
+        new AsyncNotifier.RetryingTask(() -> DONE, 0, 10, Mockito.mock(ScheduledExecutorService.class));
+    }
+
+    @Test
+    public void errorWhenDelayNegative() {
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(DELAY_MESSAGE);
+        new AsyncNotifier.RetryingTask(() -> DONE, 1, -77, Mockito.mock(ScheduledExecutorService.class));
+    }
+
+    @Test
+    public void errorWhenDelayZero() {
+        exception.expect(IllegalArgumentException.class);
+        exception.expectMessage(DELAY_MESSAGE);
+        new AsyncNotifier.RetryingTask(() -> DONE, 1, 0, Mockito.mock(ScheduledExecutorService.class));
+    }
+
     @Test
     public void taskRunsOnceWhenSuccessful() throws Exception {
 
@@ -53,6 +108,20 @@ public class AsyncNotifierTest {
         assertEquals(1, counter.intValue());
     }
 
+    private ScheduledExecutorService createMockScheduledExecutor() {
+
+        ScheduledExecutorService executorServiceMock = Mockito.mock(ScheduledExecutorService.class);
+        Answer passThrough = invocation -> {
+            ((Callable<?>) invocation.getArgument(0)).call();
+            return null;
+        };
+
+        Mockito.doAnswer(passThrough).when(executorServiceMock).submit(any(Callable.class));
+        Mockito.doAnswer(passThrough).when(executorServiceMock)
+                .schedule(any(Callable.class), anyLong(), any(TimeUnit.class));
+        return executorServiceMock;
+    }
+
     @Test
     public void taskRunsTwiceWhenFailedFirstTime() throws Exception {
 
@@ -88,17 +157,26 @@ public class AsyncNotifierTest {
         assertEquals(numOfRetries, counter.intValue());
     }
 
-    private ScheduledExecutorService createMockScheduledExecutor() {
+    @Test
+    public void workerExecutedWithGivenItemIdsAndAction()
+            throws InterruptedException, ExecutionException, TimeoutException {
 
-        ScheduledExecutorService executorServiceMock = Mockito.mock(ScheduledExecutorService.class);
-        Answer passThrough = invocation -> {
-            ((Callable<?>) invocation.getArgument(0)).call();
-            return null;
+        CompletableFuture<Boolean> completed = new CompletableFuture<>();
+        Callable<AsyncNotifier.NextAction> mockTask = () -> {
+            completed.complete(true);
+            return DONE;
         };
 
-        Mockito.doAnswer(passThrough).when(executorServiceMock).submit(any(Callable.class));
-        Mockito.doAnswer(passThrough).when(executorServiceMock)
-                .schedule(any(Callable.class), anyLong(), any(TimeUnit.class));
-        return executorServiceMock;
+        final Collection<String> itemIds = Collections.singleton(UUID.randomUUID().toString());
+        final ItemAction action = ItemAction.RESTORE;
+
+        BiFunction<Collection<String>, ItemAction, Callable<AsyncNotifier.NextAction>> mockProducer = (i, a) -> {
+            assertEquals(itemIds, i);
+            assertEquals(action, a);
+            return mockTask;
+        };
+
+        new AsyncNotifier(mockProducer, 1, 1).execute(itemIds, action);
+        assertTrue(completed.get(5, TimeUnit.SECONDS));
     }
 }
\ No newline at end of file
diff --git a/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/http/HttpTaskProducerTest.java b/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/http/HttpTaskProducerTest.java
index 3c12b37e6d..4d8a1103b8 100644
--- a/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/http/HttpTaskProducerTest.java
+++ b/openecomp-be/api/openecomp-sdc-rest-webapp/item-rest/item-rest-services/src/test/java/org/openecomp/sdcrests/item/rest/services/catalog/notification/http/HttpTaskProducerTest.java
@@ -17,11 +17,16 @@
 package org.openecomp.sdcrests.item.rest.services.catalog.notification.http;
 
 import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 
+import java.util.HashSet;
+import java.util.Set;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
 import org.openecomp.sdcrests.item.rest.services.catalog.notification.EntryNotConfiguredException;
+import org.openecomp.sdcrests.item.types.ItemAction;
 
 /**
  * @author evitaliy
@@ -33,6 +38,30 @@ public class HttpTaskProducerTest {
     public ExpectedException exception = ExpectedException.none();
 
     @Test
+    public void uniquePathExistsForEveryAction() {
+
+        ItemAction[] availableActions = ItemAction.values();
+        Set<String> collectedPaths = new HashSet<>(availableActions.length);
+        for (ItemAction action : availableActions) {
+            String path = HttpTaskProducer.getApiPath(action);
+            assertFalse("Path empty for action '" + action.name() + "'", path == null || path.isEmpty());
+            collectedPaths.add(path);
+        }
+
+        assertEquals("Paths not unique for some actions", availableActions.length, collectedPaths.size());
+    }
+
+    @Test
+    public void restorePathEqualsRestored() {
+        assertEquals("restored", HttpTaskProducer.getApiPath(ItemAction.RESTORE));
+    }
+
+    @Test
+    public void archivePathEqualsArchived() {
+        assertEquals("archived", HttpTaskProducer.getApiPath(ItemAction.ARCHIVE));
+    }
+
+    @Test
     public void errorWhenProtocolNotDefined() {
         HttpConfiguration config = mockConfiguration();
         config.setCatalogBeProtocol(null);