catalog-be/src/test/java/org/openecomp/sdc/be/components/property/GroupPropertyDeclaratorTest.java

   1 package org.openecomp.sdc.be.components.property;
   2
   3 import fj.data.Either;
   4 import org.junit.Before;
   5 import org.junit.Test;
   6 import org.junit.runner.RunWith;
   7 import org.mockito.ArgumentCaptor;
   8 import org.mockito.Captor;
   9 import org.mockito.InjectMocks;
  10 import org.mockito.Mock;
  11 import org.mockito.junit.MockitoJUnitRunner;
  12 import org.openecomp.sdc.be.components.utils.GroupDefinitionBuilder;
  13 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  14 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  15 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  16 import org.openecomp.sdc.be.model.ComponentInstancePropInput;
  17 import org.openecomp.sdc.be.model.GroupDefinition;
  18 import org.openecomp.sdc.be.model.InputDefinition;
  19 import org.openecomp.sdc.be.model.Resource;
  20 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  21 import org.openecomp.sdc.be.model.operations.impl.GroupOperation;
  22 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation;
  23
  24 import java.util.Arrays;
  25 import java.util.Collections;
  26 import java.util.List;
  27 import java.util.Optional;
  28 import java.util.stream.Collectors;
  29 import java.util.stream.Stream;
  30
  31 import static org.assertj.core.api.Java6Assertions.assertThat;
  32 import static org.mockito.ArgumentMatchers.eq;
  33 import static org.mockito.Mockito.verifyZeroInteractions;
  34 import static org.mockito.Mockito.when;
  35
  36 @RunWith(MockitoJUnitRunner.class)
  37 public class GroupPropertyDeclaratorTest extends PropertyDeclaratorTestBase {
  38
  39
  40     private static final String GROUP_ID = "groupId";
  41     @InjectMocks
  42     private GroupPropertyDeclarator groupPropertyDeclarator;
  43     @Mock
  44     private GroupOperation groupOperation;
  45     @Mock
  46     private PropertyOperation propertyOperation;
  47     @Captor
  48     private ArgumentCaptor<List<PropertyDataDefinition>> updatedPropsCapture;
  49     private Resource resource;
  50     private InputDefinition input;
  51
  52     @Override
  53     @Before
  54     public void setUp() throws Exception {
  55         super.setUp();
  56         resource = createResourceWithGroup();
  57         input = new InputDefinition();
  58         input.setUniqueId(INPUT_ID);
  59         input.setName(INPUT_ID);
  60         input.setValue("value");
  61     }
  62
  63     @Test
  64     public void testDeclarePropertiesAsInputs_groupNotExist() {
  65         Either<List<InputDefinition>, StorageOperationStatus> declareResult = groupPropertyDeclarator.declarePropertiesAsInputs(resource, "nonExistingGroup", Collections.emptyList());
  66         assertThat(declareResult.right().value()).isEqualTo(StorageOperationStatus.NOT_FOUND);
  67         verifyZeroInteractions(groupOperation);
  68     }
  69
  70     @Test
  71     public void testDeclarePropertiesAsInputs_failedToUpdateProperties() {
  72         when(groupOperation.updateGroupProperties(eq(resource), eq(GROUP_ID), updatedPropsCapture.capture())).thenReturn(StorageOperationStatus.GENERAL_ERROR);
  73         Either<List<InputDefinition>, StorageOperationStatus> declareResult = groupPropertyDeclarator.declarePropertiesAsInputs(resource, GROUP_ID, Collections.emptyList());
  74         assertThat(declareResult.right().value()).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
  75     }
  76
  77     @Test
  78     public void testDeclarePropertiesAsInputs() {
  79         List<PropertyDataDefinition> properties = Arrays.asList(prop1, prop2);
  80         List<ComponentInstancePropInput> propsToDeclare = createInstancePropInputList(properties);
  81         when(groupOperation.updateGroupProperties(eq(resource), eq(GROUP_ID), updatedPropsCapture.capture())).thenReturn(StorageOperationStatus.OK);
  82         Either<List<InputDefinition>, StorageOperationStatus> createdInputs = groupPropertyDeclarator.declarePropertiesAsInputs(resource, GROUP_ID, propsToDeclare);
  83         List<InputDefinition> inputs = createdInputs.left().value();
  84         assertThat(inputs).hasSize(2);
  85         verifyInputPropertiesList(inputs, updatedPropsCapture.getValue());
  86         //creation of inputs values is part of the DefaultPropertyDeclarator and is tested in the ComponentInstancePropertyDeclaratorTest class
  87     }
  88
  89     @Test
  90     public void testUnDeclareProperties_whenComponentHasNoGroups_returnOk() {
  91         Resource resource = new Resource();
  92         StorageOperationStatus storageOperationStatus = groupPropertyDeclarator.unDeclarePropertiesAsInputs(resource, input);
  93         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
  94         verifyZeroInteractions(groupOperation);
  95     }
  96
  97     @Test
  98     public void testUnDeclareProperties_whenNoPropertiesFromGroupMatchInputId_returnOk() {
  99         StorageOperationStatus storageOperationStatus = groupPropertyDeclarator.unDeclarePropertiesAsInputs(createResourceWithGroup(), input);
 100         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
 101         verifyZeroInteractions(groupOperation);
 102     }
 103
 104     @Test
 105     public void whenFailingToUpdateDeclaredProperties_returnErrorStatus() {
 106         Resource resource = createResourceWithGroups(GROUP_ID);
 107         Optional<GroupDefinition> groupDefinition = resource.getGroupById(GROUP_ID);
 108         assertThat(groupDefinition.isPresent()).isTrue();
 109         PropertyDataDefinition getInputPropForInput = buildGetInputProperty(INPUT_ID);
 110         groupDefinition.get().setProperties(Collections.singletonList(getInputPropForInput));
 111         when(propertyOperation.findDefaultValueFromSecondPosition(Collections.emptyList(), getInputPropForInput.getUniqueId(), getInputPropForInput.getDefaultValue())).thenReturn(Either.left(getInputPropForInput.getDefaultValue()));
 112         when(groupOperation.updateGroupProperties(eq(resource), eq(GROUP_ID), updatedPropsCapture.capture())).thenReturn(StorageOperationStatus.GENERAL_ERROR);
 113         StorageOperationStatus storageOperationStatus = groupPropertyDeclarator.unDeclarePropertiesAsInputs(resource, input);
 114         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
 115     }
 116
 117     @Test
 118     public void testUnDeclareProperties_propertiesUpdatedCorrectly() {
 119         Resource resource = createResourceWithGroups(GROUP_ID, "groupId2");
 120         Optional<GroupDefinition> groupDefinition = resource.getGroupById(GROUP_ID);
 121         PropertyDataDefinition getInputPropForInput = buildGetInputProperty(INPUT_ID);
 122         PropertyDataDefinition someOtherProperty = new PropertyDataDefinitionBuilder().build();
 123         groupDefinition.get().setProperties(Arrays.asList(getInputPropForInput, someOtherProperty));
 124
 125         when(propertyOperation.findDefaultValueFromSecondPosition(Collections.emptyList(), getInputPropForInput.getUniqueId(), getInputPropForInput.getDefaultValue())).thenReturn(Either.left(getInputPropForInput.getDefaultValue()));
 126         when(groupOperation.updateGroupProperties(eq(resource), eq(GROUP_ID), updatedPropsCapture.capture())).thenReturn(StorageOperationStatus.OK);
 127         StorageOperationStatus storageOperationStatus = groupPropertyDeclarator.unDeclarePropertiesAsInputs(resource, input);
 128
 129         assertThat(storageOperationStatus).isEqualTo(StorageOperationStatus.OK);
 130         List<PropertyDataDefinition> updatedProperties = updatedPropsCapture.getValue();
 131         assertThat(updatedProperties).hasSize(1);
 132         PropertyDataDefinition updatedProperty = updatedProperties.get(0);
 133         assertThat(updatedProperty.isGetInputProperty()).isFalse();
 134         assertThat(updatedProperty.getValue()).isEmpty();
 135         assertThat(updatedProperty.getDefaultValue()).isEqualTo(getInputPropForInput.getDefaultValue());
 136         assertThat(updatedProperty.getUniqueId()).isEqualTo(getInputPropForInput.getUniqueId());
 137     }
 138
 139     private Resource createResourceWithGroup() {
 140         return createResourceWithGroups(GROUP_ID);
 141     }
 142
 143     private Resource createResourceWithGroups(String ... groups) {
 144         List<GroupDefinition> groupsDef = Stream.of(groups)
 145                 .map(this::buildGroup)
 146                 .collect(Collectors.toList());
 147
 148         return new ResourceBuilder()
 149                 .setUniqueId(RESOURCE_ID)
 150                 .setGroups(groupsDef)
 151                 .build();
 152     }
 153
 154     private GroupDefinition buildGroup(String groupId) {
 155         return GroupDefinitionBuilder.create()
 156                 .setUniqueId(groupId)
 157                 .setName(groupId)
 158                 .build();
 159     }
 160
 161     private PropertyDataDefinition buildGetInputProperty(String inputId) {
 162         return new PropertyDataDefinitionBuilder()
 163                 .addGetInputValue(inputId)
 164                 .setUniqueId(GROUP_ID + "_" + inputId)
 165                 .setDefaultValue("defaultValue")
 166                 .setValue(generateGetInputValue(inputId))
 167                 .build();
 168     }
 169
 170 }