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