diff --git a/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java b/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..b24ecd4a56de7663e55e865484c8c4aff634cbf8
--- /dev/null
+++ b/src/policy/src/main/java/org/etsi/tfs/policy/common/ApplicationProperties.java
@@ -0,0 +1,43 @@
+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");
+}
diff --git a/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..657422071e936e077ecf69468d35f4696e860bb9
--- /dev/null
+++ b/src/policy/src/test/java/org/etsi/tfs/policy/PolicyAddServiceTest.java
@@ -0,0 +1,235 @@
+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());
+ }
+}