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