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.DummyConfigurationManager;
  15 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
  16 import org.openecomp.sdc.be.components.impl.ResponseFormatManager;
  17 import org.openecomp.sdc.be.components.utils.GroupTypeBuilder;
  18 import org.openecomp.sdc.be.components.validation.UserValidations;
  19 import org.openecomp.sdc.be.config.ConfigurationManager;
  20 import org.openecomp.sdc.be.dao.jsongraph.TitanDao;
  21 import org.openecomp.sdc.be.impl.ComponentsUtils;
  22 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  23 import org.openecomp.sdc.be.model.User;
  24 import org.openecomp.sdc.be.model.operations.impl.GroupTypeOperation;
  25 import org.openecomp.sdc.common.api.Constants;
  26 import org.springframework.context.annotation.Bean;
  27 import org.springframework.context.annotation.Configuration;
  28 import org.springframework.context.annotation.Import;
  29
  30 import javax.ws.rs.client.Invocation;
  31 import javax.ws.rs.core.GenericType;
  32 import javax.ws.rs.core.MediaType;
  33 import java.util.HashSet;
  34 import java.util.List;
  35 import java.util.Map;
  36 import java.util.Set;
  37 import java.util.stream.Stream;
  38
  39 import static java.util.Arrays.asList;
  40 import static org.assertj.core.api.Assertions.assertThat;
  41 import static org.mockito.ArgumentMatchers.anyBoolean;
  42 import static org.mockito.ArgumentMatchers.anyString;
  43 import static org.mockito.ArgumentMatchers.eq;
  44 import static org.mockito.Mockito.mock;
  45 import static org.mockito.Mockito.when;
  46
  47 public class GroupTypesEndpointTest extends JerseySpringBaseTest {
  48
  49     private static final String USER_ID = "a001";
  50     private static final String INVALID_USER_ID = "a002";
  51     private static final GroupTypeDefinition EMPTY_GROUP_TYPE = new GroupTypeDefinition();
  52     private static final String COMPONENT_TYPE = "VF";
  53     private static final HashSet<String> EXCLUDED_TYPES = Sets.newHashSet("Root", "Heat");
  54
  55     private static ComponentsUtils componentsUtils;
  56     private static GroupTypeOperation groupTypeOperation;
  57     private static TitanDao titanDao;
  58     private static UserValidations userValidations;
  59     private static User user;
  60
  61     @Configuration
  62     @Import(BaseTestConfig.class)
  63     static class GroupTypesTestConfig {
  64
  65         @Bean
  66         GroupTypesEndpoint groupTypesEndpoint() {
  67             return new GroupTypesEndpoint(groupTypeBusinessLogic());
  68         }
  69
  70         @Bean
  71         GroupTypeBusinessLogic groupTypeBusinessLogic() {
  72             return new GroupTypeBusinessLogic(groupTypeOperation, titanDao, userValidations);
  73         }
  74     }
  75
  76     @BeforeClass
  77     public static void initClass() {
  78         componentsUtils = mock(ComponentsUtils.class);
  79         groupTypeOperation = mock(GroupTypeOperation.class);
  80         titanDao = mock(TitanDao.class);
  81         userValidations = mock(UserValidations.class);
  82         user = mock(User.class);
  83     }
  84
  85     @Before
  86     public void init() {
  87         new DummyConfigurationManager();
  88         when(ConfigurationManager.getConfigurationManager().getConfiguration().getExcludedGroupTypesMapping()).thenReturn(buildExcludeGroupTypesMap());
  89         ResponseFormatManager responseFormatManager = ResponseFormatManager.getInstance();
  90         when(userValidations.validateUserExists(eq(USER_ID), anyString(), anyBoolean())).thenReturn(Either.left(user));
  91         // TODO: handle for invalid user test
  92 //        when(userValidations.validateUserExists(eq(INVALID_USER_ID), anyString(), anyBoolean())).thenReturn(Either.right(???)));
  93     }
  94
  95     @Override
  96     protected void configureClient(ClientConfig config) {
  97         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  98         config.register(jacksonJsonProvider);
  99     }
 100
 101     @Override
 102     protected ResourceConfig configure() {
 103         return super.configure(GroupTypesTestConfig.class)
 104                 .register(GroupTypesEndpoint.class);
 105     }
 106
 107     @Test
 108     public void getGroupTypes_validUser_Success() {
 109         List<GroupTypeDefinition> testConfigGroupTypes = buildGroupTypesList();
 110         when(groupTypeOperation.getAllGroupTypes(EXCLUDED_TYPES)).thenReturn(buildGroupTypesList());
 111         List<GroupTypeDefinition> fetchedGroupTypes = buildGetGroupTypesCall(USER_ID).get(new GenericType<List<GroupTypeDefinition>>(){});
 112         verifyGroupTypesList(testConfigGroupTypes, fetchedGroupTypes);
 113     }
 114
 115     @Test
 116     public void getGroupTypes_whenNoInteranlComponentType_passEmptyAsExcludedTypes() {
 117         List<GroupTypeDefinition> testConfigGroupTypes = buildGroupTypesList();
 118         when(groupTypeOperation.getAllGroupTypes(null)).thenReturn(buildGroupTypesList());
 119         List<GroupTypeDefinition> fetchedGroupTypes = buildGetGroupTypesCallNoInternalComponent(USER_ID).get(new GenericType<List<GroupTypeDefinition>>(){});
 120         verifyGroupTypesList(testConfigGroupTypes, fetchedGroupTypes);
 121     }
 122
 123     private void verifyGroupTypesList(List<GroupTypeDefinition> groupTypes, List<GroupTypeDefinition> fetchedGroupTypes) {
 124         assertThat(fetchedGroupTypes)
 125                 .usingElementComparatorOnFields("version", "type", "uniqueId")
 126                 .isEqualTo(groupTypes);
 127         verifyOnlySpecificFieldsInResponse(fetchedGroupTypes, "version", "type", "uniqueId");
 128     }
 129
 130     private void verifyOnlySpecificFieldsInResponse(List<GroupTypeDefinition> fetchedGroupTypes, String ... fields) {
 131         assertThat(fetchedGroupTypes)
 132                 .usingElementComparatorIgnoringFields(fields)
 133                 .containsOnly(EMPTY_GROUP_TYPE);
 134     }
 135
 136     private Invocation.Builder buildGetGroupTypesCall(String userId) {
 137         return target("/v1/catalog/groupTypes")
 138                 .queryParam("internalComponentType", COMPONENT_TYPE)
 139                 .request(MediaType.APPLICATION_JSON)
 140                 .header(Constants.USER_ID_HEADER, userId);
 141     }
 142
 143     private Invocation.Builder buildGetGroupTypesCallNoInternalComponent(String userId) {
 144         return target("/v1/catalog/groupTypes")
 145                 .request(MediaType.APPLICATION_JSON)
 146                 .header(Constants.USER_ID_HEADER, userId);
 147     }
 148
 149     private Map<String, Set<String>> buildExcludeGroupTypesMap() {
 150         return new ImmutableMap.Builder<String, Set<String>>()
 151                 .put("CR", Sets.newHashSet("VFModule", "Root", "Heat"))
 152                 .put(COMPONENT_TYPE, EXCLUDED_TYPES)
 153                 .build();
 154     }
 155
 156
 157     private List<GroupTypeDefinition> buildGroupTypesList() {
 158         GroupTypeDefinition type1 = GroupTypeBuilder.create()
 159                                                     .setDerivedFrom("root")
 160                                                     .setType("VFModule")
 161                                                     .setUniqueId("id1")
 162                                                     .setVersion("1.0")
 163                                                     .build();
 164         GroupTypeDefinition type2 = GroupTypeBuilder.create().setDerivedFrom("root").setType("Heat").setUniqueId("id2").build();
 165         return asList(type1, type2);
 166     }
 167
 168     private GroupTypeDefinition[] listOfEmptyGroupTypes(int size) {
 169         return Stream.generate(GroupTypeDefinition::new).limit(size).toArray(GroupTypeDefinition[]::new);
 170     }
 171
 172
 173 }