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.externalApis;
23 import com.google.gson.Gson;
24 import com.google.gson.JsonArray;
25 import com.google.gson.JsonElement;
26 import com.google.gson.JsonParser;
27 import org.json.simple.parser.JSONParser;
28 import org.junit.Rule;
29 import org.junit.rules.TestName;
30 import org.openecomp.sdc.be.dao.api.ActionStatus;
31 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
32 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
33 import org.openecomp.sdc.be.model.Resource;
34 import org.openecomp.sdc.be.model.category.CategoryDefinition;
35 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
36 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
37 import org.openecomp.sdc.ci.tests.config.Config;
38 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
39 import org.openecomp.sdc.ci.tests.datatypes.enums.NormativeTypesEnum;
40 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
41 import org.openecomp.sdc.ci.tests.datatypes.enums.SearchCriteriaEnum;
42 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
43 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
44 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
45 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
46 import org.openecomp.sdc.ci.tests.utils.rest.CategoryRestUtils;
47 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
48 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
49 import org.slf4j.Logger;
50 import org.slf4j.LoggerFactory;
51 import org.testng.Assert;
52 import org.testng.annotations.DataProvider;
53 import org.testng.annotations.Test;
55 import java.util.ArrayList;
56 import java.util.Arrays;
57 import java.util.List;
58 import java.util.Random;
60 public class SearchFilterCategoryExternalAPI extends ComponentBaseTest {
62 private static Logger log = LoggerFactory.getLogger(CRUDExternalAPI.class.getName());
64 protected Config config = Config.instance();
65 protected String contentTypeHeaderData = "application/json";
66 protected String acceptHeaderDate = "application/json";
68 protected Gson gson = new Gson();
69 protected JSONParser jsonParser = new JSONParser();
72 // public void init() throws Exception{
73 // AtomicOperationUtils.createDefaultConsumer(true);
78 public static TestName name = new TestName();
80 public SearchFilterCategoryExternalAPI() {
81 super(name, SearchFilterCategoryExternalAPI.class.getName());
85 // Search for invalid resourceType
87 public void searchWithInvalidFilter() throws Exception {
88 RestResponse restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "invalid", ResourceTypeEnum.VFC.toString());
90 Integer expectedResponseCode = 400;
91 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
93 List<String> variables = Arrays.asList("resourceTypeinvalid", "[resourceType, subCategory, category]");
94 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FILTER_KEY.name(), variables, restResponse.getResponse());
96 /*validateFailureAudit(variables);*/
99 /*private void validateFailureAudit(List<String> variables) throws Exception {
100 ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalAuditObject(AssetTypeEnum.RESOURCES, AuditingActionEnum.GET_FILTERED_ASSET_LIST, "?" + SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "invalid=" + ResourceTypeEnum.VFC.toString());
101 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FILTER_KEY.name());
102 expectedExternalAudit.setDESC(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
103 expectedExternalAudit.setSTATUS("400");
104 Map<AuditingFieldsKeysEnum, String> body = new HashMap<>();
105 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
106 AuditValidationUtils.validateAuditExternalSearchAPI(expectedExternalAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
109 @DataProvider(name="searchForResourceTypeNegativeTest", parallel=true)
110 public static Object[][] dataProviderSearchForResourceTypeNegativeTest() {
111 return new Object[][] {
112 {"invalidResourceType"},
117 // Search for invalid resourceType
118 @Test(dataProvider="searchForResourceTypeNegativeTest")
119 public void searchForResourceTypeNegativeTest(String resourceType) throws Exception {
120 RestResponse restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), resourceType);
122 Integer expectedResponseCode = 400;
123 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
125 List<String> variables = Arrays.asList();
126 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), variables, restResponse.getResponse());
128 /*ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalAuditObject(AssetTypeEnum.RESOURCES, AuditingActionEnum.GET_FILTERED_ASSET_LIST, "?" + SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "=" + resourceType);
129 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_CONTENT.name());
130 expectedExternalAudit.setDESC(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
131 expectedExternalAudit.setSTATUS("400");
132 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
133 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
134 AuditValidationUtils.validateAuditExternalSearchAPI(expectedExternalAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);*/
137 // Searching for resource filter incorrect resource type using external API
139 public void searchingForResouceFilterIncorrectResouceTypeUsingExternalAPI() throws Exception {
140 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
141 List<String> createdResoucesName = new ArrayList<String>();
142 createdResoucesName.add(resource.getName());
144 for(ResourceTypeEnum resourceTypeEnum: ResourceTypeEnum.values()) {
145 // Create resource for each type so it will not return 404
146 AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(resourceTypeEnum, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
148 RestResponse restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), resourceTypeEnum.toString());
150 Integer expectedResponseCode = 200;
151 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
152 if(resourceTypeEnum == ResourceTypeEnum.VF) {
153 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, true);
155 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, false);
159 /*ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalAuditObject(AssetTypeEnum.RESOURCES, AuditingActionEnum.GET_FILTERED_ASSET_LIST, "?" + SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "=" + resourceTypeEnum.toString());
160 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
161 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
162 AuditValidationUtils.validateAuditExternalSearchAPI(expectedExternalAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);*/
166 // Searching for several resource types using external API
168 public void searchingForSeveralResouceTypesUsingExternalAPI() throws Exception {
170 for(ResourceTypeEnum resourceTypeEnum: ResourceTypeEnum.values()) {
171 List<String> createdResoucesName = new ArrayList<String>();
172 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(resourceTypeEnum, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
173 createdResoucesName.add(resource.getName());
175 RestResponse restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), resourceTypeEnum.toString());
177 Integer expectedResponseCode = 200;
178 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
179 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, true);
181 /*ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalAuditObject(AssetTypeEnum.RESOURCES, AuditingActionEnum.GET_FILTERED_ASSET_LIST, "?" + SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "=" + resourceTypeEnum.toString());
182 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
183 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedExternalAudit.getRESOURCE_URL());
184 AuditValidationUtils.validateAuditExternalSearchAPI(expectedExternalAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);*/
188 // Searching for several resources of type VFCMT using external API
190 public void searchingForSeveralResourcesOfTypeVFCMTUsingExternalAPI() throws Exception {
192 Random random = new Random();
193 int numberOfResouceToCreate = random.nextInt(5) + 1;
194 List<String> createdResoucesName = new ArrayList<String>();
196 for(int i=0; i<numberOfResouceToCreate; i++) {
198 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VFCMT, NormativeTypesEnum.ROOT, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
199 createdResoucesName.add(resource.getName());
202 RestResponse restResponse = ResourceRestUtils.getResourceListFilterByCriteria(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), SearchCriteriaEnum.RESOURCE_TYPE.getValue(), ResourceTypeEnum.VFCMT.toString());
204 Integer expectedResponseCode = 200;
205 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
206 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, true);
208 /*ExpectedExternalAudit expectedExternalAudit = ElementFactory.getDefaultExternalAuditObject(AssetTypeEnum.RESOURCES, AuditingActionEnum.GET_FILTERED_ASSET_LIST, "?" + SearchCriteriaEnum.RESOURCE_TYPE.getValue() + "=" + ResourceTypeEnum.VFCMT.toString());
209 AuditValidationUtils.validateAuditExternalSearchAPI(expectedExternalAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), null);*/
214 @DataProvider(name="normativeResourceCategory", parallel=true)
215 public static Object[][] dataProviderNormativeResourceCategory() {
216 return new Object[][] {
217 {ResourceCategoryEnum.ALLOTTED_RESOURCE},
218 {ResourceCategoryEnum.TEMPLATE_MONITORING_TEMPLATE},
222 // Verify exist of normative resource category from data provider
223 @Test(dataProvider="normativeResourceCategory")
224 public void normativeResourceCategory(ResourceCategoryEnum resourceCategoryEnum) throws Exception {
225 RestResponse restResponse = CategoryRestUtils.getAllCategories(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), "resources");
226 validateJsonContainResourceCategory(restResponse.getResponse(), resourceCategoryEnum);
228 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, resourceCategoryEnum, UserRoleEnum.DESIGNER, true).left().value();
229 List<String> createdResoucesName = new ArrayList<String>();
230 createdResoucesName.add(resource.getName());
232 restResponse = ResourceRestUtils.getResourceListFilterByCategory(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), resourceCategoryEnum.getCategory());
234 Integer expectedResponseCode = 200;
235 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
236 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, true);
239 // Verify search filter by sub-category
241 public void validateFilterBySubcategory() throws Exception {
242 ResourceCategoryEnum resourceCategoryEnum = getRandomCategoryFromResourceCategoryEnum();
244 Resource resource = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.ROOT, resourceCategoryEnum, UserRoleEnum.DESIGNER, true).left().value();
245 List<String> createdResoucesName = new ArrayList<String>();
246 createdResoucesName.add(resource.getName());
248 RestResponse restResponse = ResourceRestUtils.getResourceListFilterBySubCategory(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), AssetTypeEnum.RESOURCES.getValue(), resourceCategoryEnum.getSubCategory());
250 Integer expectedResponseCode = 200;
251 Assert.assertEquals(restResponse.getErrorCode(), expectedResponseCode);
252 validateJsonContainResource(restResponse.getResponse(), createdResoucesName, true);
256 protected ResourceCategoryEnum getRandomCategoryFromResourceCategoryEnum() throws Exception {
257 Random random = new Random();
258 int randint = random.nextInt(ResourceCategoryEnum.values().length);
260 for(ResourceCategoryEnum resourceTypeEnum: ResourceCategoryEnum.values()) {
262 return resourceTypeEnum;
269 protected CategoryDefinition getRandomCategory() throws Exception {
270 Random random = new Random();
272 RestResponse restResponse = CategoryRestUtils.getAllCategories(ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), "resources");
273 Gson gson = new Gson();
274 JsonElement jelement = new JsonParser().parse(restResponse.getResponse());
275 JsonArray jsonArray = jelement.getAsJsonArray();
277 CategoryDefinition categoryDefinition = gson.fromJson(jsonArray.get(random.nextInt(jsonArray.size())), CategoryDefinition.class);
279 return categoryDefinition;
282 protected void validateJsonContainResource(String json, List<String> resourceNameList, Boolean willBeFound) {
283 int lenResourceNameList = resourceNameList.size();
284 Gson gson = new Gson();
285 JsonElement jsonElement = new JsonParser().parse(json);
286 JsonArray jsonArray = jsonElement.getAsJsonArray();
287 for(JsonElement jElement: jsonArray) {
288 ResourceReqDetails jResource = gson.fromJson(jElement, ResourceReqDetails.class);
290 if(resourceNameList.contains(jResource.getName())) {
291 resourceNameList.remove(jResource.getName());
295 if(resourceNameList.size() != 0 && willBeFound) {
296 Assert.assertTrue(false, "Created resource not found on search filtered by category.");
297 } else if (lenResourceNameList != resourceNameList.size() & !willBeFound) {
298 Assert.assertTrue(false, "Some of the resources found when expect that no resource will be found.");
304 protected void validateJsonContainResourceCategory(String json, ResourceCategoryEnum resourceCategoryEnum) {
305 Gson gson = new Gson();
306 JsonElement jelement = new JsonParser().parse(json);
307 JsonArray jsonArray = jelement.getAsJsonArray();
308 for(JsonElement jsonElement : jsonArray){
309 CategoryDefinition categoryDefinition = gson.fromJson(jsonElement, CategoryDefinition.class);
311 if(categoryDefinition.getName().equals(resourceCategoryEnum.getCategory())) {
312 for(SubCategoryDefinition subcategory: categoryDefinition.getSubcategories()) {
313 if(subcategory.getName().equals(resourceCategoryEnum.getSubCategory())) {
321 Assert.assertTrue(false, "Category and subcategory not found in categories list.");