gerrit.onap Code Review - sdc.git/blob

   1 package org.openecomp.sdc.be.components.merge.input;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNull;
   5
   6 import java.util.ArrayList;
   7 import java.util.Arrays;
   8 import java.util.Collections;
   9 import java.util.List;
  10 import java.util.Map;
  11
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  15 import org.openecomp.sdc.be.components.utils.ResourceBuilder;
  16 import org.openecomp.sdc.be.dao.utils.MapUtil;
  17 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
  18 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  19 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  20 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  21 import org.openecomp.sdc.be.model.InputDefinition;
  22 import org.openecomp.sdc.be.model.Resource;
  23
  24 public class InputsValuesMergingBusinessLogicTest {
  25
  26     public static final String INPUT_DEFUALT_TYPE = "string";
  27     public static final String INPUT1_ID = "input1";
  28     public static final String INPUT2_ID = "input2";
  29     public static final String INPUT3_ID = "input3";
  30     public static final String INPUT4_ID = "input4";
  31     private InputsValuesMergingBusinessLogic testInstance;
  32
  33     @Before
  34     public void setUp() throws Exception {
  35         testInstance = new InputsValuesMergingBusinessLogic();
  36     }
  37
  38     @Test
  39     public void testMergeInputs_inputsOfDifferentType_dontCopyOldValue() throws Exception {
  40         InputDefinition oldInput = createUserDefinedInputDefinition(INPUT1_ID, "oldVal1");
  41
  42         InputDefinition newInput = createInputDefinition(INPUT1_ID, null);
  43         newInput.setType("int");
  44
  45
  46         Map<String, InputDefinition> updatedInputs = Collections.singletonMap(newInput.getName(), newInput);
  47         Map<String, InputDefinition> oldInputs = Collections.singletonMap(oldInput.getName(), oldInput);
  48         testInstance.mergeComponentInputs(oldInputs, updatedInputs);
  49
  50         assertNull(updatedInputs.get(INPUT1_ID).getDefaultValue());
  51     }
  52
  53     @Test
  54     public void testMergeInputs_newInputsHaveNoValue_copyOldValues() throws Exception {
  55         InputDefinition oldInputWithCsarDefaultValue = createInputDefinition(INPUT1_ID, "oldVal1");
  56         InputDefinition oldInputWithUserDefinedValue = createUserDefinedInputDefinition(INPUT2_ID, "oldVal2");
  57         InputDefinition oldInputNotExistOnNew = createUserDefinedInputDefinition(INPUT3_ID, null);
  58
  59         InputDefinition newInput1 = createInputDefinition(INPUT1_ID, "");
  60         InputDefinition newInput2 = createUserDefinedInputDefinition(INPUT2_ID, null);
  61
  62         Map<String, InputDefinition> updatedInputs = mapInputsByName(Arrays.asList(newInput1, newInput2));
  63         Map<String, InputDefinition> oldInputs = mapInputsByName(Arrays.asList(oldInputWithCsarDefaultValue, oldInputWithUserDefinedValue, oldInputNotExistOnNew));
  64         testInstance.mergeComponentInputs(oldInputs, updatedInputs);
  65
  66         assertEquals(oldInputWithCsarDefaultValue.getDefaultValue(), updatedInputs.get(INPUT1_ID).getDefaultValue());
  67         assertEquals(oldInputWithUserDefinedValue.getDefaultValue(), updatedInputs.get(INPUT2_ID).getDefaultValue());
  68         assertNull(updatedInputs.get(INPUT3_ID));
  69     }
  70
  71     @Test
  72     public void testMergeInputs_newInputsHaveValue_dontOverrideNewValue() throws Exception {
  73         InputDefinition oldInputWithCsarDefaultValue = createInputDefinition(INPUT1_ID, "oldVal1");
  74         InputDefinition oldInputWithUserDefinedValue = createUserDefinedInputDefinition(INPUT2_ID, "oldVal2");
  75         InputDefinition oldInputWithNoValue = createUserDefinedInputDefinition(INPUT3_ID, null);
  76
  77         InputDefinition newInput1 = createInputDefinition(INPUT1_ID, "newVal1");
  78         InputDefinition newInput2 = createUserDefinedInputDefinition(INPUT2_ID, "newVal2");
  79         InputDefinition newInput3 = createUserDefinedInputDefinition(INPUT3_ID, "newVal3");
  80         InputDefinition newInput4 = createUserDefinedInputDefinition(INPUT4_ID, "newVal4");
  81
  82         Map<String, InputDefinition> updatedInputs = mapInputsByName(Arrays.asList(newInput1, newInput2, newInput3, newInput4));
  83         Map<String, InputDefinition> oldInputs = mapInputsByName(Arrays.asList(oldInputWithCsarDefaultValue, oldInputWithUserDefinedValue, oldInputWithNoValue));
  84         testInstance.mergeComponentInputs(oldInputs, updatedInputs);
  85
  86         assertEquals(updatedInputs.get(INPUT1_ID).getDefaultValue(), newInput1.getDefaultValue());
  87         assertEquals(updatedInputs.get(INPUT2_ID).getDefaultValue(), newInput2.getDefaultValue());
  88         assertEquals(updatedInputs.get(INPUT3_ID).getDefaultValue(), newInput3.getDefaultValue());
  89         assertEquals(updatedInputs.get(INPUT4_ID).getDefaultValue(), newInput4.getDefaultValue());
  90     }
  91
  92     @Test
  93     public void getPrevoislyDeclaredInputsToMerge() throws Exception {
  94         PropertyDataDefinition declaredInputProp1 = new PropertyDataDefinitionBuilder().addGetInputValue(INPUT1_ID).addGetInputValue(INPUT3_ID).setUniqueId("prevDeclaredPropId").build();
  95         PropertyDataDefinition declaredInputProp2 = new PropertyDataDefinitionBuilder().addGetInputValue(INPUT4_ID).setUniqueId("prevDeclaredPropId2").build();
  96
  97         Resource prevResource = new ResourceBuilder().addInput(INPUT1_ID).addInput(INPUT2_ID).addInput(INPUT3_ID).addInput(INPUT4_ID).build();
  98
  99         Resource currentResource = new ResourceBuilder()
 100                 .addInput(INPUT2_ID)
 101                 .addInstanceProperty("inst1", new ComponentInstanceProperty(declaredInputProp1))
 102                 .addInstanceInput("inst2", new ComponentInstanceInput(declaredInputProp2))
 103                 .build();
 104
 105         List<InputDefinition> previouslyDeclaredInputs = testInstance.getPreviouslyDeclaredInputsToMerge(prevResource, currentResource);
 106         assertEquals(3, previouslyDeclaredInputs.size());
 107
 108         assertInput(previouslyDeclaredInputs.get(0), INPUT1_ID, declaredInputProp1.getUniqueId(), "inst1");
 109         assertInput(previouslyDeclaredInputs.get(1), INPUT3_ID, declaredInputProp1.getUniqueId(), "inst1");
 110         assertInput(previouslyDeclaredInputs.get(2), INPUT4_ID, declaredInputProp2.getUniqueId(), "inst2");
 111     }
 112
 113     private void assertInput(InputDefinition inputDefinition, String expectedInputId, String expectedPropertyId, String expectedInstanceUniqueId) {
 114         assertEquals(expectedInputId, inputDefinition.getUniqueId());
 115         assertEquals(expectedPropertyId, inputDefinition.getPropertyId());
 116         assertEquals(inputDefinition.getInstanceUniqueId(), expectedInstanceUniqueId);
 117     }
 118
 119     private Map<String, InputDefinition> mapInputsByName(List<InputDefinition> inputs) {
 120         return MapUtil.toMap(inputs, InputDefinition::getName);
 121     }
 122
 123     private InputDefinition createInputDefinition(String name, String value) {
 124         InputDefinition inputDef = new InputDefinition();
 125         inputDef.setName(name);
 126         inputDef.setDefaultValue(value);
 127         inputDef.setType(INPUT_DEFUALT_TYPE);
 128         return inputDef;
 129     }
 130
 131     private InputDefinition createUserDefinedInputDefinition(String name, String value) {
 132         InputDefinition inputDef = createInputDefinition(name, value);
 133         inputDef.setOwnerId("owner");
 134         return inputDef;
 135     }
 136
 137     private void addInstanceProperty(Resource resource, ComponentInstanceProperty prop, String instanceId) {
 138         addInstancePropDefinition(resource.getComponentInstancesProperties(), prop, instanceId);
 139     }
 140
 141     private void addInstanceInput(Resource resource, ComponentInstanceInput prop, String instanceId) {
 142         addInstancePropDefinition(resource.getComponentInstancesInputs(), prop, instanceId);
 143     }
 144
 145     private <T extends PropertyDataDefinition> void addInstancePropDefinition(Map<String, List<T>> propsDefinitions, T propDef, String instanceId) {
 146         propsDefinitions.computeIfAbsent(instanceId, id -> new ArrayList<>()).add(propDef);
 147     }
 148
 149     private Resource createResourceWithInputs(String ... inputsIds) {
 150         Resource resource = new Resource();
 151         List<InputDefinition> inputs = new ArrayList<>();
 152         for (String inputId : inputsIds) {
 153             InputDefinition inputDefinition = new InputDefinition();
 154             inputDefinition.setOwnerId("cs0008");
 155             inputDefinition.setUniqueId(inputId);
 156             inputs.add(inputDefinition);
 157         }
 158         resource.setInputs(inputs);
 159         return resource;
 160     }
 161
 162
 163     private ComponentInstanceProperty createGetInputComponentProperty(String ... declaredToInputId) {
 164         ComponentInstanceProperty prevDeclaredProperty = new ComponentInstanceProperty();
 165         for (String inputId : declaredToInputId) {
 166             addGetInputValueOnProp(inputId, prevDeclaredProperty);
 167         }
 168
 169         return prevDeclaredProperty;
 170     }
 171
 172     private void addGetInputValueOnProp(String declaredToInputId, PropertyDataDefinition declaredProperty) {
 173         GetInputValueDataDefinition getInputDef = new GetInputValueDataDefinition();
 174         getInputDef.setInputId(declaredToInputId);
 175         if (declaredProperty.getGetInputValues() == null) {
 176             declaredProperty.setGetInputValues(new ArrayList<>());
 177         }
 178         declaredProperty.getGetInputValues().add(getInputDef);
 179     }
 180
 181     private ComponentInstanceInput createGetInputComponentInstanceInput(String declaredToInputId) {
 182         ComponentInstanceInput prevDeclaredProp = new ComponentInstanceInput();
 183         addGetInputValueOnProp(declaredToInputId, prevDeclaredProp);
 184         return prevDeclaredProp;
 185     }
 186 }