catalog-be/src/test/java/org/openecomp/sdc/be/servlets/GroupTypesEndpointTest.java

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import com.fasterxml.jackson.databind.DeserializationFeature;
   4 import com.google.common.collect.ImmutableMap;
   5 import com.google.common.collect.Sets;
   6 import fj.data.Either;
   7 import org.glassfish.jersey.client.ClientConfig;
   8 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
   9 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
  10 import org.glassfish.jersey.server.ResourceConfig;
  11 import org.junit.Before;
  12 import org.junit.BeforeClass;
  13 import org.junit.Test;
  14 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
  15 import org.openecomp.sdc.be.components.utils.GroupTypeBuilder;
  16 import org.openecomp.sdc.be.components.validation.UserValidations;
  17 import org.openecomp.sdc.be.config.ConfigurationManager;
  18 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao;
  19 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
  20 import org.openecomp.sdc.be.datatypes.elements.GroupTypeDataDefinition;
  21 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  22 import org.openecomp.sdc.be.impl.ComponentsUtils;
  23 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  24 import org.openecomp.sdc.be.model.User;
  25 import org.openecomp.sdc.be.model.operations.api.DerivedFromOperation;
  26 import org.openecomp.sdc.be.model.operations.impl.*;
  27 import org.openecomp.sdc.be.resources.data.GroupTypeData;
  28 import org.openecomp.sdc.common.api.ConfigurationSource;
  29 import org.openecomp.sdc.common.api.Constants;
  30 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  31 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  32 import org.springframework.context.annotation.Bean;
  33 import org.springframework.context.annotation.Import;
  34
  35 import javax.ws.rs.client.Invocation;
  36 import javax.ws.rs.core.GenericType;
  37 import javax.ws.rs.core.MediaType;
  38 import java.util.HashSet;
  39 import java.util.List;
  40 import java.util.Map;
  41 import java.util.Set;
  42 import java.util.stream.Stream;
  43
  44 import static java.util.Arrays.asList;
  45 import static org.assertj.core.api.Assertions.assertThat;
  46 import static org.mockito.ArgumentMatchers.*;
  47 import static org.mockito.Mockito.mock;
  48 import static org.mockito.Mockito.when;
  49 import static org.mockito.Mockito.mock;
  50
  51 public class GroupTypesEndpointTest extends JerseySpringBaseTest {
  52
  53     private static final String USER_ID = "a001";
  54     private static final GroupTypeDefinition EMPTY_GROUP_TYPE = new GroupTypeDefinition();
  55     private static final String COMPONENT_TYPE = "VF";
  56     private static final HashSet<String> EXCLUDED_TYPES = Sets.newHashSet("Root", "Heat");
  57
  58     private static ComponentsUtils componentsUtils;
  59     private static JanusGraphGenericDao janusGraphGenericDao;
  60     private static CapabilityTypeOperation capabilityTypeOperation;
  61     private static DerivedFromOperation derivedFromOperation;
  62     private static JanusGraphDao janusGraphDao;
  63     private static PropertyOperation propertyOperation;
  64     private static CapabilityOperation capabilityOperation;
  65     private static UserValidations userValidations;
  66     private static OperationUtils operationUtils;
  67     private static User user;
  68
  69     static ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), "src/test/resources/config/catalog-be");
  70     static ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  71
  72     @org.springframework.context.annotation.Configuration
  73     @Import(BaseTestConfig.class)
  74     static class GroupTypesTestConfig {
  75
  76         @Bean
  77         GroupTypesEndpoint groupTypesEndpoint() {
  78             return new GroupTypesEndpoint(groupTypeBusinessLogic());
  79         }
  80
  81         @Bean
  82         GroupTypeBusinessLogic groupTypeBusinessLogic() {
  83             return new GroupTypeBusinessLogic(groupTypeOperation(), janusGraphDao, userValidations, componentsUtils);
  84         }
  85
  86         @Bean
  87         GroupTypeOperation groupTypeOperation() {
  88             return new GroupTypeOperation(janusGraphGenericDao, propertyOperation, capabilityTypeOperation, capabilityOperation, derivedFromOperation, operationUtils);
  89         }
  90     }
  91
  92     @BeforeClass
  93     public static void initClass() {
  94         componentsUtils = mock(ComponentsUtils.class);
  95         propertyOperation = mock(PropertyOperation.class);
  96         capabilityTypeOperation = mock(CapabilityTypeOperation.class);
  97         janusGraphDao = mock(JanusGraphDao.class);
  98         janusGraphGenericDao = mock(JanusGraphGenericDao.class);
  99         userValidations = mock(UserValidations.class);
 100         operationUtils = mock(OperationUtils.class);
 101         user = mock(User.class);
 102     }
 103
 104     @Before
 105     public void init() {
 106         when(userValidations.validateUserExists(eq(USER_ID), anyString(), anyBoolean())).thenReturn(user);
 107         when(janusGraphGenericDao.getByCriteriaWithPredicate(eq(NodeTypeEnum.GroupType), any(), eq(GroupTypeData.class))).thenReturn(Either.left(buildGroupTypeDataList()));
 108     }
 109
 110     @Override
 111     protected void configureClient(ClientConfig config) {
 112         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 113         config.register(jacksonJsonProvider);
 114     }
 115
 116     @Override
 117     protected ResourceConfig configure() {
 118         return super.configure(GroupTypesTestConfig.class)
 119                 .register(GroupTypesEndpoint.class);
 120     }
 121
 122     @Test
 123     public void verifyExclusionMapIsCaseInsensitive() {
 124         Map<String, Set<String>> excludedGroupTypesMapping = configurationManager.getConfiguration().getExcludedGroupTypesMapping();
 125         assertThat(excludedGroupTypesMapping.get(COMPONENT_TYPE)).hasSameElementsAs(excludedGroupTypesMapping.get(COMPONENT_TYPE.toLowerCase()));
 126     }
 127
 128     @Test
 129     public void getGroupTypes_validUser_Success() {
 130         List<GroupTypeDefinition> testConfigGroupTypes = buildGroupTypesList();
 131         List<GroupTypeDefinition> fetchedGroupTypes = buildGetGroupTypesCall(USER_ID, COMPONENT_TYPE).get(new GenericType<List<GroupTypeDefinition>>(){});
 132         verifyGroupTypesList(testConfigGroupTypes, fetchedGroupTypes);
 133     }
 134
 135     @Test
 136     public void getGroupTypes_whenNoInteranlComponentType_passEmptyAsExcludedTypes() {
 137         List<GroupTypeDefinition> testConfigGroupTypes = buildGroupTypesList();
 138         List<GroupTypeDefinition> fetchedGroupTypes = buildGetGroupTypesCallNoInternalComponent(USER_ID).get(new GenericType<List<GroupTypeDefinition>>(){});
 139         verifyGroupTypesList(testConfigGroupTypes, fetchedGroupTypes);
 140     }
 141
 142     private void verifyGroupTypesList(List<GroupTypeDefinition> groupTypes, List<GroupTypeDefinition> fetchedGroupTypes) {
 143         String[] expectedReturnFields = {"version", "type", "uniqueId", "name", "icon"};
 144         assertThat(fetchedGroupTypes)
 145                 .usingElementComparatorOnFields(expectedReturnFields)
 146                 .isEqualTo(groupTypes);
 147         verifyOnlySpecificFieldsInResponse(fetchedGroupTypes, expectedReturnFields);
 148     }
 149
 150     private void verifyOnlySpecificFieldsInResponse(List<GroupTypeDefinition> fetchedGroupTypes, String ... fields) {
 151         assertThat(fetchedGroupTypes)
 152                 .usingElementComparatorIgnoringFields(fields)
 153                 .containsOnly(EMPTY_GROUP_TYPE);
 154     }
 155
 156     private Invocation.Builder buildGetGroupTypesCall(String userId, String componentType) {
 157         return target("/v1/catalog/groupTypes")
 158                 .queryParam("internalComponentType", componentType)
 159                 .request(MediaType.APPLICATION_JSON)
 160                 .header(Constants.USER_ID_HEADER, userId);
 161     }
 162
 163     private Invocation.Builder buildGetGroupTypesCallNoInternalComponent(String userId) {
 164         return target("/v1/catalog/groupTypes")
 165                 .request(MediaType.APPLICATION_JSON)
 166                 .header(Constants.USER_ID_HEADER, userId);
 167     }
 168
 169     private Map<String, Set<String>> buildExcludeGroupTypesMap() {
 170         return new ImmutableMap.Builder<String, Set<String>>()
 171                 .put("CR", Sets.newHashSet("VFModule", "Root", "Heat"))
 172                 .put(COMPONENT_TYPE, EXCLUDED_TYPES)
 173                 .build();
 174     }
 175
 176
 177     private List<GroupTypeDefinition> buildGroupTypesList() {
 178         GroupTypeDefinition type1 = GroupTypeBuilder.create()
 179                                                     .setDerivedFrom("root")
 180                                                     .setType("org.openecomp.groups.VfModule")
 181                                                     .setUniqueId("id1")
 182                                                     .setVersion("1.0")
 183                                                     .setName("vf module")
 184                                                     .setIcon("vf module icon")
 185                                                     .build();
 186         GroupTypeDefinition type2 = GroupTypeBuilder.create()
 187                                                     .setDerivedFrom("root")
 188                                                     .setType("org.openecomp.groups.NetworkCollection")
 189                                                     .setUniqueId("id2")
 190                                                     .setVersion("1.0")
 191                                                     .setName("network collection")
 192                                                     .setIcon("network collection icon")
 193                                                     .build();
 194         return asList(type1, type2);
 195     }
 196
 197     private List<GroupTypeData> buildGroupTypeDataList() {
 198         GroupTypeDataDefinition d1 = new GroupTypeDataDefinition();
 199         d1.setType("org.openecomp.groups.VfModule");
 200         d1.setDerivedFrom("root");
 201         d1.setUniqueId("id1");
 202         d1.setVersion("1.0");
 203         d1.setName("vf module");
 204         d1.setIcon("vf module icon");
 205         GroupTypeData gt1 = new GroupTypeData(d1);
 206         GroupTypeDataDefinition d2 = new GroupTypeDataDefinition();
 207         d2.setType("org.openecomp.groups.NetworkCollection");
 208         d2.setDerivedFrom("root");
 209         d2.setUniqueId("id2");
 210         d2.setVersion("1.0");
 211         d2.setName("network collection");
 212         d2.setIcon("network collection icon");
 213         GroupTypeData gt2 = new GroupTypeData(d2);
 214         return asList(gt1, gt2);
 215     }
 216
 217     private GroupTypeDefinition[] listOfEmptyGroupTypes(int size) {
 218         return Stream.generate(GroupTypeDefinition::new).limit(size).toArray(GroupTypeDefinition[]::new);
 219     }
 220
 221
 222 }