test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/datatypes/ImportReqDetails.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.datatypes;
  22
  23 import com.fasterxml.jackson.databind.ObjectMapper;
  24 import org.codehaus.jettison.json.JSONArray;
  25 import org.codehaus.jettison.json.JSONException;
  26 import org.openecomp.sdc.be.model.Resource;
  27 import org.openecomp.sdc.be.model.User;
  28 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  29 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  30 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  31 import org.yaml.snakeyaml.Yaml;
  32
  33 import java.io.*;
  34 import java.util.*;
  35
  36 import static org.testng.AssertJUnit.*;
  37
  38 public class ImportReqDetails extends ResourceReqDetails {
  39
  40         private static final String CAPS = "capabilities";
  41         private String payloadName;
  42         private String payloadData;
  43
  44         private Map<String, Object> requirements;
  45         private Map<String, Object> capabilities;
  46
  47         private List<String> derivedList;
  48         private String derivedFromField;
  49
  50         public ImportReqDetails(String resourceName, String description, List<String> tags, List<String> derivedFrom,
  51                         String vendorName, String vendorRelease, String contactId, String icon) {
  52                 super(resourceName, description, tags, null, derivedFrom, vendorName, vendorRelease, contactId, icon);
  53         }
  54
  55         public ImportReqDetails(Resource resource, String payloadName, String payloadData){
  56                 super(resource);
  57                 this.payloadData = payloadData;
  58                 this.payloadName = payloadName;
  59         }
  60
  61         public String getPayloadName() {
  62                 return payloadName;
  63         }
  64
  65         public void setPayloadName(String payloadName) {
  66                 this.payloadName = payloadName;
  67         }
  68
  69         public String getPayloadData() {
  70                 return payloadData;
  71         }
  72
  73         public void setPayloadData(String payloadData) {
  74                 this.payloadData = payloadData;
  75         }
  76
  77         @Override
  78         public String toString() {
  79                 return "ImportReqDetails [payloadName=" + payloadName + ", payloadData=" + payloadData + "]";
  80         }
  81
  82         public void setReqirementsAndCapabilities(String path, String fileName, User user, String derivedFromSource) throws IOException, JSONException{
  83                 setRequirements(path, fileName, user, derivedFromSource);
  84                 setCapabilities(path, fileName, user, derivedFromSource);
  85         }
  86
  87         public List<String> getDerivedList() {
  88                 return derivedList;
  89         }
  90
  91         public void setDerivedList(List<String> derivedList) {
  92                 this.derivedList = derivedList;
  93         }
  94
  95         public String getDerivedFromField() {
  96                 return derivedFromField;
  97         }
  98
  99         public void setDerivedFromField(String derivedFromField) {
 100                 this.derivedFromField = derivedFromField;
 101         }
 102
 103         public Map<String, Object> getRequirements() {
 104                 return requirements;
 105         }
 106
 107         public void setRequirements(String path, String fileName, User user, String derivedFromSource) throws IOException, JSONException {
 108                 Map<String, Object> requirementsFromFile = getRequirementsMapFromFile(path + File.separator + fileName,
 109                                 toscaResourceName, "requirements");
 110                 Map<String, Object> reqs = organizeRequirementsMap(requirementsFromFile);
 111                 getDerivedReqCap(user, reqs, "requirements", derivedFromSource);
 112                 this.requirements = reqs;
 113         }
 114
 115         @SuppressWarnings("unchecked")
 116         private void getDerivedReqCap(User user, Map<String, Object> reqCapMap, String field, String derivedFromResource)
 117                         throws IOException, JSONException {
 118
 119                 if (derivedFromResource == null) {
 120                         derivedFromResource = "Root";
 121                 }
 122
 123                 RestResponse rest = getResourceSource(user, derivedFromResource);
 124                 Map<String, Object> parsedFieldFromResponseAsMap = ResponseParser.getJsonValueAsMap(rest, field);
 125                 Iterator<String> iterator = parsedFieldFromResponseAsMap.keySet().iterator();
 126                 Map<String, Object> convertListToMap = null;
 127                 while (iterator.hasNext()) {
 128                         String type = iterator.next();
 129                         List<Object> lst = (List<Object>) parsedFieldFromResponseAsMap.get(type);
 130                         convertListToMap = convertListToMap(lst);
 131
 132                         if (field.equals(CAPS)) {
 133                                 convertListToMap.replace("capabilitySources", derivedList);
 134                                 lst = new ArrayList<>(Arrays.asList(convertListToMap));
 135                         }
 136
 137                         Object existingValue = reqCapMap.get(type);
 138                         if (existingValue != null) {
 139                                 Map<String, Object> convertedExistingValue = convertListToMap((List<Object>) existingValue);
 140                                 if (convertedExistingValue.get("name").toString().equalsIgnoreCase(convertListToMap.get("name").toString())) {
 141                                         lst = new ArrayList<>(Arrays.asList(convertedExistingValue));
 142                                 } else {
 143                                         lst.add(convertedExistingValue);
 144                                 }
 145                         }
 146
 147                         reqCapMap.put(type, lst);
 148                 }
 149         }
 150
 151         private RestResponse getResourceSource(User user, String source) throws IOException, JSONException {
 152                 org.codehaus.jettison.json.JSONObject getResourceJSONObject = null;
 153                 RestResponse rest = ResourceRestUtils.getResourceByNameAndVersion(user.getUserId(), source, "1.0");
 154                 if (rest.getErrorCode().intValue() == 200) {
 155                         JSONArray jArray = new JSONArray(rest.getResponse());
 156                         for (int i = 0; i < jArray.length(); i++) {
 157                                 getResourceJSONObject = jArray.getJSONObject(i);
 158                                 String resourceType = getResourceJSONObject.get("resourceType").toString();
 159                                 if (!resourceType.equals("VF")) {
 160                                         rest.setResponse(getResourceJSONObject.toString());
 161                                 }
 162                         }
 163                 }
 164                 return rest;
 165         }
 166
 167         public Map<String, Object> getCapabilities() {
 168                 return capabilities;
 169         }
 170
 171         public void setCapabilities(String path, String fileName, User user, String derivedFromSource) throws IOException, JSONException {
 172                 Map<String, Object> capabilitiesFromFile = getCapabilitiesMapFromFile(path + File.separator + fileName,
 173                                 toscaResourceName, CAPS);
 174                 Map<String, Object> caps = organizeCapabilitiesMap(capabilitiesFromFile);
 175                 getDerivedReqCap(user, caps, CAPS, derivedFromSource);
 176                 this.capabilities = caps;
 177         }
 178
 179         @SuppressWarnings("unchecked")
 180         private Map<String, Object> organizeCapabilitiesMap(Map<String, Object> capabilitiesFromFile) {
 181                 Iterator<String> iterator = capabilitiesFromFile.keySet().iterator();
 182                 Map<String, Object> capMap = new HashMap<>();
 183                 while (iterator.hasNext()) {
 184                         List<Object> valueList = new ArrayList<>();
 185                         String next = iterator.next();
 186                         Map<String, Object> valuesMap = (Map<String, Object>) capabilitiesFromFile.get(next);
 187                         String key = valuesMap.remove("type").toString();
 188                         valuesMap.put("name", next);
 189                         valuesMap.put("capabilitySources", derivedList);
 190                         valuesMap.put("type", key);
 191
 192                         if (!valuesMap.containsKey("occurrences")) {
 193                                 valuesMap.put("minOccurrences", "1");
 194                                 valuesMap.put("maxOccurrences", "UNBOUNDED");
 195                         }
 196
 197                         Object tempValue = capMap.get(key);
 198                         if (tempValue == null) {
 199                                 valueList.add(valuesMap);
 200                         } else {
 201                                 Map<String, Object> convertValue = convertListToMap((List<Object>) tempValue);
 202                                 valueList = new ArrayList<>(Arrays.asList(convertValue, valuesMap));
 203                         }
 204                         capMap.put(key, valueList);
 205                 }
 206                 return capMap;
 207         }
 208
 209         @SuppressWarnings("unchecked")
 210         private Map<String, Object> getCapabilitiesMapFromFile(String fileName, String toscaResourceName,
 211                         String fieldToTest) throws FileNotFoundException {
 212                 Map<String, Object> resourceToscaMap = getToscaResourceFromFile(fileName, toscaResourceName);
 213                 Object capMap = resourceToscaMap.get(fieldToTest);
 214                 if (capMap == null) {
 215                         return new HashMap<>();
 216                 }
 217                 return (Map<String, Object>) capMap;
 218         }
 219
 220         @SuppressWarnings("unchecked")
 221         private Map<String, Object> organizeRequirementsMap(Map<String, Object> requirementsFromFile) {
 222                 Map<String, Object> reqMap = new HashMap<>();
 223                 List<Object> valueList = new ArrayList<>();
 224                 Iterator<String> iterator = requirementsFromFile.keySet().iterator();
 225                 while (iterator.hasNext()) {
 226                         String key = iterator.next();
 227                         Map<String, Object> valuesMap = (Map<String, Object>) requirementsFromFile.get(key);
 228                         valuesMap.put("name", key);
 229                         String capability = valuesMap.get("capability").toString();
 230
 231                         List<Object> occurencesList = (List<Object>) valuesMap.remove("occurrences");
 232                         if (occurencesList != null) {
 233                                 valuesMap.put("minOccurrences", occurencesList.get(0).toString());
 234                                 valuesMap.put("maxOccurrences", occurencesList.get(1).toString());
 235                         }
 236
 237                         valueList.add(valuesMap);
 238                         reqMap.put(capability, valueList);
 239                 }
 240
 241                 return reqMap;
 242         }
 243
 244         @SuppressWarnings("unchecked")
 245         private Map<String, Object> getRequirementsMapFromFile(String fileName, String toscaResourceName,
 246                         String fieldToTest) throws FileNotFoundException {
 247                 Map<String, Object> resourceToscaMap = getToscaResourceFromFile(fileName, toscaResourceName);
 248                 List<Object> reqListFromFile = (List<Object>) resourceToscaMap.get(fieldToTest);
 249                 if (reqListFromFile == null) {
 250                         return new HashMap<>();
 251                 }
 252                 return convertListToMap(reqListFromFile);
 253         }
 254
 255         @SuppressWarnings("unchecked")
 256         private Map<String, Object> getToscaResourceFromFile(String fullFileName, String toscaResourceName) throws FileNotFoundException{
 257                 Map<String, Object> nodesTypesMap = getNodesTypesMapFromFile(fullFileName);
 258                 Map<String, Object> resourceToscaMap = (Map<String, Object>) nodesTypesMap.get(toscaResourceName);
 259
 260                 derivedFromField = resourceToscaMap.get("derived_from").toString();
 261
 262                 return resourceToscaMap;
 263         }
 264
 265         @SuppressWarnings("unchecked")
 266         private Map<String, Object> getNodesTypesMapFromFile(String fullFileName) throws FileNotFoundException {
 267                 Yaml yaml = new Yaml();
 268                 File file = new File(fullFileName);
 269                 InputStream inputStream = new FileInputStream(file);
 270                 Map<?, ?> mapFromFile = (Map<?, ?>) yaml.load(inputStream);
 271                 return (Map<String, Object>) mapFromFile.get("node_types");
 272         }
 273
 274         @SuppressWarnings("unchecked")
 275         private Map<String, Object> convertListToMap(List<Object> testedListFromFile) {
 276                 Map<String, Object> testedMapFromFile = new HashMap<>();
 277                 for (int i = 0; i < testedListFromFile.size(); i++) {
 278                         Object req = testedListFromFile.get(i);
 279                         ObjectMapper m = new ObjectMapper();
 280                         Map<? extends String, ? extends String> mappedObject = m.convertValue(req, Map.class);
 281                         testedMapFromFile.putAll(mappedObject);
 282                 }
 283                 return testedMapFromFile;
 284         }
 285
 286         @SuppressWarnings("unchecked")
 287         public void compareRequirementsOrCapabilities(Map<String, Object> exepectedReq, Map<String, Object> actualReq) {
 288                 Iterator<String> iterator = exepectedReq.keySet().iterator();
 289                 while (iterator.hasNext()) {
 290                         String key = iterator.next();
 291                         List<Object> expectedValues = (List<Object>) exepectedReq.get(key);
 292                         List<Object> actualValues = (List<Object>) actualReq.get(key);
 293                         assertNotNull(actualValues);
 294
 295                         List<Map<String, Object>> expectedMapsList = convertListToMapList(expectedValues);
 296                         List<Map<String, Object>> actualMapsList = convertListToMapList(actualValues);
 297                         assertEquals(expectedMapsList.size(), actualMapsList.size());
 298
 299                         for (int i = 0; i < expectedMapsList.size(); i++) {
 300                                 Map<String, Object> expectedMap = expectedMapsList.get(i);
 301                                 Map<String, Object> actualdMap = actualMapsList.get(i);
 302                                 if (expectedMap.get("name").equals(actualdMap.get("name"))) {
 303                                         Iterator<String> iterator2 = expectedMap.keySet().iterator();
 304                                         while (iterator2.hasNext()) {
 305                                                 String innerKey = iterator2.next();
 306                                                 assertTrue(
 307                                                                 "check " + innerKey + " in " + key + ":\nexpected: "
 308                                                                                 + expectedMap.get(innerKey).toString() + "\nactual: "
 309                                                                                 + actualdMap.get(innerKey).toString(),
 310                                                                 expectedMap.get(innerKey).equals(actualdMap.get(innerKey)));
 311
 312                                         }
 313
 314                                 }
 315                         }
 316                 }
 317         }
 318
 319         @SuppressWarnings("unchecked")
 320         private List<Map<String, Object>> convertListToMapList(List<Object> testedListFromFile) {
 321                 List<Map<String, Object>> listOfMaps = new ArrayList<>();
 322                 for (int i = 0; i < testedListFromFile.size(); i++) {
 323                         Object req = testedListFromFile.get(i);
 324                         ObjectMapper m = new ObjectMapper();
 325                         Map<? extends String, ? extends String> mappedObject = m.convertValue(req, Map.class);
 326                         mappedObject.remove("uniqueId");
 327                         Map<String, Object> testedMapFromFile = new HashMap<>();
 328                         testedMapFromFile.putAll(mappedObject);
 329                         listOfMaps.add(testedMapFromFile);
 330                 }
 331                 return listOfMaps;
 332         }
 333
 334 }