asdc-tests/src/main/java/org/openecomp/sdc/externalApis/GetSpecificAssetMetadataServlet.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 java.util.ArrayList;
  24 import java.util.List;
  25
  26 import org.junit.Rule;
  27 import org.junit.rules.TestName;
  28 import org.openecomp.sdc.be.dao.api.ActionStatus;
  29 import org.openecomp.sdc.be.datatypes.enums.AssetTypeEnum;
  30 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  31 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  32 import org.openecomp.sdc.be.model.Resource;
  33 import org.openecomp.sdc.be.model.Service;
  34 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  35 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  36 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  37 import org.openecomp.sdc.ci.tests.datatypes.ResourceAssetStructure;
  38 import org.openecomp.sdc.ci.tests.datatypes.ResourceDetailedAssetStructure;
  39 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  40 import org.openecomp.sdc.ci.tests.datatypes.ServiceAssetStructure;
  41 import org.openecomp.sdc.ci.tests.datatypes.ServiceDetailedAssetStructure;
  42 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  43 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  44 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  47 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedExternalAudit;
  48 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  49 import org.openecomp.sdc.ci.tests.utils.Utils;
  50 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  51 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  52 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  53 import org.openecomp.sdc.ci.tests.utils.rest.AssetRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  55 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  56 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  57 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  58 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  59 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  60 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63 import org.testng.annotations.BeforeMethod;
  64 import org.testng.annotations.Test;
  65
  66 public class GetSpecificAssetMetadataServlet extends ComponentBaseTest {
  67         private static Logger log = LoggerFactory.getLogger(GetAssetServlet.class.getName());
  68
  69         @Rule
  70         public static TestName name = new TestName();
  71
  72         public GetSpecificAssetMetadataServlet() {
  73                 super(name, GetSpecificAssetMetadataServlet.class.getName());
  74         }
  75
  76         @BeforeMethod
  77         public void setup() throws Exception {
  78                 AtomicOperationUtils.createDefaultConsumer(true);
  79         }
  80
  81         // get specific asset metadata
  82
  83         // Resource
  84         @Test // (enabled = false)
  85         public void getResourceAssetMetadataSuccess() throws Exception {
  86
  87                 Resource resourceVF = AtomicOperationUtils
  88                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
  89
  90                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
  91                                 resourceVF.getUUID());
  92                 BaseRestUtils.checkSuccess(assetResponse);
  93
  94                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
  95                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
  96
  97                 // Validate audit message
  98                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
  99                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 100                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 101                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 102         }
 103
 104         @Test  (enabled = false)
 105         public void getResourceAssetMetadataWithResourceInstancesSuccess() throws Exception {
 106
 107                 Resource resourceVF = AtomicOperationUtils
 108                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 109                 Resource resource2 = AtomicOperationUtils
 110                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 111                 resource2 = (Resource) AtomicOperationUtils
 112                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 113
 114                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 115                                 true);
 116                 resourceVF = ResponseParser.parseToObjectUsingMapper(
 117                                 ResourceRestUtils.getResource(resourceVF.getUniqueId()).getResponse(), Resource.class);
 118
 119                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 120                                 resourceVF.getUUID());
 121                 BaseRestUtils.checkSuccess(assetResponse);
 122
 123                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 124                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 125
 126                 // Validate audit message
 127                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 128                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 129                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 130                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 131         }
 132
 133         @Test // (enabled = false)
 134         public void getResourceAssetMetadataWithNonCertifiedResourceInstancesSuccess() throws Exception {
 135
 136                 Resource resourceVF = AtomicOperationUtils
 137                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 138                 Resource resource2 = AtomicOperationUtils
 139                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 140                 resource2 = (Resource) AtomicOperationUtils
 141                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 142                 Resource resource3 = AtomicOperationUtils
 143                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 144                 resource3 = (Resource) AtomicOperationUtils
 145                                 .changeComponentState(resource3, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 146                                 .getLeft();
 147
 148                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 149                                 true);
 150                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource3, resourceVF, UserRoleEnum.DESIGNER,
 151                                 true);
 152
 153                 // certify resource2 and add to VF(VF with resource2 0.1, 1.0 and 1.1
 154                 // versions)
 155                 resource2 = (Resource) AtomicOperationUtils
 156                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 157                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 158                                 true);
 159                 resource2 = (Resource) AtomicOperationUtils
 160                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 161                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 162                                 true);
 163                 resourceVF = ResponseParser.parseToObjectUsingMapper(
 164                                 ResourceRestUtils.getResource(resourceVF.getUniqueId()).getResponse(), Resource.class);
 165
 166                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 167                                 resourceVF.getUUID());
 168                 BaseRestUtils.checkSuccess(assetResponse);
 169
 170                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 171                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 172
 173                 // Validate audit message
 174                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 175                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 176                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 177                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 178         }
 179
 180         @Test // (enabled = false)
 181         public void getResourceAssetMetadataWithResourceInstancesVfInSubmitForTestingSuccess() throws Exception {
 182
 183                 Resource resourceVF = AtomicOperationUtils
 184                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 185                 Resource resource2 = AtomicOperationUtils
 186                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 187                 resource2 = (Resource) AtomicOperationUtils
 188                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 189                 Resource resource3 = AtomicOperationUtils
 190                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 191                 resource3 = (Resource) AtomicOperationUtils
 192                                 .changeComponentState(resource3, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 193
 194                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 195                                 true);
 196                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource3, resourceVF, UserRoleEnum.DESIGNER,
 197                                 true);
 198
 199                 // certify resource2 and add to VF(VF with resource2 1.0, 2.0 and 3.0
 200                 // versions)
 201                 resource2 = (Resource) AtomicOperationUtils
 202                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 203                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 204                                 true);
 205                 resource2 = (Resource) AtomicOperationUtils
 206                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 207                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 208                                 true);
 209                 resourceVF = (Resource) AtomicOperationUtils
 210                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 211                                 .getLeft();
 212
 213                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 214                                 resourceVF.getUUID());
 215                 BaseRestUtils.checkSuccess(assetResponse);
 216
 217                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 218                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 219
 220                 // Validate audit message
 221                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 222                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 223                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 224                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 225         }
 226
 227         @Test // (enabled = false)
 228         public void getResourceAssetMetadataWithResourceInstancesVfInStartCertificationSuccess() throws Exception {
 229
 230                 Resource resourceVF = AtomicOperationUtils
 231                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 232                 Resource resource2 = AtomicOperationUtils
 233                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 234                 resource2 = (Resource) AtomicOperationUtils
 235                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 236                 Resource resource3 = AtomicOperationUtils
 237                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 238                 resource3 = (Resource) AtomicOperationUtils
 239                                 .changeComponentState(resource3, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 240
 241                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 242                                 true);
 243                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource3, resourceVF, UserRoleEnum.DESIGNER,
 244                                 true);
 245
 246                 // certify resource2 and add to VF(VF with resource2 1.0, 2.0 and 3.0
 247                 // versions)
 248                 resource2 = (Resource) AtomicOperationUtils
 249                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 250                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 251                                 true);
 252                 resource2 = (Resource) AtomicOperationUtils
 253                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 254                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 255                                 true);
 256                 resourceVF = (Resource) AtomicOperationUtils
 257                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.STARTCERTIFICATION, true)
 258                                 .getLeft();
 259
 260                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 261                                 resourceVF.getUUID());
 262                 BaseRestUtils.checkSuccess(assetResponse);
 263
 264                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 265                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 266
 267                 // Validate audit message
 268                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 269                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 270                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 271                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 272         }
 273
 274         @Test // (enabled = false)
 275         public void getResourceAssetMetadataWithResourceInstancesCertifiedVFSuccess() throws Exception {
 276
 277                 Resource resourceVF = AtomicOperationUtils
 278                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 279                 Resource resource2 = AtomicOperationUtils
 280                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 281                 resource2 = (Resource) AtomicOperationUtils
 282                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 283                 Resource resource3 = AtomicOperationUtils
 284                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 285                 resource3 = (Resource) AtomicOperationUtils
 286                                 .changeComponentState(resource3, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 287
 288                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 289                                 true);
 290                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource3, resourceVF, UserRoleEnum.DESIGNER,
 291                                 true);
 292
 293                 // certify resource2 and add to VF(VF with resource2 1.0, 2.0 and 3.0
 294                 // versions)
 295                 resource2 = (Resource) AtomicOperationUtils
 296                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 297                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 298                                 true);
 299                 resource2 = (Resource) AtomicOperationUtils
 300                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 301                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 302                                 true);
 303                 resourceVF = (Resource) AtomicOperationUtils
 304                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 305
 306                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 307                                 resourceVF.getUUID());
 308                 BaseRestUtils.checkSuccess(assetResponse);
 309
 310                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 311                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 312
 313                 // Validate audit message
 314                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 315                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 316                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 317                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 318         }
 319
 320         @Test // (enabled = false)
 321         public void getResourceAssetMetadataWithNonCertifiedResourceInstancesAndArtifactsSuccess() throws Exception {
 322
 323                 Resource resourceVF = AtomicOperationUtils
 324                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 325                 Resource resource2 = AtomicOperationUtils
 326                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 327                 resource2 = (Resource) AtomicOperationUtils
 328                                 .changeComponentState(resource2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 329                 Resource resource3 = AtomicOperationUtils
 330                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
 331                 resource3 = (Resource) AtomicOperationUtils
 332                                 .changeComponentState(resource3, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFICATIONREQUEST, true)
 333                                 .getLeft();
 334
 335                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource2, resourceVF, UserRoleEnum.DESIGNER,
 336                                 true);
 337                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resource3, resourceVF, UserRoleEnum.DESIGNER,
 338                                 true);
 339
 340                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.VENDOR_LICENSE, resourceVF, UserRoleEnum.DESIGNER,
 341                                 true, true);
 342                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.APPC_CONFIG, resourceVF, UserRoleEnum.DESIGNER, true,
 343                                 true);
 344                 resourceVF = ResponseParser.parseToObjectUsingMapper(
 345                                 ResourceRestUtils.getResource(resourceVF.getUniqueId()).getResponse(), Resource.class);
 346
 347                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.RESOURCES,
 348                                 resourceVF.getUUID());
 349                 BaseRestUtils.checkSuccess(assetResponse);
 350
 351                 ResourceDetailedAssetStructure resourceAssetMetadata = AssetRestUtils.getResourceAssetMetadata(assetResponse);
 352                 AssetRestUtils.resourceMetadataValidatior(resourceAssetMetadata, resourceVF, AssetTypeEnum.RESOURCES);
 353
 354                 // Validate audit message
 355                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 356                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.RESOURCES, resourceVF);
 357                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 358                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 359         }
 360
 361         // Import CSAR
 362
 363         // Service
 364         @Test // (enabled = false)
 365         public void getServiceAssetMetadataSuccess() throws Exception {
 366
 367                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 368
 369                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 370                                 service.getUUID());
 371                 BaseRestUtils.checkSuccess(assetResponse);
 372
 373                 ServiceDetailedAssetStructure serviceAssetMetadata = AssetRestUtils.getServiceAssetMetadata(assetResponse);
 374                 AssetRestUtils.serviceMetadataValidatior(serviceAssetMetadata, service, AssetTypeEnum.SERVICES);
 375
 376                 // Validate audit message
 377                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 378                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.SERVICES, service);
 379                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 380                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 381         }
 382
 383         @Test // (enabled = false)
 384         public void getServiceAssetMetadataWithResourceInstancesSuccess() throws Exception {
 385
 386                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 387                 Resource resourceVF = AtomicOperationUtils
 388                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 389                 resourceVF = (Resource) AtomicOperationUtils
 390                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 391
 392                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 393                 service = ResponseParser.parseToObjectUsingMapper(ServiceRestUtils
 394                                 .getService(service.getUniqueId(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)).getResponse(),
 395                                 Service.class);
 396
 397                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 398                                 service.getUUID());
 399                 BaseRestUtils.checkSuccess(assetResponse);
 400
 401                 ServiceDetailedAssetStructure serviceAssetMetadata = AssetRestUtils.getServiceAssetMetadata(assetResponse);
 402                 AssetRestUtils.serviceMetadataValidatior(serviceAssetMetadata, service, AssetTypeEnum.SERVICES);
 403
 404                 // Validate audit message
 405                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 406                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.SERVICES, service);
 407                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 408                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 409
 410         }
 411
 412         @Test // (enabled = false)
 413         public void getServiceAssetMetadataWithNonCertifiedResourceInstancesWithArtifactsSuccess() throws Exception {
 414
 415                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 416
 417                 Resource resourceVF = AtomicOperationUtils
 418                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 419                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.VENDOR_LICENSE, resourceVF, UserRoleEnum.DESIGNER,
 420                                 true, true);
 421                 resourceVF = (Resource) AtomicOperationUtils
 422                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 423
 424                 Resource resourceVF2 = AtomicOperationUtils
 425                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 426                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.APPC_CONFIG, resourceVF2, UserRoleEnum.DESIGNER,
 427                                 true, true);
 428                 resourceVF2 = (Resource) AtomicOperationUtils
 429                                 .changeComponentState(resourceVF2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 430
 431                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 432                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF2, service, UserRoleEnum.DESIGNER,
 433                                 true);
 434                 resourceVF = (Resource) AtomicOperationUtils
 435                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 436                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 437
 438                 // service with 0.1, 0.1 and 1.0 RIs versions
 439                 service = ResponseParser.parseToObjectUsingMapper(ServiceRestUtils
 440                                 .getService(service.getUniqueId(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)).getResponse(),
 441                                 Service.class);
 442
 443                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 444                                 service.getUUID());
 445                 BaseRestUtils.checkSuccess(assetResponse);
 446
 447                 ServiceDetailedAssetStructure serviceAssetMetadata = AssetRestUtils.getServiceAssetMetadata(assetResponse);
 448                 AssetRestUtils.serviceMetadataValidatior(serviceAssetMetadata, service, AssetTypeEnum.SERVICES);
 449
 450                 // Validate audit message
 451                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 452                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.SERVICES, service);
 453                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 454                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 455
 456         }
 457
 458         @Test  (enabled = false)
 459         public void getServiceAssetMetadataWithCertifiedResourceInstancesAndArtifactsOnRIsAndServiceSuccess()
 460                         throws Exception {
 461
 462                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 463
 464                 Resource resourceVF = AtomicOperationUtils
 465                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 466                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.VENDOR_LICENSE, resourceVF, UserRoleEnum.DESIGNER,
 467                                 true, true);
 468                 resourceVF = (Resource) AtomicOperationUtils
 469                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 470
 471                 Resource resourceVF2 = AtomicOperationUtils
 472                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 473                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.APPC_CONFIG, resourceVF2, UserRoleEnum.DESIGNER,
 474                                 true, true);
 475                 resourceVF2 = (Resource) AtomicOperationUtils
 476                                 .changeComponentState(resourceVF2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 477
 478                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 479                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF2, service, UserRoleEnum.DESIGNER,
 480                                 true);
 481                 resourceVF = (Resource) AtomicOperationUtils
 482                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 483                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.MODEL_INVENTORY_PROFILE, resourceVF,
 484                                 UserRoleEnum.DESIGNER, true, true);
 485                 resourceVF = (Resource) AtomicOperationUtils
 486                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 487                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 488
 489                 // service with resourceVF 1.0(1 art), 2.0(2 art) versions and
 490                 // resourceVF2 1.0(1 art), service 1 artifact version
 491                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.MODEL_INVENTORY_PROFILE, service,
 492                                 UserRoleEnum.DESIGNER, true, true);
 493                 service = ResponseParser.parseToObjectUsingMapper(ServiceRestUtils
 494                                 .getService(service.getUniqueId(), ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER)).getResponse(),
 495                                 Service.class);
 496
 497                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 498                                 service.getUUID());
 499                 BaseRestUtils.checkSuccess(assetResponse);
 500
 501                 ServiceDetailedAssetStructure serviceAssetMetadata = AssetRestUtils.getServiceAssetMetadata(assetResponse);
 502                 AssetRestUtils.serviceMetadataValidatior(serviceAssetMetadata, service, AssetTypeEnum.SERVICES);
 503
 504                 // Validate audit message
 505                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 506                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.SERVICES, service);
 507                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 508                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 509
 510         }
 511
 512         @Test // (enabled = false)
 513         public void getServiceAssetMetadataWithResourceInstancesServiceInSubmitForTestingSuccess() throws Exception {
 514
 515                 Service service = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 516
 517                 Resource resourceVF = AtomicOperationUtils
 518                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 519                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.VENDOR_LICENSE, resourceVF, UserRoleEnum.DESIGNER,
 520                                 true, true);
 521                 resourceVF = (Resource) AtomicOperationUtils
 522                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 523
 524                 Resource resourceVF2 = AtomicOperationUtils
 525                                 .createResourceByType(ResourceTypeEnum.VF, UserRoleEnum.DESIGNER, true).left().value();
 526                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.APPC_CONFIG, resourceVF2, UserRoleEnum.DESIGNER,
 527                                 true, true);
 528                 resourceVF = (Resource) AtomicOperationUtils
 529                                 .changeComponentState(resourceVF2, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 530
 531                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 532                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF2, service, UserRoleEnum.DESIGNER,
 533                                 true);
 534                 resourceVF = (Resource) AtomicOperationUtils
 535                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 536                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.MODEL_INVENTORY_PROFILE, resourceVF,
 537                                 UserRoleEnum.DESIGNER, true, true);
 538                 resourceVF = (Resource) AtomicOperationUtils
 539                                 .changeComponentState(resourceVF, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 540                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceVF, service, UserRoleEnum.DESIGNER, true);
 541
 542                 // service with resourceVF 1.0(1 art), 2.0(2 art) versions and
 543                 // resourceVF2 1.0(1 art), service 1 artifact version
 544                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.MODEL_INVENTORY_PROFILE, service,
 545                                 UserRoleEnum.DESIGNER, true, true);
 546                 service = (Service) AtomicOperationUtils
 547                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 548
 549                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 550                                 service.getUUID());
 551                 BaseRestUtils.checkSuccess(assetResponse);
 552
 553                 ServiceDetailedAssetStructure serviceAssetMetadata = AssetRestUtils.getServiceAssetMetadata(assetResponse);
 554                 AssetRestUtils.serviceMetadataValidatior(serviceAssetMetadata, service, AssetTypeEnum.SERVICES);
 555
 556                 // Validate audit message
 557                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 558                                 .getDefaultAssetMetadataAudit(AssetTypeEnum.SERVICES, service);
 559                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 560                                 AuditingActionEnum.GET_ASSET_METADATA.getName(), null);
 561         }
 562
 563         @Test // (enabled = false)
 564         public void getServiceAssetMetadataServiceNotFound() throws Exception {
 565
 566                 String serviceUuid = "notExistingServiceUuid";
 567                 RestResponse assetResponse = AssetRestUtils.getAssetMetadataByAssetTypeAndUuid(true, AssetTypeEnum.SERVICES,
 568                                 serviceUuid);
 569
 570                 // Validate audit message
 571                 ArrayList<String> variables = new ArrayList<>();
 572                 variables.add(serviceUuid);
 573                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), variables,
 574                                 assetResponse.getResponse());
 575         }
 576
 577         // Add to service VF instance imported from CSAR
 578
 579         @Test
 580         public void getFilteredResourceAssetSuccess() throws Exception {
 581
 582                 List<String> expectedAssetNamesList = new ArrayList<>();
 583
 584                 ResourceReqDetails resourceDetails = ElementFactory
 585                                 .getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_APP_SERVER);
 586                 resourceDetails.setName("ciResource1");
 587                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 588                 RestResponse createResource = ResourceRestUtils.createResource(resourceDetails,
 589                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 590                 BaseRestUtils.checkCreateResponse(createResource);
 591                 Resource resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 592                 expectedAssetNamesList.add(resource.getName());
 593
 594                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_BORDER);
 595                 resourceDetails.setName("ciResource2");
 596                 resourceDetails.setResourceType(ResourceTypeEnum.VFC.name());
 597                 createResource = ResourceRestUtils.createResource(resourceDetails,
 598                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 599                 BaseRestUtils.checkCreateResponse(createResource);
 600                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 601                 resource = (Resource) AtomicOperationUtils
 602                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 603                 resource = (Resource) AtomicOperationUtils
 604                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 605                 resource = (Resource) AtomicOperationUtils
 606                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 607                 resource = (Resource) AtomicOperationUtils
 608                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 609
 610                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.GENERIC_INFRASTRUCTURE);
 611                 resourceDetails.setName("ciResource3");
 612                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 613                 createResource = ResourceRestUtils.createResource(resourceDetails,
 614                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 615                 BaseRestUtils.checkCreateResponse(createResource);
 616                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 617                 resource = (Resource) AtomicOperationUtils
 618                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 619                 resource = (Resource) AtomicOperationUtils
 620                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 621                 resource = (Resource) AtomicOperationUtils
 622                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 623
 624                 resourceDetails = ElementFactory.getDefaultResource(ResourceCategoryEnum.APPLICATION_L4_FIREWALL);
 625                 resourceDetails.setName("ciResource4");
 626                 resourceDetails.setResourceType(ResourceTypeEnum.VF.name());
 627                 createResource = ResourceRestUtils.createResource(resourceDetails,
 628                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 629                 BaseRestUtils.checkCreateResponse(createResource);
 630                 resource = ResponseParser.parseToObjectUsingMapper(createResource.getResponse(), Resource.class);
 631                 resource = (Resource) AtomicOperationUtils
 632                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 633                 resource = (Resource) AtomicOperationUtils
 634                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 635                 resource = (Resource) AtomicOperationUtils
 636                                 .changeComponentState(resource, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 637                 expectedAssetNamesList.add(resource.getName());
 638
 639                 log.debug("4 resources created");
 640                 String query = "category=Application%20L4%2B";
 641                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
 642                 BaseRestUtils.checkSuccess(assetResponse);
 643
 644                 List<ResourceAssetStructure> resourceAssetList = AssetRestUtils.getResourceAssetList(assetResponse);
 645                 List<String> getActualAssetNamesList = AssetRestUtils.getResourceNamesList(resourceAssetList);
 646                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 647
 648                 AssetRestUtils.checkResourceTypeInObjectList(resourceAssetList, ResourceTypeEnum.VF);
 649
 650                 // Validate audit message
 651                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 652                                 .getDefaultFilteredAssetListAudit(AssetTypeEnum.RESOURCES, "?" + query);
 653                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 654                                 AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), null);
 655
 656         }
 657
 658         @Test
 659         public void getFilteredResourceAssetCategoryNotFound() throws Exception {
 660
 661                 String query = "category=Application%20L3%2B";
 662                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.RESOURCES, query);
 663                 BaseRestUtils.checkErrorResponse(assetResponse, ActionStatus.COMPONENT_CATEGORY_NOT_FOUND, "resource",
 664                                 "category", "Application L3+");
 665
 666                 // Validate audit message
 667                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 668                                 .getFilteredAssetListAuditCategoryNotFound(AssetTypeEnum.RESOURCES, "?" + query, "Application L3+");
 669                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 670                                 AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), null);
 671
 672         }
 673
 674         @Test
 675         public void getFilteredServiceAssetSuccess() throws Exception {
 676
 677                 List<String> expectedAssetNamesList = new ArrayList<>();
 678                 ArtifactReqDetails artifactDetails = ElementFactory.getArtifactByType(ArtifactTypeEnum.OTHER,
 679                                 ArtifactTypeEnum.OTHER, true);
 680
 681                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 682                 serviceDetails.setName("ciService1");
 683                 RestResponse createService = ServiceRestUtils.createService(serviceDetails,
 684                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 685                 BaseRestUtils.checkCreateResponse(createService);
 686                 Service service = ResponseParser.parseToObjectUsingMapper(createService.getResponse(), Service.class);
 687
 688                 serviceDetails.setName("ciService2");
 689                 createService = ServiceRestUtils.createService(serviceDetails,
 690                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 691                 BaseRestUtils.checkCreateResponse(createService);
 692                 service = ResponseParser.parseToObjectUsingMapper(createService.getResponse(), Service.class);
 693                 RestResponse addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(
 694                                 artifactDetails, ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 695                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 696                 service = (Service) AtomicOperationUtils
 697                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 698
 699                 ServiceReqDetails certifyService = new ServiceReqDetails(service);
 700                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(),
 701                                 ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null,
 702                                 DistributionStatusEnum.DISTRIBUTION_APPROVED);
 703                 AtomicOperationUtils.distributeService(service, false);
 704                 expectedAssetNamesList.add(service.getName());
 705
 706                 serviceDetails.setName("ciService3");
 707                 createService = ServiceRestUtils.createService(serviceDetails,
 708                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 709                 BaseRestUtils.checkCreateResponse(createService);
 710                 service = ResponseParser.parseToObjectUsingMapper(createService.getResponse(), Service.class);
 711                 addInformationalArtifactToService = ArtifactRestUtils.addInformationalArtifactToService(artifactDetails,
 712                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER), service.getUniqueId());
 713                 BaseRestUtils.checkSuccess(addInformationalArtifactToService);
 714                 service = (Service) AtomicOperationUtils
 715                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 716                 service = (Service) AtomicOperationUtils
 717                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 718                 service = (Service) AtomicOperationUtils
 719                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CERTIFY, true).getLeft();
 720                 certifyService = new ServiceReqDetails(service);
 721                 LifecycleRestUtils.changeDistributionStatus(certifyService, certifyService.getVersion(),
 722                                 ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR), null,
 723                                 DistributionStatusEnum.DISTRIBUTION_APPROVED);
 724                 AtomicOperationUtils.distributeService(service, false);
 725                 expectedAssetNamesList.add(service.getName());
 726
 727                 serviceDetails.setName("ciService4");
 728                 createService = ServiceRestUtils.createService(serviceDetails,
 729                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 730                 BaseRestUtils.checkCreateResponse(createService);
 731                 service = ResponseParser.parseToObjectUsingMapper(createService.getResponse(), Service.class);
 732                 service = (Service) AtomicOperationUtils
 733                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 734                 service = (Service) AtomicOperationUtils
 735                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 736                 service = (Service) AtomicOperationUtils
 737                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 738                 service = (Service) AtomicOperationUtils
 739                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 740                 service = (Service) AtomicOperationUtils
 741                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 742
 743                 serviceDetails.setName("ciService5");
 744                 createService = ServiceRestUtils.createService(serviceDetails,
 745                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
 746                 BaseRestUtils.checkCreateResponse(createService);
 747                 service = ResponseParser.parseToObjectUsingMapper(createService.getResponse(), Service.class);
 748                 service = (Service) AtomicOperationUtils
 749                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 750                 service = (Service) AtomicOperationUtils
 751                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 752                 service = (Service) AtomicOperationUtils
 753                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKIN, true).getLeft();
 754                 service = (Service) AtomicOperationUtils
 755                                 .changeComponentState(service, UserRoleEnum.DESIGNER, LifeCycleStatesEnum.CHECKOUT, true).getLeft();
 756
 757                 String query = "distributionStatus=Distributed";
 758                 RestResponse assetResponse = AssetRestUtils.getFilteredComponentList(AssetTypeEnum.SERVICES, query);
 759                 BaseRestUtils.checkSuccess(assetResponse);
 760
 761                 List<ServiceAssetStructure> resourceAssetList = AssetRestUtils.getServiceAssetList(assetResponse);
 762                 List<String> getActualAssetNamesList = AssetRestUtils.getServiceNamesList(resourceAssetList);
 763                 Utils.compareArrayLists(getActualAssetNamesList, expectedAssetNamesList, "Element");
 764
 765                 // Validate audit message
 766                 ExpectedExternalAudit expectedAssetListAudit = ElementFactory
 767                                 .getDefaultFilteredAssetListAudit(AssetTypeEnum.SERVICES, "?" + query);
 768                 AuditValidationUtils.validateExternalAudit(expectedAssetListAudit,
 769                                 AuditingActionEnum.GET_FILTERED_ASSET_LIST.getName(), null);
 770
 771         }
 772
 773 }