asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/service/ChangeServiceDistributionStatusApiTest.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.ci.tests.execute.service;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertNotNull;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.List;
  30
  31 import org.junit.Rule;
  32 import org.junit.rules.TestName;
  33 import org.openecomp.sdc.be.dao.api.ActionStatus;
  34 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  35 import org.openecomp.sdc.be.model.Component;
  36 import org.openecomp.sdc.be.model.DistributionStatusEnum;
  37 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  38 import org.openecomp.sdc.be.model.Service;
  39 import org.openecomp.sdc.be.model.User;
  40 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  41 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  42 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  43 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  44 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  45 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  47 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  48 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  49 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  50 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  51 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  52 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  53 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  55 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  56 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  57 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  58 import org.openecomp.sdc.ci.tests.utils.validation.ServiceValidationUtils;
  59 import org.testng.annotations.BeforeMethod;
  60 import org.testng.annotations.Test;
  61
  62 public class ChangeServiceDistributionStatusApiTest extends ComponentBaseTest {
  63
  64         protected ResourceReqDetails resourceDetails;
  65         protected ServiceReqDetails serviceDetails;
  66         protected User sdncDesignerDetails;
  67         protected User sdncAdminDetails;
  68         protected User sdncGovernorDeatails;
  69         protected User sdncTesterDetails;
  70         protected User sdncOpsDetails;
  71         protected ComponentInstanceReqDetails resourceInstanceReqDetails;
  72         protected Component resourceDetailsVFCcomp;
  73         protected Component serviceDetailsCompp;
  74
  75         private String userRemarks = "commentTest";
  76
  77         private List<String> variablesAsList;
  78
  79         @Rule
  80         public static TestName name = new TestName();
  81
  82         public ChangeServiceDistributionStatusApiTest() throws Exception {
  83                 super(name, ChangeServiceDistributionStatusApiTest.class.getName());
  84
  85         }
  86
  87         @BeforeMethod
  88         public void init() throws Exception {
  89
  90                 variablesAsList = new ArrayList<String>();
  91                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  92                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  93                 sdncGovernorDeatails = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  94                 sdncTesterDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  95                 sdncOpsDetails = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
  96                 resourceDetailsVFCcomp = AtomicOperationUtils
  97                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
  98                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.HEAT, resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
  99                                 true, true);
 100
 101                 AtomicOperationUtils.changeComponentState(resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
 102                                 LifeCycleStatesEnum.CERTIFY, true);
 103                 Service serviceServ = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 104                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceDetailsVFCcomp, serviceServ,
 105                                 UserRoleEnum.DESIGNER, true);
 106
 107                 serviceDetails = new ServiceReqDetails(serviceServ);
 108
 109         }
 110
 111         // -----------------------------------------------T E S T
 112         // S--------------------------------------------//
 113
 114         @Test
 115         public void approveNotCertifiedService_checkout() throws Exception {
 116                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 117                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 403, serviceDetails.getVersion());
 118
 119                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 120                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 121                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 122
 123                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 124                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 125
 126                 validateAudit("DApprove", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
 127                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 128                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 129         }
 130
 131         @Test
 132         public void approveNotCertifiedService_checkedin() throws Exception {
 133                 RestResponse checkinResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 134                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 135                 assertEquals(200, checkinResp.getErrorCode().intValue());
 136
 137                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 138                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 403, serviceDetails.getVersion());
 139
 140                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 141                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 142                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 143
 144                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 145                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 146
 147                 validateAudit("DApprove", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN,
 148                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 149                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 150         }
 151
 152         @Test
 153         public void approveNotCertifiedService_inProgress() throws Exception {
 154                 RestResponse certReqResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 155                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 156                 assertEquals(200, certReqResp.getErrorCode().intValue());
 157
 158                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 159                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 403, serviceDetails.getVersion());
 160
 161                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 162                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 163                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 164
 165                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 166                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 167
 168                 // ErrorInfo errorInfo =
 169                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 170                 // String auditAction="DApprove";
 171                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 172                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 173                 // version, sdncAdminDetails);
 174                 // expectedResourceAuditJavaObject.setAction(auditAction);
 175                 // expectedResourceAuditJavaObject.setResourceType("Service");
 176                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.READY_FOR_CERTIFICATION.name());
 177                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 178                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 179                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 180                 // expectedResourceAuditJavaObject.setStatus("403");
 181                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 182                 // + ": " + errorInfo.getMessage(), version,
 183                 // serviceDetails.getServiceName()));
 184                 //
 185                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 186                 // auditAction);
 187
 188                 validateAudit("DApprove", LifecycleStateEnum.READY_FOR_CERTIFICATION,
 189                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 190                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 191
 192         }
 193
 194         @Test
 195         public void approveNotCertifiedService_readyForCer() throws Exception {
 196                 approveNotCertifiedService_inProgress();
 197                 DbUtils.deleteFromEsDbByPattern("_all");
 198
 199                 RestResponse startCertResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails,
 200                                 serviceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 201                 assertEquals(200, startCertResp.getErrorCode().intValue());
 202
 203                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 204                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 403, serviceDetails.getVersion());
 205
 206                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 207                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 208                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 209
 210                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 211                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 212
 213                 // ErrorInfo errorInfo =
 214                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 215                 // String auditAction="DApprove";
 216                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 217                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 218                 // version, sdncAdminDetails);
 219                 // expectedResourceAuditJavaObject.setAction(auditAction);
 220                 // expectedResourceAuditJavaObject.setResourceType("Service");
 221                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 222                 // expectedResourceAuditJavaObject.setPrevState("");
 223                 // expectedResourceAuditJavaObject.setDprevStatus("");
 224                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 225                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 226                 // expectedResourceAuditJavaObject.setStatus("403");
 227                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 228                 // + ": " + errorInfo.getMessage(), version,
 229                 // serviceDetails.getServiceName()));
 230                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 231                 //
 232                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 233                 // auditAction);
 234
 235                 validateAudit("DApprove", LifecycleStateEnum.CERTIFICATION_IN_PROGRESS,
 236                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 237                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 238         }
 239
 240         @Test
 241         public void rejectNotCertifiedService_checkeout() throws Exception {
 242                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 243                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 403, serviceDetails.getVersion());
 244
 245                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 246                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 247                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 248
 249                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 250                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 251
 252                 // ErrorInfo errorInfo =
 253                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 254                 // String auditAction="DReject";
 255                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 256                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 257                 // version, sdncAdminDetails);
 258                 // expectedResourceAuditJavaObject.setAction(auditAction);
 259                 // expectedResourceAuditJavaObject.setResourceType("Service");
 260                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 261                 // expectedResourceAuditJavaObject.setPrevState("");
 262                 // expectedResourceAuditJavaObject.setDprevStatus("");
 263                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 264                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 265                 // expectedResourceAuditJavaObject.setStatus("403");
 266                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 267                 // + ": " + errorInfo.getMessage(), version,
 268                 // serviceDetails.getServiceName()));
 269                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 270                 //
 271                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 272                 // auditAction);
 273
 274                 validateAudit("DReject", LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT,
 275                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 276                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 277         }
 278
 279         @Test
 280         public void rejectNotCertifiedService_checkedin() throws Exception {
 281                 RestResponse startCertResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails,
 282                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
 283                 assertEquals(200, startCertResp.getErrorCode().intValue());
 284
 285                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 286                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 403, serviceDetails.getVersion());
 287
 288                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 289                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 290                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 291
 292                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 293                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 294
 295                 // ErrorInfo errorInfo =
 296                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 297                 // String auditAction="DReject";
 298                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 299                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 300                 // version, sdncAdminDetails);
 301                 // expectedResourceAuditJavaObject.setAction(auditAction);
 302                 // expectedResourceAuditJavaObject.setResourceType("Service");
 303                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN.name());
 304                 // expectedResourceAuditJavaObject.setPrevState("");
 305                 // expectedResourceAuditJavaObject.setDprevStatus("");
 306                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 307                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 308                 // expectedResourceAuditJavaObject.setStatus("403");
 309                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 310                 // + ": " + errorInfo.getMessage(), version,
 311                 // serviceDetails.getServiceName()));
 312                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 313                 //
 314                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 315                 // auditAction);
 316
 317                 validateAudit("DReject", LifecycleStateEnum.NOT_CERTIFIED_CHECKIN,
 318                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 319                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 320         }
 321
 322         @Test
 323         public void rejectNotCertifiedService_inProgress() throws Exception {
 324                 RestResponse startCertResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails,
 325                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 326                 assertEquals(200, startCertResp.getErrorCode().intValue());
 327
 328                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 329                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 403, serviceDetails.getVersion());
 330
 331                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 332                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 333                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 334
 335                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 336                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 337
 338                 // ErrorInfo errorInfo =
 339                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 340                 // String auditAction="DReject";
 341                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 342                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 343                 // version, sdncAdminDetails);
 344                 // expectedResourceAuditJavaObject.setAction(auditAction);
 345                 // expectedResourceAuditJavaObject.setResourceType("Service");
 346                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.READY_FOR_CERTIFICATION.name());
 347                 // expectedResourceAuditJavaObject.setPrevState("");
 348                 // expectedResourceAuditJavaObject.setDprevStatus("");
 349                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 350                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 351                 // expectedResourceAuditJavaObject.setStatus("403");
 352                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 353                 // + ": " + errorInfo.getMessage(), version,
 354                 // serviceDetails.getServiceName()));
 355                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 356                 //
 357                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 358                 // auditAction);
 359
 360                 validateAudit("DReject", LifecycleStateEnum.READY_FOR_CERTIFICATION,
 361                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 362                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 363         }
 364
 365         @Test
 366         public void rejectNotCertifiedService_readyForCer() throws Exception {
 367                 rejectNotCertifiedService_inProgress();
 368                 DbUtils.deleteFromEsDbByPattern("_all");
 369
 370                 RestResponse startCertResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncAdminDetails,
 371                                 serviceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
 372                 assertEquals(200, startCertResp.getErrorCode().intValue());
 373
 374                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 375                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 403, serviceDetails.getVersion());
 376
 377                 variablesAsList = Arrays.asList(serviceDetails.getVersion(), serviceDetails.getName());
 378                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name(),
 379                                 variablesAsList, changeDistStatusAndValidate.getResponse());
 380
 381                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 382                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 383
 384                 // ErrorInfo errorInfo =
 385                 // utils.parseYaml(ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION.name());
 386                 // String auditAction="DReject";
 387                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 388                 // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
 389                 // version, sdncAdminDetails);
 390                 // expectedResourceAuditJavaObject.setAction(auditAction);
 391                 // expectedResourceAuditJavaObject.setResourceType("Service");
 392                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 393                 // expectedResourceAuditJavaObject.setPrevState("");
 394                 // expectedResourceAuditJavaObject.setDprevStatus("");
 395                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 396                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 397                 // expectedResourceAuditJavaObject.setStatus("403");
 398                 // expectedResourceAuditJavaObject.setDesc(String.format(errorInfo.getMessageId()
 399                 // + ": " + errorInfo.getMessage(), version,
 400                 // serviceDetails.getServiceName()));
 401                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 402                 //
 403                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 404                 // auditAction);
 405
 406                 validateAudit("DReject", LifecycleStateEnum.CERTIFICATION_IN_PROGRESS,
 407                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 408                                 "403", ActionStatus.SERVICE_NOT_AVAILABLE_FOR_DISTRIBUTION, sdncAdminDetails);
 409
 410         }
 411
 412         @Test
 413         public void approveCertifiedService_bysdncGovernorDeatails() throws Exception {
 414
 415                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 416                 Service certifyServiceServ = ResponseParser
 417                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 418                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 419                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 420                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncGovernorDeatails, 200, certifyService.getVersion());
 421                 getDistrubtionStatusValue(changeDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 422
 423                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 424                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 425
 426                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 427                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, null, null, sdncGovernorDeatails);
 428         }
 429
 430         @Test
 431         public void approveCertifiedService_bysdncAdminDetails() throws Exception {
 432                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 433                 Service certifyServiceServ = ResponseParser
 434                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 435                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 436
 437                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 438                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 200, certifyService.getVersion());
 439                 getDistrubtionStatusValue(changeDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 440
 441                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 442                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 443
 444                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 445                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, null, null, sdncAdminDetails);
 446         }
 447
 448         @Test
 449         public void approveCertifiedService_byDesigner() throws Exception {
 450                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 451                 Service certifyServiceServ = ResponseParser
 452                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 453                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 454
 455                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 456                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncDesignerDetails, 409, certifyService.getVersion());
 457                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 458                                 changeDistStatusAndValidate.getResponse());
 459
 460                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 461                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 462
 463                 // ErrorInfo errorInfo =
 464                 // utils.parseYaml(ActionStatus.RESTRICTED_OPERATION.name());
 465                 // String auditAction="DApprove";
 466                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 467                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 468                 // certifyService.getVersion(), sdncDesignerDetails);
 469                 // expectedResourceAuditJavaObject.setAction(auditAction);
 470                 // expectedResourceAuditJavaObject.setResourceType("Service");
 471                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 472                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 473                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 474                 // expectedResourceAuditJavaObject.setStatus("409");
 475                 // expectedResourceAuditJavaObject.setDesc(errorInfo.getMessageId() + ":
 476                 // " + errorInfo.getMessage());
 477                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 478                 //
 479                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 480                 // auditAction);
 481
 482                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 483                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 484                                 sdncDesignerDetails);
 485         }
 486
 487         @Test
 488         public void approveCertifiedService_byTester() throws Exception {
 489                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 490                 Service certifyServiceServ = ResponseParser
 491                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 492                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 493                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 494                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncTesterDetails, 409, certifyService.getVersion());
 495                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 496                                 changeDistStatusAndValidate.getResponse());
 497
 498                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 499                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 500
 501                 // ErrorInfo errorInfo =
 502                 // utils.parseYaml(ActionStatus.RESTRICTED_OPERATION.name());
 503                 // String auditAction="DApprove";
 504                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 505                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 506                 // certifyService.getVersion(), sdncTesterDetails);
 507                 // expectedResourceAuditJavaObject.setAction(auditAction);
 508                 // expectedResourceAuditJavaObject.setResourceType("Service");
 509                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 510                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 511                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 512                 // expectedResourceAuditJavaObject.setStatus("409");
 513                 // expectedResourceAuditJavaObject.setDesc(errorInfo.getMessageId() + ":
 514                 // " + errorInfo.getMessage());
 515                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 516                 //
 517                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 518                 // auditAction);
 519
 520                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 521                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 522                                 sdncTesterDetails);
 523         }
 524
 525         @Test
 526         public void approveCertifiedService_byOps() throws Exception {
 527                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 528                 Service certifyServiceServ = ResponseParser
 529                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 530                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 531                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 532                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncOpsDetails, 409, certifyService.getVersion());
 533                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 534                                 changeDistStatusAndValidate.getResponse());
 535
 536                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 537                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 538
 539                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 540                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 541                                 sdncOpsDetails);
 542
 543         }
 544
 545         @Test
 546         public void rejectCertifiedService_bysdncGovernorDeatails() throws Exception {
 547                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 548                 Service certifyServiceServ = ResponseParser
 549                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 550                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 551                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 552                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncGovernorDeatails, 200, certifyService.getVersion());
 553                 getDistrubtionStatusValue(changeDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_REJECTED);
 554
 555                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 556                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_REJECTED);
 557
 558                 // String auditAction="DReject";
 559                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 560                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 561                 // certifyService.getVersion(), sdncGovernorDeatails);
 562                 // expectedResourceAuditJavaObject.setAction(auditAction);
 563                 // expectedResourceAuditJavaObject.setResourceType("Service");
 564                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 565                 // expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 566                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 567                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_REJECTED.name());
 568                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 569                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 570                 //
 571                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 572                 // auditAction);
 573
 574                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 575                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, null, null, sdncGovernorDeatails);
 576
 577         }
 578
 579         @Test
 580         public void rejectCertifiedService_bysdncAdminDetails() throws Exception {
 581                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 582                 Service certifyServiceServ = ResponseParser
 583                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 584                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 585                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 586                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 200, certifyService.getVersion());
 587                 getDistrubtionStatusValue(changeDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_REJECTED);
 588
 589                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 590                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_REJECTED);
 591
 592                 // String auditAction="DReject";
 593                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 594                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 595                 // certifyService.getVersion(), sdncAdminDetails);
 596                 // expectedResourceAuditJavaObject.setAction(auditAction);
 597                 // expectedResourceAuditJavaObject.setResourceType("Service");
 598                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 599                 // expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 600                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 601                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_REJECTED.name());
 602                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 603                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 604                 //
 605                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 606                 // auditAction);
 607
 608                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 609                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, null, null, sdncAdminDetails);
 610         }
 611
 612         @Test
 613         public void rejectCertifiedService_byDesigner() throws Exception {
 614                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 615                 Service certifyServiceServ = ResponseParser
 616                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 617                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 618                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 619                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncDesignerDetails, 409, certifyService.getVersion());
 620                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 621                                 changeDistStatusAndValidate.getResponse());
 622
 623                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 624                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 625
 626                 // ErrorInfo errorInfo =
 627                 // utils.parseYaml(ActionStatus.RESTRICTED_OPERATION.name());
 628                 // String auditAction="DReject";
 629                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 630                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 631                 // certifyService.getVersion(), sdncDesignerDetails);
 632                 // expectedResourceAuditJavaObject.setAction(auditAction);
 633                 // expectedResourceAuditJavaObject.setResourceType("Service");
 634                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 635                 // expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 636                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 637                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 638                 // expectedResourceAuditJavaObject.setStatus("409");
 639                 // expectedResourceAuditJavaObject.setDesc(errorInfo.getMessageId() + ":
 640                 // " + errorInfo.getMessage());
 641                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 642                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 643                 //
 644                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 645                 // auditAction);
 646
 647                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 648                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 649                                 sdncDesignerDetails);
 650         }
 651
 652         @Test
 653         public void rejectCertifiedService_byTester() throws Exception {
 654                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 655                 Service certifyServiceServ = ResponseParser
 656                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 657                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 658                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 659                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncTesterDetails, 409, certifyService.getVersion());
 660                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 661                                 changeDistStatusAndValidate.getResponse());
 662
 663                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 664                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 665
 666                 // ErrorInfo errorInfo =
 667                 // utils.parseYaml(ActionStatus.RESTRICTED_OPERATION.name());
 668                 // String auditAction="DReject";
 669                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 670                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 671                 // certifyService.getVersion(), sdncTesterDetails);
 672                 // expectedResourceAuditJavaObject.setAction(auditAction);
 673                 // expectedResourceAuditJavaObject.setResourceType("Service");
 674                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 675                 // expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 676                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 677                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 678                 // expectedResourceAuditJavaObject.setStatus("409");
 679                 // expectedResourceAuditJavaObject.setDesc(errorInfo.getMessageId() + ":
 680                 // " + errorInfo.getMessage());
 681                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 682                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 683                 //
 684                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 685                 // auditAction);
 686
 687                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 688                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 689                                 sdncTesterDetails);
 690         }
 691
 692         @Test
 693         public void rejectCertifiedService_byOps() throws Exception {
 694                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 695                 Service certifyServiceServ = ResponseParser
 696                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 697                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 698                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 699                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncOpsDetails, 409, certifyService.getVersion());
 700                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), new ArrayList<String>(),
 701                                 changeDistStatusAndValidate.getResponse());
 702
 703                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 704                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 705
 706                 // ErrorInfo errorInfo =
 707                 // utils.parseYaml(ActionStatus.RESTRICTED_OPERATION.name());
 708                 // String auditAction="DReject";
 709                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 710                 // ServiceValidationUtils.constructFieldsForAuditValidation(certifyService,
 711                 // certifyService.getVersion(), sdncOpsDetails);
 712                 // expectedResourceAuditJavaObject.setAction(auditAction);
 713                 // expectedResourceAuditJavaObject.setResourceType("Service");
 714                 // expectedResourceAuditJavaObject.setCurrState(LifecycleStateEnum.CERTIFIED.name());
 715                 // expectedResourceAuditJavaObject.setPrevState(LifecycleStateEnum.CERTIFICATION_IN_PROGRESS.name());
 716                 // expectedResourceAuditJavaObject.setDprevStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 717                 // expectedResourceAuditJavaObject.setDcurrStatus(DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED.name());
 718                 // expectedResourceAuditJavaObject.setStatus("409");
 719                 // expectedResourceAuditJavaObject.setDesc(errorInfo.getMessageId() + ":
 720                 // " + errorInfo.getMessage());
 721                 // expectedResourceAuditJavaObject.setComment(userRemarks);
 722                 // expectedResourceAuditJavaObject.setPrevVersion("0.1");
 723                 //
 724                 // AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject,
 725                 // auditAction);
 726
 727                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED,
 728                                 DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED, "409", ActionStatus.RESTRICTED_OPERATION,
 729                                 sdncOpsDetails);
 730         }
 731
 732         @Test
 733         public void approveServiceNotFound() throws Exception {
 734                 String previuosId = serviceDetails.getUniqueId();
 735                 serviceDetails.setUniqueId("dummyId");
 736
 737                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 738                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 404, serviceDetails.getVersion());
 739                 serviceDetails.setUniqueId(previuosId);
 740
 741                 variablesAsList = Arrays.asList("dummyId");
 742                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), variablesAsList,
 743                                 changeDistStatusAndValidate.getResponse());
 744
 745         }
 746
 747         @Test
 748         public void rejectServiceNotFound() throws Exception {
 749                 String previuosId = serviceDetails.getUniqueId();
 750                 serviceDetails.setUniqueId("dummyId");
 751
 752                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 753                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 404, serviceDetails.getVersion());
 754                 serviceDetails.setUniqueId(previuosId);
 755
 756                 variablesAsList = Arrays.asList("dummyId");
 757                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_NOT_FOUND.name(), variablesAsList,
 758                                 changeDistStatusAndValidate.getResponse());
 759
 760         }
 761
 762         @Test
 763         public void rejectService_emptyComment() throws Exception {
 764                 userRemarks = "";
 765
 766                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 767                 Service certifyServiceServ = ResponseParser
 768                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 769                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 770                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 771                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 400, certifyService.getVersion());
 772                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 773                                 changeDistStatusAndValidate.getResponse());
 774
 775                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 776                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 777
 778         }
 779
 780         @Test
 781         public void rejectService_nullComment() throws Exception {
 782                 userRemarks = null;
 783
 784                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 785                 Service certifyServiceServ = ResponseParser
 786                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 787                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 788                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 789                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 400, certifyService.getVersion());
 790                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 791                                 changeDistStatusAndValidate.getResponse());
 792
 793                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 794                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 795         }
 796
 797         @Test
 798         public void rejectService_spaceComment() throws Exception {
 799                 userRemarks = " ";
 800
 801                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 802                 Service certifyServiceServ = ResponseParser
 803                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 804                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 805                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 806                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncAdminDetails, 400, certifyService.getVersion());
 807                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 808                                 changeDistStatusAndValidate.getResponse());
 809
 810                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 811                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 812
 813         }
 814
 815         @Test
 816         public void approveService_emptyComment() throws Exception {
 817                 userRemarks = "";
 818
 819                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 820                 Service certifyServiceServ = ResponseParser
 821                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 822                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 823                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 824                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 400, certifyService.getVersion());
 825                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 826                                 changeDistStatusAndValidate.getResponse());
 827
 828                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 829                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 830
 831         }
 832
 833         @Test
 834         public void approveService_nullComment() throws Exception {
 835                 userRemarks = null;
 836
 837                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 838                 Service certifyServiceServ = ResponseParser
 839                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 840                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 841                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 842                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 400, certifyService.getVersion());
 843                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 844                                 changeDistStatusAndValidate.getResponse());
 845
 846                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 847                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 848
 849         }
 850
 851         @Test
 852         public void approveService_spaceComment() throws Exception {
 853                 userRemarks = " ";
 854
 855                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 856                 Service certifyServiceServ = ResponseParser
 857                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 858                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 859                 RestResponse changeDistStatusAndValidate = changeDistStatusAndValidate(
 860                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 400, certifyService.getVersion());
 861                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_CONTENT.name(), new ArrayList<String>(),
 862                                 changeDistStatusAndValidate.getResponse());
 863
 864                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 865                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTION_NOT_APPROVED);
 866
 867         }
 868
 869         @Test
 870         public void distributionStatusChange_approve_Reject_AprroveBysdncAdminDetails() throws Exception {
 871                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 872                 Service certifyServiceServ = ResponseParser
 873                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 874                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 875
 876                 RestResponse approveDistStatusAndValidate = changeDistStatusAndValidate(
 877                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncGovernorDeatails, 200, certifyService.getVersion());
 878                 getDistrubtionStatusValue(approveDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 879
 880                 DbUtils.deleteFromEsDbByPattern("_all");
 881                 RestResponse rejectDistStatusAndValidate = changeDistStatusAndValidate(
 882                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, sdncGovernorDeatails, 200, certifyService.getVersion());
 883                 getDistrubtionStatusValue(rejectDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_REJECTED);
 884
 885                 validateAudit("DReject", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_APPROVED,
 886                                 DistributionStatusEnum.DISTRIBUTION_REJECTED, null, null, sdncGovernorDeatails);
 887
 888                 DbUtils.deleteFromEsDbByPattern("_all");
 889                 RestResponse secondApproveDistStatusAndValidate = changeDistStatusAndValidate(
 890                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncAdminDetails, 200, certifyService.getVersion());
 891                 getDistrubtionStatusValue(secondApproveDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 892
 893                 validateAudit("DApprove", LifecycleStateEnum.CERTIFIED, DistributionStatusEnum.DISTRIBUTION_REJECTED,
 894                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, null, null, sdncAdminDetails);
 895
 896         }
 897
 898         @Test
 899         public void distributeNotCertifiedServiceTest() throws Exception {
 900                 RestResponse approveDistStatusAndValidate = changeDistStatusAndValidate(DistributionStatusEnum.DISTRIBUTED,
 901                                 sdncGovernorDeatails, 200, serviceDetails.getVersion());
 902
 903                 RestResponse getService = ServiceRestUtils.getService(serviceDetails, sdncDesignerDetails);
 904                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTED);
 905
 906         }
 907
 908         @Test
 909         public void distributeCertifiedServiceTest() throws Exception {
 910                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 911                 Service certifyServiceServ = ResponseParser
 912                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 913                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 914                 RestResponse approveDistStatusAndValidate = changeDistStatusAndValidate(DistributionStatusEnum.DISTRIBUTED,
 915                                 sdncGovernorDeatails, 200, certifyService.getVersion());
 916
 917                 RestResponse getService = ServiceRestUtils.getService(certifyService, sdncDesignerDetails);
 918                 getDistrubtionStatusValue(getService, DistributionStatusEnum.DISTRIBUTED);
 919
 920         }
 921
 922         @Test
 923         public void approveCheckedoutCertifiedServiceTest() throws Exception {
 924                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 925                 Service certifyServiceServ = ResponseParser
 926                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 927                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 928                 RestResponse approveDistStatusAndValidate = changeDistStatusAndValidate(
 929                                 DistributionStatusEnum.DISTRIBUTION_APPROVED, sdncGovernorDeatails, 200, certifyService.getVersion());
 930                 getDistrubtionStatusValue(approveDistStatusAndValidate, DistributionStatusEnum.DISTRIBUTION_APPROVED);
 931
 932                 RestResponse checkoutResp = LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails,
 933                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
 934                 assertEquals(200, checkoutResp.getErrorCode().intValue());
 935                 // Utils r = new Utils();
 936
 937                 String distributionStatus = ResponseParser.getValueFromJsonResponse(checkoutResp.getResponse(),
 938                                 "distributionStatus");
 939                 // Utils r1 = new Utils();
 940                 String lifecycleState = ResponseParser.getValueFromJsonResponse(checkoutResp.getResponse(), "lifecycleState");
 941
 942                 assertTrue("NOT_CERTIFIED_CHECKOUT".equals(lifecycleState));
 943                 assertTrue("DISTRIBUTION_NOT_APPROVED".equals(distributionStatus));
 944         }
 945
 946         private RestResponse changeDistStatusAndValidate(DistributionStatusEnum distStatus, User user, int errorCode,
 947                         String serviceVersion) throws Exception {
 948                 RestResponse distributionResponse = LifecycleRestUtils.changeDistributionStatus(serviceDetails, serviceVersion,
 949                                 user, userRemarks, distStatus);
 950                 assertNotNull(distributionResponse);
 951                 assertNotNull(distributionResponse.getErrorCode());
 952                 assertEquals(errorCode, distributionResponse.getErrorCode().intValue());
 953
 954                 if (userRemarks == " " || userRemarks == null) {
 955                         userRemarks = "";
 956                 }
 957
 958                 return distributionResponse;
 959         }
 960
 961         private void getDistrubtionStatusValue(RestResponse response, DistributionStatusEnum expectedDistributionValue)
 962                         throws Exception {
 963                 String actualDistributionValue = ResponseParser.getValueFromJsonResponse(response.getResponse(),
 964                                 "distributionStatus");
 965                 assertEquals(expectedDistributionValue.name(), actualDistributionValue);
 966         }
 967
 968         private void validateAudit(String Action, LifecycleStateEnum currState, DistributionStatusEnum dPrevStatus,
 969                         DistributionStatusEnum dCurrStatus, String status, ActionStatus errorInfoFromFile, User user)
 970                         throws Exception {
 971
 972                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 973                                 .constructFieldsForAuditValidation(serviceDetails, serviceDetails.getVersion(), user);
 974                 expectedResourceAuditJavaObject.setAction(Action);
 975                 expectedResourceAuditJavaObject.setResourceType("Service");
 976                 expectedResourceAuditJavaObject.setCurrState(currState.name());
 977                 expectedResourceAuditJavaObject.setDprevStatus(dPrevStatus.name());
 978                 expectedResourceAuditJavaObject.setDcurrStatus(dCurrStatus.name());
 979                 expectedResourceAuditJavaObject.setComment(userRemarks);
 980                 expectedResourceAuditJavaObject.setDesc("OK");
 981
 982                 if (errorInfoFromFile != null) {
 983                         ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(errorInfoFromFile.name());
 984                         expectedResourceAuditJavaObject
 985                                         .setDesc(AuditValidationUtils.buildAuditDescription(errorInfo, variablesAsList));
 986                 }
 987
 988                 if (status != null)
 989                         expectedResourceAuditJavaObject.setStatus(status);
 990
 991                 if (currState != LifecycleStateEnum.CERTIFIED) {
 992                         expectedResourceAuditJavaObject.setModifierName("");
 993                 }
 994
 995                 AuditValidationUtils.validateAuditDistribution(expectedResourceAuditJavaObject, Action);
 996         }
 997
 998         // private ServiceReqDetails certifyService() throws Exception
 999         // {
1000         // ServiceReqDetails certifyService =
1001         // LifecycleRestUtils.certifyService(serviceDetails,
1002         // serviceDetails.getVersion(), sdncAdminDetails);
1003         //// version = certifyService.getVersion();
1004         //
1005         // return certifyService;
1006         // }
1007
1008 }