package org.openecomp.sdc.be.components.impl;


import fj.data.Either;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import org.openecomp.sdc.be.components.utils.ComponentInstanceBuilder;
import org.openecomp.sdc.be.components.utils.GroupDefinitionBuilder;
import org.openecomp.sdc.be.components.utils.ResourceBuilder;
import org.openecomp.sdc.be.components.validation.UserValidations;
import org.openecomp.sdc.be.config.ConfigurationManager;
import org.openecomp.sdc.be.dao.api.ActionStatus;
import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
import org.openecomp.sdc.be.impl.ComponentsUtils;
import org.openecomp.sdc.be.model.Component;
import org.openecomp.sdc.be.model.ComponentInstance;
import org.openecomp.sdc.be.model.ComponentParametersView;
import org.openecomp.sdc.be.model.GroupDefinition;
import org.openecomp.sdc.be.model.LifecycleStateEnum;
import org.openecomp.sdc.be.model.PolicyDefinition;
import org.openecomp.sdc.be.model.PolicyTargetDTO;
import org.openecomp.sdc.be.model.PolicyTypeDefinition;
import org.openecomp.sdc.be.model.Resource;
import org.openecomp.sdc.be.model.User;
import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
import org.openecomp.sdc.be.model.jsontitan.datamodel.ToscaElementTypeEnum;
import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
import org.openecomp.sdc.be.model.operations.api.IGraphLockOperation;
import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
import org.openecomp.sdc.be.model.operations.impl.PolicyTypeOperation;
import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
import org.openecomp.sdc.common.impl.ExternalConfiguration;
import org.openecomp.sdc.common.impl.FSConfigurationSource;
import org.openecomp.sdc.exception.ResponseFormat;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.assertj.core.api.Java6Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class PolicyBusinessLogicTest {

    @InjectMocks
    private PolicyBusinessLogic businessLogic;
    @Mock
    private ComponentsUtils componentsUtils;
    @Mock
    private ToscaOperationFacade toscaOperationFacade;
    @Mock
    private IGraphLockOperation graphLockOperation;
    @Mock
    private PolicyTypeOperation policyTypeOperation;
    @Mock
    private UserValidations userValidations;
    @Mock
    private TitanDao titanDao;
    @Mock
    private ApplicationDataTypeCache dataTypeCache;
    @Mock
    private PropertyOperation propertyOperation;

    private final static String COMPONENT_ID = "componentId";
    private final static String COMPONENT_NAME = "componentName";
    private final static String POLICY_TYPE_NAME = "policyTypeName";
    private final static String POLICY_ID = "policyId";
    private final static String INVALID_POLICY_ID = "invalidPolicyId";
    private final static String POLICY_NAME = "policyName";
    private final static String OTHER_POLICY_NAME = "otherPolicyName";
    private final static String USER_ID = "jh0003";
    private final static String UNIQUE_ID_EXSISTS = "uniqueIdExists";
    private final static String UNIQUE_ID_DOESNT_EXSISTS = "uniqueIdDoesntExists";
    private final static String FAKE_TYPE = "fakeType";
    private final static String COMPONENT_INSTANCE_TYPE = "component_Instances";
    private final static String GROUP_TYPE = "GROUPS";




    private final String CREATE_POLICY = "create Policy";

    private final static User user = buildUser();
    private final static PolicyDefinition policy = buildPolicy(POLICY_NAME);
    private final static PolicyDefinition otherPolicy = buildPolicy(OTHER_POLICY_NAME);
    private final static Resource resource = buildResource();
    private final static PolicyTypeDefinition policyType = buildPolicyType();

    private static Either<User, ResponseFormat> userSuccessEither;
    private static Either<Component, StorageOperationStatus> componentSuccessEither;
    private static Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyTypeSuccessEither;
    private static Either<PolicyDefinition, StorageOperationStatus> policySuccessEither;
    private static ResponseFormat notFoundResponse;
    private static ResponseFormat invalidContentResponse;
    private static ResponseFormat nameExistsResponse;

    @BeforeClass
    public static void setup() {
        String appConfigDir = "src/test/resources/config/catalog-be";
        new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir));
        createResponses();
        new ConfigurationManager(new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir));
    }

    private static void createResponses() {
        userSuccessEither = Either.left(user);
        componentSuccessEither = Either.left(resource);
        getPolicyTypeSuccessEither = Either.left(policyType);
        policySuccessEither = Either.left(policy);
        notFoundResponse = new ResponseFormat();
        notFoundResponse.setStatus(404);
        invalidContentResponse = new ResponseFormat();
        invalidContentResponse.setStatus(400);
        nameExistsResponse = new ResponseFormat();
        nameExistsResponse.setStatus(409);
    }

    @Test
    public void createPolicySuccessTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeSuccessEither);
        when(toscaOperationFacade.associatePolicyToComponent(eq(COMPONENT_ID), any(PolicyDefinition.class), eq(0))).thenReturn(policySuccessEither);
        stubUnlockAndCommit();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
        assertTrue(response.isLeft());
    }
    
    @Test
    public void createPolicyUserFailureTest(){
        Either<User, ResponseFormat> userNotFoundResponse = Either.right(new ResponseFormat(404));
        when(userValidations.validateUserExists(eq(USER_ID), eq(CREATE_POLICY), eq(false))).thenReturn(userNotFoundResponse);
        stubRollback();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
        assertNotFound(response);
    }

    private void assertNotFound(Either<PolicyDefinition, ResponseFormat> response) {
        assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
    }
    
    @Test
    public void createPolicyComponentFailureTest(){
        when(userValidations.validateUserExists(eq(USER_ID), eq(CREATE_POLICY), eq(false))).thenReturn(userSuccessEither);
        Either<Component, StorageOperationStatus> componentNotFoundResponse = Either.right(StorageOperationStatus.NOT_FOUND);
        when(componentsUtils.convertFromStorageResponse(eq(StorageOperationStatus.NOT_FOUND), eq(ComponentTypeEnum.RESOURCE))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
        when(componentsUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND), anyString())).thenReturn(notFoundResponse);
        when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(componentNotFoundResponse);
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
        assertNotFound(response);
    }
    
    @Test
    public void createPolicyPolicyTypeFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        Either<PolicyTypeDefinition, StorageOperationStatus> getPolicyTypeFailed = Either.right(StorageOperationStatus.NOT_FOUND);
        when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeFailed);
        when(componentsUtils.convertFromStorageResponse(eq(getPolicyTypeFailed.right().value()))).thenReturn(ActionStatus.RESOURCE_NOT_FOUND);
        when(componentsUtils.getResponseFormat(eq(ActionStatus.RESOURCE_NOT_FOUND))).thenReturn(notFoundResponse);
        stubUnlockAndRollback();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
        assertNotFound(response);
    }
    
    @Test
    public void createPolicyComponentTypeFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(policyTypeOperation.getLatestPolicyTypeByType(eq(POLICY_TYPE_NAME))).thenReturn(getPolicyTypeSuccessEither);
        Either<PolicyDefinition, StorageOperationStatus> addPolicyRes = Either.right(StorageOperationStatus.BAD_REQUEST);
        when(toscaOperationFacade.associatePolicyToComponent(eq(COMPONENT_ID), any(PolicyDefinition.class), eq(0))).thenReturn(addPolicyRes);
        when(componentsUtils.convertFromStorageResponse(eq(addPolicyRes.right().value()))).thenReturn(ActionStatus.INVALID_CONTENT);
        when(componentsUtils.getResponseFormat(eq(ActionStatus.INVALID_CONTENT))).thenReturn(invalidContentResponse);
        stubUnlockAndRollback();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.createPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_TYPE_NAME, USER_ID, true);
        assertTrue(response.isRight() && response.right().value().getStatus().equals(400));
    }

    @Test
    public void updatePolicySuccessTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), any(PolicyDefinition.class))).thenReturn(policySuccessEither);
        stubUnlockAndCommit();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.updatePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, otherPolicy, USER_ID, true);
        assertTrue(response.isLeft());
    }
    
    @Test
    public void updatePolicyNameFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NAME_ALREADY_EXIST), eq(POLICY_NAME))).thenReturn(nameExistsResponse);
        stubUnlockAndRollback();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.updatePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, policy, USER_ID, true);
        assertTrue(response.isRight() && response.right().value().getStatus().equals(409));
    }
    
    @Test
    public void getPolicySuccessTest(){
        stubValidationSuccess(CREATE_POLICY);
        stubCommit();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.getPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, USER_ID);
        assertTrue(response.isLeft());
    }
    
    @Test
    public void getPolicyFailureTest(){
        stubValidationSuccess(CREATE_POLICY);
        stubRollback();
        when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NOT_FOUND_ON_CONTAINER), eq(INVALID_POLICY_ID), eq(COMPONENT_ID))).thenReturn(notFoundResponse);
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.getPolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, INVALID_POLICY_ID, USER_ID);
        assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
    }
    
    @Test
    public void deletePolicySuccessTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        stubCommit();
        when(toscaOperationFacade.removePolicyFromComponent(eq(COMPONENT_ID),eq(POLICY_ID))).thenReturn(StorageOperationStatus.OK);
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.deletePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, USER_ID, true);
        assertTrue(response.isLeft());
    }
    
    @Test
    public void deletePolicyFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        stubCommit();
        stubComponentUtilsGetResponsePOLICY_NOT_FOUND_ON_CONTAINER();
        Either<PolicyDefinition, ResponseFormat>  response = businessLogic.deletePolicy(ComponentTypeEnum.RESOURCE, COMPONENT_ID, INVALID_POLICY_ID, USER_ID, true);
        assertNotFound(response);
    }

    private void stubComponentUtilsGetResponsePOLICY_NOT_FOUND_ON_CONTAINER() {
        when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_NOT_FOUND_ON_CONTAINER), anyString(), anyString())).thenReturn(new ResponseFormat(404));
    }

    @Test
    public void updatePolicyPropertiesSuccessTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
        String prop1 = "Name";
        String prop2 = "Type";
        when(propertyOperation.validateAndUpdatePropertyValue(eq(null), eq(prop1), anyBoolean(), eq(null), anyMap())).thenReturn(Either.left(prop1));
        when(propertyOperation.validateAndUpdatePropertyValue(eq(null), eq(prop2), anyBoolean(), eq(null), anyMap())).thenReturn(Either.left(prop2));
        when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), any(PolicyDefinition.class))).thenReturn(policySuccessEither);
        stubUnlockAndCommit();
        PropertyDataDefinition[] properties = getProperties(prop1, prop2);
        policy.setProperties(Arrays.asList(properties));
        Either<List<PropertyDataDefinition>, ResponseFormat>  response = businessLogic.updatePolicyProperties(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, properties , USER_ID, true);
        assertTrue(response.isLeft());
    }

    @Test
    public void updatePolicyTargetsSuccessTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        stubGetToscaFullElementSuccess();
        stubUpdatePolicyOfComponentSuccess();
        stubGetToscaElementSuccess();
        stubGetTargetType();

        Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargets(), USER_ID);

        Assert.assertTrue(result.isLeft());
        PolicyDefinition policyResult = result.left().value();
        Map<PolicyTargetType, List<String>> targets = getTargets();
        assertThat(policyResult.getTargets().values()).usingFieldByFieldElementComparator().containsExactlyInAnyOrder(targets.get(PolicyTargetType.GROUPS), targets.get(PolicyTargetType.COMPONENT_INSTANCES));

    }

    private void stubGetTargetType() {
    }

    @Test
    public void updatePolicyTargetsTargetIDFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        stubGetToscaFullElementSuccess();
        stubGetToscaElementSuccess();
        stubUpdatePolicyOfComponentSuccess();
        stubComponentUtilsGetResponseTargetNotFound();
        stubRollback();

        Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargetListFakeId(), USER_ID);

        Assert.assertTrue(result.isRight());
        ResponseFormat responseResult = result.right().value();
        Assert.assertEquals(responseResult.getStatus().longValue(), 400L);

    }

    private void stubComponentUtilsGetResponseTargetNotFound() {
        when(componentsUtils.getResponseFormat(eq(ActionStatus.POLICY_TARGET_DOES_NOT_EXIST), (anyString()))).thenReturn(new ResponseFormat(400));
    }

    @Test
    public void updatePolicyTargetsTypeFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        stubGetToscaFullElementSuccess();
        stubGetToscaElementSuccess();
        stubUpdatePolicyOfComponentSuccess();
        stubComponentUtilsGetResponseTargetNotFound();
        stubRollback();

        Either<PolicyDefinition, ResponseFormat> result = businessLogic.updatePolicyTargets(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getTargetListFakeType(), USER_ID);

        Assert.assertTrue(result.isRight());
        ResponseFormat responseResult = result.right().value();
        Assert.assertTrue(responseResult.getStatus().equals(400));

    }

    private void stubUpdatePolicyOfComponentSuccess() {
        when(toscaOperationFacade.updatePolicyOfComponent(eq(COMPONENT_ID), eq(policy))).thenReturn(policySuccessEither);
    }


    @Test
    public void updatePolicyPropertiesFailureTest(){
        stubValidateAndLockSuccess(CREATE_POLICY);
        when(componentsUtils.getResponseFormat(eq(ActionStatus.PROPERTY_NOT_FOUND))).thenReturn(notFoundResponse);
        stubUnlockAndRollback();
        policy.setProperties(null);
        Either<List<PropertyDataDefinition>, ResponseFormat>  response = businessLogic.updatePolicyProperties(ComponentTypeEnum.RESOURCE, COMPONENT_ID, POLICY_ID, getProperties("Name", "Type") , USER_ID, true);
        assertTrue(response.isRight() && response.right().value().getStatus().equals(404));
    }
    
    private PropertyDataDefinition[] getProperties(String prop1, String prop2) {
        PropertyDataDefinition property1 = new PropertyDataDefinition();
        property1.setName(prop1);
        property1.setValue(prop1);
        PropertyDataDefinition property2 = new PropertyDataDefinition();
        property2.setName(prop2);
        property2.setValue(prop2);
        PropertyDataDefinition[] properties = {property1, property2};
        return properties;
    }
    
    
    private void stubUnlockAndRollback() {
        when(graphLockOperation.unlockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
        stubRollback();
    }

    private void stubCommit() {
        when(titanDao.commit()).thenReturn(TitanOperationStatus.OK);
    }

    private void stubRollback() {
        when(titanDao.rollback()).thenReturn(TitanOperationStatus.OK);
    }

    private void stubUnlockAndCommit() {
        when(graphLockOperation.unlockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
        stubCommit();
    }
    
    private void stubValidateAndLockSuccess(String methodName) {
        stubValidationSuccess(methodName);
        when(graphLockOperation.lockComponent(eq(COMPONENT_ID), any(NodeTypeEnum.class))).thenReturn(StorageOperationStatus.OK);
    }

    private void stubValidationSuccess(String methodName) {
        when(userValidations.validateUserExists(eq(USER_ID), eq(methodName), eq(false))).thenReturn(userSuccessEither);
        when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID), any(ComponentParametersView.class))).thenReturn(componentSuccessEither);
    }

    private void stubGetToscaFullElementSuccess() {
        when(toscaOperationFacade.getToscaFullElement(eq(COMPONENT_ID))).thenReturn(buildElementEither());
    }

    private void stubGetToscaElementSuccess() {
        when(toscaOperationFacade.getToscaElement(eq(COMPONENT_ID))).thenReturn(componentSuccessEither);
    }

    private Either<Component, StorageOperationStatus> buildElementEither() {
        ResourceBuilder builder = new ResourceBuilder();
        GroupDefinition groupDefinition = GroupDefinitionBuilder.create().setUniqueId(UNIQUE_ID_EXSISTS).build();
        ComponentInstanceBuilder componentInstanceBuilder = new ComponentInstanceBuilder();
        ComponentInstance componentInstance = componentInstanceBuilder.setUniqueId(UNIQUE_ID_EXSISTS).build();
        return Either.left(builder.addGroups(groupDefinition).addComponentInstance(componentInstance).build());
    }

    private Map<PolicyTargetType, List<String>> getTargets() {
        Map<PolicyTargetType, List<String>> targets = new HashMap<>();
        targets.put(PolicyTargetType.COMPONENT_INSTANCES, Collections.singletonList(UNIQUE_ID_EXSISTS));
        targets.put(PolicyTargetType.GROUPS, Collections.singletonList(UNIQUE_ID_EXSISTS));
        return targets;
    }



    private static PolicyTypeDefinition buildPolicyType() {
        PolicyTypeDefinition policyType = new PolicyTypeDefinition();
        policyType.setType(POLICY_TYPE_NAME);
        return policyType;
    }

    private static PolicyDefinition buildPolicy(String policyName) {
        PolicyDefinition policy = new PolicyDefinition();
        policy.setUniqueId(POLICY_ID);
        policy.setPolicyTypeName(POLICY_TYPE_NAME);
        policy.setComponentName(COMPONENT_NAME);
        policy.setName(policyName);
        return policy;
    }

    private static Resource buildResource() {
        Resource resource = new Resource();
        resource.setUniqueId(COMPONENT_ID);
        resource.setName(COMPONENT_NAME);
        resource.setCreatorUserId(USER_ID);
        resource.setLastUpdaterUserId(USER_ID);
        resource.setState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
        resource.setIsDeleted(false);
        resource.setResourceType(ResourceTypeEnum.VF);
        resource.setToscaType(ToscaElementTypeEnum.TopologyTemplate.getValue());
        Map<String, PolicyDefinition> policies = new HashMap<>();
        policies.put(POLICY_ID, policy);
        resource.setPolicies(policies);
        return resource;
    }

    private static User buildUser() {
        User user = new User();
        user.setUserId(USER_ID);
        return user;
    }
    private List<PolicyTargetDTO> getTargetDTOList() {
        PolicyTargetDTO target1 = new PolicyTargetDTO();
        target1.setUniqueIds(Collections.singletonList(UNIQUE_ID_EXSISTS));
        target1.setType("GROUPS");

        PolicyTargetDTO target2 = new PolicyTargetDTO();
        target2.setUniqueIds(Collections.singletonList(UNIQUE_ID_EXSISTS));
        target2.setType("componentInstances");

        return Arrays.asList(target1, target2);
    }

    private List<PolicyTargetDTO> getFakeIDTargetDTOList() {
        PolicyTargetDTO target1 = new PolicyTargetDTO();
        target1.setUniqueIds(Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
        target1.setType(GROUP_TYPE);

        PolicyTargetDTO target2 = new PolicyTargetDTO();
        target2.setUniqueIds(Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
        target2.setType(COMPONENT_INSTANCE_TYPE);

        return Arrays.asList(target1, target2);
    }
    private List<PolicyTargetDTO> getFakeTypeTargetDTOList() {
        PolicyTargetDTO target1 = new PolicyTargetDTO();
        target1.setUniqueIds(Collections.singletonList(UNIQUE_ID_EXSISTS));
        target1.setType(FAKE_TYPE);

        PolicyTargetDTO target2 = new PolicyTargetDTO();
        target2.setUniqueIds(Collections.singletonList(UNIQUE_ID_EXSISTS));
        target2.setType(FAKE_TYPE);

        return Arrays.asList(target1, target2);
    }

    private Map<PolicyTargetType, List<String>> getTargetListFakeType() {
        Map<PolicyTargetType, List<String>> targets = new HashMap<>();
        targets.put(PolicyTargetType.TYPE_DOES_NOT_EXIST, Collections.singletonList(UNIQUE_ID_EXSISTS));
        targets.put(PolicyTargetType.TYPE_DOES_NOT_EXIST, Collections.singletonList(UNIQUE_ID_EXSISTS));
        return targets;
    }

    private Map<PolicyTargetType, List<String>> getTargetListFakeId() {
        Map<PolicyTargetType, List<String>> targets = new HashMap<>();
        targets.put(PolicyTargetType.COMPONENT_INSTANCES, Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
        targets.put(PolicyTargetType.GROUPS, Collections.singletonList(UNIQUE_ID_DOESNT_EXSISTS));
        return targets;
    }

}