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