2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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=========================================================
21 package org.openecomp.sdc.ci.tests.utils.validation;
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertTrue;
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.Iterator;
29 import java.util.LinkedHashSet;
30 import java.util.List;
34 import org.openecomp.sdc.be.model.ArtifactDefinition;
35 import org.openecomp.sdc.be.model.InterfaceDefinition;
36 import org.openecomp.sdc.be.model.Operation;
37 import org.openecomp.sdc.be.model.Resource;
38 import org.openecomp.sdc.be.model.category.CategoryDefinition;
39 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
40 import org.openecomp.sdc.ci.tests.datatypes.ResourceRespJavaObject;
41 import org.openecomp.sdc.ci.tests.datatypes.enums.RespJsonKeysEnum;
42 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
43 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
45 import com.google.gson.Gson;
47 public class ResourceValidationUtils {
49 public static void validateResourceReqVsResp(ResourceReqDetails resourceDetails,
50 ResourceRespJavaObject resourceRespJavaObject) {
54 expected = resourceDetails.getDescription();
55 assertEquals("resource description - ", expected, resourceRespJavaObject.getDescription());
57 expected = resourceDetails.getVendorName();
58 assertEquals("resource vendorName - ", expected, resourceRespJavaObject.getVendorName());
60 expected = resourceDetails.getVendorRelease();
61 assertEquals("resource vendorReleaseName - ", expected, resourceRespJavaObject.getVendorRelease());
63 expected = resourceDetails.getContactId();
64 assertEquals("resource contactId - ", expected, resourceRespJavaObject.getContactId());
68 public static void validateResourceReqVsResp(ResourceReqDetails resourceDetails, Resource resourceRespJavaObject) {
72 expected = resourceDetails.getDescription();
73 assertEquals("resource description - ", expected, resourceRespJavaObject.getDescription());
75 expected = resourceDetails.getVendorName();
76 assertEquals("resource vendorName - ", expected, resourceRespJavaObject.getVendorName());
78 expected = resourceDetails.getVendorRelease();
79 assertEquals("resource vendorReleaseName - ", expected, resourceRespJavaObject.getVendorRelease());
81 expected = resourceDetails.getContactId();
82 assertEquals("resource contactId - ", expected, resourceRespJavaObject.getContactId());
84 // Validating deduplication of tags
85 List<String> expectedTags = resourceDetails.getTags();
86 if (expectedTags != null) {
87 Set<String> hs = new LinkedHashSet<>(expectedTags);
89 expectedTags.addAll(hs);
90 List<String> receivedTags = resourceRespJavaObject.getTags();
91 assertEquals("resource tags - ", expectedTags, receivedTags);
96 public static void validateModelObjects(Resource expected, Resource actual) throws Exception {
98 compareElements(expected.getUniqueId(), actual.getUniqueId());
99 compareElements(expected.getName(), actual.getName());
100 compareElements(expected.getVersion(), actual.getVersion());
101 compareElements(expected.getCreatorUserId(), actual.getCreatorUserId());
102 compareElements(expected.getCreatorFullName(), actual.getCreatorFullName());
103 compareElements(expected.getLastUpdaterUserId(), actual.getLastUpdaterUserId());
104 compareElements(expected.getLastUpdaterFullName(), actual.getLastUpdaterFullName());
105 compareElements(expected.getCreatorFullName(), actual.getCreatorFullName());
106 compareElements(expected.getCreationDate(), actual.getCreationDate());
107 compareElements(expected.getLastUpdateDate(), actual.getLastUpdateDate());
108 compareElements(expected.getDescription(), actual.getDescription());
109 compareElements(expected.getIcon(), actual.getIcon());
110 compareElements(expected.getLastUpdateDate(), actual.getLastUpdateDate());
112 compareElements(expected.getCategories(), actual.getCategories());
113 compareElements(expected.getLifecycleState(), actual.getLifecycleState());
114 compareElements(expected.getVendorName(), actual.getVendorName());
115 compareElements(expected.getVendorRelease(), actual.getVendorRelease());
116 compareElements(expected.getContactId(), actual.getContactId());
117 compareElements(expected.getUUID(), actual.getUUID());
118 compareElements(expected.getVersion(), actual.getVersion());
122 public static void validateResp(RestResponse restResponse, ResourceRespJavaObject resourceRespJavaObject)
125 Gson gson = new Gson();
126 String response = restResponse.getResponse();
128 validateResp(response, resourceRespJavaObject, gson);
132 public static void validateResp(String response, ResourceRespJavaObject resourceRespJavaObject, Gson gson) {
134 Map<String, Object> map = new HashMap<String, Object>();
135 map = (Map<String, Object>) gson.fromJson(response, map.getClass());
137 // De-duplicating the tags list for comparison
138 List<String> tags = resourceRespJavaObject.getTags();
140 Set<String> hs = new LinkedHashSet<>(tags);
141 tags = new ArrayList<String>(hs);
142 resourceRespJavaObject.setTags(tags);
143 tags = new ArrayList<String>(hs);
144 resourceRespJavaObject.setTags(tags);
147 validateField(map, RespJsonKeysEnum.RESOURCE_NAME.getRespJsonKeyName(), resourceRespJavaObject.getName());
148 validateField(map, RespJsonKeysEnum.RESOURCE_DESC.getRespJsonKeyName(),
149 resourceRespJavaObject.getDescription());
150 // validateField(map, RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName(),
151 // resourceRespJavaObject.getCategories());
152 validateField(map, RespJsonKeysEnum.VENDOR_NAME.getRespJsonKeyName(), resourceRespJavaObject.getVendorName());
153 validateField(map, RespJsonKeysEnum.VENDOR_RELEASE.getRespJsonKeyName(),
154 resourceRespJavaObject.getVendorRelease());
155 validateField(map, RespJsonKeysEnum.CONTACT_ID.getRespJsonKeyName(), resourceRespJavaObject.getContactId());
156 validateField(map, RespJsonKeysEnum.ICON.getRespJsonKeyName(), resourceRespJavaObject.getIcon());
157 validateField(map, RespJsonKeysEnum.IS_ABSTRACT.getRespJsonKeyName(),
158 Boolean.valueOf(resourceRespJavaObject.getAbstractt()));
159 validateField(map, RespJsonKeysEnum.HIGHEST_VERSION.getRespJsonKeyName(),
160 Boolean.valueOf(resourceRespJavaObject.getIsHighestVersion()));
161 validateField(map, RespJsonKeysEnum.UNIQUE_ID.getRespJsonKeyName(), resourceRespJavaObject.getUniqueId());
162 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceRespJavaObject.getVersion());
163 validateField(map, RespJsonKeysEnum.LIFE_CYCLE_STATE.getRespJsonKeyName(),
164 resourceRespJavaObject.getLifecycleState());
165 validateField(map, RespJsonKeysEnum.TAGS.getRespJsonKeyName(), tags);
166 validateField(map, RespJsonKeysEnum.CREATOR_USER_ID.getRespJsonKeyName(),
167 resourceRespJavaObject.getCreatorUserId());
168 validateField(map, RespJsonKeysEnum.CREATOR_FULL_NAME.getRespJsonKeyName(),
169 resourceRespJavaObject.getCreatorFullName());
170 validateField(map, RespJsonKeysEnum.LAST_UPDATER_USER_ID.getRespJsonKeyName(),
171 resourceRespJavaObject.getLastUpdaterUserId());
172 validateField(map, RespJsonKeysEnum.LAST_UPDATER_FULL_NAME.getRespJsonKeyName(),
173 resourceRespJavaObject.getLastUpdaterFullName());
174 validateField(map, RespJsonKeysEnum.COST.getRespJsonKeyName(), resourceRespJavaObject.getCost());
175 validateField(map, RespJsonKeysEnum.LICENSE_TYPE.getRespJsonKeyName(), resourceRespJavaObject.getLicenseType());
176 validateField(map, RespJsonKeysEnum.RESOURCE_TYPE.getRespJsonKeyName(),
177 resourceRespJavaObject.getResourceType().toString());
178 if (resourceRespJavaObject.getResourceType().equals("VF")) {
179 validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(), null);
181 validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(),
182 resourceRespJavaObject.getDerivedFrom());
185 validateCategories(resourceRespJavaObject, map);
187 String uuid = ResponseParser.getValueFromJsonResponse(response, RespJsonKeysEnum.UUID.getRespJsonKeyName());
188 assertTrue("UUID is empty", uuid != null && !uuid.isEmpty());
191 private static void validateCategories(ResourceRespJavaObject resourceRespJavaObject, Map<String, Object> map) {
192 assertTrue(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName() + " is missing",
193 map.containsKey(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName()));
194 Object foundValue = map.get(RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName());
195 List<Map<String, Object>> foundList = (List<Map<String, Object>>) foundValue;
196 List<CategoryDefinition> excpectedList = resourceRespJavaObject.getCategories();
198 assertTrue(foundList.size() == excpectedList.size());
199 for (int i = 0; i < foundList.size(); i++) {
200 CategoryDefinition expCat = excpectedList.get(i);
201 Map<String, Object> foun = foundList.get(i);
202 assertTrue("expected " + expCat.getName() + " not equal to actual " + foundValue,
203 foun.get("name").equals(expCat.getName()));
207 public static void validateField(Map<String, Object> map, String jsonField, Object expectedValue) {
208 if (expectedValue == null) {
209 assertTrue(jsonField + " is expected to be null", !map.containsKey(jsonField));
211 assertTrue(jsonField + " is missing", map.containsKey(jsonField));
212 Object foundValue = map.get(jsonField);
213 compareElements(expectedValue, foundValue);
217 public static void compareElements(Object expectedValue, Object foundValue) {
218 if (expectedValue instanceof String) {
219 assertTrue(foundValue instanceof String);
220 assertTrue("expected " + expectedValue + " not equal to actual " + foundValue,
221 foundValue.equals(expectedValue));
224 * else if( expectedValue instanceof Number){ assertTrue(foundValue
225 * instanceof Number); assertTrue(foundValue == expectedValue); }
227 else if (expectedValue instanceof Boolean) {
228 assertTrue(foundValue instanceof Boolean);
229 assertTrue(foundValue == expectedValue);
230 } else if (expectedValue instanceof Map) {
231 assertTrue(foundValue instanceof Map);
232 Map<String, Object> foundMap = (Map<String, Object>) foundValue;
233 Map<String, Object> excpectedMap = (Map<String, Object>) expectedValue;
234 assertTrue(foundMap.size() == excpectedMap.size());
235 Iterator<String> foundkeyItr = foundMap.keySet().iterator();
236 while (foundkeyItr.hasNext()) {
237 String foundKey = foundkeyItr.next();
238 assertTrue(excpectedMap.containsKey(foundKey));
239 compareElements(excpectedMap.get(foundKey), foundMap.get(foundKey));
242 } else if (expectedValue instanceof List) {
243 assertTrue(foundValue instanceof List);
244 List<Object> foundList = (List<Object>) foundValue;
245 List<Object> excpectedList = (List<Object>) expectedValue;
246 assertTrue(foundList.size() == excpectedList.size());
247 for (int i = 0; i < foundList.size(); i++) {
248 compareElements(excpectedList.get(i), foundList.get(i));
252 assertTrue(foundValue.equals(expectedValue));
256 public static boolean validateUuidAfterChangingStatus(String oldUuid, String newUuid) {
257 return oldUuid.equals(newUuid);
261 public static void validateRespArt(RestResponse restResponse, ResourceRespJavaObject resourceRespJavaObject,
262 String interfaze) throws Exception {
264 Gson gson = new Gson();
265 String response = restResponse.getResponse();
267 Map<String, Object> map = new HashMap<String, Object>();
268 map = (Map<String, Object>) gson.fromJson(response, map.getClass());
270 Resource resource = gson.fromJson(response, Resource.class);
272 Map<String, ArtifactDefinition> artifacts = resource.getArtifacts();
273 Map<String, InterfaceDefinition> interfaces = null;
275 if (interfaze != null) {
276 interfaces = resource.getInterfaces();
277 Map<String, Operation> operation = interfaces.get(interfaze).getOperationsMap();
278 // operation.get("configure").getUniqueId();
281 validateField(map, RespJsonKeysEnum.RESOURCE_NAME.getRespJsonKeyName(), resourceRespJavaObject.getName());
282 validateField(map, RespJsonKeysEnum.RESOURCE_DESC.getRespJsonKeyName(),
283 resourceRespJavaObject.getDescription());
284 // validateField(map, RespJsonKeysEnum.CATEGORIES.getRespJsonKeyName(),
285 // resourceRespJavaObject.getCategories());
286 validateField(map, RespJsonKeysEnum.DERIVED_FROM.getRespJsonKeyName(), resourceRespJavaObject.getDerivedFrom());
287 validateField(map, RespJsonKeysEnum.VENDOR_NAME.getRespJsonKeyName(), resourceRespJavaObject.getVendorName());
288 validateField(map, RespJsonKeysEnum.VENDOR_RELEASE.getRespJsonKeyName(),
289 resourceRespJavaObject.getVendorRelease());
290 validateField(map, RespJsonKeysEnum.CONTACT_ID.getRespJsonKeyName(), resourceRespJavaObject.getContactId());
291 validateField(map, RespJsonKeysEnum.ICON.getRespJsonKeyName(), resourceRespJavaObject.getIcon());
292 validateField(map, RespJsonKeysEnum.IS_ABSTRACT.getRespJsonKeyName(),
293 Boolean.valueOf(resourceRespJavaObject.getAbstractt()));
294 validateField(map, RespJsonKeysEnum.HIGHEST_VERSION.getRespJsonKeyName(),
295 Boolean.valueOf(resourceRespJavaObject.getIsHighestVersion()));
296 validateField(map, RespJsonKeysEnum.UNIQUE_ID.getRespJsonKeyName(), resourceRespJavaObject.getUniqueId());
297 validateField(map, RespJsonKeysEnum.RESOURCE_VERSION.getRespJsonKeyName(), resourceRespJavaObject.getVersion());
298 validateField(map, RespJsonKeysEnum.LIFE_CYCLE_STATE.getRespJsonKeyName(),
299 resourceRespJavaObject.getLifecycleState());
300 validateField(map, RespJsonKeysEnum.TAGS.getRespJsonKeyName(), resourceRespJavaObject.getTags());
301 validateField(map, RespJsonKeysEnum.CREATOR_USER_ID.getRespJsonKeyName(),
302 resourceRespJavaObject.getCreatorUserId());
303 validateField(map, RespJsonKeysEnum.CREATOR_FULL_NAME.getRespJsonKeyName(),
304 resourceRespJavaObject.getCreatorFullName());
305 validateField(map, RespJsonKeysEnum.LAST_UPDATER_USER_ID.getRespJsonKeyName(),
306 resourceRespJavaObject.getLastUpdaterUserId());
307 validateField(map, RespJsonKeysEnum.LAST_UPDATER_FULL_NAME.getRespJsonKeyName(),
308 resourceRespJavaObject.getLastUpdaterFullName());
310 // validate number of artifacts
311 if (resourceRespJavaObject.getArtifacts() != null) {
313 // assertEquals("check number of artifacts",
314 // resourceRespJavaObject.getArtifacts().size(), artifacts.size());
316 ArrayList<String> myArtifacats = new ArrayList<String>();
317 Iterator it = artifacts.entrySet().iterator();
318 while (it.hasNext()) {
320 Map.Entry pair = (Map.Entry) it.next();
321 // System.out.println(pair.getKey() + " = " + pair.getValue());
322 ArtifactDefinition myArtifact = artifacts.get(pair.getKey());
323 myArtifacats.add(myArtifact.getEsId());
324 it.remove(); // avoids a ConcurrentModificationException
326 // assertTrue("check service contains
327 // artifacts",myArtifacats.containsAll(resourceRespJavaObject.getArtifacts()));
330 // validate number of interfaces:
332 if (interfaze != null) {
333 assertEquals("check number of interfaces", resourceRespJavaObject.getInterfaces().size(),
339 public static boolean validateResourceIsAbstartct(List<Resource> resourceList, Boolean bool) {
340 if (resourceList != null && resourceList.size() > 0) {
341 for (Resource resource : resourceList) {
342 if (resource.isAbstract().equals(bool))
352 public static void validateResourceVersion(Resource resource, String expectedVersion) {
353 if (resource != null && !resource.equals("")) {
354 assertTrue("expected resource version is: " + expectedVersion + ", but actual is: " + resource.getVersion(),
355 resource.getVersion().equals(expectedVersion));