openecomp-be/lib/openecomp-sdc-translator-lib/openecomp-sdc-translator-core/src/test/java/org/openecomp/sdc/translator/services/heattotosca/impl/functiontranslation/FunctionTranslationGetParamImplTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation;
  18
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.openecomp.sdc.translator.services.heattotosca.impl.resourcetranslation.BaseResourceTranslationTest;
  22
  23 import java.io.IOException;
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  28
  29 import static org.junit.Assert.*;
  30 import static org.openecomp.sdc.translator.services.heattotosca.impl.functiontranslation.FunctionTranslator.getFunctionTranslateTo;
  31
  32 public class FunctionTranslationGetParamImplTest extends BaseResourceTranslationTest {
  33
  34   @Override
  35   @Before
  36   public void setUp() throws IOException {
  37     // do not delete this function. it prevents the superclass setup from running
  38   }
  39
  40   @Test
  41   public void testStringGetParamFuncValue() {
  42     FunctionTranslationGetParamImpl translationImpl = new FunctionTranslationGetParamImpl();
  43     String functionValue = "parameter1";
  44
  45     FunctionTranslator functionTranslator = new FunctionTranslator(getFunctionTranslateTo(null, null, "dummy", null,
  46             null), null, functionValue, null);
  47     Object translatedFunc = translationImpl.translateFunction(functionTranslator);
  48
  49     assertTrue(translatedFunc instanceof Map);
  50     assertNotNull(((Map) translatedFunc).get("get_input"));
  51     assertEquals(functionValue, ((Map) translatedFunc).get("get_input"));
  52
  53   }
  54
  55   @Test
  56   public void testListGetParamFuncValue() {
  57     FunctionTranslationGetParamImpl translationImpl = new FunctionTranslationGetParamImpl();
  58     List<Object> functionValue = new ArrayList<>();
  59     functionValue.add("parameter1");
  60     functionValue.add(0);
  61     functionValue.add("key1");
  62
  63     FunctionTranslator functionTranslator = new FunctionTranslator(getFunctionTranslateTo(null, null, "dummy", null,
  64             null), null, functionValue, null);
  65     Object translatedFunc = translationImpl.translateFunction(functionTranslator);
  66
  67     assertTrue(translatedFunc instanceof Map);
  68     assertNotNull(((Map) translatedFunc).get("get_input"));
  69     Object translatedFunValue = ((Map) translatedFunc).get("get_input");
  70     assertTrue(translatedFunValue instanceof List);
  71
  72     assertEquals(functionValue.get(0), ((List) translatedFunValue).get(0));
  73     assertEquals(functionValue.get(1), ((List) translatedFunValue).get(1));
  74     assertEquals(functionValue.get(2), ((List) translatedFunValue).get(2));
  75
  76   }
  77
  78   @Test
  79   public void testMapGetParamFuncValue() {
  80     // input heat function expression
  81     //{get_param: [parameter1, {get_param:indexParam}, key1]}
  82     // output translated function expression
  83     //{get_input: [parameter1, {get_input:indexParam}, key1]}
  84
  85     FunctionTranslationGetParamImpl translationImpl = new FunctionTranslationGetParamImpl();
  86     List<Object> functionValue = new ArrayList<>();
  87     functionValue.add("parameter1");
  88     Map<String, String> innerParamMap = new HashMap<>();
  89     innerParamMap.put("get_param", "indexParam");
  90     functionValue.add(innerParamMap);
  91     functionValue.add("key1");
  92
  93     FunctionTranslator functionTranslator = new FunctionTranslator(getFunctionTranslateTo(null, null, "dummy", null,
  94             null), null, functionValue, null);
  95     Object translatedFunc = translationImpl.translateFunction(functionTranslator);
  96
  97     assertTrue(translatedFunc instanceof Map);
  98     assertNotNull(((Map) translatedFunc).get("get_input"));
  99     Object translatedFunValue = ((Map) translatedFunc).get("get_input");
 100     assertTrue(translatedFunValue instanceof List);
 101     assertEquals(functionValue.get(0), ((List) translatedFunValue).get(0));
 102     assertEquals(functionValue.get(2), ((List) translatedFunValue).get(2));
 103     assertTrue(((List) translatedFunValue).get(1) instanceof Map);
 104     if (((List) translatedFunValue).get(1) instanceof Map) {
 105       assertEquals(innerParamMap.get("get_param"), ((Map) ((List) translatedFunValue).get(1))
 106               .get("get_input"));
 107     }
 108
 109   }
 110
 111   @Test
 112   public void testMapWithMapGetParamFuncValue() {
 113     // input heat function expression
 114     //{get_param: [parameter1, {get_param:[parameter2, {get_param:indexParam}]}, key1]}
 115     // output translated function expression
 116     //{get_input: [parameter1, {get_input:[parameter2, {get_input:indexParam}]}, key1]}
 117
 118     FunctionTranslationGetParamImpl translationImpl = new FunctionTranslationGetParamImpl();
 119     List<Object> functionValue = new ArrayList<>();
 120     functionValue.add("parameter1");
 121     Map<String, Object> firstInnerParamMap = new HashMap<>();
 122     Map<String, String> secondInnerParamMap = new HashMap<>();
 123     secondInnerParamMap.put("get_param", "indexParam");
 124     List<Object> innerfunction = new ArrayList<>();
 125     innerfunction.add("parameter2");
 126     innerfunction.add(secondInnerParamMap);
 127     firstInnerParamMap.put("get_param", innerfunction);
 128     functionValue.add(firstInnerParamMap);
 129     functionValue.add("key1");
 130
 131     FunctionTranslator functionTranslator = new FunctionTranslator(getFunctionTranslateTo(null, null, "dummy", null,
 132             null), null, functionValue, null);
 133     Object translatedFunc = translationImpl.translateFunction(functionTranslator);
 134
 135     assertTrue(translatedFunc instanceof Map);
 136     assertNotNull(((Map) translatedFunc).get("get_input"));
 137     Object translatedFunValue = ((Map) translatedFunc).get("get_input");
 138     assertTrue(translatedFunValue instanceof List);
 139     assertEquals(functionValue.get(0), ((List) translatedFunValue).get(0));
 140     assertEquals(functionValue.get(2), ((List) translatedFunValue).get(2));
 141     assertTrue(((List) translatedFunValue).get(1) instanceof Map);
 142     if (((List) translatedFunValue).get(1) instanceof Map) {
 143       assertTrue(((Map) ((List) translatedFunValue).get(1)).get("get_input") instanceof List);
 144       List innerTranslatedFunction = (List) ((Map) ((List) translatedFunValue).get(1)).get("get_input");
 145       assertEquals(innerfunction.get(0), innerTranslatedFunction.get(0));
 146       assertTrue(innerTranslatedFunction.get(1) instanceof Map);
 147       assertEquals(secondInnerParamMap.get("get_param"), ((Map) innerTranslatedFunction.get(1)).get("get_input"));
 148     }
 149   }
 150
 151   @Test
 152   public void testInnerNotSupportedFuncGetParamFuncValue() {
 153     // input heat function expression
 154     //{get_param: [parameter1, {str_replace: {template:$AAkgiru, AA:{get_param:prameter2}}}, key1]}
 155     // output translated function expression
 156     //{get_input: [parameter1, {str_replace: {template:$AAkgiru, AA:{get_input:parameter2}}}, key1]}
 157
 158     FunctionTranslationGetParamImpl translationImpl = new FunctionTranslationGetParamImpl();
 159     List<Object> functionValue = new ArrayList<>();
 160     functionValue.add("parameter1");
 161
 162     Map<String, Object> templateMap = new HashMap<>();
 163     templateMap.put("template", "$AAkgiru");
 164
 165     Map<String, Object> strReplaceFuncMap = new HashMap<>();
 166     Map<String, Object> getParamMapInner = new HashMap<>();
 167     getParamMapInner.put("get_param", "parameter2");
 168     templateMap.put("AA", getParamMapInner);
 169
 170     Map<String, Object> innerParamValue = new HashMap<>();
 171     innerParamValue.putAll(templateMap);
 172     innerParamValue.putAll(strReplaceFuncMap);
 173
 174     strReplaceFuncMap.put("str_replace", innerParamValue);
 175     functionValue.add(strReplaceFuncMap);
 176
 177     functionValue.add("key1");
 178
 179     FunctionTranslator functionTranslator = new FunctionTranslator(getFunctionTranslateTo(null, null, "dummy", null,
 180             null), null, functionValue, null);
 181     Object translatedFunc = translationImpl.translateFunction(functionTranslator);
 182
 183     assertTrue(translatedFunc instanceof Map);
 184     assertNotNull(((Map) translatedFunc).get("get_input"));
 185     Object translatedFunValue = ((Map) translatedFunc).get("get_input");
 186     assertTrue(translatedFunValue instanceof List);
 187     assertEquals(functionValue.get(0), ((List) translatedFunValue).get(0));
 188     assertEquals(functionValue.get(2), ((List) translatedFunValue).get(2));
 189     assertTrue(((List) translatedFunValue).get(1) instanceof Map);
 190     if (((List) translatedFunValue).get(1) instanceof Map) {
 191       assertEquals(strReplaceFuncMap.get("get_param"),
 192               ((Map) ((List) translatedFunValue).get(1))
 193                       .get("get_input"));
 194     }
 195     assertTrue(((List) translatedFunValue).get(1) instanceof Map);
 196     if (((List) translatedFunValue).get(1) instanceof Map) {
 197       assertTrue(((Map) ((List) translatedFunValue).get(1)).get("str_replace") instanceof Map);
 198       Map strReplacefunctionValue = (Map) ((Map) ((List) translatedFunValue).get(1)).get("str_replace");
 199       assertEquals(templateMap.get("template"), strReplacefunctionValue.get("template"));
 200       assertTrue(strReplacefunctionValue.get("AA") instanceof Map);
 201       if (strReplacefunctionValue.get("AA") instanceof Map) {
 202         assertEquals(getParamMapInner.get("get_param"), ((Map) strReplacefunctionValue.get
 203                 ("AA")).get("get_input"));
 204       }
 205     }
 206   }
 207
 208   @Test
 209   public void testTranslateHeatPseudoParamUsedFromMainHeat() throws Exception {
 210     inputFilesPath =
 211             "/mock/services/heattotosca/heatPseudoParameters/usedFromMainHeat/inputfiles";
 212     outputFilesPath =
 213             "/mock/services/heattotosca/heatPseudoParameters/usedFromMainHeat/expectedoutputfiles";
 214     initTranslatorAndTranslate();
 215     testTranslation();
 216   }
 217
 218   @Test
 219   public void testTranslateHeatPseudoParamUsedFromNestedHeat() throws Exception {
 220     inputFilesPath =
 221             "/mock/services/heattotosca/heatPseudoParameters/usedFromNestedHeat/inputfiles";
 222     outputFilesPath =
 223             "/mock/services/heattotosca/heatPseudoParameters/usedFromNestedHeat/expectedoutputfiles";
 224     initTranslatorAndTranslate();
 225     testTranslation();
 226   }
 227
 228
 229 }