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