test-apis-ci/src/main/java/org/openecomp/sdc/externalApis/GetFilteredAssetServlet.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.externalApis;
  22
  23 import org.junit.Rule;
  24 import org.junit.rules.TestName;
  25 import org.openecomp.sdc.be.dao.api.ActionStatus;
  26 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  27 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  28 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  29 import org.openecomp.sdc.be.model.Resource;
  30 import org.openecomp.sdc.be.model.Service;
  31 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  32 import org.openecomp.sdc.ci.tests.datatypes.*;
  33 import org.openecomp.sdc.ci.tests.datatypes.enums.*;
  34 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  35 import org.openecomp.sdc.ci.tests.utils.Utils;
  36 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  37 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  38 import org.openecomp.sdc.ci.tests.utils.rest.*;
  39 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  40 import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.testng.annotations.Test;
  44
  45 import java.util.ArrayList;
  46 import java.util.Arrays;
  47 import java.util.List;
  48
  49 import static org.testng.AssertJUnit.assertEquals;
  50 import static org.testng.AssertJUnit.assertNotNull;
  51
  52 public class GetFilteredAssetServlet extends ComponentBaseTest {
  53
  54         private static Logger log = LoggerFactory.getLogger(GetAssetServlet.class.getName());
  55         protected final static String categoryFilterKey = "category";
  56         protected final static String subCategoryFilterKey = "subCategory";
  57         protected final static String distributionStatusFilterKey = "distributionStatus";
  58         protected final static String serviceKey = "service";
  59         protected final static String resourceKey = "resource";
  60         protected final static String resourceType = "resourceType";
  61         protected final static String validFilterParameters = "[" + resourceType + ", "+ subCategoryFilterKey + ", " + categoryFilterKey + "]";
  62
  63         @Rule
  64         public static TestName name = new TestName();
  65
  66         public GetFilteredAssetServlet() {
  67                 super(name, GetFilteredAssetServlet.class.getName());
  68         }
  69
  70 //      @BeforeMethod
  71 //      public void setup() throws Exception {
  72 //              AtomicOperationUtils.createDefaultConsumer(true);
  73 //      }
  74
  75         // RESOURCE
  76         // Success
  77
  78         @Test // (enabled = false)
  79         public void getResourceAssetBySpecifiedCategory() throws Exception {
  80                 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory() };
  81                 List<String> expectedAssetNamesList = new ArrayList<>();
  82
  83                 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
  84                 expectedAssetNamesList.add(resource1.getName());
  85                 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, UserRoleEnum.DESIGNER, true).left().value();
  86                 expectedAssetNamesList.add(resource2.getName());
  87                 Resource resource3 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.NETWORK_CONNECTIVITY_CON_POINT, UserRoleEnum.DESIGNER, true).left().value();
  88
  89                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
  90                 BaseRestUtils.checkSuccess(assetResponse);
  91
  92                 List<ResourceAssetStructure> resourceAssetList = AssetRestUtils.getResourceAssetList(assetResponse);
  93                 List<String> getActualAssetNamesList = AssetRestUtils.getResourceNamesList(resourceAssetList);
  94                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
  95
  96                 /*// Validate audit message
  97                 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
  98
  99         }
 100
 101         // 2 resources has the same category and different subcategory
 102         @Test // (enabled = false)
 103         public void getResourceAssetBySpecifiedCategoryAndSubCategory() throws Exception {
 104                 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory(), subCategoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getSubCategory() };
 105                 // String[] filter2 = {categoryFilterKey + "=" +
 106                 // ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getCategory(),
 107                 // subCategoryFilterKey + "=" +
 108                 // ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS.getSubCategory()};
 109                 List<String> expectedAssetNamesList = new ArrayList<>();
 110
 111                 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
 112                 expectedAssetNamesList.add(resource1.getName());
 113                 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_NETWORK_ELEMENTS, UserRoleEnum.DESIGNER, true).left().value();
 114
 115                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 116                 BaseRestUtils.checkSuccess(assetResponse);
 117
 118                 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 119                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
 120                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 121
 122                 /*// Validate audit message
 123                 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
 124         }
 125
 126         @Test // (enabled = false)
 127         public void getResourceAssetBySpecifiedSubCategoryAndCategory() throws Exception {
 128                 String[] filter = { subCategoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_DATABASE.getSubCategory(), categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_DATABASE.getCategory(), };
 129                 List<String> expectedAssetNamesList = new ArrayList<>();
 130
 131                 Resource resource1 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.COMPUTE, ResourceCategoryEnum.GENERIC_ABSTRACT, UserRoleEnum.DESIGNER, true).left().value();
 132                 Resource resource2 = AtomicOperationUtils.createResourcesByTypeNormTypeAndCatregory(ResourceTypeEnum.VF, NormativeTypesEnum.DATABASE, ResourceCategoryEnum.GENERIC_DATABASE, UserRoleEnum.DESIGNER, true).left().value();
 133                 expectedAssetNamesList.add(resource2.getName());
 134
 135                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 136                 BaseRestUtils.checkSuccess(assetResponse);
 137
 138                 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 139                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
 140                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 141
 142                 /*// Validate audit message
 143                 validateSuccessAudit(filter, AssetTypeEnum.RESOURCES);*/
 144         }
 145
 146         // Failure
 147         @Test // (enabled = false)
 148         public void getResourceAssetCategoryNotExists() throws Exception {
 149                 String[] filter = { categoryFilterKey + "=" + "NotExistingCategory" };
 150
 151                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 152                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 153
 154                 assertNotNull("check response object is not null after create resouce", assetResponse);
 155                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 156                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 157
 158                 List<String> variables = Arrays.asList(resourceKey, categoryFilterKey, "NotExistingCategory");
 159                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 160
 161                 /*// Validate audit message
 162                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES)*/;
 163         }
 164
 165         @Test // (enabled = false)
 166         public void getResourceAssetSubCategoryNotExists() throws Exception {
 167                 String[] filter = { categoryFilterKey + "=" + ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory(), subCategoryFilterKey + "=" + "NotExistingSubCategory" };
 168
 169                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 170                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY.name());
 171
 172                 assertNotNull("check response object is not null after create resouce", assetResponse);
 173                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 174                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 175
 176                 List<String> variables = Arrays.asList("Resource", "NotExistingSubCategory", ResourceCategoryEnum.GENERIC_ABSTRACT.getCategory());
 177                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY.name(), variables, assetResponse.getResponse());
 178
 179                 /*// Validate audit message
 180                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
 181         }
 182
 183         @Test // (enabled = false)
 184         public void getResourceAssetCategoryNotExistsSubCategoryExists() throws Exception {
 185                 String[] filter = { subCategoryFilterKey + "=" + ResourceCategoryEnum.NETWORK_L2_3_GETEWAY.getSubCategory(), categoryFilterKey + "=" + "NotExistingCategory" };
 186
 187                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 188                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 189
 190                 assertNotNull("check response object is not null after create resouce", assetResponse);
 191                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 192                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 193
 194                 List<String> variables = Arrays.asList(resourceKey, categoryFilterKey, "NotExistingCategory");
 195                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 196
 197                 /*// Validate audit message
 198                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
 199         }
 200
 201         @Test // (enabled = false)
 202         public void getResourceAssetInvalidFilterKey() throws Exception {
 203                 String[] filter = { subCategoryFilterKey + "1=" + ResourceCategoryEnum.NETWORK_L2_3_GETEWAY.getSubCategory(), categoryFilterKey + "=" + "NotExistingCategory" };
 204
 205                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.RESOURCES, filter);
 206                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FILTER_KEY.name());
 207
 208                 assertNotNull("check response object is not null after create resouce", assetResponse);
 209                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 210                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 211
 212                 List<String> variables = Arrays.asList(subCategoryFilterKey + "1", validFilterParameters);
 213                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FILTER_KEY.name(), variables, assetResponse.getResponse());
 214
 215                 /*// Validate audit message
 216                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.RESOURCES);*/
 217         }
 218
 219         // ---------------------------------------------------------------------------------------------------------
 220         // SERVICE
 221         // Success
 222         @Test // (enabled = false)
 223         public void getServiceAssetBySpecifiedCategory() throws Exception {
 224                 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue() };
 225                 List<String> expectedAssetNamesList = new ArrayList<>();
 226
 227                 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 228                 expectedAssetNamesList.add(service1.getName());
 229
 230                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 231                 BaseRestUtils.checkSuccess(assetResponse);
 232
 233                 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 234                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
 235                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 236
 237                 /*// Validate audit message
 238                 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
 239         }
 240
 241         @Test // (enabled = false)
 242         public void getServiceAssetBySpecifiedCategoryAndDistributionStatus() throws Exception {
 243                 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue(), distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED };
 244                 List<String> expectedAssetNamesList = new ArrayList<>();
 245                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
 246
 247                 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 248                 expectedAssetNamesList.add(service1.getName());
 249                 Service service2 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 250                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service2.getUniqueId());
 251                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 252                 service2 = (Service) AtomicOperationUtils.changeComponentState(service2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 253                 expectedAssetNamesList.add(service2.getName());
 254
 255                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 256                 BaseRestUtils.checkSuccess(assetResponse);
 257
 258                 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 259                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
 260                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 261
 262                 /*// Validate audit message
 263                 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
 264         }
 265
 266         @Test // (enabled = false)
 267         public void getServiceAssetByDistributionStatus() throws Exception {
 268                 String[] filter = { distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED };
 269                 List<String> expectedAssetNamesList = new ArrayList<>();
 270                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
 271
 272                 Service service1 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 273                 expectedAssetNamesList.add(service1.getName());
 274                 Service service2 = AtomicOperationUtils.createServiceByCategory(ServiceCategoriesEnum.MOBILITY, UserRoleEnum.DESIGNER, true).left().value();
 275                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service2.getUniqueId());
 276                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 277                 service2 = (Service) AtomicOperationUtils.changeComponentState(service2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 278                 ServiceRestUtils.approveServiceDistribution(service2.getUniqueId(), UserRoleEnum.GOVERNOR.getUserId());
 279
 280                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 281                 BaseRestUtils.checkSuccess(assetResponse);
 282
 283                 List<ServiceAssetStructure> serviceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 284                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(serviceAssetList);
 285                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 286
 287                 /*// Validate audit message
 288                 validateSuccessAudit(filter, AssetTypeEnum.SERVICES);*/
 289         }
 290
 291         // Failure
 292         @Test // (enabled = false)
 293         public void getServiceAssetCategoryNotExists() throws Exception {
 294                 String[] filter = { categoryFilterKey + "=" + "NotExistingCategory" };
 295
 296                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 297                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 298
 299                 assertNotNull("check response object is not null after create resouce", assetResponse);
 300                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 301                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 302
 303                 List<String> variables = Arrays.asList(serviceKey, categoryFilterKey, "NotExistingCategory");
 304                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 305
 306                 /*// Validate audit message
 307                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
 308         }
 309
 310         @Test // (enabled = false)
 311         public void getServiceAssetInvalidDistributionStatus() throws Exception {
 312                 String[] filter = { distributionStatusFilterKey + "=" + "NotExistingDistributionStatus" };
 313                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 314                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 315
 316                 assertNotNull("check response object is not null after create resouce", assetResponse);
 317                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 318                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 319
 320                 List<String> variables = Arrays.asList(serviceKey, distributionStatusFilterKey, "NotExistingDistributionStatus");
 321                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 322
 323                 /*// Validate audit message
 324                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
 325         }
 326
 327         @Test // (enabled = false)
 328         public void getServiceAssetCategoryExitsDistributionStatusInvalid() throws Exception {
 329                 String[] filter = { categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue(), distributionStatusFilterKey + "=" + "NotExistingDistributionStatus" };
 330
 331                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 332                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 333
 334                 assertNotNull("check response object is not null after create resouce", assetResponse);
 335                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 336                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 337
 338                 List<String> variables = Arrays.asList(serviceKey, distributionStatusFilterKey, "NotExistingDistributionStatus");
 339                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 340
 341                 /*// Validate audit message
 342                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
 343         }
 344
 345         @Test // (enabled = false)
 346         public void getServiceAssetCategoryNotExistsDistributionStatus() throws Exception {
 347                 String[] filter = { distributionStatusFilterKey + "=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, categoryFilterKey + "=" + "NotExistingCategory" };
 348
 349                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 350                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name());
 351
 352                 assertNotNull("check response object is not null after create resouce", assetResponse);
 353                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 354                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 355
 356                 List<String> variables = Arrays.asList(serviceKey, categoryFilterKey, "NotExistingCategory");
 357                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND.name(), variables, assetResponse.getResponse());
 358
 359                 /*// Validate audit message
 360                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
 361         }
 362
 363         @Test // (enabled = false)
 364         public void getServiceAssetInvalidFilterKey() throws Exception {
 365                 String[] filter = { distributionStatusFilterKey + "1=" + DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, categoryFilterKey + "=" + ServiceCategoriesEnum.MOBILITY.getValue() };
 366
 367                 RestResponse assetResponse = AssetRestUtils.getComponentListByAssetType(true, AssetTypeEnum.SERVICES, filter);
 368                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FILTER_KEY.name());
 369
 370                 assertNotNull("check response object is not null after create resouce", assetResponse);
 371                 assertNotNull("check error code exists in response after create resource", assetResponse.getErrorCode());
 372                 assertEquals("Check response code after create resource", errorInfo.getCode(), assetResponse.getErrorCode());
 373
 374                 List<String> variables = Arrays.asList(distributionStatusFilterKey + "1", "[" + categoryFilterKey + ", " + distributionStatusFilterKey + "]");
 375                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FILTER_KEY.name(), variables, assetResponse.getResponse());
 376
 377                 /*// Validate audit message
 378                 validateFailureAudit(filter, errorInfo, variables, AssetTypeEnum.SERVICES);*/
 379
 380         }
 381
 382         @Test
 383         public void getFilteredResourceAssetCategoryNotFound() throws Exception {
 384
 385                 String query = "category=Application%20L3%2B";
 386                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
 387                 BaseRestUtils.checkErrorResponse(assetResponse, ActionStatus.COMPONENT_CATEGORY_NOT_FOUND, "resource", "category", "Application L3+");
 388
 389                 /*// Validate audit message
 390                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getFilteredAssetListAuditCategoryNotFound(AssetTypeEnum.RESOURCES, "?" + query, "Application L3+");
 391                 Map <AuditingFieldsKeysEnum, String> body = new HashMap<>();
 392         body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
 393         AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);*/
 394
 395         }
 396
 397         @Test
 398         public void getFilteredResourceAssetSuccess() throws Exception {
 399
 400                 List<String> expectedAssetNamesList = new ArrayList<>();
 401
 402                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_APP_SERVER);
 403                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 404                 Resource resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
 405                 expectedAssetNamesList.add(resource.getName());
 406
 407                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_BORDER);
 408                 resourceDetails.setResourceType(ResourceTypeEnum.VFC.name());
 409                 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
 410                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 411                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 412                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 413                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 414
 415                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.GENERIC_INFRASTRUCTURE);
 416                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 417                 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
 418                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 419                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 420                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 421
 422                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_FIREWALL);
 423                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 424                 resource = AtomicOperationUtils.createResourceByResourceDetails(resourceDetails, UserRoleEnum.DESIGNER, true).left().value();
 425                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 426                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 427                 resource = (Resource) AtomicOperationUtils.changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 428                 expectedAssetNamesList.add(resource.getName());
 429
 430                 log.debug("4 resources created");
 431                 String query = "category=Application%20L4%2B";
 432                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
 433                 BaseRestUtils.checkSuccess(assetResponse);
 434
 435                 List<ResourceAssetStructure> resourceAssetList = AssetRestUtils.getResourceAssetList(assetResponse);
 436                 List<String> getActualAssetNamesList = AssetRestUtils.getResourceNamesList(resourceAssetList);
 437                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 438
 439 //                      Andrey L. This condition can not be checked in case resources list has two or ore different resource types
 440 //                      AssetRestUtils.checkResourceTypeInObjectList(resourceAssetList, ResourceTypeEnum.VF);
 441
 442                 /*// Validate audit message
 443                 validateFilteredAudit(query, AssetTypeEnum.RESOURCES);*/
 444
 445         }
 446
 447         @Test
 448         public void getFilteredServiceAssetInformationalSuccess() throws Exception {
 449
 450                 List<String> expectedAssetNamesList = new ArrayList<>();
 451                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
 452                 artifactDetails.setArtifactGroupType(ArtifactGroupTypeEnum.INFORMATIONAL.getType());
 453
 454                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 455                 Service service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 456
 457                 serviceDetails = ElementFactory.getDefaultService();
 458                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 459                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 460                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 461                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 462
 463                 ServiceReqDetails certifyService = new ServiceReqDetails(service);
 464                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 465                 AtomicOperationUtils.distributeService(service, false);
 466                 expectedAssetNamesList.add(service.getName());
 467
 468                 serviceDetails = ElementFactory.getDefaultService();
 469                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 470                 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 471                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 472                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 473                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 474                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 475                 certifyService = new ServiceReqDetails(service);
 476                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 477                 AtomicOperationUtils.distributeService(service, false);
 478                 expectedAssetNamesList.add(service.getName());
 479
 480                 serviceDetails = ElementFactory.getDefaultService();
 481                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 482                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 483                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 484                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 485                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 486                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 487
 488                 serviceDetails = ElementFactory.getDefaultService();
 489                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 490                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 491                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 492                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 493                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 494
 495                 String query = "distributionStatus=Distributed";
 496                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.SERVICES, query);
 497                 BaseRestUtils.checkSuccess(assetResponse);
 498
 499                 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 500                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
 501                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 502
 503                 /*// Validate audit message
 504                 validateFilteredAudit(query, AssetTypeEnum.SERVICES);*/
 505
 506         }
 507
 508         @Test
 509         public void getFilteredServiceAssetDeploymentSuccess() throws Exception {
 510
 511                 List<String> expectedAssetNamesList = new ArrayList<>();
 512                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER, ArtifactTypeEnum.OTHER, true);
 513
 514                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 515                 Service service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 516
 517                 serviceDetails = ElementFactory.getDefaultService();
 518                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 519                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 520                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 521                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 522
 523                 ServiceReqDetails certifyService = new ServiceReqDetails(service);
 524                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 525                 AtomicOperationUtils.distributeService(service, false);
 526                 expectedAssetNamesList.add(service.getName());
 527
 528                 serviceDetails = ElementFactory.getDefaultService();
 529                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 530                 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 531                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 532                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 533                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 534                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 535                 certifyService = new ServiceReqDetails(service);
 536                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(), ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 537                 AtomicOperationUtils.distributeService(service, false);
 538                 expectedAssetNamesList.add(service.getName());
 539
 540                 serviceDetails = ElementFactory.getDefaultService();
 541                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 542                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 543                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 544                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 545                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 546                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 547
 548                 serviceDetails = ElementFactory.getDefaultService();
 549                 service = AtomicOperationUtils.createCustomService(serviceDetails, UserRoleEnum.DESIGNER, true).left().value();
 550                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 551                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 552                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 553                 service = (Service) AtomicOperationUtils.changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 554
 555                 String query = "distributionStatus=Distributed";
 556                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.SERVICES, query);
 557                 BaseRestUtils.checkSuccess(assetResponse);
 558
 559                 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 560                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
 561                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 562
 563                 /*// Validate audit message
 564                 validateFilteredAudit(query, AssetTypeEnum.SERVICES);*/
 565         }
 566
 567         /*private void validateSuccessAudit(String[] filter, AssetTypeEnum assetType) throws Exception {
 568                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultAssetListAudit(assetType, AuditingActionEnum.GET_FILTERED_ASSET_LIST);
 569                 expectedAssetListAudit.setRESOURCE_URL(AssetRestUtils.buildUrlWithFilter(expectedAssetListAudit.getRESOURCE_URL(), filter));
 570                 Map<AuditingFieldsKeysEnum, String> body = new HashMap<>();
 571                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
 572                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
 573         }
 574
 575         private void validateFilteredAudit(String query, AssetTypeEnum assetType) throws Exception {
 576                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultFilteredAssetListAudit(assetType, "?" + query);
 577                 Map<AuditingFieldsKeysEnum, String> body = new HashMap<>();
 578                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
 579                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
 580         }
 581
 582         private void validateFailureAudit(String[] filter, ErrorInfo errorInfo, List<String> variables, AssetTypeEnum assetType) throws Exception {
 583                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory.getDefaultAssetListAudit(assetType, AuditingActionEnum.GET_FILTERED_ASSET_LIST);
 584                 expectedAssetListAudit.setRESOURCE_URL(AssetRestUtils.buildUrlWithFilter(expectedAssetListAudit.getRESOURCE_URL(), filter));
 585                 expectedAssetListAudit.setSTATUS(errorInfo.getCode().toString());
 586                 expectedAssetListAudit.setDESC(AuditValidationUtils.buildAuditDescription(errorInfo, variables));
 587                 Map<AuditingFieldsKeysEnum, String> body = new HashMap<>();
 588                 body.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_URL, expectedAssetListAudit.getRESOURCE_URL());
 589                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit, AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), body);
 590         }*/
 591 }