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