Commit 7a31182d authored by Konstantinos Poulakakis's avatar Konstantinos Poulakakis
Browse files

test: Create tests for addDevice , updateDevice , updateService , deleteService

parent bfdfbb1c

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

+6 −36
Original line number Diff line number Diff line
@@ -16,6 +16,8 @@ 


package org.etsi.tfs.policy;



import static org.etsi.tfs.policy.common.ApplicationProperties.*;



import io.smallrye.mutiny.Multi;

import io.smallrye.mutiny.Uni;

import io.smallrye.mutiny.groups.UniJoin;
@@ -64,8 +66,7 @@ import org.jboss.logging.Logger; 
public class PolicyServiceImpl implements PolicyService {



    private static final Logger LOGGER = Logger.getLogger(PolicyServiceImpl.class);

    private static final String INVALID_MESSAGE = "%s is invalid.";

    private static final String VALID_MESSAGE = "%s is valid.";



    private static final int POLICY_EVALUATION_TIMEOUT = 5;

    private static final int ACCEPTABLE_NUMBER_OF_ALARMS = 3;

    private static final int MONITORING_WINDOW_IN_SECONDS = 5;
@@ -74,39 +75,6 @@ public class PolicyServiceImpl implements PolicyService { 
    // Temporary solution for not calling the same rpc more than it's needed

    private static int noAlarms = 0;



    private static final PolicyRuleState INSERTED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_INSERTED, "Successfully entered to INSERTED state");

    private static final PolicyRuleState VALIDATED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_VALIDATED, "Successfully transitioned to VALIDATED state");

    private static final PolicyRuleState PROVISIONED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_PROVISIONED,

                    "Successfully transitioned from VALIDATED to PROVISIONED state");

    private static final PolicyRuleState ACTIVE_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_ACTIVE,

                    "Successfully transitioned from PROVISIONED to ACTIVE state");

    private static final PolicyRuleState ENFORCED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_ENFORCED,

                    "Successfully transitioned from ACTIVE to ENFORCED state");

    private static final PolicyRuleState INEFFECTIVE_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_INEFFECTIVE,

                    "Transitioned from ENFORCED to INEFFECTIVE state");

    private static final PolicyRuleState EFFECTIVE_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_EFFECTIVE,

                    "Successfully transitioned from ENFORCED to EFFECTIVE state");

    private static final PolicyRuleState UPDATED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_UPDATED, "Successfully entered to UPDATED state");

    private static final PolicyRuleState REMOVED_POLICYRULE_STATE =

            new PolicyRuleState(

                    PolicyRuleStateEnum.POLICY_REMOVED, "Successfully entered to REMOVED state");



    private final ContextService contextService;

    private final MonitoringService monitoringService;

    private final ServiceService serviceService;
@@ -457,7 +425,9 @@ public class PolicyServiceImpl implements PolicyService { 
                                                            policyRuleBasic.getPolicyRuleId()));



                            contextService.removePolicyRule(policyId).subscribe().with(x -> {});

                            subscriptionList.get(policyId).cancel();



                            // TODO: When the Map doesn't contains the policyId we should throw an exception?

                            if (subscriptionList.contains(policyId)) subscriptionList.get(policyId).cancel();



                            return policyRuleBasic.getPolicyRuleState();

                        });

src/policy/src/main/java/org/etsi/tfs/policy/model/PolicyRuleDevice.java

+1 −1
Original line number Diff line number Diff line
@@ -40,7 +40,7 @@ public class PolicyRuleDevice { 
            this.policyRuleBasic = policyRuleBasic;

            this.deviceIds = new ArrayList<String>();

            this.isValid = false;

            this.exceptionMessage = e.toString();

            this.exceptionMessage = e.getMessage();

        }

    }

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

0 → 100644
+188 −0
Original line number Diff line number Diff line 
package org.etsi.tfs.policy;



import static org.assertj.core.api.Assertions.assertThat;

import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE;

import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE;



import io.quarkus.test.junit.QuarkusTest;

import io.quarkus.test.junit.mockito.InjectMock;

import io.smallrye.mutiny.Uni;

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.model.BooleanOperator;

import org.etsi.tfs.policy.model.NumericalOperator;

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.PolicyRuleDevice;

import org.etsi.tfs.policy.model.PolicyRuleState;

import org.etsi.tfs.policy.model.PolicyRuleStateEnum;

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

class PolicyAddDeviceTest {



    @Inject PolicyServiceImpl policyService;



    @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;



    @InjectMock ContextService contextService;



    static PolicyRuleBasic policyRuleBasic;

    static PolicyRuleDevice policyRuleDevice;



    @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));



        List<String> deviceIds = Arrays.asList("device1", "device2");



        policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds);

    }



    @Test

    void deviceListMustNotBeEmpty()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>());



        PolicyRuleState expectedResult =

                new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty.");



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleBasic policyRuleBasic =

                new PolicyRuleBasic(

                        "policyId",

                        new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),

                        0,

                        new ArrayList<>(),

                        BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,

                        new ArrayList<>());



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty.");



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void isUpdatedPolicyRuleIdValid()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_FAILED,

                        String.format(

                                INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId()));



        Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))

                .thenReturn(Uni.createFrom().item(Boolean.FALSE));



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void successUpdatePolicyService()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_VALIDATED,

                        VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());



        Mockito.when(policyRuleConditionValidator.isDeviceIdValid(Mockito.anyString()))

                .thenReturn(Uni.createFrom().item(Boolean.TRUE));



        policyService

                .addPolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }

}

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

0 → 100644
+112 −0
Original line number Diff line number Diff line 
package org.etsi.tfs.policy;



import static org.assertj.core.api.Assertions.assertThat;

import static org.etsi.tfs.policy.common.ApplicationProperties.REMOVED_POLICYRULE_STATE;



import io.quarkus.test.junit.QuarkusTest;

import io.quarkus.test.junit.mockito.InjectMock;

import io.smallrye.mutiny.Uni;

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.model.PolicyRuleType;

import org.etsi.tfs.policy.model.PolicyRuleTypeService;

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

class PolicyDeleteServiceTest {



    @Inject PolicyServiceImpl policyService;

    @InjectMock ContextService contextService;



    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<>();



        String policyRuleId = "";

        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_REMOVED,

                        REMOVED_POLICYRULE_STATE.getPolicyRuleStateMessage());



        PolicyRuleType policyRuleType = new PolicyRuleTypeService(policyRuleService);



        PolicyRule policyRule = new PolicyRule(policyRuleType);



        Mockito.when(contextService.getPolicyRule(Mockito.anyString()))

                .thenReturn(Uni.createFrom().item(policyRule));



        policyService

                .deletePolicy(policyRuleId)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }

}

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

0 → 100644
+185 −0
Original line number Diff line number Diff line 
package org.etsi.tfs.policy;



import static org.assertj.core.api.Assertions.assertThat;

import static org.etsi.tfs.policy.common.ApplicationProperties.INVALID_MESSAGE;

import static org.etsi.tfs.policy.common.ApplicationProperties.VALIDATED_POLICYRULE_STATE;



import io.quarkus.test.junit.QuarkusTest;

import io.quarkus.test.junit.mockito.InjectMock;

import io.smallrye.mutiny.Uni;

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.model.BooleanOperator;

import org.etsi.tfs.policy.model.NumericalOperator;

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.PolicyRuleDevice;

import org.etsi.tfs.policy.model.PolicyRuleState;

import org.etsi.tfs.policy.model.PolicyRuleStateEnum;

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

class PolicyUpdateDeviceTest {



    @Inject PolicyServiceImpl policyService;



    @InjectMock PolicyRuleConditionValidator policyRuleConditionValidator;



    static PolicyRuleBasic policyRuleBasic;

    static PolicyRuleDevice policyRuleDevice;



    @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));



        List<String> deviceIds = Arrays.asList("device1", "device2");



        policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, deviceIds);

    }



    @Test

    void deviceListMustNotBeEmpty()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice = new PolicyRuleDevice(policyRuleBasic, new ArrayList<>());



        PolicyRuleState expectedResult =

                new PolicyRuleState(PolicyRuleStateEnum.POLICY_FAILED, "Device Ids must not be empty.");



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void isPolicyRuleBasicValid() throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleBasic policyRuleBasic =

                new PolicyRuleBasic(

                        "policyId",

                        new PolicyRuleState(PolicyRuleStateEnum.POLICY_INSERTED, "Failed due to some errors"),

                        0,

                        new ArrayList<>(),

                        BooleanOperator.POLICYRULE_CONDITION_BOOLEAN_OR,

                        new ArrayList<>());



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_FAILED, "Policy Rule conditions cannot be empty.");



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void isUpdatedPolicyRuleIdValid()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1", "device2"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_FAILED,

                        String.format(

                                INVALID_MESSAGE, policyRuleDevice.getPolicyRuleBasic().getPolicyRuleId()));



        Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))

                .thenReturn(Uni.createFrom().item(Boolean.FALSE));



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }



    @Test

    void successUpdatePolicyService()

            throws ExecutionException, InterruptedException, TimeoutException {

        CompletableFuture<PolicyRuleState> message = new CompletableFuture<>();



        PolicyRuleDevice policyRuleDevice =

                new PolicyRuleDevice(policyRuleBasic, Arrays.asList("device1"));



        PolicyRuleState expectedResult =

                new PolicyRuleState(

                        PolicyRuleStateEnum.POLICY_VALIDATED,

                        VALIDATED_POLICYRULE_STATE.getPolicyRuleStateMessage());



        Mockito.when(policyRuleConditionValidator.isUpdatedPolicyRuleIdValid(Mockito.anyString()))

                .thenReturn(Uni.createFrom().item(Boolean.TRUE));



        policyService

                .updatePolicyDevice(policyRuleDevice)

                .subscribe()

                .with(

                        item -> {

                            message.complete(item);

                        });



        assertThat(message.get(5, TimeUnit.SECONDS).getPolicyRuleStateMessage())

                .isEqualTo(expectedResult.getPolicyRuleStateMessage().toString());

    }

}