asdc-tests/src/main/java/org/openecomp/sdc/ci/tests/execute/service/UpdateServiceMetadataTest.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
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.List;
  29
  30 import org.apache.commons.lang3.StringUtils;
  31 import org.codehaus.jettison.json.JSONException;
  32 import org.junit.Rule;
  33 import org.junit.rules.TestName;
  34 import org.openecomp.sdc.be.dao.api.ActionStatus;
  35 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  36 import org.openecomp.sdc.be.model.Component;
  37 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  38 import org.openecomp.sdc.be.model.Service;
  39 import org.openecomp.sdc.be.model.User;
  40 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  41 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  42 import org.openecomp.sdc.ci.tests.api.Urls;
  43 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  44 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  45 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  46 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  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.http.RestResponse;
  51 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  52 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  53 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  54 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  55 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  56 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  57 import org.openecomp.sdc.ci.tests.utils.validation.ServiceValidationUtils;
  58 import org.testng.AssertJUnit;
  59 import org.testng.annotations.BeforeMethod;
  60 import org.testng.annotations.Test;
  61
  62 public class UpdateServiceMetadataTest extends ComponentBaseTest {
  63
  64         protected ArrayList<String> listForMessage = new ArrayList<String>();
  65
  66         protected ResourceReqDetails resourceDetails;
  67         protected ServiceReqDetails serviceDetails;
  68         protected User sdncDesignerDetails;
  69         protected User sdncDesignerDetails2;
  70         protected User sdncAdminDetails;
  71         protected User sdncGovernorDeatails;
  72         protected User sdncTesterDetails;
  73         protected User sdncOpsDetails;
  74         protected ComponentInstanceReqDetails resourceInstanceReqDetails;
  75         protected Component resourceDetailsVFCcomp;
  76         protected Component serviceDetailsCompp;
  77
  78         @Rule
  79         public static TestName name = new TestName();
  80         protected ServiceReqDetails updatedServiceDetails;
  81
  82         public UpdateServiceMetadataTest() {
  83                 super(name, UpdateServiceMetadataTest.class.getName());
  84         }
  85
  86         @BeforeMethod
  87         public void setUp() throws Exception {
  88
  89                 sdncDesignerDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
  90                 sdncDesignerDetails2 = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER2);
  91                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  92                 sdncAdminDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN4);
  93                 sdncGovernorDeatails = ElementFactory.getDefaultUser(UserRoleEnum.GOVERNOR);
  94                 sdncTesterDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
  95                 sdncOpsDetails = ElementFactory.getDefaultUser(UserRoleEnum.OPS);
  96                 resourceDetailsVFCcomp = AtomicOperationUtils
  97                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
  98                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.HEAT, resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
  99                                 true, true);
 100
 101                 AtomicOperationUtils.changeComponentState(resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
 102                                 LifeCycleStatesEnum.CERTIFY, true);
 103                 Service serviceServ = AtomicOperationUtils.createDefaultService(UserRoleEnum.DESIGNER, true).left().value();
 104                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceDetailsVFCcomp, serviceServ,
 105                                 UserRoleEnum.DESIGNER, true);
 106
 107                 serviceDetails = new ServiceReqDetails(serviceServ);
 108                 updatedServiceDetails = updatedServiceDetails(serviceDetails);
 109
 110         }
 111
 112         protected void certifyService(ServiceReqDetails serviceDetails, String version) throws Exception {
 113                 LifecycleRestUtils.certifyService(serviceDetails);
 114         }
 115
 116         protected ServiceReqDetails updatedServiceDetails(ServiceReqDetails service) {
 117                 ServiceReqDetails updatedServiceDetails = new ServiceReqDetails(service);
 118
 119                 updatedServiceDetails.setDescription("updatedDescription");
 120                 updatedServiceDetails.setName(service.getName());
 121                 updatedServiceDetails.setProjectCode("987654654");
 122                 updatedServiceDetails.setIcon("icon-service-red3");
 123                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("updateTag", updatedServiceDetails.getName())));
 124                 updatedServiceDetails.removeAllCategories();
 125                 updatedServiceDetails.setCategories(null);
 126                 updatedServiceDetails.addCategory(ServiceCategoriesEnum.VOIP.getValue());
 127                 updatedServiceDetails.setContactId("xy0123");
 128
 129                 return updatedServiceDetails;
 130         }
 131
 132         protected void addMandatoryArtifactsToService() throws Exception {
 133                 // TODO Andrey US575052
 134                 // ServiceRestUtils.addServiceMandatoryArtifacts(sdncDesignerDetails,
 135                 // createServiceResponse);
 136         }
 137
 138         protected void getServiceAndValidate(ServiceReqDetails excpectedService, User creator, User updater,
 139                         LifecycleStateEnum lifeCycleState) throws Exception {
 140                 RestResponse getServiceResponse = ServiceRestUtils.getService(excpectedService.getUniqueId(),
 141                                 sdncDesignerDetails);
 142                 AssertJUnit.assertNotNull("check response object is not null after updating service", getServiceResponse);
 143                 AssertJUnit.assertNotNull("check if error code exists in response after updating service",
 144                                 getServiceResponse.getErrorCode());
 145                 AssertJUnit.assertEquals("Check response code after updating service", 200,
 146                                 getServiceResponse.getErrorCode().intValue());
 147                 Service actualService = ResponseParser.convertServiceResponseToJavaObject(getServiceResponse.getResponse());
 148                 ServiceValidationUtils.validateServiceResponseMetaData(excpectedService, actualService, creator, updater,
 149                                 lifeCycleState);
 150         }
 151
 152         public void getServiceAndValidate(ServiceReqDetails excpectedService, LifecycleStateEnum lifecycleState)
 153                         throws Exception {
 154                 getServiceAndValidate(excpectedService, sdncDesignerDetails, sdncDesignerDetails, lifecycleState);
 155         }
 156
 157         protected void validateResponse(RestResponse response, int errorCode, ActionStatus actionResponse,
 158                         List<String> listOfVariables) throws Exception {
 159                 AssertJUnit.assertNotNull("check response object is not null after updating service", response);
 160                 AssertJUnit.assertNotNull("check if error code exists in response after updating service",
 161                                 response.getErrorCode());
 162                 AssertJUnit.assertEquals("Check response code after updating service", errorCode,
 163                                 response.getErrorCode().intValue());
 164
 165                 if (actionResponse != null) {
 166                         ErrorValidationUtils.checkBodyResponseOnError(actionResponse.name(), listOfVariables,
 167                                         response.getResponse());
 168                         return;
 169                 }
 170
 171                 Service actualService = ResponseParser.convertServiceResponseToJavaObject(response.getResponse());
 172                 ServiceValidationUtils.validateServiceResponseMetaData(updatedServiceDetails, actualService,
 173                                 sdncDesignerDetails, sdncDesignerDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 174         }
 175
 176         protected void validateActualVsExpected(ServiceReqDetails expectedService, RestResponse actualServiceFromResponse) {
 177                 Service actualService = ResponseParser
 178                                 .convertServiceResponseToJavaObject(actualServiceFromResponse.getResponse());
 179                 ServiceValidationUtils.validateServiceResponseMetaData(updatedServiceDetails, actualService,
 180                                 sdncDesignerDetails, sdncDesignerDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 181         }
 182
 183         protected String multipleString(String ch, int repeat) {
 184                 return StringUtils.repeat(ch, repeat);
 185         }
 186
 187         protected void correctUpdate() throws Exception {
 188                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 189                 validateResponse(updateServiceResponse, 200, null, listForMessage);
 190                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 191         }
 192
 193         protected void updateWithInvalidValue(ActionStatus invalidValue, List<String> arr) throws Exception {
 194                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 195                 validateResponse(updateServiceResponse, 400, invalidValue, arr);
 196                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 197         }
 198
 199         protected void charactersInRangeChecking(int min, int max, String field) throws Exception {
 200                 if (field != null) {
 201                         if (field == "name") {
 202                                 for (char ch = (char) min; ch <= (char) max; ch++) {
 203                                         updatedServiceDetails.setName("testname" + String.valueOf(ch));
 204                                         updatedServiceDetails.setTags(
 205                                                         addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 206                                         updateWithInvalidValue(ActionStatus.INVALID_COMPONENT_NAME,
 207                                                         new ArrayList<>(Arrays.asList("Service")));
 208                                 }
 209                         } else if (field == "icon") {
 210                                 for (char ch = (char) min; ch <= (char) max; ch++) {
 211                                         updatedServiceDetails.setIcon("testname" + String.valueOf(ch));
 212                                         updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_ICON,
 213                                                         new ArrayList<>(Arrays.asList("Service")));
 214                                 }
 215                         } else if (field == "tags") {
 216                                 List<String> variables = Arrays.asList("Service", "tag");
 217                                 for (char ch = (char) min; ch <= (char) max; ch++) {
 218                                         updatedServiceDetails.setTags(
 219                                                         new ArrayList<>(Arrays.asList(String.valueOf(ch), updatedServiceDetails.getName())));
 220                                         updateWithInvalidValue(ActionStatus.INVALID_FIELD_FORMAT, variables);
 221                                 }
 222                         } else if (field == "category") {
 223                                 for (char ch = (char) min; ch <= (char) max; ch++) {
 224                                         updatedServiceDetails.addCategoryChain(multipleString("1", 5) + String.valueOf(ch),
 225                                                         multipleString("1", 5) + String.valueOf(ch));
 226                                         updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CATEGORY,
 227                                                         new ArrayList<>(Arrays.asList("Service")));
 228                                 }
 229                         }
 230
 231                         else if (field == "projectCode") {
 232                                 for (char ch = (char) min; ch <= (char) max; ch++) {
 233                                         updatedServiceDetails.setProjectCode(multipleString("1", 5) + String.valueOf(ch));
 234                                         updateWithInvalidValue(ActionStatus.INVALID_PROJECT_CODE, listForMessage);
 235                                 }
 236                         }
 237
 238                         else
 239                                 return;
 240                 }
 241
 242         }
 243
 244         protected void specialCharsChecking(String field) throws Exception {
 245                 charactersInRangeChecking(33, 44, field);
 246                 charactersInRangeChecking(47, 47, field);
 247                 charactersInRangeChecking(58, 64, field);
 248                 charactersInRangeChecking(91, 94, field);
 249                 charactersInRangeChecking(96, 96, field);
 250                 charactersInRangeChecking(123, 126, field);
 251         }
 252
 253         @Test
 254         public void updateServiceSuccessfully() throws Exception {
 255                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 256                 validateResponse(updateServiceResponse, 200, null, listForMessage);
 257
 258                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 259
 260         }
 261
 262         protected void checkErrorResponse(ActionStatus actionStatus, ArrayList<String> arrList, RestResponse response)
 263                         throws Exception, JSONException {
 264                 ErrorValidationUtils.checkBodyResponseOnError(actionStatus.name(), arrList, response.getResponse());
 265         }
 266
 267         protected List<String> addServiceNameToTagsList(String serviceName, List<String> tagsList) {
 268                 tagsList.add(serviceName);
 269                 return tagsList;
 270
 271         }
 272
 273         // @Test
 274         // public void updateMetadateSuccessTest() throws Exception {
 275         // CloseableHttpClient httpClient = HttpClients.createDefault();
 276         // HttpGet httpGet =
 277         // ServiceRestUtils.createGetServiceGetRquest(serviceDetails,
 278         // sdncDesignerDetails);
 279         // CloseableHttpResponse response = httpClient.execute(httpGet);
 280         // assertTrue(response.getStatusLine().getStatusCode() == 200);
 281         // String responseString = new
 282         // BasicResponseHandler().handleResponse(response);
 283         // Service serviceObject =
 284         // ResponseParser.convertServiceResponseToJavaObject(responseString);
 285         // assertTrue("service object creation failed the returned object is null",
 286         // serviceObject != null);
 287         // String currentCategory = serviceObject.getCategories().get(0).getName();
 288         // String currentServiceName = serviceObject.getName();
 289         // String currentProjectCode = serviceObject.getProjectCode();
 290         // String currentIcon = serviceObject.getIcon();
 291         // String currentDescription = serviceObject.getDescription();
 292         // List<String> currentTags = serviceObject.getTags();
 293         //
 294         // String newCategory = ServiceCategoriesEnum.VOIP.getValue();
 295         // serviceDetails.addCategory(newCategory);
 296         // // String newServiceName = "updated name";
 297         // // serviceDetails.setServiceName(newServiceName);
 298         // String newProjectCode = "68686868";
 299         // serviceDetails.setProjectCode(newProjectCode);
 300         // String newIcon = "updated-icon";
 301         // serviceDetails.setIcon(newIcon);
 302         // String newDescription = "updated description <html></html>";
 303         // serviceDetails.setDescription(newDescription);
 304         // List<String> newTags = new ArrayList<>();
 305         // newTags.add("update1");
 306         // newTags.add("update2");
 307         // newTags.add(currentServiceName);
 308         // serviceDetails.setTags(newTags);
 309         // HttpPut httpPut =
 310         // ServiceRestUtils.createUpdateServiceMetaDataPutRequest(serviceDetails,
 311         // sdncDesignerDetails);
 312         // response = httpClient.execute(httpPut);
 313         // assertTrue(response.getStatusLine().getStatusCode() == 200);
 314         // responseString = new BasicResponseHandler().handleResponse(response);
 315         // String serviceUid =
 316         // ServiceRestUtils.getServiceUniqueIdFromString(responseString);
 317         //
 318         // ServiceReqDetails details = new ServiceReqDetails();
 319         // details.setUniqueId(serviceUid);
 320         //
 321         // httpGet = ServiceRestUtils.createGetServiceGetRquest(details,
 322         // sdncDesignerDetails);
 323         // response = httpClient.execute(httpGet);
 324         // assertTrue(response.getStatusLine().getStatusCode() == 200);
 325         // responseString = new BasicResponseHandler().handleResponse(response);
 326         // serviceObject =
 327         // ResponseParser.convertServiceResponseToJavaObject(responseString);
 328         // assertTrue("service object creation failed the returned object is null",
 329         // serviceObject != null);
 330         // String updatedCategory = serviceObject.getCategories().get(0).getName();
 331         // String updatedServiceName = serviceObject.getName();
 332         // String updatedProjectCode = serviceObject.getProjectCode();
 333         // String updatedIcon = serviceObject.getIcon();
 334         // String updatedDescription = serviceObject.getDescription();
 335         // List<String> updatedTags = serviceObject.getTags();
 336         // assertFalse("category did not cahnge",
 337         // currentCategory.equals(updatedCategory));
 338         // assertEquals("categoruy did not match expacted value", updatedCategory,
 339         // newCategory);
 340         // // assertFalse("service name did not change",
 341         // currentServiceName.equals(updatedServiceName) );
 342         // // assertEquals("service name did not match expacted
 343         // value",updatedServiceName,newServiceName);
 344         // assertFalse("projectCode did not change", currentProjectCode.equals(updatedProjectCode));
 345         // assertEquals("projectCode not match expacted value", updatedProjectCode, newProjectCode);
 346         // assertFalse("icon did not change", currentIcon.equals(updatedIcon));
 347         // assertEquals("icon did not match expacted value", updatedIcon, newIcon);
 348         // assertFalse("description did not change",
 349         // currentDescription.equals(updatedDescription));
 350         // assertEquals("description did not match expacted value", "updated
 351         // description", updatedDescription);
 352         // assertFalse("tags did not change", currentTags.containsAll(updatedTags));
 353         // assertTrue("tags did not match expacted value",
 354         // updatedTags.containsAll(newTags));
 355         // }
 356
 357         @Test
 358         public void updateService_ByOtherDesigner() throws Exception {
 359                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails,
 360                                 sdncDesignerDetails2);
 361                 validateResponse(updateServiceResponse, 409, ActionStatus.RESTRICTED_OPERATION, listForMessage);
 362
 363                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 364         }
 365
 366         @Test
 367         public void updateService_ByAdmin() throws Exception {
 368                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncAdminDetails);
 369                 validateResponse(updateServiceResponse, 409, ActionStatus.RESTRICTED_OPERATION, listForMessage);
 370
 371                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 372         }
 373
 374         @Test
 375         public void updateServiceNotExist() throws Exception {
 376                 updatedServiceDetails.setUniqueId("nnnnn");
 377                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 378                 validateResponse(updateServiceResponse, 404, ActionStatus.SERVICE_NOT_FOUND,
 379                                 new ArrayList<String>(Arrays.asList("")));
 380         }
 381
 382         @Test
 383         public void updateCheckedinService() throws Exception {
 384                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 385                                 LifeCycleStatesEnum.CHECKIN);
 386                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 387                 validateResponse(updateServiceResponse, 409, ActionStatus.RESTRICTED_OPERATION, listForMessage);
 388                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 389         }
 390
 391         @Test
 392         public void updateCertifiedService() throws Exception {
 393                 // addMandatoryArtifactsToService();
 394                 certifyService(serviceDetails, serviceDetails.getVersion());
 395
 396                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 397                 validateResponse(updateServiceResponse, 409, ActionStatus.RESTRICTED_OPERATION, listForMessage);
 398                 getServiceAndValidate(serviceDetails, sdncDesignerDetails, sdncAdminDetails, LifecycleStateEnum.CERTIFIED);
 399         }
 400
 401         // TODO Irrelevant
 402         // @Test(enabled = false)
 403         // public void updateService_NameCaseSensitiveTest() throws Exception {
 404         // ServiceRestUtils.setServiceUniqueId(serviceDetails.getName().toUpperCase());
 405         //
 406         // RestResponse updateServiceResponse =
 407         // ServiceRestUtils.updateService(updatedServiceDetails,
 408         // sdncDesignerDetails);
 409         // validateResponse(updateServiceResponse, 200, null, listForMessage);
 410         //
 411         // Service serviceFromJsonResponse =
 412         // ResponseParser.convertServiceResponseToJavaObject(updateServiceResponse.getResponse());
 413         // ServiceValidationUtils.validateServiceResponseMetaData(updatedServiceDetails,
 414         // serviceFromJsonResponse, sdncDesignerDetails, (LifecycleStateEnum)null);
 415         //
 416         // getServiceAndValidate(updatedServiceDetails,
 417         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 418         // }
 419
 420         // @Test
 421         // public void updateApprovedDistributionServiceTest() throws Exception {
 422         // // addMandatoryArtifactsToService();
 423         // certifyService(serviceDetails, serviceDetails.getVersion());
 424         //
 425         // RestResponse approveResponse =
 426         // ServiceRestUtils.sendApproveDistribution(sdncAdminDetails,
 427         // serviceDetails.getUniqueId(), userRemarks);
 428         // // validateResponse(approveResponse, 200, null, listForMessage);
 429         //
 430         // RestResponse updateServiceResponse =
 431         // ServiceRestUtils.updateService(updatedServiceDetails,
 432         // sdncDesignerDetails);
 433         // validateResponse(updateServiceResponse, 409,
 434         // ActionStatus.RESTRICTED_OPERATION, listForMessage);
 435         //
 436         // getServiceAndValidate(serviceDetails, sdncDesignerDetails,
 437         // sdncAdminDetails,LifecycleStateEnum.CERTIFIED);
 438         // }
 439
 440         @Test
 441         public void updateServiceByMethod_delete() throws Exception {
 442                 RestResponse updateServiceResponse = ServiceRestUtils.createServiceByHttpMethod(updatedServiceDetails,
 443                                 sdncDesignerDetails, "DELETE", Urls.UPDATE_SERVICE_METADATA);
 444                 validateResponse(updateServiceResponse, 405, ActionStatus.NOT_ALLOWED, listForMessage);
 445
 446                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 447         }
 448
 449         @Test
 450         public void updateServiceByMethod_get() throws Exception {
 451                 RestResponse updateServiceResponse = ServiceRestUtils.createServiceByHttpMethod(updatedServiceDetails,
 452                                 sdncDesignerDetails, "GET", Urls.UPDATE_SERVICE_METADATA);
 453                 validateResponse(updateServiceResponse, 405, ActionStatus.NOT_ALLOWED, listForMessage);
 454
 455                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 456         }
 457
 458         @Test
 459         public void updateServiceByMethod_post() throws Exception {
 460                 RestResponse updateServiceResponse = ServiceRestUtils.createServiceByHttpMethod(updatedServiceDetails,
 461                                 sdncDesignerDetails, "POST", Urls.UPDATE_SERVICE_METADATA);
 462                 validateResponse(updateServiceResponse, 405, ActionStatus.NOT_ALLOWED, listForMessage);
 463
 464                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 465         }
 466
 467         @Test
 468         public void updateCheckoutCertifiedService() throws Exception // certify a
 469                                                                                                                                         // service
 470                                                                                                                                         // and
 471                                                                                                                                         // checkout
 472                                                                                                                                         // it
 473         {
 474                 // addMandatoryArtifactsToService();
 475                 certifyService(serviceDetails, serviceDetails.getVersion());
 476                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 477                                 LifeCycleStatesEnum.CHECKOUT);
 478                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 479                 validateResponse(updateServiceResponse, 400, ActionStatus.SERVICE_CATEGORY_CANNOT_BE_CHANGED, listForMessage);
 480
 481                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 482         }
 483
 484         // ---------------------------------------------------------Validation
 485         // Tests---------------------------------------------------------
 486
 487         @Test
 488         public void missingCategoryTest1() throws Exception {
 489                 List<CategoryDefinition> categories = updatedServiceDetails.getCategories();
 490                 CategoryDefinition categoryDefinition = categories.get(0);
 491                 CategoryDefinition categoryDefinition2 = categoryDefinition;
 492                 categoryDefinition2.setName("");
 493                 categories.set(0, categoryDefinition2);
 494                 updatedServiceDetails.setCategories(categories);
 495                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 496                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_CATEGORY, Arrays.asList("Service"));
 497                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 498         }
 499
 500         @Test
 501         public void missingCategoryTest2() throws Exception {
 502                 updatedServiceDetails.setCategories(null);
 503                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 504                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_CATEGORY, Arrays.asList("Service"));
 505                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 506         }
 507
 508         @Test
 509         public void missingServiceNameTest1() throws Exception {
 510                 updatedServiceDetails.setName(StringUtils.EMPTY);
 511                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 512                 validateResponse(updateServiceResponse, 400, ActionStatus.MISSING_COMPONENT_NAME, Arrays.asList("Service"));
 513                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 514         }
 515
 516         @Test
 517         public void missingServiceNameTest2() throws Exception {
 518
 519                 updatedServiceDetails.setName(null);
 520                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 521                 validateResponse(updateServiceResponse, 400, ActionStatus.MISSING_COMPONENT_NAME, Arrays.asList("Service"));
 522                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 523         }
 524
 525         @Test
 526         public void environmentContextService() throws Exception {
 527                 updatedServiceDetails.setEnvironmentContext("General_Revenue-Bearing");
 528                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 529                 validateResponse(updateServiceResponse, 200, null, listForMessage);
 530                 Service actualService = ResponseParser.convertServiceResponseToJavaObject(updateServiceResponse.getResponse());
 531                 assertEquals(updatedServiceDetails.getEnvironmentContext(), actualService.getEnvironmentContext());
 532         }
 533
 534         // TODO Irrelevant
 535         @Test(enabled = false)
 536         public void missingProjectCodeTest1() throws Exception {
 537                 updatedServiceDetails.setProjectCode(StringUtils.EMPTY);
 538                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 539                 validateResponse(updateServiceResponse, 400, ActionStatus.MISSING_PROJECT_CODE, listForMessage);
 540                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 541         }
 542
 543         // TODO Irrelevant
 544         @Test(enabled = false)
 545         public void missingProjectCodeTest2() throws Exception {
 546
 547                 updatedServiceDetails.setProjectCode(null);
 548                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 549                 validateResponse(updateServiceResponse, 400, ActionStatus.MISSING_PROJECT_CODE, listForMessage);
 550                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 551         }
 552
 553         @Test
 554         public void missingIconTest1() throws Exception {
 555                 updatedServiceDetails.setIcon(StringUtils.EMPTY);
 556                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 557                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_ICON, Arrays.asList("Service"));
 558                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 559         }
 560
 561         @Test
 562         public void missingIconTest2() throws Exception {
 563                 updatedServiceDetails.setIcon(null);
 564                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 565                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_ICON, Arrays.asList("Service"));
 566                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 567         }
 568
 569         @Test
 570         public void missingDescriptionTest1() throws Exception {
 571                 updatedServiceDetails.setDescription(StringUtils.EMPTY);
 572                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 573                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
 574                                 Arrays.asList("Service"));
 575                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 576         }
 577
 578         @Test
 579         public void missingDescriptionTest2() throws Exception {
 580                 updatedServiceDetails.setDescription(null);
 581                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 582                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_DESCRIPTION,
 583                                 Arrays.asList("Service"));
 584                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 585         }
 586
 587         @Test
 588         public void missingTagsTest1() throws Exception {
 589                 updatedServiceDetails.setTags(new ArrayList<String>());
 590                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 591                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_TAGS, listForMessage);
 592                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 593         }
 594
 595         @Test
 596         public void missingTagsTest2() throws Exception {
 597                 updatedServiceDetails.setTags(null);
 598                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 599                 validateResponse(updateServiceResponse, 400, ActionStatus.COMPONENT_MISSING_TAGS, listForMessage);
 600                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 601         }
 602
 603         @Test
 604         public void missingTagsTest3() throws Exception {
 605                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList(StringUtils.EMPTY)));
 606                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 607                 validateResponse(updateServiceResponse, 400, ActionStatus.INVALID_FIELD_FORMAT,
 608                                 Arrays.asList("Service", "tag"));
 609                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 610         }
 611
 612         @Test
 613         public void missingTagsTest4() throws Exception {
 614                 updatedServiceDetails
 615                                 .setTags(new ArrayList<>(Arrays.asList(StringUtils.EMPTY, updatedServiceDetails.getName())));
 616                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 617                 validateResponse(updateServiceResponse, 400, ActionStatus.INVALID_FIELD_FORMAT,
 618                                 Arrays.asList("Service", "tag"));
 619                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 620         }
 621
 622         // update non-settable/"updatable" parameters tests
 623
 624         // ------------------------------------------correct
 625         // values------------------------------------------
 626         @Test
 627         public void contactIdValidationTest1() throws Exception {
 628                 updatedServiceDetails.setContactId("ab3456");
 629                 correctUpdate();
 630         }
 631
 632         @Test
 633         public void contactIdValidationTest2() throws Exception {
 634
 635                 updatedServiceDetails.setContactId("cd789E");
 636                 correctUpdate();
 637         }
 638
 639         @Test
 640         public void contactIdValidationTest3() throws Exception {
 641
 642                 updatedServiceDetails.setContactId("ef4567");
 643                 correctUpdate();
 644         }
 645
 646         @Test
 647         public void contactIdValidationTest4() throws Exception {
 648                 updatedServiceDetails.setContactId("AA012A");
 649                 correctUpdate();
 650         }
 651
 652         @Test
 653         public void contactIdValidationTest5() throws Exception {
 654                 updatedServiceDetails.setContactId("CD012c");
 655                 correctUpdate();
 656         }
 657
 658         @Test
 659         public void contactIdValidationTest6() throws Exception {
 660                 updatedServiceDetails.setContactId("EF0123");
 661                 correctUpdate();
 662         }
 663
 664         // ------------------------------------------invalid
 665         // values------------------------------------------
 666         @Test
 667         public void contactIdValidationTest7() throws Exception {
 668                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 669                                 LifeCycleStatesEnum.CHECKIN);
 670                 updatedServiceDetails.setContactId("ab0001");
 671                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 672                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
 673         }
 674
 675         @Test
 676         public void contactIdValidationTest8() throws Exception {
 677                 // addMandatoryArtifactsToService();
 678
 679                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
 680                 Service certifyServiceServ = ResponseParser
 681                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
 682                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
 683                 updatedServiceDetails = new ServiceReqDetails(certifyService);
 684                 updatedServiceDetails.setContactId("ab0001");
 685                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 686                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
 687         }
 688
 689         @Test
 690         public void contactIdValidationTest9() throws Exception {
 691                 updatedServiceDetails.setContactId("01345a");
 692                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, Arrays.asList("Service"));
 693         }
 694
 695         @Test
 696         public void contactIdValidationTest10() throws Exception {
 697                 updatedServiceDetails.setContactId("0y000B");
 698                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, Arrays.asList("Service"));
 699         }
 700
 701         @Test
 702         public void contactIdValidationTest11() throws Exception {
 703                 updatedServiceDetails.setContactId("Y1000b");
 704                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, Arrays.asList("Service"));
 705         }
 706
 707         @Test
 708         public void contactIdValidationTest12() throws Exception {
 709                 updatedServiceDetails.setContactId("abxyzC");
 710                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, Arrays.asList("Service"));
 711         }
 712
 713         @Test
 714         public void contactIdValidationTest13() throws Exception {
 715                 updatedServiceDetails.setContactId("cdXYZc");
 716                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 717         }
 718
 719         @Test
 720         public void contactIdValidationTest14() throws Exception {
 721                 updatedServiceDetails.setContactId("efXY1D");
 722                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 723         }
 724
 725         @Test
 726         public void contactIdValidationTest15() throws Exception {
 727                 updatedServiceDetails.setContactId("EFabcD");
 728                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 729         }
 730
 731         @Test
 732         public void contactIdValidationTest16() throws Exception {
 733                 updatedServiceDetails.setContactId("EFABCD");
 734                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 735         }
 736
 737         @Test
 738         public void contactIdValidationTest17() throws Exception {
 739                 updatedServiceDetails.setContactId("EFABC1");
 740                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 741         }
 742
 743         @Test
 744         public void contactIdValidationTest18() throws Exception {
 745                 updatedServiceDetails.setContactId("efui1D");
 746                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 747         }
 748
 749         @Test
 750         public void contactIdValidationTest19() throws Exception {
 751                 updatedServiceDetails.setContactId("efui1!");
 752                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 753         }
 754
 755         @Test
 756         public void contactIdValidationTest20() throws Exception {
 757                 updatedServiceDetails.setContactId("ef555!");
 758                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 759         }
 760
 761         @Test
 762         public void contactIdValidationTest21() throws Exception {
 763                 updatedServiceDetails.setContactId(",f555");
 764                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 765         }
 766
 767         @Test
 768         public void contactIdValidationTest22() throws Exception {
 769                 updatedServiceDetails.setContactId("EF55.5");
 770                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 771         }
 772
 773         @Test
 774         public void contactIdValidationTest23() throws Exception {
 775                 updatedServiceDetails.setContactId("ab000");
 776                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 777         }
 778
 779         @Test
 780         public void contactIdValidationTest24() throws Exception {
 781                 updatedServiceDetails.setContactId("ab000c0");
 782                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 783         }
 784
 785         @Test
 786         public void contactIdValidationTest25() throws Exception {
 787                 updatedServiceDetails.setContactId("  ab0001");
 788                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CONTACT, new ArrayList<>(Arrays.asList("Service")));
 789         }
 790
 791         @Test
 792         public void contactIdValidationTest26() throws Exception {
 793                 // addMandatoryArtifactsToService();
 794                 certifyService(serviceDetails, serviceDetails.getVersion());
 795                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 796                                 LifeCycleStatesEnum.CHECKOUT);
 797                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
 798                 updatedServiceDetails.setContactId("xy0002");
 799                 correctUpdate();
 800         }
 801
 802         @Test
 803         public void serviceNameValidationTest1() throws Exception {
 804                 updatedServiceDetails.setName(multipleString("a", 49));
 805                 updatedServiceDetails
 806                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 807                 correctUpdate();
 808         }
 809
 810         @Test
 811         public void serviceNameValidationTest2() throws Exception {
 812                 updatedServiceDetails.setName(multipleString("b", 50));
 813                 updatedServiceDetails
 814                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 815                 correctUpdate();
 816         }
 817
 818         @Test
 819         public void serviceNameValidationTest3() throws Exception {
 820                 updatedServiceDetails.setName("testNamE");
 821                 updatedServiceDetails
 822                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 823                 correctUpdate();
 824         }
 825
 826         @Test
 827         public void serviceNameValidationTest4() throws Exception {
 828                 updatedServiceDetails.setName("Testname");
 829                 updatedServiceDetails
 830                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 831                 correctUpdate();
 832         }
 833
 834         @Test
 835         public void serviceNameValidationTest5() throws Exception {
 836                 updatedServiceDetails.setName("Test_name");
 837                 updatedServiceDetails
 838                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 839                 correctUpdate();
 840         }
 841
 842         @Test
 843         public void serviceNameValidationTest6() throws Exception {
 844                 updatedServiceDetails.setName("Test name");
 845                 updatedServiceDetails
 846                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 847                 correctUpdate();
 848         }
 849
 850         @Test
 851         public void serviceNameValidationTest7() throws Exception {
 852                 updatedServiceDetails.setName("Test-name");
 853                 updatedServiceDetails
 854                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 855                 correctUpdate();
 856         }
 857
 858         @Test
 859         public void serviceNameValidationTest8() throws Exception {
 860                 updatedServiceDetails.setName("Test.name");
 861                 updatedServiceDetails
 862                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 863                 correctUpdate();
 864         }
 865
 866         @Test
 867         public void serviceNameValidationTest9() throws Exception {
 868                 updatedServiceDetails.setName("...1...");
 869                 updatedServiceDetails
 870                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 871                 correctUpdate();
 872         }
 873
 874         @Test
 875         public void serviceNameValidationTest10() throws Exception {
 876                 updatedServiceDetails.setName("-a_1. Arrrrrr");
 877                 updatedServiceDetails
 878                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 879                 correctUpdate();
 880         }
 881
 882         @Test
 883         public void serviceNameValidationTest11() throws Exception {
 884                 updatedServiceDetails.setName("Testname1234567890");
 885                 updatedServiceDetails
 886                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 887                 correctUpdate();
 888         }
 889
 890         @Test
 891         public void serviceNameValidationTest14() throws Exception {
 892                 updatedServiceDetails.setName(StringUtils.SPACE); // one space with
 893                                                                                                                         // nothing
 894                 updatedServiceDetails
 895                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 896                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 897                 // updateWithInvalidValue(ActionStatus.INVALID_COMPONENT_NAME, new
 898                 // ArrayList<>(Arrays.asList("Service")));
 899                 validateResponse(updateServiceResponse, 400, ActionStatus.MISSING_COMPONENT_NAME,
 900                                 new ArrayList<>(Arrays.asList("Service")));
 901         }
 902
 903         // ------------------------------------------invalid
 904         // values------------------------------------------
 905         @Test
 906         public void serviceNameValidationTest12() throws Exception {
 907                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 908                                 LifeCycleStatesEnum.CHECKIN);
 909                 updatedServiceDetails.setName("TestNamE");
 910                 updatedServiceDetails
 911                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 912                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 913                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
 914                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
 915         }
 916
 917         @Test
 918         public void serviceNameValidationTest13() throws Exception {
 919                 updatedServiceDetails.setName(multipleString("c", 51));
 920                 updatedServiceDetails
 921                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 922                 updateWithInvalidValue(ActionStatus.COMPONENT_NAME_EXCEEDS_LIMIT,
 923                                 new ArrayList<>(Arrays.asList("Service", "50")));
 924         }
 925
 926         @Test
 927         public void serviceNameValidationTest15() throws Exception {
 928                 specialCharsChecking("name");
 929         }
 930
 931         @Test
 932         public void serviceNameValidationTest16() throws Exception {
 933                 // addMandatoryArtifactsToService();
 934                 LifecycleRestUtils.certifyService(serviceDetails);
 935                 updatedServiceDetails.setName("testnamename");
 936                 updatedServiceDetails.setCategories(serviceDetails.getCategories());
 937                 updatedServiceDetails
 938                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 939                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
 940                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
 941                 getServiceAndValidate(serviceDetails, sdncDesignerDetails, sdncTesterDetails, LifecycleStateEnum.CERTIFIED);
 942         }
 943
 944         @Test
 945         public void serviceNameValidationTest17() throws Exception {
 946                 // addMandatoryArtifactsToService();
 947                 certifyService(serviceDetails, serviceDetails.getVersion());
 948                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
 949                                 LifeCycleStatesEnum.CHECKOUT);
 950                 updatedServiceDetails.setName("TestNamE");
 951                 updatedServiceDetails.setCategories(serviceDetails.getCategories());
 952                 updatedServiceDetails
 953                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 954                 RestResponse updateServiceResponse2 = ServiceRestUtils.updateService(updatedServiceDetails,
 955                                 sdncDesignerDetails);
 956                 validateResponse(updateServiceResponse2, 400, ActionStatus.SERVICE_NAME_CANNOT_BE_CHANGED, listForMessage);
 957                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 958         }
 959
 960         @Test
 961         public void serviceNameValidationTest18() throws Exception {
 962                 updatedServiceDetails.setName("  testname  ");
 963                 updatedServiceDetails
 964                                 .setTags(addServiceNameToTagsList(updatedServiceDetails.getName(), updatedServiceDetails.getTags()));
 965                 RestResponse updateServiceResponse1 = ServiceRestUtils.updateService(updatedServiceDetails,
 966                                 sdncDesignerDetails);
 967                 assertNotNull(updateServiceResponse1);
 968                 assertNotNull(updateServiceResponse1.getErrorCode());
 969                 assertEquals(200, updateServiceResponse1.getErrorCode().intValue());
 970                 updatedServiceDetails.setName(updatedServiceDetails.getName());
 971                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse1);
 972                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 973         }
 974
 975         @Test
 976         public void iconValidationTest1() throws Exception {
 977                 updatedServiceDetails.setIcon(multipleString("a", 24));
 978                 correctUpdate();
 979         }
 980
 981         @Test
 982         public void iconValidationTest2() throws Exception {
 983                 updatedServiceDetails.setIcon(multipleString("b", 25));
 984                 correctUpdate();
 985         }
 986
 987         @Test
 988         public void iconValidationTest3() throws Exception {
 989                 updatedServiceDetails.setIcon("testNamE");
 990                 correctUpdate();
 991         }
 992
 993         @Test
 994         public void iconValidationTest4() throws Exception {
 995                 updatedServiceDetails.setIcon("Testname");
 996                 correctUpdate();
 997         }
 998
 999         @Test
1000         public void iconValidationTest5() throws Exception {
1001                 updatedServiceDetails.setIcon("Test_name");
1002                 correctUpdate();
1003         }
1004
1005         @Test
1006         public void iconValidationTest6() throws Exception {
1007                 updatedServiceDetails.setIcon("Test-name");
1008                 correctUpdate();
1009         }
1010
1011         @Test
1012         public void iconValidationTest7() throws Exception {
1013                 updatedServiceDetails.setIcon("Testname1234567890");
1014                 correctUpdate();
1015         }
1016
1017         @Test
1018         public void iconValidationTest8() throws Exception {
1019                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1020                                 LifeCycleStatesEnum.CHECKIN);
1021                 updatedServiceDetails.setIcon("TestNamE");
1022                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1023                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1024         }
1025
1026         @Test
1027         public void iconValidationTest9() throws Exception {
1028                 // addMandatoryArtifactsToService();
1029                 LifecycleRestUtils.certifyService(serviceDetails);
1030                 updatedServiceDetails.setIcon("testnamename");
1031                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1032                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1033         }
1034
1035         // ------------------------------------------invalid
1036         // values------------------------------------------
1037         @Test
1038         public void iconValidationTest10() throws Exception {
1039                 updatedServiceDetails.setIcon("Test name");
1040                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_ICON, new ArrayList<>(Arrays.asList("Service")));
1041         }
1042
1043         @Test
1044         public void iconValidationTest11() throws Exception {
1045                 updatedServiceDetails.setIcon(StringUtils.SPACE); // one space with
1046                                                                                                                         // nothing
1047                 updateWithInvalidValue(ActionStatus.COMPONENT_MISSING_ICON, new ArrayList<>(Arrays.asList("Service")));
1048         }
1049
1050         @Test
1051         public void iconValidationTest12() throws Exception {
1052                 updatedServiceDetails.setIcon("Test.name");
1053                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_ICON, new ArrayList<>(Arrays.asList("Service")));
1054         }
1055
1056         @Test
1057         public void iconValidationTest13() throws Exception {
1058                 specialCharsChecking("icon");
1059                 charactersInRangeChecking(46, 46, "icon");
1060         }
1061
1062         @Test
1063         public void iconValidationTest14() throws Exception {
1064                 updatedServiceDetails.setIcon(multipleString("c", 26));
1065                 updateWithInvalidValue(ActionStatus.COMPONENT_ICON_EXCEEDS_LIMIT,
1066                                 new ArrayList<>(Arrays.asList("Service", "25")));
1067         }
1068
1069         @Test
1070         public void iconValidationTest15() throws Exception {
1071                 // addMandatoryArtifactsToService();
1072                 RestResponse certifyServiceResp = LifecycleRestUtils.certifyService(serviceDetails);
1073                 Service certifyServiceServ = ResponseParser
1074                                 .convertServiceResponseToJavaObject(certifyServiceResp.getResponse());
1075                 ServiceReqDetails certifyService = new ServiceReqDetails(certifyServiceServ);
1076                 updatedServiceDetails = new ServiceReqDetails(certifyService);
1077                 updatedServiceDetails.setIcon("testnamename");
1078                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1079                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1080         }
1081
1082         @Test
1083         public void iconValidationTest16() throws Exception {
1084                 // addMandatoryArtifactsToService();
1085                 certifyService(serviceDetails, serviceDetails.getVersion());
1086                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1087                                 LifeCycleStatesEnum.CHECKOUT);
1088                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
1089                 updatedServiceDetails.setIcon("TestNamE");
1090                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1091                 checkErrorResponse(ActionStatus.SERVICE_ICON_CANNOT_BE_CHANGED, listForMessage, updateServiceResponse);
1092         }
1093
1094         @Test
1095         public void iconValidationTest17() throws Exception {
1096                 updatedServiceDetails.setIcon("  Icon  ");
1097                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_ICON, new ArrayList<>(Arrays.asList("Service")));
1098         }
1099
1100         @Test
1101         public void categoryValidationTest1() throws Exception {
1102                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1103                                 LifeCycleStatesEnum.CHECKIN);
1104                 updatedServiceDetails.addCategory(ServiceCategoriesEnum.VOIP.getValue());
1105                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1106                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1107         }
1108
1109         @Test
1110         public void categoryValidationTest2() throws Exception {
1111                 // updatedServiceDetails.addCategory("someCategory");
1112                 updatedServiceDetails.setCategories(null);
1113                 updatedServiceDetails.addCategoryChain("someCategory", null);
1114                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CATEGORY, new ArrayList<>(Arrays.asList("Service")));
1115         }
1116
1117         @Test
1118         public void categoryValidationTest3() throws Exception {
1119                 updatedServiceDetails.setCategories(null);
1120                 updatedServiceDetails.addCategoryChain("SomeCategory10", null);
1121                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CATEGORY, new ArrayList<>(Arrays.asList("Service")));
1122         }
1123
1124         @Test
1125         public void categoryValidationTest4() throws Exception {
1126                 updatedServiceDetails.setCategories(null);
1127                 updatedServiceDetails.addCategoryChain("some Category", null);
1128                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_CATEGORY, new ArrayList<>(Arrays.asList("Service")));
1129         }
1130
1131         @Test
1132         public void categoryValidationTest5() throws Exception {
1133                 // addMandatoryArtifactsToService();
1134                 certifyService(serviceDetails, serviceDetails.getVersion());
1135                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
1136                 updatedServiceDetails.addCategory("Network L1-3");
1137                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1138                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1139         }
1140
1141         @Test
1142         public void categoryValidationTest6() throws Exception {
1143                 // addMandatoryArtifactsToService();
1144                 certifyService(serviceDetails, serviceDetails.getVersion());
1145                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1146                                 LifeCycleStatesEnum.CHECKOUT);
1147                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
1148                 updatedServiceDetails = serviceDetails;
1149                 List<CategoryDefinition> categories = updatedServiceDetails.getCategories();
1150                 CategoryDefinition categoryDefinition = categories.get(0);
1151                 CategoryDefinition categoryDefinition2 = categoryDefinition;
1152                 categoryDefinition2.setName("ccc");
1153                 categories.set(0, categoryDefinition2);
1154                 updatedServiceDetails.setCategories(categories);
1155                 RestResponse updateServiceResponse2 = ServiceRestUtils.updateService(updatedServiceDetails,
1156                                 sdncDesignerDetails);
1157                 validateResponse(updateServiceResponse2, 400, ActionStatus.SERVICE_CATEGORY_CANNOT_BE_CHANGED, listForMessage);
1158                 getServiceAndValidate(serviceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1159         }
1160
1161         @Test
1162         public void categoryValidationTest7() throws Exception {
1163                 updatedServiceDetails.removeAllCategories();
1164                 updatedServiceDetails.addCategory(ServiceCategoriesEnum.NETWORK_L3.getValue());
1165                 correctUpdate();
1166         }
1167
1168         @Test
1169         public void categoryValidationTest8() throws Exception {
1170                 updatedServiceDetails.setCategories(null);
1171                 updatedServiceDetails.addCategoryChain("Network L1-3", null);
1172                 correctUpdate();
1173         }
1174
1175         @Test
1176         public void tagsValidationTest1() throws Exception {
1177                 updatedServiceDetails
1178                                 .setTags(new ArrayList<>(Arrays.asList(multipleString("a", 49), updatedServiceDetails.getName())));
1179                 correctUpdate();
1180         }
1181
1182         @Test
1183         public void tagsValidationTest2() throws Exception {
1184                 updatedServiceDetails
1185                                 .setTags(new ArrayList<>(Arrays.asList(multipleString("B", 50), updatedServiceDetails.getName())));
1186                 correctUpdate();
1187         }
1188
1189         @Test
1190         public void tagsValidationTest3() throws Exception {
1191                 updatedServiceDetails.setTags(new ArrayList<>(
1192                                 Arrays.asList(multipleString("A", 50), multipleString("B", 50), updatedServiceDetails.getName())));
1193                 correctUpdate();
1194         }
1195
1196         @Test
1197         public void tagsValidationTest5() throws Exception {
1198                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("testTaG", updatedServiceDetails.getName())));
1199                 correctUpdate();
1200         }
1201
1202         @Test
1203         public void tagsValidationTest6() throws Exception {
1204                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("Testtag", updatedServiceDetails.getName())));
1205                 correctUpdate();
1206         }
1207
1208         @Test
1209         public void tagsValidationTest7() throws Exception {
1210                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("Test_tag", updatedServiceDetails.getName())));
1211                 correctUpdate();
1212         }
1213
1214         @Test
1215         public void tagsValidationTest8() throws Exception {
1216                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("Test tag", updatedServiceDetails.getName())));
1217                 correctUpdate();
1218         }
1219
1220         @Test
1221         public void tagsValidationTest9() throws Exception {
1222                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("Test-tag", updatedServiceDetails.getName())));
1223                 correctUpdate();
1224         }
1225
1226         @Test
1227         public void tagsValidationTest10() throws Exception {
1228                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("Test.tag", updatedServiceDetails.getName())));
1229                 correctUpdate();
1230         }
1231
1232         @Test
1233         public void tagsValidationTest11() throws Exception {
1234                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("...1...", updatedServiceDetails.getName())));
1235                 correctUpdate();
1236         }
1237
1238         @Test
1239         public void tagsValidationTest12() throws Exception {
1240                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("-a_1. Arrrrrr", updatedServiceDetails.getName())));
1241                 correctUpdate();
1242         }
1243
1244         @Test
1245         public void tagsValidationTest13() throws Exception {
1246                 updatedServiceDetails
1247                                 .setTags(new ArrayList<>(Arrays.asList("Testtag1234567890", updatedServiceDetails.getName())));
1248                 correctUpdate();
1249         }
1250
1251         @Test
1252         public void tagsValidationTest14() throws Exception {
1253                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("1", "2", "2", updatedServiceDetails.getName())));
1254                 correctUpdate();
1255         }
1256
1257         @Test
1258         public void tagsValidationTest15() throws Exception {
1259                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1260                                 LifeCycleStatesEnum.CHECKIN);
1261                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("TestTaG", updatedServiceDetails.getName())));
1262                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1263                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1264         }
1265
1266         @Test
1267         public void tagsValidationTest16() throws Exception {
1268                 // addMandatoryArtifactsToService();
1269                 LifecycleRestUtils.certifyService(serviceDetails);
1270                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
1271                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("testtagtag", updatedServiceDetails.getName())));
1272                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1273                 checkErrorResponse(ActionStatus.RESTRICTED_OPERATION, listForMessage, updateServiceResponse);
1274         }
1275
1276         @Test
1277         public void tagsValidationTest17() throws Exception {
1278                 // addMandatoryArtifactsToService();
1279                 certifyService(serviceDetails, serviceDetails.getVersion());
1280                 LifecycleRestUtils.changeServiceState(serviceDetails, sdncDesignerDetails, serviceDetails.getVersion(),
1281                                 LifeCycleStatesEnum.CHECKOUT);
1282                 updatedServiceDetails = new ServiceReqDetails(serviceDetails);
1283                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("TestTaG", updatedServiceDetails.getName())));
1284                 correctUpdate();
1285         }
1286
1287         @Test
1288         public void tagsValidationTest18() throws Exception {
1289                 int lengthOfServiceName = updatedServiceDetails.getName().length();
1290                 int maxLengthTag = 50;
1291                 int tagsCount = 1024 - lengthOfServiceName;
1292                 ArrayList<String> tagsList = new ArrayList<>();
1293                 tagsList.add(updatedServiceDetails.getName());
1294                 while (tagsCount > maxLengthTag) {
1295                         tagsList.add(multipleString("a", maxLengthTag));
1296                         tagsCount -= maxLengthTag + 1
1297                                         + 1/* (50 and comma of each tag + one space, totally 52) */;
1298                 }
1299                 tagsList.add(multipleString("a", tagsCount));
1300                 updatedServiceDetails.setTags(tagsList);
1301                 correctUpdate();
1302         }
1303
1304         @Test
1305         public void tagsValidationTest19() throws Exception {
1306                 updatedServiceDetails.setTags(new ArrayList<>(Arrays.asList("   Tag   ", updatedServiceDetails.getName())));
1307                 RestResponse updateServiceResponse1 = ServiceRestUtils.updateService(updatedServiceDetails,
1308                                 sdncDesignerDetails);
1309                 assertNotNull(updateServiceResponse1);
1310                 assertNotNull(updateServiceResponse1.getErrorCode());
1311                 assertEquals(200, updateServiceResponse1.getErrorCode().intValue());
1312                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse1);
1313                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1314         }
1315
1316         @Test
1317         public void tagsValidationTest20() throws Exception {
1318                 ArrayList<String> tagsList = new ArrayList<>();
1319                 tagsList.add(updatedServiceDetails.getName());
1320                 tagsList.add("");
1321                 updatedServiceDetails.setTags(tagsList);
1322                 updateWithInvalidValue(ActionStatus.INVALID_FIELD_FORMAT, Arrays.asList("Service", "tag"));
1323         }
1324
1325         // ------------------------------------------invalid
1326         // values------------------------------------------
1327
1328         @Test
1329         public void tagsValidationTest21() throws Exception {
1330                 ArrayList<String> tagsList = new ArrayList<>();
1331                 tagsList.add("onetag");
1332                 updatedServiceDetails.setTags(tagsList);
1333                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_TAGS_NO_COMP_NAME, listForMessage);
1334
1335         }
1336
1337         @Test
1338         public void tagsValidationTest22() throws Exception {
1339                 specialCharsChecking("tags");
1340         }
1341
1342         @Test
1343         public void descriptionValidationTest1() throws Exception {
1344                 updatedServiceDetails.setDescription(multipleString("a", 1023));
1345                 correctUpdate();
1346         }
1347
1348         @Test
1349         public void descriptionValidationTest2() throws Exception {
1350                 updatedServiceDetails.setDescription(multipleString("a", 1024));
1351                 correctUpdate();
1352         }
1353
1354         @Test
1355         public void descriptionValidationTest3() throws Exception {
1356                 updatedServiceDetails.setDescription(multipleString("aB", 1024 / 2));
1357                 correctUpdate();
1358         }
1359
1360         @Test
1361         public void descriptionValidationTest4() throws Exception {
1362                 updatedServiceDetails.setDescription("1234567890");
1363                 correctUpdate();
1364         }
1365
1366         @Test
1367         public void descriptionValidationTest5() throws Exception {
1368                 updatedServiceDetails.setDescription("desc ription");
1369                 correctUpdate();
1370         }
1371
1372         @Test
1373         public void descriptionValidationTest6() throws Exception {
1374                 updatedServiceDetails.setDescription("desc\tription");
1375                 RestResponse updateServiceResponse1 = ServiceRestUtils.updateService(updatedServiceDetails,
1376                                 sdncDesignerDetails);
1377                 assertNotNull(updateServiceResponse1);
1378                 assertNotNull(updateServiceResponse1.getErrorCode());
1379                 assertEquals(200, updateServiceResponse1.getErrorCode().intValue());
1380                 updatedServiceDetails.setDescription("desc ription");
1381                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse1);
1382                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1383         }
1384
1385         @Test
1386         public void descriptionValidationTest7() throws Exception {
1387                 updatedServiceDetails.setDescription("desc      ription     ");
1388                 RestResponse updateServiceResponse2 = ServiceRestUtils.updateService(updatedServiceDetails,
1389                                 sdncDesignerDetails);
1390                 assertNotNull(updateServiceResponse2);
1391                 assertNotNull(updateServiceResponse2.getErrorCode());
1392                 assertEquals(200, updateServiceResponse2.getErrorCode().intValue());
1393                 updatedServiceDetails.setDescription("desc ription");
1394                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse2);
1395                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1396         }
1397
1398         @Test
1399         public void descriptionValidationTest8() throws Exception {
1400                 updatedServiceDetails.setDescription("desc" + StringUtils.LF + "ription");
1401                 RestResponse updateServiceResponse3 = ServiceRestUtils.updateService(updatedServiceDetails,
1402                                 sdncDesignerDetails);
1403                 assertNotNull(updateServiceResponse3);
1404                 assertNotNull(updateServiceResponse3.getErrorCode());
1405                 assertEquals(200, updateServiceResponse3.getErrorCode().intValue());
1406                 updatedServiceDetails.setDescription("desc ription");
1407                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse3);
1408                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1409         }
1410
1411         @Test
1412         public void descriptionValidationTest9() throws Exception {
1413                 updatedServiceDetails.setDescription("<html>Hello, <b>world!</b></html>");
1414                 RestResponse updateServiceResponse4 = ServiceRestUtils.updateService(updatedServiceDetails,
1415                                 sdncDesignerDetails);
1416                 assertNotNull(updateServiceResponse4);
1417                 assertNotNull(updateServiceResponse4.getErrorCode());
1418                 assertEquals(200, updateServiceResponse4.getErrorCode().intValue());
1419                 updatedServiceDetails.setDescription("Hello, world!");
1420                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse4);
1421                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1422         }
1423
1424         @Test
1425         public void descriptionValidationTest10() throws Exception {
1426                 updatedServiceDetails.setDescription("\uC2B5");
1427                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_DESCRIPTION, new ArrayList<>(Arrays.asList("Service")));
1428
1429         }
1430
1431         @Test
1432         public void descriptionValidationTest10_a() throws Exception {
1433                 updatedServiceDetails.setDescription("文");
1434                 updateWithInvalidValue(ActionStatus.COMPONENT_INVALID_DESCRIPTION, new ArrayList<>(Arrays.asList("Service")));
1435
1436         }
1437
1438         @Test
1439         public void descriptionValidationTest10_b() throws Exception {
1440                 updatedServiceDetails.setDescription("\uC2B5abc");
1441                 RestResponse updateServiceResponse5 = ServiceRestUtils.updateService(updatedServiceDetails,
1442                                 sdncDesignerDetails);
1443                 assertNotNull(updateServiceResponse5);
1444                 assertNotNull(updateServiceResponse5.getErrorCode());
1445                 assertEquals(200, updateServiceResponse5.getErrorCode().intValue());
1446                 updatedServiceDetails.setDescription("abc");
1447                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse5);
1448                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1449
1450         }
1451
1452         @Test
1453         public void descriptionValidationTest11() throws Exception {
1454                 updatedServiceDetails.setDescription("&<>");
1455                 RestResponse updateServiceResponse6 = ServiceRestUtils.updateService(updatedServiceDetails,
1456                                 sdncDesignerDetails);
1457                 assertNotNull(updateServiceResponse6);
1458                 assertNotNull(updateServiceResponse6.getErrorCode());
1459                 assertEquals(200, updateServiceResponse6.getErrorCode().intValue());
1460                 updatedServiceDetails.setDescription("&amp;&lt;&gt;");
1461                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse6);
1462                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1463         }
1464
1465         @Test
1466         public void descriptionValidationTest12() throws Exception {
1467                 updatedServiceDetails.setDescription("文 test");
1468                 RestResponse updateServiceResponse7 = ServiceRestUtils.updateService(updatedServiceDetails,
1469                                 sdncDesignerDetails);
1470                 assertNotNull(updateServiceResponse7);
1471                 assertNotNull(updateServiceResponse7.getErrorCode());
1472                 assertEquals(200, updateServiceResponse7.getErrorCode().intValue());
1473                 updatedServiceDetails.setDescription("test");
1474                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse7);
1475                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1476         }
1477
1478         @Test
1479         public void descriptionValidationTest13() throws Exception {
1480                 updatedServiceDetails.setDescription("   description");
1481                 RestResponse updateServiceResponse8 = ServiceRestUtils.updateService(updatedServiceDetails,
1482                                 sdncDesignerDetails);
1483                 assertNotNull(updateServiceResponse8);
1484                 assertNotNull(updateServiceResponse8.getErrorCode());
1485                 assertEquals(200, updateServiceResponse8.getErrorCode().intValue());
1486                 updatedServiceDetails.setDescription("description");
1487                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse8);
1488                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1489         }
1490
1491         @Test
1492         public void descriptionValidationTest14() throws Exception {
1493                 updatedServiceDetails.setDescription(multipleString("a", 1025));
1494                 updateWithInvalidValue(ActionStatus.COMPONENT_DESCRIPTION_EXCEEDS_LIMIT,
1495                                 new ArrayList<>(Arrays.asList("Service", "1024")));
1496         }
1497
1498         @Test
1499         public void projectCodeValidationTest1() throws Exception {
1500                 String desc = StringUtils.EMPTY;
1501                 for (int i = 0; i < 10; i++) {
1502                         desc += Integer.toString(i);
1503                         if (i >= 4) {
1504                                 updatedServiceDetails.setProjectCode(desc);
1505                                 correctUpdate();
1506                         }
1507                 }
1508         }
1509
1510         @Test
1511         public void projectCodeValidationTest2() throws Exception {
1512                 updatedServiceDetails.setProjectCode(multipleString("1", 6));
1513                 correctUpdate();
1514         }
1515
1516         @Test
1517         public void projectCodeValidationTest3() throws Exception {
1518                 this.specialCharsChecking("projectCode");
1519         }
1520
1521         // TODO Irrelevant
1522         @Test(enabled = false)
1523         public void projectCodeValidationTest4() throws Exception {
1524                 updatedServiceDetails.setProjectCode(multipleString(" ", 5) + "99999");
1525                 RestResponse updateServiceResponse = ServiceRestUtils.updateService(updatedServiceDetails, sdncDesignerDetails);
1526                 assertNotNull(updateServiceResponse);
1527                 assertNotNull(updateServiceResponse.getErrorCode());
1528                 assertEquals(200, updateServiceResponse.getErrorCode().intValue());
1529                 updatedServiceDetails.setProjectCode("12345");
1530                 validateActualVsExpected(updatedServiceDetails, updateServiceResponse);
1531                 getServiceAndValidate(updatedServiceDetails, LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1532
1533         }
1534
1535         @Test
1536         public void projectCodeValidationTest5() throws Exception {
1537                 updatedServiceDetails.setProjectCode(multipleString("0", 11));
1538                 updateWithInvalidValue(ActionStatus.INVALID_PROJECT_CODE, listForMessage);
1539         }
1540
1541         @Test
1542         public void projectCodeValidationTest6() throws Exception {
1543                 updatedServiceDetails.setProjectCode(multipleString("1", 4));
1544                 updateWithInvalidValue(ActionStatus.INVALID_PROJECT_CODE, listForMessage);
1545         }
1546
1547         @Test
1548         public void projectCodeValidationTest7() throws Exception {
1549                 updatedServiceDetails.setProjectCode("123456789");
1550                 correctUpdate();
1551         }
1552
1553         // ////US553874
1554         // @JsonIgnore
1555         // @Test
1556         // public void UpdateServiceVersion01_isVNF_toTrue() throws Exception{
1557         //
1558         // //choose the user to create service
1559         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1560         // // new service details
1561         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1562         // // clean audit DB before updating service
1563         // DbUtils.cleanAllAudits();
1564         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1565         // sdncUserDetails.getUserId());
1566         // serviceDetails = ElementFactory.getDefaultService();
1567         //
1568         // //send create service toward BE
1569         // RestResponse restResponse =
1570         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1571         // assertNotNull("check error code exists in response after create service",
1572         // restResponse.getErrorCode());
1573         // assertEquals("Check response code after updating Interface Artifact",
1574         // 201, restResponse.getErrorCode().intValue());
1575         //
1576         // //get service and verify that service created with isVNF defined in
1577         // serviceDetails
1578         // RestResponse serviceByNameAndVersion =
1579         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1580         // serviceDetails.getName(), "0.1");
1581         // Service serviceObject =
1582         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1583         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1584         // serviceObject, sdncUserDetails,
1585         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1586         //
1587         // //validate audit
1588         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1589         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1590         // sdncUserDetails);
1591         // String auditAction="Create";
1592         // expectedResourceAuditJavaObject.setPrevState("");
1593         // expectedResourceAuditJavaObject.setPrevVersion("");
1594         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1595         // expectedResourceAuditJavaObject.setStatus("201");
1596         // expectedResourceAuditJavaObject.setDesc("OK");
1597         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1598         // auditAction, null, false);
1599         //
1600         //
1601         // //Update Service IsVNF to True
1602         // restResponse =
1603         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1604         // serviceDetails, sdncUserDetails);
1605         // assertNotNull("check error code exists in response after create service",
1606         // restResponse.getErrorCode());
1607         // assertEquals("Check response code after updating Interface Artifact",
1608         // 200, restResponse.getErrorCode().intValue());
1609         //
1610         // //get service and verify that service created with isVNF defined in
1611         // serviceDetails
1612         // serviceByNameAndVersion =
1613         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1614         // serviceDetails.getName(), "0.1");
1615         // serviceObject =
1616         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1617         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1618         // serviceObject, sdncUserDetails,
1619         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1620         //
1621         // }
1622         //
1623         // @JsonIgnore
1624         // @Test
1625         // public void UpdateServiceVersion02_isVNF_toFalse() throws Exception{
1626         //
1627         // //choose the user to create service
1628         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1629         // // new service details
1630         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1631         // // clean audit DB before updating service
1632         // DbUtils.cleanAllAudits();
1633         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1634         // sdncUserDetails.getUserId());
1635         // serviceDetails = ElementFactory.getDefaultService();
1636         //
1637         // //send create service toward BE
1638         // RestResponse restResponse =
1639         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1640         // assertNotNull("check error code exists in response after create service",
1641         // restResponse.getErrorCode());
1642         // assertEquals("Check response code after updating Interface Artifact",
1643         // 201, restResponse.getErrorCode().intValue());
1644         //
1645         // //get service and verify that service created with isVNF defined in
1646         // serviceDetails
1647         // RestResponse serviceByNameAndVersion =
1648         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1649         // serviceDetails.getName(), "0.1");
1650         // Service serviceObject =
1651         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1652         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1653         // serviceObject, sdncUserDetails,
1654         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1655         //
1656         // //validate audit
1657         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1658         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1659         // sdncUserDetails);
1660         // String auditAction="Create";
1661         // expectedResourceAuditJavaObject.setPrevState("");
1662         // expectedResourceAuditJavaObject.setPrevVersion("");
1663         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1664         // expectedResourceAuditJavaObject.setStatus("201");
1665         // expectedResourceAuditJavaObject.setDesc("OK");
1666         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1667         // auditAction, null, false);
1668         //
1669         //
1670         // //Update Service IsVNF to True
1671         // restResponse =
1672         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1673         // serviceDetails, sdncUserDetails);
1674         // assertNotNull("check error code exists in response after create service",
1675         // restResponse.getErrorCode());
1676         // assertEquals("Check response code after updating Interface Artifact",
1677         // 200, restResponse.getErrorCode().intValue());
1678         //
1679         // //get service and verify that service created with isVNF defined in
1680         // serviceDetails
1681         // serviceByNameAndVersion =
1682         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1683         // serviceDetails.getName(), "0.1");
1684         // serviceObject =
1685         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1686         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1687         // serviceObject, sdncUserDetails,
1688         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1689         // }
1690         //
1691         // @JsonIgnore
1692         // @Test
1693         // public void UpdateServiceVersion01_isVNF_TrueToNull() throws Exception{
1694         //
1695         // //choose the user to create service
1696         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1697         // // new service details
1698         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1699         // // clean audit DB before updating service
1700         // DbUtils.cleanAllAudits();
1701         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1702         // sdncUserDetails.getUserId());
1703         // serviceDetails = ElementFactory.getDefaultService();
1704         //
1705         // //send create service toward BE
1706         // RestResponse restResponse =
1707         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1708         // assertNotNull("check error code exists in response after create service",
1709         // restResponse.getErrorCode());
1710         // assertEquals("Check response code after updating Interface Artifact",
1711         // 201, restResponse.getErrorCode().intValue());
1712         //
1713         // //get service and verify that service created with isVNF defined in
1714         // serviceDetails
1715         // RestResponse serviceByNameAndVersion =
1716         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1717         // serviceDetails.getName(), "0.1");
1718         // Service serviceObject =
1719         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1720         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1721         // serviceObject, sdncUserDetails,
1722         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1723         //
1724         // //validate audit
1725         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1726         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1727         // sdncUserDetails);
1728         // String auditAction="Create";
1729         // expectedResourceAuditJavaObject.setPrevState("");
1730         // expectedResourceAuditJavaObject.setPrevVersion("");
1731         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1732         // expectedResourceAuditJavaObject.setStatus("201");
1733         // expectedResourceAuditJavaObject.setDesc("OK");
1734         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1735         // auditAction, null, false);
1736         //
1737         //
1738         // //Update Service IsVNF to True
1739         // restResponse =
1740         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1741         // serviceDetails, sdncUserDetails);
1742         // assertNotNull("check error code exists in response after create service",
1743         // restResponse.getErrorCode());
1744         // assertEquals("Check response code after updating Interface Artifact",
1745         // 400, restResponse.getErrorCode().intValue());
1746         // List<String> variables = Arrays.asList("VNF Service Indicator");
1747         // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_DATA.name(),
1748         // variables, restResponse.getResponse());
1749         //
1750         // //get service and verify that service created with isVNF is remained with
1751         // isVNF = true
1752         // serviceByNameAndVersion =
1753         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1754         // serviceDetails.getName(), "0.1");
1755         // serviceObject =
1756         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1757         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1758         // serviceObject, sdncUserDetails,
1759         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1760         // }
1761         //
1762         // @JsonIgnore
1763         // @Test
1764         // public void UpdateServiceVersion01_isVNF_FalseToNull() throws Exception{
1765         //
1766         // //choose the user to create service
1767         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1768         // // new service details
1769         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1770         // // clean audit DB before updating service
1771         // DbUtils.cleanAllAudits();
1772         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1773         // sdncUserDetails.getUserId());
1774         // serviceDetails = ElementFactory.getDefaultService();
1775         //
1776         // //send create service toward BE
1777         // RestResponse restResponse =
1778         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1779         // assertNotNull("check error code exists in response after create service",
1780         // restResponse.getErrorCode());
1781         // assertEquals("Check response code after updating Interface Artifact",
1782         // 201, restResponse.getErrorCode().intValue());
1783         //
1784         // //get service and verify that service created with isVNF defined in
1785         // serviceDetails
1786         // RestResponse serviceByNameAndVersion =
1787         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1788         // serviceDetails.getName(), "0.1");
1789         // Service serviceObject =
1790         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1791         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1792         // serviceObject, sdncUserDetails,
1793         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1794         //
1795         // //validate audit
1796         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1797         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1798         // sdncUserDetails);
1799         // String auditAction="Create";
1800         // expectedResourceAuditJavaObject.setPrevState("");
1801         // expectedResourceAuditJavaObject.setPrevVersion("");
1802         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1803         // expectedResourceAuditJavaObject.setStatus("201");
1804         // expectedResourceAuditJavaObject.setDesc("OK");
1805         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1806         // auditAction, null, false);
1807         //
1808         //
1809         // //Update Service IsVNF to True
1810         // restResponse =
1811         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1812         // serviceDetails, sdncUserDetails);
1813         // assertNotNull("check error code exists in response after create service",
1814         // restResponse.getErrorCode());
1815         // assertEquals("Check response code after updating Interface Artifact",
1816         // 400, restResponse.getErrorCode().intValue());
1817         // List<String> variables = Arrays.asList("VNF Service Indicator");
1818         // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_DATA.name(),
1819         // variables, restResponse.getResponse());
1820         //
1821         // //get service and verify that service created with isVNF is remained with
1822         // isVNF = true
1823         // serviceByNameAndVersion =
1824         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1825         // serviceDetails.getName(), "0.1");
1826         // serviceObject =
1827         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1828         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1829         // serviceObject, sdncUserDetails,
1830         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1831         // }
1832         //
1833         // @JsonIgnore
1834         // @Test
1835         // public void UpdateServiceVersion02_IsVNF_toTrue() throws Exception{
1836         //
1837         // //choose the user to create service
1838         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1839         // // new service details
1840         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1841         // // clean audit DB before updating service
1842         // DbUtils.cleanAllAudits();
1843         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1844         // sdncUserDetails.getUserId());
1845         // serviceDetails = ElementFactory.getDefaultService();
1846         //
1847         // //send create service toward BE
1848         // RestResponse restResponse =
1849         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1850         // assertNotNull("check error code exists in response after create service",
1851         // restResponse.getErrorCode());
1852         // assertEquals("Check response code after updating Interface Artifact",
1853         // 201, restResponse.getErrorCode().intValue());
1854         //
1855         // //get service and verify that service created with isVNF defined in
1856         // serviceDetails
1857         // RestResponse serviceByNameAndVersion =
1858         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1859         // serviceDetails.getName(), "0.1");
1860         // Service serviceObject =
1861         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1862         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1863         // serviceObject, sdncUserDetails,
1864         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1865         //
1866         // LifecycleRestUtils.changeServiceState(serviceDetails,
1867         // sdncDesignerDetails, serviceDetails.getVersion(),
1868         // LifeCycleStatesEnum.CHECKIN);
1869         // LifecycleRestUtils.changeServiceState(serviceDetails,
1870         // sdncDesignerDetails, serviceDetails.getVersion(),
1871         // LifeCycleStatesEnum.CHECKOUT);
1872         //
1873         // //validate audit
1874         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1875         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1876         // sdncUserDetails);
1877         // String auditAction="Create";
1878         // expectedResourceAuditJavaObject.setPrevState("");
1879         // expectedResourceAuditJavaObject.setPrevVersion("");
1880         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1881         // expectedResourceAuditJavaObject.setStatus("201");
1882         // expectedResourceAuditJavaObject.setDesc("OK");
1883         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1884         // auditAction, null, false);
1885         //
1886         //
1887         // //Update Service IsVNF to True
1888         // restResponse =
1889         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1890         // serviceDetails, sdncUserDetails);
1891         // assertNotNull("check error code exists in response after create service",
1892         // restResponse.getErrorCode());
1893         // assertEquals("Check response code after updating Interface Artifact",
1894         // 200, restResponse.getErrorCode().intValue());
1895         //
1896         // //get service and verify that service created with isVNF defined in
1897         // serviceDetails
1898         // serviceByNameAndVersion =
1899         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1900         // serviceDetails.getName(), "0.1");
1901         // serviceObject =
1902         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1903         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1904         // serviceObject, sdncUserDetails,
1905         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1906         //
1907         // }
1908         //
1909         // @JsonIgnore
1910         // @Test
1911         // public void UpdateServiceVersion02_IsVNF_toFalse() throws Exception{
1912         //
1913         // //choose the user to create service
1914         // User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1915         // // new service details
1916         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1917         // // clean audit DB before updating service
1918         // DbUtils.cleanAllAudits();
1919         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1920         // sdncUserDetails.getUserId());
1921         // serviceDetails = ElementFactory.getDefaultService();
1922         //
1923         // //send create service toward BE
1924         // RestResponse restResponse =
1925         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1926         // assertNotNull("check error code exists in response after create service",
1927         // restResponse.getErrorCode());
1928         // assertEquals("Check response code after updating Interface Artifact",
1929         // 201, restResponse.getErrorCode().intValue());
1930         //
1931         // //get service and verify that service created with isVNF defined in
1932         // serviceDetails
1933         // RestResponse serviceByNameAndVersion =
1934         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1935         // serviceDetails.getName(), "0.1");
1936         // Service serviceObject =
1937         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1938         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1939         // serviceObject, sdncUserDetails,
1940         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1941         //
1942         // LifecycleRestUtils.changeServiceState(serviceDetails,
1943         // sdncDesignerDetails, serviceDetails.getVersion(),
1944         // LifeCycleStatesEnum.CHECKIN);
1945         // LifecycleRestUtils.changeServiceState(serviceDetails,
1946         // sdncDesignerDetails, serviceDetails.getVersion(),
1947         // LifeCycleStatesEnum.CHECKOUT);
1948         //
1949         // //validate audit
1950         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
1951         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
1952         // sdncUserDetails);
1953         // String auditAction="Create";
1954         // expectedResourceAuditJavaObject.setPrevState("");
1955         // expectedResourceAuditJavaObject.setPrevVersion("");
1956         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1957         // expectedResourceAuditJavaObject.setStatus("201");
1958         // expectedResourceAuditJavaObject.setDesc("OK");
1959         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
1960         // auditAction, null, false);
1961         //
1962         //
1963         // //Update Service IsVNF to false
1964         // restResponse =
1965         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1966         // serviceDetails, sdncUserDetails);
1967         // //restResponse =
1968         // ServiceRestUtils.updateService(serviceDetails.getUniqueId(),
1969         // serviceDetails, sdncUserDetails);
1970         // assertNotNull("check error code exists in response after create service",
1971         // restResponse.getErrorCode());
1972         // assertEquals("Check response code after updating Interface Artifact",
1973         // 200, restResponse.getErrorCode().intValue());
1974         //
1975         // //get service and verify that service created with isVNF defined in
1976         // serviceDetails
1977         // serviceByNameAndVersion =
1978         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
1979         // serviceDetails.getName(), "0.1");
1980         // serviceObject =
1981         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
1982         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
1983         // serviceObject, sdncUserDetails,
1984         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
1985         //
1986         // }
1987         //
1988         // @JsonIgnore
1989         // @Test
1990         // public void UpdateServiceVersion11_IsVNF_toFalse() throws Exception{
1991         // // Can't update isVNF when service version is 1.X
1992         // User sdncUserDetails =
1993         // ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1994         // // new service details
1995         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1996         // // clean audit DB before updating service
1997         // DbUtils.cleanAllAudits();
1998         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
1999         // sdncUserDetails.getUserId());
2000         // serviceDetails = ElementFactory.getDefaultService();
2001         //
2002         // //send create service toward BE
2003         // RestResponse restResponse =
2004         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
2005         // assertNotNull("check error code exists in response after create service",
2006         // restResponse.getErrorCode());
2007         // assertEquals("Check response code after updating Interface Artifact",
2008         // 201, restResponse.getErrorCode().intValue());
2009         //
2010         // //get service and verify that service created with isVNF defined in
2011         // serviceDetails
2012         // RestResponse serviceByNameAndVersion =
2013         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
2014         // serviceDetails.getName(), "0.1");
2015         // Service serviceObject =
2016         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
2017         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
2018         // serviceObject, sdncUserDetails,
2019         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2020         // //String serviceUniqueName =
2021         // ServiceRestUtils.getServiceUniqueId(serviceByNameAndVersion);
2022         //
2023         // //validate audit
2024         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
2025         // ServiceRestUtils.constructFieldsForAuditValidation(serviceDetails, "0.1",
2026         // sdncUserDetails);
2027         // String auditAction="Create";
2028         // expectedResourceAuditJavaObject.setPrevState("");
2029         // expectedResourceAuditJavaObject.setPrevVersion("");
2030         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
2031         // expectedResourceAuditJavaObject.setStatus("201");
2032         // expectedResourceAuditJavaObject.setDesc("OK");
2033         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
2034         // auditAction, null, false);
2035         //
2036         //// ServiceRestUtils.addServiceMandatoryArtifacts(sdncUserDetails,
2037         // restResponse);
2038         // RestResponse response =
2039         // ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails,
2040         // sdncUserDetails, serviceDetails.getUniqueId(),
2041         // ComponentTypeEnum.SERVICE);
2042         // assertTrue("response code is not 201, returned: " +
2043         // response.getErrorCode(),response.getErrorCode() == 201);
2044         // RestResponse changeServiceState =
2045         // LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
2046         // assertTrue("certify service request returned status:" +
2047         // changeServiceState.getErrorCode(),changeServiceState.getErrorCode() ==
2048         // 200);
2049         // LifecycleRestUtils.changeServiceState(serviceDetails, sdncUserDetails,
2050         // LifeCycleStatesEnum.CHECKOUT);
2051         //
2052         // //Update Service IsVNF to false
2053         // restResponse = ServiceRestUtils.updateService(serviceDetails,
2054         // sdncUserDetails);
2055         // assertNotNull("check error code exists in response after create service",
2056         // restResponse.getErrorCode());
2057         // assertEquals("Check response code after updating service metadata", 400,
2058         // restResponse.getErrorCode().intValue());
2059         // List<String> variables = new ArrayList<String>();
2060         // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_IS_VNF_CANNOT_BE_CHANGED.name(),
2061         // variables, restResponse.getResponse());
2062         //
2063         //
2064         // //get service and verify that service created with isVNF defined in
2065         // serviceDetails
2066         // serviceByNameAndVersion =
2067         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
2068         // serviceDetails.getName(), "1.1");
2069         // serviceObject =
2070         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
2071         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
2072         // serviceObject, sdncUserDetails,
2073         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2074         //
2075         // }
2076         //
2077         // @JsonIgnore
2078         // @Test
2079         // public void UpdateServiceVersion11_IsVNF_toTrue() throws Exception{
2080         // // Can't update isVNF when service version is 1.X
2081         // User sdncUserDetails =
2082         // ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
2083         // // new service details
2084         // // ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
2085         // // clean audit DB before updating service
2086         // DbUtils.cleanAllAudits();
2087         // ServiceRestUtils.deleteServiceById(serviceDetails.getUniqueId(),
2088         // sdncUserDetails.getUserId());
2089         // serviceDetails = ElementFactory.getDefaultService();
2090         //
2091         // //send create service toward BE
2092         // RestResponse restResponse =
2093         // ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
2094         // assertNotNull("check error code exists in response after create service",
2095         // restResponse.getErrorCode());
2096         // assertEquals("Check response code after updating Interface Artifact",
2097         // 201, restResponse.getErrorCode().intValue());
2098         //
2099         // //get service and verify that service created with isVNF defined in
2100         // serviceDetails
2101         // RestResponse serviceByNameAndVersion =
2102         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
2103         // serviceDetails.getName(), "0.1");
2104         // Service serviceObject =
2105         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
2106         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
2107         // serviceObject, sdncUserDetails,
2108         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2109         // //String serviceUniqueName =
2110         // ServiceRestUtils.getServiceUniqueId(serviceByNameAndVersion);
2111         //
2112         // //validate audit
2113         // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
2114         // ServiceValidationUtils.constructFieldsForAuditValidation(serviceDetails,
2115         // "0.1", sdncUserDetails);
2116         // String auditAction="Create";
2117         // expectedResourceAuditJavaObject.setPrevState("");
2118         // expectedResourceAuditJavaObject.setPrevVersion("");
2119         // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
2120         // expectedResourceAuditJavaObject.setStatus("201");
2121         // expectedResourceAuditJavaObject.setDesc("OK");
2122         // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
2123         // auditAction, null, false);
2124         //
2125         //// ServiceRestUtils.addServiceMandatoryArtifacts(sdncUserDetails,
2126         // restResponse);
2127         // RestResponse response =
2128         // ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails,
2129         // sdncUserDetails, serviceDetails.getUniqueId(),
2130         // ComponentTypeEnum.SERVICE);
2131         // assertTrue("response code is not 201, returned: " +
2132         // response.getErrorCode(),response.getErrorCode() == 201);
2133         // RestResponse changeServiceState =
2134         // LCSbaseTest.certifyService(serviceDetails, sdncDesignerDetails);
2135         // assertTrue("certify service request returned status:" +
2136         // changeServiceState.getErrorCode(),changeServiceState.getErrorCode() ==
2137         // 200);
2138         // LifecycleRestUtils.changeServiceState(serviceDetails, sdncUserDetails,
2139         // LifeCycleStatesEnum.CHECKOUT);
2140         //
2141         // //Update Service IsVNF to false
2142         // restResponse = ServiceRestUtils.updateService(serviceDetails,
2143         // sdncUserDetails);
2144         // assertNotNull("check error code exists in response after create service",
2145         // restResponse.getErrorCode());
2146         // assertEquals("Check response code after updating service metadata", 400,
2147         // restResponse.getErrorCode().intValue());
2148         // List<String> variables = new ArrayList<String>();
2149         // ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.SERVICE_IS_VNF_CANNOT_BE_CHANGED.name(),
2150         // variables, restResponse.getResponse());
2151         //
2152         // //get service and verify that service created with isVNF defined in
2153         // serviceDetails
2154         // serviceByNameAndVersion =
2155         // ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
2156         // serviceDetails.getName(), "1.1");
2157         // serviceObject =
2158         // ResponseParser.convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
2159         // ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails,
2160         // serviceObject, sdncUserDetails,
2161         // LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
2162         // }
2163
2164 }