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