test: Change PolicyServiceTest to PolicyAddServiceTest

src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java

+package org.etsi.tfs.policy.common;
+
+import org.etsi.tfs.policy.model.PolicyRuleState;
+import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
+
+public class ApplicationProperties {
+
+    public static final String INVALID_MESSAGE = "%s is invalid.";
+    public static final String VALID_MESSAGE = "%s is valid.";
+
+    public static final PolicyRuleState INSERTED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_INSERTED, "Successfully entered to INSERTED state");
+    public static final PolicyRuleState VALIDATED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_VALIDATED, "Successfully transitioned to VALIDATED state");
+    public static final PolicyRuleState PROVISIONED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_PROVISIONED,
+                    "Successfully transitioned from VALIDATED to PROVISIONED state");
+    public static final PolicyRuleState ACTIVE_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_ACTIVE,
+                    "Successfully transitioned from PROVISIONED to ACTIVE state");
+    public static final PolicyRuleState ENFORCED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_ENFORCED,
+                    "Successfully transitioned from ACTIVE to ENFORCED state");
+    public static final PolicyRuleState INEFFECTIVE_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_INEFFECTIVE,
+                    "Transitioned from ENFORCED to INEFFECTIVE state");
+    public static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_EFFECTIVE,
+                    "Successfully transitioned from ENFORCED to EFFECTIVE state");
+    public static final PolicyRuleState UPDATED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_UPDATED, "Successfully entered to UPDATED state");
+    public static final PolicyRuleState REMOVED_POLICYRULE_STATE =
+            new PolicyRuleState(
+                    PolicyRuleStateEnum.POLICY_REMOVED, "Successfully entered to REMOVED state");
+}

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

+package org.etsi.tfs.policy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.etsi.tfs.policy.common.ApplicationProperties.*;
+
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.mockito.InjectMock;
+import io.smallrye.mutiny.Uni;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import javax.inject.Inject;
+import org.etsi.tfs.policy.context.ContextService;
+import org.etsi.tfs.policy.context.model.Service;
+import org.etsi.tfs.policy.context.model.ServiceId;
+import org.etsi.tfs.policy.context.model.ServiceTypeEnum;
+import org.etsi.tfs.policy.model.BooleanOperator;
+import org.etsi.tfs.policy.model.NumericalOperator;
+import org.etsi.tfs.policy.model.PolicyRule;
+import org.etsi.tfs.policy.model.PolicyRuleAction;
+import org.etsi.tfs.policy.model.PolicyRuleActionConfig;
+import org.etsi.tfs.policy.model.PolicyRuleActionEnum;
+import org.etsi.tfs.policy.model.PolicyRuleBasic;
+import org.etsi.tfs.policy.model.PolicyRuleCondition;
+import org.etsi.tfs.policy.model.PolicyRuleService;
+import org.etsi.tfs.policy.model.PolicyRuleState;
+import org.etsi.tfs.policy.model.PolicyRuleStateEnum;
+import org.etsi.tfs.policy.monitoring.MonitoringService;
+import org.etsi.tfs.policy.monitoring.model.IntegerKpiValue;
+import org.etsi.tfs.policy.monitoring.model.KpiValue;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+@QuarkusTest
+public class PolicyAddServiceTest {
+
+    @Inject PolicyServiceImpl policyService;
+
+    @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;
+
+    @InjectMock ContextService contextService;
+
+    @InjectMock MonitoringService monitoringService;
+
+    static PolicyRuleBasic policyRuleBasic;
+    static PolicyRuleService policyRuleService;
+
+    @BeforeAll
+    static void init() {
+
+        String policyId = "policyRuleId";
+        KpiValue kpiValue = new IntegerKpiValue(100);
+
+        PolicyRuleCondition policyRuleCondition =
+                new PolicyRuleCondition(
+                        "kpiId", NumericalOperator.POLICY_RULE_CONDITION_NUMERICAL_GREATER_THAN, kpiValue);
+
+        PolicyRuleActionConfig policyRuleActionConfig = new PolicyRuleActionConfig("key", "value");
+
+        PolicyRuleAction policyRuleAction =
+                new PolicyRuleAction(
+                        PolicyRuleActionEnum.POLICY_RULE_ACTION_NO_ACTION,
+                        Arrays.asList(policyRuleActionConfig));
+
+        policyRuleBasic =
+                new PolicyRuleBasic(
+                        policyId,
+                        new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
+                        1,
+                        Arrays.asList(policyRuleCondition),
+                        BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,
+                        Arrays.asList(policyRuleAction));
+
+        ServiceId serviceId = new ServiceId("contextId", "serviceId");
+
+        Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
+
+        List<String> deviceIds = Arrays.asList("device1", "device2");
+
+        policyRuleService = new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
+    }
+
+    @Test
+    void contextOrServiceIdMustNotBeEmpty()
+            throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
+
+        ServiceId serviceId = new ServiceId("", "");
+        List<String> deviceIds = Arrays.asList("device1", "device2");
+
+        PolicyRuleService policyRuleService =
+                new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
+
+        PolicyRuleState expectedResult =
+                new PolicyRuleState(
+                        PolicyRuleStateEnum.POLICY_FAILED, "Context Id of Service Id must not be empty.");
+
+        policyService
+                .addPolicyService(policyRuleService)
+                .subscribe()
+                .with(
+                        item -> {
+                            message.complete(item);
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
+                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    }
+
+    @Test
+    void serviceIdMustNotBeEmpty() throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
+
+        ServiceId serviceId = new ServiceId("sdf", "");
+        List<String> deviceIds = Arrays.asList("device1", "device2");
+
+        PolicyRuleService policyRuleService =
+                new PolicyRuleService(policyRuleBasic, serviceId, deviceIds);
+
+        PolicyRuleState expectedResult =
+                new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Service Id must not be empty.");
+
+        policyService
+                .addPolicyService(policyRuleService)
+                .subscribe()
+                .with(item -> message.complete(item));
+
+        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
+                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    }
+
+    @Test
+    void policyRuleIdMustNotBeEmpty()
+            throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
+
+        String policyId = "";
+
+        PolicyRuleBasic policyRuleBasic =
+                new PolicyRuleBasic(
+                        policyId,
+                        new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),
+                        1,
+                        new ArrayList<>(),
+                        null,
+                        new ArrayList<>());
+
+        ServiceId serviceId = new ServiceId("contextId", "serviceId");
+
+        Service service = new Service(serviceId, ServiceTypeEnum.UNKNOWN, null, null, null, null, 0.0);
+
+        PolicyRuleService policyRuleService =
+                new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
+
+        PolicyRuleState expectedResult =
+                new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Policy rule ID must not be empty.");
+
+        policyService
+                .addPolicyService(policyRuleService)
+                .subscribe()
+                .with(
+                        item -> {
+                            message.complete(item);
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
+                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    }
+
+    @Test
+    void checkMessageIfServiceIsNotValid()
+            throws ExecutionException, InterruptedException, TimeoutException {
+        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
+
+        ServiceId serviceId = new ServiceId("contextId", "serviceId");
+
+        PolicyRuleService policyRuleService =
+                new PolicyRuleService(policyRuleBasic, serviceId, new ArrayList<>());
+
+        PolicyRuleState expectedResult =
+                new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, serviceId + " is invalid.");
+
+        Mockito.when(
+                        policyRuleConditionValidator.isServiceIdValid(
+                                Mockito.any(ServiceId.class), Mockito.anyList()))
+                .thenReturn(Uni.createFrom().item(Boolean.FALSE));
+
+        policyService
+                .addPolicyService(policyRuleService)
+                .subscribe()
+                .with(
+                        item -> {
+                            message.complete(item);
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
+                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    }
+
+    @Test
+    void policyServiceSuccess()
+            throws ExecutionException, InterruptedException, TimeoutException, IOException {
+        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();
+
+        PolicyRuleState expectedResult =
+                new PolicyRuleState(
+                        PolicyRuleStateEnum.POLICY_VALIDATED,
+                        VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());
+
+        Mockito.when(
+                        policyRuleConditionValidator.isServiceIdValid(
+                                Mockito.any(ServiceId.class), Mockito.anyList()))
+                .thenReturn(Uni.createFrom().item(Boolean.TRUE));
+
+        Mockito.when(contextService.setPolicyRule(Mockito.any(PolicyRule.class)))
+                .thenReturn(Uni.createFrom().item("policyRuleId"));
+
+        policyService
+                .addPolicyService(policyRuleService)
+                .subscribe()
+                .with(
+                        item -> {
+                            message.complete(item);
+                        });
+
+        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())
+                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());
+    }
+}