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

   1 package org.openecomp.sdc.be.servlets;
   2
   3 import com.fasterxml.jackson.databind.DeserializationFeature;
   4 import fj.data.Either;
   5 import org.assertj.core.api.AssertionsForClassTypes;
   6 import org.glassfish.jersey.client.ClientConfig;
   7 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJaxbJsonProvider;
   8 import org.glassfish.jersey.jackson.internal.jackson.jaxrs.json.JacksonJsonProvider;
   9 import org.glassfish.jersey.logging.LoggingFeature;
  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.mockito.invocation.InvocationOnMock;
  15 import org.mockito.stubbing.Answer;
  16 import org.openecomp.sdc.be.components.impl.GroupBusinessLogicNew;
  17 import org.openecomp.sdc.be.components.validation.AccessValidations;
  18 import org.openecomp.sdc.be.components.validation.ComponentValidations;
  19 import org.openecomp.sdc.be.config.ConfigurationManager;
  20 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  21 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  22 import org.openecomp.sdc.be.model.ComponentInstance;
  23 import org.openecomp.sdc.be.model.GroupDefinition;
  24 import org.openecomp.sdc.be.model.GroupProperty;
  25 import org.openecomp.sdc.be.model.Resource;
  26 import org.openecomp.sdc.be.model.jsontitan.operations.GroupsOperation;
  27 import org.openecomp.sdc.be.model.operations.StorageException;
  28 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  29 import org.openecomp.sdc.be.model.operations.impl.GroupOperation;
  30 import org.openecomp.sdc.common.api.ConfigurationSource;
  31 import org.openecomp.sdc.common.api.Constants;
  32 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  33 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  34 import org.springframework.context.annotation.Bean;
  35 import org.springframework.context.annotation.Configuration;
  36 import org.springframework.context.annotation.Import;
  37 import org.springframework.http.HttpStatus;
  38
  39 import javax.ws.rs.client.Entity;
  40 import javax.ws.rs.client.Invocation;
  41 import javax.ws.rs.core.GenericType;
  42 import javax.ws.rs.core.MediaType;
  43 import javax.ws.rs.core.Response;
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.List;
  47 import java.util.Optional;
  48
  49 import static org.assertj.core.api.Assertions.assertThat;
  50 import static org.mockito.ArgumentMatchers.any;
  51 import static org.mockito.ArgumentMatchers.anyString;
  52 import static org.mockito.ArgumentMatchers.eq;
  53 import static org.mockito.ArgumentMatchers.isA;
  54 import static org.mockito.Mockito.anyList;
  55 import static org.mockito.Mockito.*;
  56 import static org.openecomp.sdc.be.model.operations.api.StorageOperationStatus.NOT_FOUND;
  57
  58 public class GroupEndpointTest extends JerseySpringBaseTest {
  59
  60     private static final String VALID_USER = "ab001";
  61     private static final String INVALID_USER = "ab002";
  62     private static final String VALID_COMPONENT_ID = "12345";
  63     private static final String INVALID_COMPONENT_ID = "9999";
  64     private static final String VALID_GROUP_ID = "1";
  65     private static final String INVALID_GROUP_ID = "2";
  66     public static final String A = "a";
  67     private static final String VL1 = "VL1";
  68     private static final String OLD_VALUE = "old value";
  69     private static AccessValidations accessValidations;
  70     private static ComponentValidations componentValidations;
  71     private static GroupsOperation groupsOperation;
  72     private static GroupOperation groupOperation;
  73     private Resource cr;
  74     private GroupDefinition g1;
  75     private ComponentInstance ci;
  76     private GroupProperty gp1;
  77
  78     @Configuration
  79     @Import(BaseTestConfig.class)
  80     static class GroupEndpointTestConfig {
  81
  82         @Bean
  83         GroupEndpoint groupEndpoint() {
  84             return new GroupEndpoint(groupBusinessLogic());
  85         }
  86
  87         @Bean
  88         GroupBusinessLogicNew groupBusinessLogic() {
  89             return new GroupBusinessLogicNew(accessValidations, componentValidations, groupsOperation, groupOperation);
  90         }
  91     }
  92
  93     @BeforeClass
  94     public static void initClass() {
  95         ExternalConfiguration.setAppName("catalog-be");
  96         String appConfigDir = "src/test/resources/config/catalog-be";
  97         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
  98         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  99         //ComponentsUtils needs configuration singleton to be set
 100         componentValidations = mock(ComponentValidations.class);
 101         accessValidations = mock(AccessValidations.class);
 102         groupsOperation = mock(GroupsOperation.class);
 103         groupOperation = mock(GroupOperation.class);
 104
 105     }
 106
 107     @Override
 108     protected void configureClient(ClientConfig config) {
 109         final JacksonJsonProvider jacksonJsonProvider = new JacksonJaxbJsonProvider()
 110                 .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 111         config.register(jacksonJsonProvider);
 112     }
 113
 114     @Override
 115     protected ResourceConfig configure() {
 116         return super.configure(GroupEndpointTestConfig.class)
 117                 .register(GroupEndpoint.class)
 118                 .property(LoggingFeature.LOGGING_FEATURE_LOGGER_LEVEL_SERVER, "WARNING");
 119     }
 120
 121     @Before
 122     public void init() {
 123         cr = new Resource();
 124         cr.setSystemName("CR1");
 125         g1 = new GroupDefinition();
 126         g1.setUniqueId(VALID_GROUP_ID);
 127         gp1 = new GroupProperty();
 128         gp1.setUniqueId("1");
 129         gp1.setName("p1");
 130         gp1.setValue(OLD_VALUE);
 131         g1.setProperties(Arrays.asList(gp1));
 132         cr.setGroups(Arrays.asList(g1));
 133         ci = new ComponentInstance();
 134         ci.setUniqueId(A);
 135         ci.setName(VL1);
 136         happyScenarioSetup();
 137         unhappyScenarioSetup();
 138     }
 139
 140     private void unhappyScenarioSetup() {
 141         when(accessValidations.validateUserCanWorkOnComponent(eq(INVALID_COMPONENT_ID), eq(ComponentTypeEnum.RESOURCE), eq(VALID_USER), anyString())).thenThrow(new StorageException(NOT_FOUND, INVALID_COMPONENT_ID));
 142         when(componentValidations.getComponentInstance(cr, A)).thenReturn(Optional.of(ci));
 143     }
 144
 145
 146     private void happyScenarioSetup() {
 147         when(accessValidations.validateUserCanWorkOnComponent(eq(VALID_COMPONENT_ID), any(ComponentTypeEnum.class), eq(VALID_USER), anyString())).thenReturn(cr);
 148         when(accessValidations.validateUserCanRetrieveComponentData(eq(VALID_COMPONENT_ID), eq("resources"), eq(VALID_USER), anyString()))
 149                 .thenReturn(cr);
 150         when(componentValidations.getComponentInstance(cr, A)).thenReturn(Optional.of(ci));
 151         doNothing().when(groupsOperation).updateGroupOnComponent(eq(VALID_COMPONENT_ID), isA(GroupDefinition.class));
 152         when(groupOperation.validateAndUpdatePropertyValue(isA(GroupProperty.class))).thenReturn(StorageOperationStatus.OK);
 153         when(groupsOperation.updateGroupPropertiesOnComponent(eq(VALID_COMPONENT_ID), isA(GroupDefinition.class), anyList())).thenAnswer(new Answer<Either>() {
 154             @Override
 155             public Either answer(InvocationOnMock invocationOnMock) throws Throwable {
 156                 Object[] args = invocationOnMock.getArguments();
 157                 return Either.left(Arrays.asList(args[2]));
 158             }
 159         });
 160     }
 161
 162     @Test
 163     public void updateGroupMembers_success() {
 164         List<String> ids = Arrays.asList(A);
 165         List<String> updatedIds = buildUpdateGroupMembersCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 166                 .post(Entity.entity(ids, MediaType.APPLICATION_JSON), new GenericType<List<String>>() {
 167                 });
 168         assertThat(updatedIds.size()).isEqualTo(ids.size());
 169         assertThat(updatedIds).containsExactlyInAnyOrder(ids.toArray(new String[ids.size()]));
 170     }
 171
 172     @Test
 173     public void updateGroupMembersWith2IdenticalMembers_success() {
 174         List<String> ids = Arrays.asList(A, A);
 175         List<String> updatedIds = buildUpdateGroupMembersCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 176                 .post(Entity.entity(ids, MediaType.APPLICATION_JSON), new GenericType<List<String>>() {
 177                 });
 178         assertThat(updatedIds.size()).isEqualTo(1);
 179         assertThat(updatedIds).containsExactlyInAnyOrder(String.valueOf(A));
 180     }
 181
 182     @Test
 183     public void updateGroupMembersWithEmptyList_success() {
 184         List<String> ids = new ArrayList<>();
 185         List<String> updatedIds = buildUpdateGroupMembersCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 186                 .post(Entity.entity(ids, MediaType.APPLICATION_JSON), new GenericType<List<String>>() {
 187                 });
 188         assertThat(updatedIds.size()).isEqualTo(0);
 189     }
 190
 191     @Test
 192     public void updateGroupMember_InvalidComponentId_failure() {
 193         List<String> ids = new ArrayList<>();
 194         Response response = buildUpdateGroupMembersCall(INVALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 195                 .post(Entity.entity(ids, MediaType.APPLICATION_JSON), Response.class);
 196         AssertionsForClassTypes.assertThat(response.getStatus()).isEqualTo(HttpStatus.NOT_FOUND.value());
 197     }
 198
 199     @Test
 200     public void updateGroupProperty_success() {
 201         GroupProperty property = new GroupProperty();
 202         property.setValue("value1");
 203         property.setName("prop");
 204         String propertyStr = "[{\"uniqueId\":\"1\",\"type\":null,\"required\":false,\"definition\":false,\"defaultValue\":null,\"description\":null,\"schema\":null,\"password\":false,\"name\":\"p1\",\"value\":\"new value\",\"label\":null,\"hidden\":false,\"immutable\":false,\"inputPath\":null,\"status\":null,\"inputId\":null,\"instanceUniqueId\":null,\"propertyId\":null,\"parentUniqueId\":null,\"getInputValues\":null,\"constraints\":null,\"valueUniqueUid\":null,\"ownerId\":null}]";
 205         List<GroupProperty> properties = Arrays.asList(property);
 206         //TODO define GroupPropertyDTO (after finding other usage in UI code) and improve test coverage
 207 //        List<GroupProperty> updatedProperties = buildUpdateGroupPropertiesCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 208 //                .put(Entity.entity(propertyStr, MediaType.APPLICATION_JSON), new GenericType<List<GroupProperty>>() {
 209 //                });
 210 //        assertThat(updatedProperties.size()).isEqualTo(1);
 211         Response response = buildUpdateGroupPropertiesCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 212                 .put(Entity.entity(propertyStr, MediaType.APPLICATION_JSON));
 213         assertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
 214     }
 215
 216     @Test
 217     public void getGroupProperties_success() {
 218         List<PropertyDataDefinition> properties = buildUpdateGroupPropertiesCall(VALID_COMPONENT_ID, VALID_GROUP_ID, VALID_USER)
 219                 .get(new GenericType<List<PropertyDataDefinition>>(){});
 220         assertThat(properties.size()).isEqualTo(1);
 221         assertThat(properties.get(0).getValue()).isEqualTo(OLD_VALUE);
 222     }
 223
 224     private Invocation.Builder buildUpdateGroupMembersCall(String componentId, String groupId, String userId) {
 225         return target("/v1/catalog/resources/" + componentId + "/groups/" + groupId + "/members")
 226                 .request(MediaType.APPLICATION_JSON)
 227                 .accept(MediaType.APPLICATION_JSON)
 228                 .header(Constants.USER_ID_HEADER, userId);
 229     }
 230
 231     private Invocation.Builder buildUpdateGroupPropertiesCall(String componentId, String groupId, String userId) {
 232         return target("/v1/catalog/resources/" + componentId + "/groups/" + groupId + "/properties")
 233                 .request(MediaType.APPLICATION_JSON)
 234                 .accept(MediaType.APPLICATION_JSON)
 235                 .header(Constants.USER_ID_HEADER, userId);
 236     }
 237
 238
 239 }