test: add PolicyRuleServiceValidation tests

package eu.teraflow.policy;

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

import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.Mockito.when;

import eu.teraflow.policy.context.ContextService;

import eu.teraflow.policy.context.model.ConfigActionEnum;

import eu.teraflow.policy.context.model.ConfigRule;

import eu.teraflow.policy.context.model.ConfigRuleCustom;

import eu.teraflow.policy.context.model.ConfigRuleTypeCustom;

import eu.teraflow.policy.context.model.Device;

import eu.teraflow.policy.context.model.DeviceConfig;

import eu.teraflow.policy.context.model.DeviceDriverEnum;

import eu.teraflow.policy.context.model.DeviceOperationalStatus;

import eu.teraflow.policy.context.model.EndPoint.EndPointBuilder;

import eu.teraflow.policy.context.model.EndPointId;

import eu.teraflow.policy.context.model.Location;

import eu.teraflow.policy.context.model.LocationTypeRegion;

import eu.teraflow.policy.context.model.ServiceId;

import eu.teraflow.policy.context.model.TopologyId;

import eu.teraflow.policy.kpi_sample_types.model.KpiSampleType;

import eu.teraflow.policy.model.BooleanOperator;

import eu.teraflow.policy.model.NumericalOperator;

import eu.teraflow.policy.model.PolicyRuleAction;

import eu.teraflow.policy.monitoring.model.IntegerKpiValue;

import eu.teraflow.policy.monitoring.model.KpiValue;

import io.quarkus.test.junit.QuarkusTest;

import io.smallrye.mutiny.Uni;

import java.util.Collections;

import java.util.List;

import java.util.UUID;

import javax.inject.Inject;

import org.junit.jupiter.api.BeforeEach;

import org.junit.jupiter.api.Test;

import org.mockito.Mockito;

@QuarkusTest

class PolicyRuleServiceValidationTest {

    @Inject Serializer serializer;

    private MutinyContextServiceWrapper mutinyContextServiceStub;

    private ContextService contextService;

    private PolicyRuleConditionValidator policyRuleConditionValidator;

    @BeforeEach

    void setUp() {

        contextService = Mockito.mock(ContextService.class);

        policyRuleConditionValidator = new PolicyRuleConditionValidator(contextService);

        mutinyContextServiceStub = Mockito.mock(MutinyContextServiceWrapper.class);

    }

    @Test

    void testIsDeviceIdValid_grpc() {

        String deviceId = "deviceIdGrpc";

        final Device device = createDevice(deviceId);

        final var serializedDevice = serializer.serialize(device);

        final var serializedDeviceId = serializedDevice.getDeviceId();

        when(mutinyContextServiceStub.getDevice(serializedDeviceId))

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

        Boolean result = policyRuleConditionValidator.isDeviceIdValid(deviceId).await().indefinitely();

        assertThat(result).isEqualTo(true);

    }

    @Test

    void testIsDeviceIdValidReturnsTrue() {

        String deviceId = "deviceId";

        Device device = createDevice(deviceId);

        when(contextService.getDevice(anyString())).thenReturn(Uni.createFrom().item(device));

        Boolean result = policyRuleConditionValidator.isDeviceIdValid(deviceId).await().indefinitely();

        assertThat(result).isEqualTo(true);

    }

    @Test

    void testIsDeviceIdValidReturnsFalse() {

        String deviceId = "deviceId";

        when(contextService.getDevice(anyString()))

                .thenReturn(Uni.createFrom().failure(new RuntimeException("Failure")));

        Boolean result = policyRuleConditionValidator.isDeviceIdValid(deviceId).await().indefinitely();

        assertThat(result).isEqualTo(false);

    }

    Device createDevice(String deviceId) {

        final var configRuleCustomA = new ConfigRuleCustom("resourceKeyA", "resourceValueA");

        final var configRuleTypeA = new ConfigRuleTypeCustom(configRuleCustomA);

        final var deviceConfig =

                new DeviceConfig(List.of(new ConfigRule(ConfigActionEnum.SET, configRuleTypeA)));

        final var deviceDrivers = List.of(DeviceDriverEnum.IETF_NETWORK_TOPOLOGY, DeviceDriverEnum.P4);

        final var expectedTopologyIdB = new TopologyId("contextIdB", "idB");

        final var expectedDeviceIdB = "expectedDeviceIdB";

        final var expectedIdB = "expectedIdB";

        final var endPointIdB = new EndPointId(expectedTopologyIdB, expectedDeviceIdB, expectedIdB);

        final var endPointTypeB = "endPointTypeB";

        final var kpiSampleTypesB =

                List.of(KpiSampleType.BYTES_RECEIVED, KpiSampleType.BYTES_TRANSMITTED);

        final var locationTypeRegionB = new LocationTypeRegion("ATH");

        final var locationB = new Location(locationTypeRegionB);

        final var endPointB =

                new EndPointBuilder(endPointIdB, endPointTypeB, kpiSampleTypesB)

                        .location(locationB)

                        .build();

        final var endPoints = List.of(endPointB);

        return new Device(

                deviceId,

                "deviceType",

                deviceConfig,

                DeviceOperationalStatus.ENABLED,

                deviceDrivers,

                endPoints);

    }

    private List<PolicyRuleCondition> createPolicyRuleConditions(

            String kpiId, NumericalOperator numericalOperator, KpiValue<?> kpiValue) {