refactor: add failure mechanism to AddPolicyDevice.

src/policy/src/main/java/org/etsi/tfs/policy/PolicyServiceImpl.java

@@ -32,7 +32,6 @@ import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
-
 import org.etsi.tfs.policy.context.ContextService;
 import org.etsi.tfs.policy.context.model.ConfigActionEnum;
 import org.etsi.tfs.policy.context.model.ConfigRule;
@@ -297,14 +296,18 @@ public class PolicyServiceImpl implements PolicyService {
         }
 
         final var deviceIds = policyRuleDevice.getDeviceIds();
-        final var areDevicesValid = returnInvalidDeviceIds(deviceIds);
+//        final var areDevicesValid = returnInvalidDeviceIds(deviceIds);
+        final var areDevicesValid = Uni.createFrom().item(List.of(true));
 
         return areDevicesValid
+                .onFailure()
+                .transform(failure -> new ExternalServiceFailureException(failure.getMessage()))
                 .onItem()
-                .transform(areDevices -> areDeviceOnContext(areDevices, policyRuleDevice, policyRuleBasic));
+                .transform(areDevices -> areDeviceOnContext(areDevices, policyRuleDevice, policyRuleBasic))
+                .flatMap(Function.identity());
     }
 
-    private PolicyRuleState areDeviceOnContext(
+    private Uni<PolicyRuleState> areDeviceOnContext(
             List<Boolean> areDevices,
             PolicyRuleDevice policyRuleDevice,
             PolicyRuleBasic policyRuleBasic) {
@@ -315,7 +318,7 @@ public class PolicyServiceImpl implements PolicyService {
                             String.format(
                                     INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId()));
 
-            return policyRuleState;
+            return Uni.createFrom().item(policyRuleState);
         }
 
         final var policyRuleTypeDevice = new PolicyRuleTypeDevice(policyRuleDevice);
@@ -329,19 +332,20 @@ public class PolicyServiceImpl implements PolicyService {
                             String.format(
                                     "Invalid PolicyRuleConditions in PolicyRule with ID: %s",
                                     policyRuleBasic.getPolicyRuleId()));
-            return policyRuleState;
+            return Uni.createFrom().item(policyRuleState);
         }
 
-        contextService
+        return contextService
                 .setPolicyRule(policyRule)
-                .subscribe()
-                .with(
+                .onFailure()
+                .transform(failure -> new ExternalServiceFailureException(failure.getMessage()))
+                .onItem()
+                .transform(
                         policyId -> {
                             startMonitoringBasedOnAlarmDescriptors(
                                     policyId, policyRuleDevice, alarmDescriptorList);
+                            return VALIDATED_POLICYRULE_STATE;
                         });
-
-        return VALIDATED_POLICYRULE_STATE;
     }
 
     private void startMonitoringBasedOnAlarmDescriptors(
@@ -427,6 +431,8 @@ public class PolicyServiceImpl implements PolicyService {
                 policyRuleConditionValidator.isPolicyRuleServiceValid(policyRuleId, serviceId);
 
         return isPolicyRuleServiceValid
+                .onFailure()
+                .transform(failure -> new ExternalServiceFailureException(failure.getMessage()))
                 .onItem()
                 .transform(
                         isPolicyRuleService -> {

src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddDeviceTest.java

@@ -190,6 +190,9 @@ class PolicyAddDeviceTest {
         Mockito.when(policyRuleConditionValidator.isDeviceIdValid(Mockito.anyString()))
                 .thenReturn(Uni.createFrom().item(Boolean.TRUE));
 
+        Mockito.when(contextService.setPolicyRule(Mockito.any()))
+                .thenReturn(Uni.createFrom().item("policyRuleId"));
+
         policyService
                 .addPolicyDevice(policyRuleDevice)
                 .subscribe()
@@ -201,4 +204,45 @@ class PolicyAddDeviceTest {
         assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
                 .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
     }
+
+    //    @Test
+    //    void failurePolicyDevice() throws ExecutionException, InterruptedException, TimeoutException
+    // {
+    //        CompletableFuture<ExternalServiceFailureException> message = new CompletableFuture<>();
+    //
+    //        PolicyRuleDevice policyRuleDevice =
+    //                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));
+    //
+    //        //        String expectedResult = "Failed1 to set policy rule for testing purposes.";
+    //
+    //        PolicyRuleState expectedResult =
+    //                new PolicyRuleState(
+    //                        PolicyRuleStateEnum.POLICY_VALIDATED,
+    //                        "Failed1 to set policy rule for testing purposes.");
+    //
+    //        Mockito.when(policyRuleConditionValidator.isDeviceIdValid(Mockito.anyString()))
+    //                .thenReturn(Uni.createFrom().item(Boolean.TRUE));
+    //
+    //        Mockito.when(contextService.setPolicyRule(Mockito.any()))
+    //                .thenReturn(
+    //                        Uni.createFrom()
+    //                                .failure(
+    //                                        new ExternalServiceFailureException(
+    //                                                "Failed to set policy rule for testing
+    // purposes.")));
+    //
+    //        policyService
+    //                .addPolicyDevice(policyRuleDevice)
+    //                .subscribe()
+    //                .with(
+    //                        item -> {},
+    //                        error -> {
+    //
+    // assertThat(error.getMessage()).isEqualTo(expectedResult.getPolicyRuleStateMessage());
+    //                                                        message.completeExceptionally(error);
+    //                        });
+    //
+    //                assertThat(message.get(5, TimeUnit.SECONDS).getMessage())
+    //                        .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    //    }
 }