test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/property/AdditionalInformationServletTest.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.property;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import java.io.IOException;
  29 import java.lang.reflect.Type;
  30 import java.util.ArrayList;
  31 import java.util.HashMap;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 import org.json.simple.parser.JSONParser;
  36 import org.junit.Rule;
  37 import org.junit.rules.TestName;
  38 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.model.AdditionalInformationDefinition;
  41 import org.openecomp.sdc.be.model.PropertyConstraint;
  42 import org.openecomp.sdc.be.model.Resource;
  43 import org.openecomp.sdc.be.model.User;
  44 import org.openecomp.sdc.be.model.operations.impl.PropertyOperation.PropertyConstraintDeserialiser;
  45 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  46 import org.openecomp.sdc.ci.tests.api.Urls;
  47 import org.openecomp.sdc.ci.tests.config.Config;
  48 import org.openecomp.sdc.ci.tests.datatypes.ArtifactReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  50 import org.openecomp.sdc.ci.tests.datatypes.ResourceReqDetails;
  51 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.enums.ResourceCategoryEnum;
  55 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  56 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  57 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  58 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  59 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  60 import org.openecomp.sdc.ci.tests.execute.resource.ResourceApiTest;
  61 import org.openecomp.sdc.ci.tests.utils.Utils;
  62 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  63 import org.openecomp.sdc.ci.tests.utils.rest.ArtifactRestUtils;
  64 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  65 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  66 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  67 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  68 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  69 import org.testng.AssertJUnit;
  70 import org.testng.annotations.Test;
  71
  72 import com.google.gson.Gson;
  73 import com.google.gson.GsonBuilder;
  74 import com.google.gson.reflect.TypeToken;
  75
  76 public class AdditionalInformationServletTest extends ComponentBaseTest {
  77
  78         protected Type constraintType = new TypeToken<PropertyConstraint>() {
  79         }.getType();
  80
  81         protected Gson gson = new GsonBuilder().registerTypeAdapter(constraintType, new PropertyConstraintDeserialiser()).create();
  82
  83         @Rule
  84         public static TestName name = new TestName();
  85
  86         protected String contentTypeHeaderData = "application/json";
  87         protected String acceptHeaderDate = "application/json";
  88
  89         protected JSONParser jsonParser = new JSONParser();
  90
  91         public AdditionalInformationServletTest() {
  92                 super(name, AdditionalInformationServletTest.class.getName());
  93         }
  94
  95         // @Before
  96         // public void deleteResources() {
  97         // //TODO Evg : will be new API added for delete by name and version
  98         //
  99         // ResourceReqDetails resource = getResource();
 100         // User user = getUser();
 101         //
 102         // try {
 103         // String resourceName = resource.getResourceName();
 104         // ResourceRestUtils.deleteResourceByNameAndVersion(user, resourceName,
 105         // "0.1");
 106         // ResourceRestUtils.deleteResourceByNameAndVersion(user, resourceName,
 107         // "0.2");
 108         // ResourceRestUtils.deleteResourceByNameAndVersion(user, resourceName,
 109         // "1.0");
 110         // ResourceRestUtils.deleteResourceByNameAndVersion(user, resourceName,
 111         // "1.1");
 112         // ResourceRestUtils.deleteResourceByNameAndVersion(user, resourceName +
 113         // "aa", "0.1");
 114         // resourceUtils.deleteResource_allVersions(resource, user);
 115         //
 116         // } catch (IOException e) {
 117         // assertTrue(false);
 118         // }
 119         //
 120         // try {
 121         // ServiceReqDetails serviceDetails = getServiceDetails();
 122         //
 123         // RestResponse deleteServiceResponse =
 124         // serviceUtils.deleteServiceByNameAndVersion(UserUtils.getAdminDetails(),
 125         // serviceDetails.getServiceName(), "0.1");
 126         //
 127         // assertNotNull("check response object is not null after delete
 128         // service",deleteServiceResponse);
 129         // assertNotNull("check error code exists in response after delete
 130         // service",deleteServiceResponse.getErrorCode());
 131         // assertTrue("delete service failed status:" +
 132         // deleteServiceResponse.getErrorCode(),
 133         // deleteServiceResponse.getErrorCode() != 500);
 134         //
 135         // deleteServiceResponse =
 136         // serviceUtils.deleteServiceByNameAndVersion(UserUtils.getAdminDetails(),
 137         // serviceDetails.getServiceName(), "1.0");
 138         //
 139         // assertNotNull("check response object is not null after delete
 140         // service",deleteServiceResponse);
 141         // assertNotNull("check error code exists in response after delete
 142         // service",deleteServiceResponse.getErrorCode());
 143         // assertTrue("delete service failed status:" +
 144         // deleteServiceResponse.getErrorCode(),
 145         // deleteServiceResponse.getErrorCode() != 500);
 146         //
 147         // serviceUtils.deleteService_allVersions(serviceDetails, user);
 148         //
 149         // } catch (IOException e) {
 150         // assertTrue(false);
 151         // }
 152         // }
 153
 154         @Test
 155         public void updateResourceAdditionalInformationTest() throws Exception {
 156                 User user = getUser();
 157                 ResourceReqDetails resource = getResource();
 158
 159                 // deleteResource(resourceId, user);
 160                 RestResponse createResourceResponse = createResource(resource, user);
 161
 162                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 163
 164                 AssertJUnit.assertNotNull("check response object is not null after create resource", createResourceResponse);
 165                 AssertJUnit.assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 166                 AssertJUnit.assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 167
 168                 String key = "AAA  AAA";
 169                 String value = "BBBB";
 170
 171                 String updatedKey = "ZZZ  ZZZ";
 172                 String updatedValue = "JJJJ";
 173
 174                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 175
 176                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 177                 AssertJUnit.assertNotNull("check response object is not null after create property", createProperty);
 178                 AssertJUnit.assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 179                 AssertJUnit.assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 180
 181                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 182                 AssertJUnit.assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 183                 AssertJUnit.assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 184
 185                 fromJson.setKey(updatedKey);
 186                 fromJson.setValue(updatedValue);
 187
 188                 RestResponse updatedProperty = updateAdditionalInformation(resourceId, fromJson, user, fromJson.getUniqueId());
 189                 AssertJUnit.assertNotNull("check response object is not null after update additional information", updatedProperty);
 190                 AssertJUnit.assertNotNull("check error code exists in response after additional information", updatedProperty.getErrorCode());
 191                 AssertJUnit.assertEquals("Check response code after additional information", 200, updatedProperty.getErrorCode().intValue());
 192
 193                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(updatedProperty.getResponse(), AdditionalInfoParameterInfo.class);
 194                 AssertJUnit.assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
 195                 AssertJUnit.assertEquals("check returned key", "ZZZ ZZZ", updatedJson.getKey());
 196                 AssertJUnit.assertEquals("check returned value", updatedValue, updatedJson.getValue());
 197                 AssertJUnit.assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
 198
 199         }
 200
 201         @Test
 202         public void deleteResourceAdditionalInformationTest() throws Exception {
 203                 User user = getUser();
 204                 ResourceReqDetails resource = getResource();
 205
 206                 RestResponse createResourceResponse = createResource(resource, user);
 207
 208                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 209
 210                 AssertJUnit.assertNotNull("check response object is not null after create resource", createResourceResponse);
 211                 AssertJUnit.assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 212                 AssertJUnit.assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 213
 214                 String key = "AAA  AAA";
 215                 String value = "BBBB";
 216
 217                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 218
 219                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 220                 AssertJUnit.assertNotNull("check response object is not null after create property", createProperty);
 221                 AssertJUnit.assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 222                 AssertJUnit.assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 223
 224                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 225                 AssertJUnit.assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 226                 AssertJUnit.assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 227
 228                 RestResponse deletedProperty = deleteAdditionalInformation(resourceId, fromJson.getUniqueId(), user);
 229                 AssertJUnit.assertNotNull("check response object is not null after update additional information", deletedProperty);
 230                 AssertJUnit.assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
 231                 AssertJUnit.assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
 232
 233                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInfoParameterInfo.class);
 234                 AssertJUnit.assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
 235                 AssertJUnit.assertEquals("check returned key", "AAA AAA", updatedJson.getKey());
 236                 AssertJUnit.assertEquals("check returned value", value, updatedJson.getValue());
 237                 AssertJUnit.assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
 238
 239                 deletedProperty = deleteAdditionalInformation(resourceId, fromJson.getUniqueId(), user);
 240                 AssertJUnit.assertNotNull("check response object is not null after update additional information", deletedProperty);
 241                 AssertJUnit.assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
 242                 AssertJUnit.assertEquals("Check response code after additional information", 409, deletedProperty.getErrorCode().intValue());
 243
 244         }
 245
 246         @Test
 247         public void createResourceAdditionalInformationTestDuringLifecycle() throws Exception {
 248                 User user = getUser();
 249                 ResourceReqDetails resource = getResource();
 250
 251                 // deleteResource(resourceId, user);
 252                 RestResponse createResourceResponse = createResource(resource, user);
 253
 254                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 255
 256                 AssertJUnit.assertNotNull("check response object is not null after create resource", createResourceResponse);
 257                 AssertJUnit.assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 258                 AssertJUnit.assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 259
 260                 String key = "AAA  AAA";
 261                 String value = "BBBB";
 262
 263                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 264
 265                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 266                 AssertJUnit.assertNotNull("check response object is not null after create property", createProperty);
 267                 AssertJUnit.assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 268                 AssertJUnit.assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 269
 270                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 271                 AssertJUnit.assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 272                 AssertJUnit.assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 273
 274                 resource.setUniqueId(resourceId);
 275
 276                 // resourceUtils.addResourceMandatoryArtifacts(user,
 277                 // createResourceResponse);
 278
 279                 certifyResource(user, resource, null, 1);
 280
 281         }
 282
 283         public RestResponse createService() {
 284
 285                 User user = getUser();
 286                 ServiceReqDetails serviceDetails = getServiceDetails();
 287
 288                 RestResponse createServiceResponse = null;
 289                 try {
 290                         createServiceResponse = ServiceRestUtils.createService(serviceDetails, user);
 291                         AssertJUnit.assertNotNull("check response object is not null after create user", createServiceResponse);
 292                         AssertJUnit.assertNotNull("check error code exists in response after create resource", createServiceResponse.getErrorCode());
 293                         AssertJUnit.assertEquals("Check response code after checkout resource", 201, createServiceResponse.getErrorCode().intValue());
 294                 } catch (Exception e) {
 295                         AssertJUnit.assertTrue(false);
 296                 }
 297
 298                 return createServiceResponse;
 299
 300         }
 301
 302         protected User getUser() {
 303                 String adminFirstName = "Jimmy";
 304                 String adminLastName = "Hendrix";
 305                 String adminUserId = "jh0003";
 306                 return new User(adminFirstName, adminLastName, adminUserId, null, null, null);
 307         }
 308
 309         protected ResourceReqDetails getResource() {
 310                 String resourceName = "ciResourceforproperty4";
 311                 String description = "description";
 312                 ArrayList<String> resourceTags = new ArrayList<String>();
 313                 resourceTags.add(resourceName);
 314                 ArrayList<String> derivedFrom = new ArrayList<String>();
 315                 derivedFrom.add("tosca.nodes.Root");
 316                 String vendorName = "Oracle";
 317                 String vendorRelease = "1.5";
 318                 String contactId = "pe0123";
 319                 String icon = "myICON";
 320                 ResourceReqDetails resource = new ResourceReqDetails(resourceName, description, resourceTags, null, derivedFrom, vendorName, vendorRelease, contactId, icon);
 321                 resource.addCategoryChain(ResourceCategoryEnum.GENERIC_DATABASE.getCategory(), ResourceCategoryEnum.GENERIC_DATABASE.getSubCategory());
 322                 return resource;
 323         }
 324
 325         protected RestResponse createResource(ResourceReqDetails resourceDetails, User sdncModifierDetails) throws IOException {
 326
 327                 ResourceApiTest rat = new ResourceApiTest();
 328                 ResourceReqDetails resourceObj = rat.getResourceObj();
 329
 330                 Config config = Utils.getConfig();
 331
 332                 Map<String, String> headersMap = new HashMap<String, String>();
 333                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 334                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 335                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 336
 337                 Gson gson = new Gson();
 338                 String userBodyJson = gson.toJson(resourceDetails);
 339                 HttpRequest http = new HttpRequest();
 340                 String url = String.format(Urls.CREATE_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort());
 341                 RestResponse createResourceResponse = http.httpSendPost(url, userBodyJson, headersMap);
 342
 343                 return createResourceResponse;
 344
 345         }
 346
 347         protected RestResponse getResource(User sdncModifierDetails, String resourceUid) throws IOException {
 348
 349                 ResourceApiTest rat = new ResourceApiTest();
 350                 ResourceReqDetails resourceObj = rat.getResourceObj();
 351
 352                 Config config = Utils.getConfig();
 353
 354                 Map<String, String> headersMap = new HashMap<String, String>();
 355                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 356                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 357                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 358
 359                 Gson gson = new Gson();
 360                 HttpRequest http = new HttpRequest();
 361                 String url = String.format(Urls.GET_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceUid);
 362                 RestResponse createResourceResponse = http.httpSendGet(url, headersMap);
 363
 364                 return createResourceResponse;
 365
 366         }
 367
 368         protected RestResponse deleteResource(String resourceName, String resourceVersion, User sdncModifierDetails) throws IOException {
 369                 RestResponse deleteResourceResponse = ResourceRestUtils.deleteResourceByNameAndVersion(sdncModifierDetails, resourceName, resourceVersion);
 370
 371                 return deleteResourceResponse;
 372
 373         }
 374
 375         protected RestResponse updateAdditionalInformation(String resourceId, AdditionalInfoParameterInfo additionalInfo, User sdncModifierDetails, String id) throws IOException {
 376                 Config config = Utils.getConfig();
 377
 378                 Map<String, String> headersMap = new HashMap<String, String>();
 379                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 380                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 381                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 382
 383                 Gson gson = new Gson();
 384                 String body = gson.toJson(additionalInfo);
 385                 HttpRequest http = new HttpRequest();
 386                 String url = String.format(Urls.UPDATE_ADDITIONAL_INFORMATION_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 387                 return http.httpSendPut(url, body, headersMap);
 388
 389         }
 390
 391         protected RestResponse updateServiceAdditionalInformation(String resourceId, AdditionalInfoParameterInfo additionalInfo, User sdncModifierDetails, String id) throws IOException {
 392                 Config config = Utils.getConfig();
 393
 394                 Map<String, String> headersMap = new HashMap<String, String>();
 395                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 396                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 397                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 398
 399                 Gson gson = new Gson();
 400                 String body = gson.toJson(additionalInfo);
 401                 HttpRequest http = new HttpRequest();
 402                 String url = String.format(Urls.UPDATE_ADDITIONAL_INFORMATION_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 403                 return http.httpSendPut(url, body, headersMap);
 404
 405         }
 406
 407         protected RestResponse deleteAdditionalInformation(String resourceId, String id, User sdncModifierDetails) throws IOException {
 408                 Config config = Utils.getConfig();
 409
 410                 Map<String, String> headersMap = new HashMap<String, String>();
 411                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 412                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 413                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 414
 415                 Gson gson = new Gson();
 416                 HttpRequest http = new HttpRequest();
 417                 String url = String.format(Urls.DELETE_ADDITIONAL_INFORMATION_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 418                 return http.httpSendDelete(url, headersMap);
 419
 420         }
 421
 422         protected RestResponse deleteServiceAdditionalInformation(String resourceId, String id, User sdncModifierDetails) throws IOException {
 423                 Config config = Utils.getConfig();
 424
 425                 Map<String, String> headersMap = new HashMap<String, String>();
 426                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 427                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 428                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 429
 430                 HttpRequest http = new HttpRequest();
 431                 String url = String.format(Urls.DELETE_ADDITIONAL_INFORMATION_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 432                 return http.httpSendDelete(url, headersMap);
 433
 434         }
 435
 436         protected RestResponse getAdditionalInformation(String resourceId, String id, User sdncModifierDetails) throws IOException {
 437                 Config config = Utils.getConfig();
 438
 439                 Map<String, String> headersMap = new HashMap<String, String>();
 440                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 441                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 442                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 443
 444                 HttpRequest http = new HttpRequest();
 445                 String url = String.format(Urls.GET_ADDITIONAL_INFORMATION_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 446                 return http.httpSendGet(url, headersMap);
 447
 448         }
 449
 450         protected RestResponse getServiceAdditionalInformation(String resourceId, String id, User sdncModifierDetails) throws IOException {
 451                 Config config = Utils.getConfig();
 452
 453                 Map<String, String> headersMap = new HashMap<String, String>();
 454                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 455                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 456                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 457
 458                 HttpRequest http = new HttpRequest();
 459                 String url = String.format(Urls.GET_ADDITIONAL_INFORMATION_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId, id);
 460                 return http.httpSendGet(url, headersMap);
 461
 462         }
 463
 464         protected RestResponse getResourceAllAdditionalInformation(String resourceId, User sdncModifierDetails) throws IOException {
 465                 Config config = Utils.getConfig();
 466
 467                 Map<String, String> headersMap = new HashMap<String, String>();
 468                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 469                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 470                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 471
 472                 Gson gson = new Gson();
 473                 HttpRequest http = new HttpRequest();
 474                 String url = String.format(Urls.GET_ALL_ADDITIONAL_INFORMATION_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
 475                 return http.httpSendGet(url, headersMap);
 476
 477         }
 478
 479         protected RestResponse getServiceAllAdditionalInformation(String resourceId, User sdncModifierDetails) throws IOException {
 480                 Config config = Utils.getConfig();
 481
 482                 Map<String, String> headersMap = new HashMap<String, String>();
 483                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 484                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 485                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 486
 487                 Gson gson = new Gson();
 488                 HttpRequest http = new HttpRequest();
 489                 String url = String.format(Urls.GET_ALL_ADDITIONAL_INFORMATION_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
 490                 return http.httpSendGet(url, headersMap);
 491
 492         }
 493
 494         protected RestResponse createResourceAdditionalInformation(String resourceId, AdditionalInfoParameterInfo additionalInfo, User sdncModifierDetails) throws IOException {
 495                 Config config = Utils.getConfig();
 496
 497                 Map<String, String> headersMap = new HashMap<String, String>();
 498                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 499                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 500                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 501
 502                 Gson gson = new Gson();
 503                 String body = gson.toJson(additionalInfo);
 504                 HttpRequest http = new HttpRequest();
 505                 String url = String.format(Urls.CREATE_ADDITIONAL_INFORMATION_RESOURCE, config.getCatalogBeHost(), config.getCatalogBePort(), resourceId);
 506                 return http.httpSendPost(url, body, headersMap);
 507
 508         }
 509
 510         protected RestResponse createServiceAdditionalInformation(String serviceId, AdditionalInfoParameterInfo additionalInfo, User sdncModifierDetails) throws IOException {
 511                 Config config = Utils.getConfig();
 512
 513                 Map<String, String> headersMap = new HashMap<String, String>();
 514                 headersMap.put(HttpHeaderEnum.CONTENT_TYPE.getValue(), contentTypeHeaderData);
 515                 headersMap.put(HttpHeaderEnum.ACCEPT.getValue(), acceptHeaderDate);
 516                 headersMap.put(HttpHeaderEnum.USER_ID.getValue(), sdncModifierDetails.getUserId());
 517
 518                 Gson gson = new Gson();
 519                 String body = gson.toJson(additionalInfo);
 520                 HttpRequest http = new HttpRequest();
 521                 String url = String.format(Urls.CREATE_ADDITIONAL_INFORMATION_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort(), serviceId);
 522                 return http.httpSendPost(url, body, headersMap);
 523
 524         }
 525
 526         protected ServiceReqDetails getServiceDetails() {
 527                 String serviceName = "ciNewTestService21";
 528                 String category = ServiceCategoriesEnum.MOBILITY.getValue();
 529                 ArrayList<String> tags = new ArrayList<String>();
 530                 tags.add("serviceTag");
 531                 tags.add(serviceName);
 532                 String description = "service Description";
 533                 String vendorName = "Oracle";
 534                 String vendorRelease = "0.1";
 535                 String contactId = "al1976";
 536                 String icon = "myIcon";
 537
 538                 return new ServiceReqDetails(serviceName, category, tags, description, contactId, icon);
 539         }
 540
 541         // TODO Tal: Since Cashing change partial resource returned that causes null
 542         // pointer exception in line:
 543         // commented out till fixing
 544         protected Resource certifyResource(User user, ResourceReqDetails resource, String resourceVersion, int numberOfAI) throws IOException {
 545                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKIN);
 546
 547                 AssertJUnit.assertNotNull("check response object is not null after create user", checkInResponse);
 548                 AssertJUnit.assertNotNull("check error code exists in response after create user", checkInResponse.getErrorCode());
 549                 AssertJUnit.assertEquals("Check response code after create user", 200, checkInResponse.getErrorCode().intValue());
 550
 551                 Resource resourceAfterOperation = gson.fromJson(checkInResponse.getResponse(), Resource.class);
 552                 // TODO Tal: Since Cashing change partial resource returned that causes
 553                 // null pointer exception
 554                 /*
 555                  * AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 556                  */
 557                 /*
 558                  * AssertJUnit.assertEquals("check size of additional information", numberOfAI, resourceAfterOperation.getAdditionalInformation().get(0). getParameters().size());
 559                  */
 560
 561                 RestResponse req4certResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 562
 563                 AssertJUnit.assertNotNull("check response object is not null after create user", req4certResponse);
 564                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, req4certResponse.getErrorCode().intValue());
 565
 566                 resourceAfterOperation = gson.fromJson(req4certResponse.getResponse(), Resource.class);
 567                 // TODO Tal: Since Cashing change partial resource returned that causes
 568                 // null pointer exception
 569                 /*
 570                  * AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 571                  */
 572                 /*
 573                  * AssertJUnit.assertEquals("check size of additional information", numberOfAI, resourceAfterOperation.getAdditionalInformation().get(0). getParameters().size());
 574                  */
 575
 576                 // change modifier
 577                 user.setUserId(UserRoleEnum.TESTER.getUserId());
 578                 // start certification
 579
 580                 RestResponse startCertResourceResponse3 = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
 581                 AssertJUnit.assertNotNull("check response object is not null after create user", startCertResourceResponse3);
 582                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, startCertResourceResponse3.getErrorCode().intValue());
 583
 584                 resourceAfterOperation = gson.fromJson(startCertResourceResponse3.getResponse(), Resource.class);
 585                 // TODO Tal: Since Cashing change partial resource returned that causes
 586                 // null pointer exception
 587                 /*
 588                  * AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 589                  */
 590                 /*
 591                  * AssertJUnit.assertEquals("check size of additional information", numberOfAI, resourceAfterOperation.getAdditionalInformation().get(0). getParameters().size());
 592                  */
 593
 594                 // certify
 595
 596                 RestResponse certifyResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CERTIFY);
 597                 AssertJUnit.assertNotNull("check response object is not null after create user", certifyResponse);
 598                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, certifyResponse.getErrorCode().intValue());
 599
 600                 resourceAfterOperation = gson.fromJson(certifyResponse.getResponse(), Resource.class);
 601                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 602                 AssertJUnit.assertEquals("check size of additional information", numberOfAI, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
 603
 604                 Resource certifyResource = gson.fromJson(certifyResponse.getResponse(), Resource.class);
 605                 return certifyResource;
 606         }
 607
 608         protected Resource certifyService(User user, ServiceReqDetails service, String resourceVersion) throws Exception {
 609                 RestResponse checkInResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CHECKIN);
 610
 611                 AssertJUnit.assertNotNull("check response object is not null after create user", checkInResponse);
 612                 AssertJUnit.assertNotNull("check error code exists in response after create user", checkInResponse.getErrorCode());
 613                 AssertJUnit.assertEquals("Check response code after create user", 200, checkInResponse.getErrorCode().intValue());
 614
 615                 Resource resourceAfterOperation = gson.fromJson(checkInResponse.getResponse(), Resource.class);
 616                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 617                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
 618
 619                 RestResponse req4certResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
 620
 621                 AssertJUnit.assertNotNull("check response object is not null after create user", req4certResponse);
 622                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, req4certResponse.getErrorCode().intValue());
 623
 624                 resourceAfterOperation = gson.fromJson(req4certResponse.getResponse(), Resource.class);
 625                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 626                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
 627
 628                 // change modifier
 629                 user.setUserId(UserRoleEnum.TESTER.getUserId());
 630                 // start certification
 631
 632                 RestResponse startCertResourceResponse3 = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION);
 633                 AssertJUnit.assertNotNull("check response object is not null after create user", startCertResourceResponse3);
 634                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, startCertResourceResponse3.getErrorCode().intValue());
 635
 636                 resourceAfterOperation = gson.fromJson(startCertResourceResponse3.getResponse(), Resource.class);
 637                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 638                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
 639
 640                 // certify
 641
 642                 RestResponse certifyResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CERTIFY);
 643                 AssertJUnit.assertNotNull("check response object is not null after create user", certifyResponse);
 644                 AssertJUnit.assertEquals("Check response code after checkout resource", 200, certifyResponse.getErrorCode().intValue());
 645
 646                 resourceAfterOperation = gson.fromJson(certifyResponse.getResponse(), Resource.class);
 647                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
 648                 AssertJUnit.assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
 649
 650                 Resource certifyResource = gson.fromJson(certifyResponse.getResponse(), Resource.class);
 651                 return certifyResource;
 652         }
 653
 654         @Test
 655         public void createResourceAdditionalInformationTest() throws Exception {
 656                 User user = getUser();
 657                 ResourceReqDetails resource = getResource();
 658
 659                 // deleteResource(resourceId, user);
 660                 RestResponse createResourceResponse = createResource(resource, user);
 661
 662                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 663
 664                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 665                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 666                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 667
 668                 String key = "AAA  AAA";
 669                 String value = "BBBB";
 670
 671                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 672
 673                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 674                 assertNotNull("check response object is not null after create property", createProperty);
 675                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 676                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 677
 678                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 679                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 680                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 681
 682                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 683                 assertNotNull("check response object is not null after create property", createProperty);
 684                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 685                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
 686
 687         }
 688
 689         @Test
 690         public void createResourceAdditionalInfoFormatWithTags() throws Exception {
 691                 User user = getUser();
 692                 ResourceReqDetails resource = getResource();
 693
 694                 // deleteResource(resourceId, user);
 695                 RestResponse createResourceResponse = createResource(resource, user);
 696
 697                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 698
 699                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 700                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 701                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 702
 703                 String key = "AAA  AAA";
 704                 String value = "<b>Bold<</b>";
 705
 706                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 707
 708                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 709                 assertNotNull("check response object is not null after create property", createProperty);
 710                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 711                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 712
 713                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 714                 assertEquals("check returned key", "Bold&amp;lt;", fromJson.getValue());
 715
 716         }
 717
 718         @Test
 719         public void createServiceAdditionalInfoFormatWithTags() throws Exception {
 720                 User user = getUser();
 721                 RestResponse createServiceResponse = createService();
 722
 723                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 724
 725                 assertNotNull("check response object is not null after create resource", createServiceResponse);
 726                 assertNotNull("check error code exists in response after create resource", createServiceResponse.getErrorCode());
 727                 assertEquals("Check response code after create resource", 201, createServiceResponse.getErrorCode().intValue());
 728
 729                 String key = "AAA  AAA";
 730                 String value = "<b>Bold<</b>";
 731
 732                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 733
 734                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 735                 assertNotNull("check response object is not null after create property", createProperty);
 736                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 737                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 738
 739                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 740                 assertEquals("check returned key", "Bold&amp;lt;", fromJson.getValue());
 741
 742         }
 743
 744         @Test
 745         public void createResourceAdditionalInfoFormatWithWhiteSpaces() throws Exception {
 746                 User user = getUser();
 747                 ResourceReqDetails resource = getResource();
 748
 749                 // deleteResource(resourceId, user);
 750                 RestResponse createResourceResponse = createResource(resource, user);
 751
 752                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 753
 754                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 755                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 756                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 757
 758                 String key = "AAA  AAA";
 759                 String value = "      ";
 760
 761                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 762
 763                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 764                 assertNotNull("check response object is not null after create property", createProperty);
 765                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 766                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 767
 768                 key = "    ";
 769                 value = "AAA  AAA";
 770
 771                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 772
 773                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 774                 assertNotNull("check response object is not null after create property", createProperty);
 775                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 776                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 777
 778         }
 779
 780         @Test
 781         public void createServiceAdditionalInfoFormatWithWhiteSpaces() throws Exception {
 782                 User user = getUser();
 783
 784                 RestResponse createServiceResponse = createService();
 785                 ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 786
 787                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 788
 789                 assertNotNull("check response object is not null after create resource", createServiceResponse);
 790                 assertNotNull("check error code exists in response after create resource", createServiceResponse.getErrorCode());
 791                 assertEquals("Check response code after create resource", 201, createServiceResponse.getErrorCode().intValue());
 792
 793                 String key = "AAA  AAA";
 794                 String value = "      ";
 795
 796                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 797
 798                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 799                 assertNotNull("check response object is not null after create property", createProperty);
 800                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 801                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 802
 803                 key = "    ";
 804                 value = "AAA  AAA";
 805
 806                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 807
 808                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 809                 assertNotNull("check response object is not null after create property", createProperty);
 810                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 811                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 812
 813         }
 814
 815         @Test
 816         public void createResourceAndUpdateAdditionalInfo() throws Exception {
 817                 User user = getUser();
 818                 ResourceReqDetails resource = getResource();
 819
 820                 // deleteResource(resourceId, user);
 821                 RestResponse createResourceResponse = createResource(resource, user);
 822
 823                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 824
 825                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 826                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 827                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 828
 829                 String key = "AAA  AAA";
 830                 String value = "BBBB";
 831
 832                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 833
 834                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 835                 assertNotNull("check response object is not null after create property", createProperty);
 836                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 837                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 838
 839                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 840                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 841                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 842
 843                 key = "BBB  BBB";
 844                 value = "BBBB";
 845
 846                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 847
 848                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 849                 assertNotNull("check response object is not null after create property", createProperty);
 850                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 851                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 852
 853                 fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 854                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 855                 assertEquals("check returned key", "BBB BBB", fromJson.getKey());
 856
 857                 String updatedKey = "AAA  AAA";
 858                 String updatedValue = "JJJJ";
 859
 860                 fromJson.setKey(updatedKey);
 861                 fromJson.setValue(updatedValue);
 862
 863                 RestResponse updatedProperty = updateAdditionalInformation(resourceId, fromJson, user, fromJson.getUniqueId());
 864                 assertNotNull("check response object is not null after update additional information", updatedProperty);
 865                 assertNotNull("check error code exists in response after additional information", updatedProperty.getErrorCode());
 866                 assertEquals("Check response code after additional information", 409, updatedProperty.getErrorCode().intValue());
 867
 868         }
 869
 870         @Test
 871         public void createServiceAdditionalInformationTest() throws Exception {
 872                 User user = getUser();
 873
 874                 RestResponse createServiceResponse = createService();
 875
 876                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 877
 878                 String key = "AAA  AAA";
 879                 String value = "BBBB";
 880
 881                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 882
 883                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 884                 assertNotNull("check response object is not null after create property", createProperty);
 885                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 886                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
 887
 888                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
 889                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
 890                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
 891
 892                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 893                 assertNotNull("check response object is not null after create property", createProperty);
 894                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 895                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
 896
 897         }
 898
 899         @Test
 900         public void createResourceEmptyAdditionalInformationTest() throws Exception {
 901                 User user = getUser();
 902                 ResourceReqDetails resource = getResource();
 903
 904                 // deleteResource(resourceId, user);
 905                 RestResponse createResourceResponse = createResource(resource, user);
 906
 907                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 908
 909                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 910                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 911                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 912
 913                 String key = "";
 914                 String value = "BBBB";
 915
 916                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 917
 918                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 919                 assertNotNull("check response object is not null after create property", createProperty);
 920                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 921                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 922
 923                 key = "BBBB";
 924                 value = "";
 925
 926                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 927
 928                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 929                 assertNotNull("check response object is not null after create property", createProperty);
 930                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 931                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 932
 933         }
 934
 935         @Test
 936         public void createServiceEmptyAdditionalInformationTest() throws Exception {
 937
 938                 User user = getUser();
 939
 940                 RestResponse createServiceResponse = createService();
 941
 942                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 943
 944                 String key = "";
 945                 String value = "BBBB";
 946
 947                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 948
 949                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 950                 assertNotNull("check response object is not null after create property", createProperty);
 951                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 952                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 953
 954         }
 955
 956         @Test
 957         public void createResourceAllSpacesAdditionalInformationTest() throws Exception {
 958                 User user = getUser();
 959                 ResourceReqDetails resource = getResource();
 960
 961                 // deleteResource(resourceId, user);
 962                 RestResponse createResourceResponse = createResource(resource, user);
 963
 964                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
 965
 966                 assertNotNull("check response object is not null after create resource", createResourceResponse);
 967                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
 968                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
 969
 970                 String key = "           ";
 971                 String value = "BBBB";
 972
 973                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 974
 975                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
 976                 assertNotNull("check response object is not null after create property", createProperty);
 977                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 978                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 979
 980         }
 981
 982         @Test
 983         public void createServiceAllSpacesAdditionalInformationTest() throws Exception {
 984                 User user = getUser();
 985
 986                 RestResponse createServiceResponse = createService();
 987
 988                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
 989
 990                 String key = "           ";
 991                 String value = "BBBB";
 992
 993                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
 994
 995                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
 996                 assertNotNull("check response object is not null after create property", createProperty);
 997                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
 998                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
 999
1000         }
1001
1002         @Test
1003         public void createResourceInvalidKeyAdditionalInformationTest() throws Exception {
1004                 User user = getUser();
1005                 ResourceReqDetails resource = getResource();
1006
1007                 // deleteResource(resourceId, user);
1008                 RestResponse createResourceResponse = createResource(resource, user);
1009
1010                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1011
1012                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1013                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1014                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1015
1016                 String key = "abc?";
1017                 String value = "BBBB";
1018
1019                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1020
1021                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1022                 assertNotNull("check response object is not null after create property", createProperty);
1023                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1024                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
1025
1026         }
1027
1028         @Test
1029         public void createServiceInvalidKeyAdditionalInformationTest() throws Exception {
1030                 User user = getUser();
1031
1032                 RestResponse createServiceResponse = createService();
1033
1034                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1035
1036                 String key = "abc?";
1037                 String value = "BBBB";
1038
1039                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1040
1041                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1042                 assertNotNull("check response object is not null after create property", createProperty);
1043                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1044                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
1045
1046         }
1047
1048         @Test
1049         public void createResourceAdditionalInformationNullKeyTest() throws Exception {
1050
1051                 User user = getUser();
1052                 ResourceReqDetails resource = getResource();
1053
1054                 RestResponse createResourceResponse = createResource(resource, user);
1055
1056                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1057                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1058                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1059
1060                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1061
1062                 String key = null;
1063                 String value = "BBBB";
1064
1065                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1066
1067                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1068                 assertNotNull("check response object is not null after create property", createProperty);
1069                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1070                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
1071
1072         }
1073
1074         @Test
1075         public void createServiceAdditionalInformationNullKeyTest() throws Exception {
1076                 User user = getUser();
1077
1078                 RestResponse createServiceResponse = createService();
1079
1080                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1081
1082                 String key = null;
1083                 String value = "BBBB";
1084
1085                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1086
1087                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1088                 assertNotNull("check response object is not null after create property", createProperty);
1089                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1090                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
1091
1092         }
1093
1094         @Test
1095         public void createResourceMaximumInformationTest() throws Exception {
1096                 User user = getUser();
1097                 ResourceReqDetails resource = getResource();
1098
1099                 // deleteResource(resourceId, user);
1100                 RestResponse createResourceResponse = createResource(resource, user);
1101
1102                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1103
1104                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1105                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1106                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1107
1108                 String key = "AAA  AAA";
1109                 String value = "BBBB";
1110
1111                 for (int i = 0; i < 50; i++) {
1112
1113                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + i, value);
1114
1115                         RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1116                         assertNotNull("check response object is not null after create property", createProperty);
1117                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1118                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1119
1120                 }
1121
1122                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1123                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1124
1125                 assertNotNull("check response object is not null after create property", createProperty);
1126                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1127                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1128
1129         }
1130
1131         @Test
1132         public void createResourceLifeCycleAndMaximumInformationTest() throws Exception {
1133                 User user = getUser();
1134                 ResourceReqDetails resource = getResource();
1135
1136                 // deleteResource(resourceId, user);
1137                 RestResponse createResourceResponse = createResource(resource, user);
1138
1139                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1140                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1141                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1142
1143                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1144                 resource.setUniqueId(resourceId);
1145
1146                 String key = "AAA  AAA";
1147                 String value = "BBBB";
1148
1149                 for (int i = 0; i < 49; i++) {
1150
1151                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + i, value);
1152
1153                         RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1154                         assertNotNull("check response object is not null after create property", createProperty);
1155                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1156                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1157
1158                 }
1159
1160                 String resourceVersion = "0.1";
1161                 String checkinComment = "good checkin";
1162                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
1163                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
1164
1165                 assertNotNull("check response object is not null after create property", checkInResponse);
1166                 assertNotNull("check error code exists in response after create property", checkInResponse.getErrorCode());
1167                 assertEquals("Check response code after create property", 200, checkInResponse.getErrorCode().intValue());
1168
1169                 resourceVersion = "0.2";
1170
1171                 RestResponse checkOutResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT, null);
1172
1173                 resourceId = ResponseParser.getUniqueIdFromResponse(checkOutResponse);
1174                 resource.setUniqueId(resourceId);
1175
1176                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 50, value);
1177                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1178
1179                 assertNotNull("check response object is not null after create property", createProperty);
1180                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1181                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1182
1183                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 51, value);
1184                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1185
1186                 assertNotNull("check response object is not null after create property", createProperty);
1187                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1188                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1189
1190                 RestResponse checkUndoOutResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.UNDOCHECKOUT, null);
1191
1192                 resourceVersion = "0.1";
1193
1194                 checkOutResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT, null);
1195                 resourceId = ResponseParser.getUniqueIdFromResponse(checkOutResponse);
1196                 resource.setUniqueId(resourceId);
1197
1198                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 50, value);
1199                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1200
1201                 assertNotNull("check response object is not null after create property", createProperty);
1202                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1203                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1204
1205                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 51, value);
1206                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1207
1208                 assertNotNull("check response object is not null after create property", createProperty);
1209                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1210                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1211
1212         }
1213
1214         @Test
1215         public void createResourceLifeCycleCertifyAndMaximumInformationTest() throws Exception {
1216                 User user = getUser();
1217                 ResourceReqDetails resource = getResource();
1218
1219                 // deleteResource(resourceId, user);
1220                 RestResponse createResourceResponse = createResource(resource, user);
1221
1222                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1223                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1224                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1225
1226                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1227                 resource.setUniqueId(resourceId);
1228
1229                 String key = "AAA  AAA";
1230                 String value = "BBBB";
1231
1232                 for (int i = 0; i < 49; i++) {
1233
1234                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + i, value);
1235
1236                         RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1237                         assertNotNull("check response object is not null after create property", createProperty);
1238                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1239                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1240
1241                 }
1242
1243                 String resourceVersion = "0.1";
1244                 String checkinComment = "good checkin";
1245                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
1246
1247                 // resourceUtils.addResourceMandatoryArtifacts(user,
1248                 // createResourceResponse);
1249
1250                 RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
1251
1252                 assertNotNull("check response object is not null after create property", checkInResponse);
1253                 assertNotNull("check error code exists in response after create property", checkInResponse.getErrorCode());
1254                 assertEquals("Check response code after create property", 200, checkInResponse.getErrorCode().intValue());
1255
1256                 RestResponse changeStateResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CERTIFICATIONREQUEST, null);
1257                 changeStateResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.STARTCERTIFICATION, null);
1258                 changeStateResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CERTIFY, null);
1259
1260                 assertNotNull("check response object is not null after create property", checkInResponse);
1261                 assertNotNull("check error code exists in response after create property", checkInResponse.getErrorCode());
1262                 assertEquals("Check response code after create property", 200, checkInResponse.getErrorCode().intValue());
1263
1264                 resourceId = ResponseParser.getUniqueIdFromResponse(changeStateResponse);
1265                 resource.setUniqueId(resourceId);
1266
1267                 resourceVersion = "1.0";
1268
1269                 changeStateResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT, null);
1270                 resourceId = ResponseParser.getUniqueIdFromResponse(changeStateResponse);
1271                 resource.setUniqueId(resourceId);
1272
1273                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 50, value);
1274                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1275
1276                 assertNotNull("check response object is not null after create property", createProperty);
1277                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1278                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1279
1280                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 51, value);
1281                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1282
1283                 assertNotNull("check response object is not null after create property", createProperty);
1284                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1285                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1286
1287         }
1288
1289         @Test
1290         public void createServiceCycleAndMaximumInformationTest() throws Exception {
1291
1292                 User user = getUser();
1293
1294                 ServiceReqDetails service = getServiceDetails();
1295
1296                 RestResponse createServiceResponse = createService();
1297
1298                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1299
1300                 assertNotNull("check response object is not null after create resource", createServiceResponse);
1301                 assertNotNull("check error code exists in response after create resource", createServiceResponse.getErrorCode());
1302                 assertEquals("Check response code after create resource", 201, createServiceResponse.getErrorCode().intValue());
1303
1304                 service.setUniqueId(serviceId);
1305
1306                 String key = "AAA  AAA";
1307                 String value = "BBBB";
1308
1309                 for (int i = 0; i < 49; i++) {
1310
1311                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + i, value);
1312
1313                         RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1314                         assertNotNull("check response object is not null after create property", createProperty);
1315                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1316                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1317
1318                 }
1319
1320                 String resourceVersion = "0.1";
1321                 String checkinComment = "good checkin";
1322                 String checkinComentJson = "{\"userRemarks\": \"" + checkinComment + "\"}";
1323                 RestResponse checkInResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CHECKIN, checkinComentJson);
1324
1325                 assertNotNull("check response object is not null after create property", checkInResponse);
1326                 assertNotNull("check error code exists in response after create property", checkInResponse.getErrorCode());
1327                 assertEquals("Check response code after create property", 200, checkInResponse.getErrorCode().intValue());
1328
1329                 resourceVersion = "0.2";
1330
1331                 RestResponse checkOutResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT, null);
1332
1333                 serviceId = ResponseParser.convertServiceResponseToJavaObject(checkOutResponse.getResponse()).getUniqueId();
1334                 service.setUniqueId(serviceId);
1335
1336                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 50, value);
1337                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1338
1339                 assertNotNull("check response object is not null after create property", createProperty);
1340                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1341                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1342
1343                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 51, value);
1344                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1345
1346                 assertNotNull("check response object is not null after create property", createProperty);
1347                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1348                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1349
1350                 RestResponse checkUndoOutResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.UNDOCHECKOUT, null);
1351
1352                 resourceVersion = "0.1";
1353
1354                 checkOutResponse = LifecycleRestUtils.changeServiceState(service, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT, null);
1355                 serviceId = ResponseParser.convertServiceResponseToJavaObject(checkOutResponse.getResponse()).getUniqueId();
1356                 service.setUniqueId(serviceId);
1357
1358                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 50, value);
1359                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1360
1361                 assertNotNull("check response object is not null after create property", createProperty);
1362                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1363                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1364
1365                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + 51, value);
1366                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1367
1368                 assertNotNull("check response object is not null after create property", createProperty);
1369                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1370                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1371
1372         }
1373
1374         @Test
1375         public void createServiceMaximumInformationTest() throws Exception {
1376                 User user = getUser();
1377
1378                 RestResponse createServiceResponse = createService();
1379
1380                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1381
1382                 String key = "AAA  AAA";
1383                 String value = "BBBB";
1384
1385                 String lastCreatedProperty = null;
1386
1387                 for (int i = 0; i < 50; i++) {
1388
1389                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key + i, value);
1390
1391                         RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1392                         assertNotNull("check response object is not null after create property", createProperty);
1393                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1394                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1395
1396                         AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1397                         lastCreatedProperty = fromJson.getUniqueId();
1398
1399                 }
1400
1401                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1402                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1403
1404                 assertNotNull("check response object is not null after create property", createProperty);
1405                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1406                 assertEquals("Check response code after create property", 409, createProperty.getErrorCode().intValue());
1407
1408                 RestResponse deletedProperty = deleteServiceAdditionalInformation(serviceId, lastCreatedProperty, user);
1409                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1410                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1411                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1412
1413                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1414                 createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1415
1416                 assertNotNull("check response object is not null after create property", createProperty);
1417                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1418                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1419
1420         }
1421
1422         @Test
1423         public void updateServiceAdditionalInformationTest() throws Exception {
1424                 User user = getUser();
1425
1426                 RestResponse createServiceResponse = createService();
1427
1428                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1429
1430                 String key = "AAA  AAA";
1431                 String value = "BBBB";
1432
1433                 String updatedKey = "ZZZ  ZZZ";
1434                 String updatedValue = "JJJJ";
1435
1436                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1437
1438                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1439                 assertNotNull("check response object is not null after create property", createProperty);
1440                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1441                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1442
1443                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1444                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1445                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1446
1447                 fromJson.setKey(updatedKey);
1448                 fromJson.setValue(updatedValue);
1449
1450                 RestResponse updatedProperty = updateServiceAdditionalInformation(serviceId, fromJson, user, fromJson.getUniqueId());
1451                 assertNotNull("check response object is not null after update additional information", updatedProperty);
1452                 assertNotNull("check error code exists in response after additional information", updatedProperty.getErrorCode());
1453                 assertEquals("Check response code after additional information", 200, updatedProperty.getErrorCode().intValue());
1454
1455                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(updatedProperty.getResponse(), AdditionalInfoParameterInfo.class);
1456                 assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
1457                 assertEquals("check returned key", "ZZZ ZZZ", updatedJson.getKey());
1458                 assertEquals("check returned value", updatedValue, updatedJson.getValue());
1459                 assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
1460
1461                 fromJson.setKey(updatedKey);
1462                 fromJson.setValue("\uC2B5");
1463
1464                 updatedProperty = updateServiceAdditionalInformation(serviceId, fromJson, user, fromJson.getUniqueId());
1465                 assertNotNull("check response object is not null after update additional information", updatedProperty);
1466                 assertNotNull("check error code exists in response after additional information", updatedProperty.getErrorCode());
1467                 assertEquals("Check response code after additional information", 400, updatedProperty.getErrorCode().intValue());
1468
1469         }
1470
1471         @Test
1472         public void deleteServiceAdditionalInformationTest() throws Exception {
1473                 User user = getUser();
1474
1475                 RestResponse createServiceResponse = createService();
1476
1477                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1478
1479                 String key = "AAA  AAA";
1480                 String value = "BBBB";
1481
1482                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1483
1484                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1485                 assertNotNull("check response object is not null after create property", createProperty);
1486                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1487                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1488
1489                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1490                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1491                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1492
1493                 RestResponse deletedProperty = deleteServiceAdditionalInformation(serviceId, fromJson.getUniqueId(), user);
1494                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1495                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1496                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1497
1498                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInfoParameterInfo.class);
1499                 assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
1500                 assertEquals("check returned key", "AAA AAA", updatedJson.getKey());
1501                 assertEquals("check returned value", value, updatedJson.getValue());
1502                 assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
1503
1504                 deletedProperty = deleteServiceAdditionalInformation(serviceId, fromJson.getUniqueId(), user);
1505                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1506                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1507                 assertEquals("Check response code after additional information", 409, deletedProperty.getErrorCode().intValue());
1508
1509         }
1510
1511         @Test
1512         public void getResourceAdditionalInformationTest() throws Exception {
1513                 User user = getUser();
1514                 ResourceReqDetails resource = getResource();
1515
1516                 RestResponse createResourceResponse = createResource(resource, user);
1517
1518                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1519
1520                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1521                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1522                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1523
1524                 String key = "AAA  AAA";
1525                 String value = "BBBB";
1526
1527                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1528
1529                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1530                 assertNotNull("check response object is not null after create property", createProperty);
1531                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1532                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1533
1534                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1535                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1536                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1537
1538                 RestResponse deletedProperty = getAdditionalInformation(resourceId, fromJson.getUniqueId(), user);
1539                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1540                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1541                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1542
1543                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInfoParameterInfo.class);
1544                 assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
1545                 assertEquals("check returned key", "AAA AAA", updatedJson.getKey());
1546                 assertEquals("check returned value", value, updatedJson.getValue());
1547                 assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
1548
1549         }
1550
1551         @Test
1552         public void getServiceAdditionalInformationTest() throws Exception {
1553                 User user = getUser();
1554
1555                 RestResponse createServiceResponse = createService();
1556
1557                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1558
1559                 String key = "AAA  AAA";
1560                 String value = "BBBB";
1561
1562                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1563
1564                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1565                 assertNotNull("check response object is not null after create property", createProperty);
1566                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1567                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1568
1569                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1570                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1571                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1572
1573                 RestResponse deletedProperty = getServiceAdditionalInformation(serviceId, fromJson.getUniqueId(), user);
1574                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1575                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1576                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1577
1578                 AdditionalInfoParameterInfo updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInfoParameterInfo.class);
1579                 assertFalse("check number of spaces", updatedJson.getKey().contains("  "));
1580                 assertEquals("check returned key", "AAA AAA", updatedJson.getKey());
1581                 assertEquals("check returned value", value, updatedJson.getValue());
1582                 assertEquals("check returned id", fromJson.getUniqueId(), updatedJson.getUniqueId());
1583
1584         }
1585
1586         @Test
1587         public void getResourceAllAdditionalInformationTest() throws Exception {
1588                 User user = getUser();
1589                 ResourceReqDetails resource = getResource();
1590
1591                 RestResponse createResourceResponse = createResource(resource, user);
1592
1593                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1594
1595                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1596                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1597                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1598
1599                 String key = "AAA  AAA";
1600                 String value = "BBBB";
1601
1602                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1603
1604                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1605                 assertNotNull("check response object is not null after create property", createProperty);
1606                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1607                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1608
1609                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1610                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1611                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1612
1613                 RestResponse deletedProperty = getResourceAllAdditionalInformation(resourceId, user);
1614                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1615                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1616                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1617
1618                 AdditionalInformationDefinition updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInformationDefinition.class);
1619                 assertEquals("check number of parameters", 1, updatedJson.getParameters().size());
1620                 AdditionalInfoParameterInfo info = updatedJson.getParameters().iterator().next();
1621
1622                 assertFalse("check number of spaces", info.getKey().contains("  "));
1623                 assertEquals("check returned key", "AAA AAA", info.getKey());
1624                 assertEquals("check returned value", value, info.getValue());
1625                 assertEquals("check returned id", fromJson.getUniqueId(), info.getUniqueId());
1626
1627         }
1628
1629         @Test
1630         public void getServiceAllAdditionalInformationTest() throws Exception {
1631                 User user = getUser();
1632
1633                 RestResponse createServiceResponse = createService();
1634
1635                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1636
1637                 String key = "AAA  AAA";
1638                 String value = "BBBB";
1639
1640                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1641
1642                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1643                 assertNotNull("check response object is not null after create property", createProperty);
1644                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1645                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1646
1647                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1648                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1649                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1650
1651                 RestResponse deletedProperty = getServiceAllAdditionalInformation(serviceId, user);
1652                 assertNotNull("check response object is not null after update additional information", deletedProperty);
1653                 assertNotNull("check error code exists in response after additional information", deletedProperty.getErrorCode());
1654                 assertEquals("Check response code after additional information", 200, deletedProperty.getErrorCode().intValue());
1655
1656                 AdditionalInformationDefinition updatedJson = gson.fromJson(deletedProperty.getResponse(), AdditionalInformationDefinition.class);
1657                 assertEquals("check number of parameters", 1, updatedJson.getParameters().size());
1658                 AdditionalInfoParameterInfo info = updatedJson.getParameters().iterator().next();
1659
1660                 assertFalse("check number of spaces", info.getKey().contains("  "));
1661                 assertEquals("check returned key", "AAA AAA", info.getKey());
1662                 assertEquals("check returned value", value, info.getValue());
1663                 assertEquals("check returned id", fromJson.getUniqueId(), info.getUniqueId());
1664
1665         }
1666
1667         @Test
1668         public void createServiceAdditionalInformationTestDuringLifecycle() throws Exception {
1669
1670                 User user = getUser();
1671                 RestResponse createServiceResponse = createService();
1672                 String serviceId = ResponseParser.convertServiceResponseToJavaObject(createServiceResponse.getResponse()).getUniqueId();
1673                 String key = "AAA  AAA";
1674                 String value = "BBBB";
1675                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1676
1677                 RestResponse createProperty = createServiceAdditionalInformation(serviceId, additionalInfoParameterInfo, user);
1678                 assertNotNull("check response object is not null after create property", createProperty);
1679                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1680                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1681
1682                 AdditionalInfoParameterInfo fromJson = gson.fromJson(createProperty.getResponse(), AdditionalInfoParameterInfo.class);
1683                 assertFalse("check number of spaces", fromJson.getKey().contains("  "));
1684                 assertEquals("check returned key", "AAA AAA", fromJson.getKey());
1685
1686                 ServiceReqDetails serviceDetails = getServiceDetails();
1687
1688                 serviceDetails.setUniqueId(serviceId);
1689
1690                 // serviceUtils.addServiceMandatoryArtifacts(user,
1691                 // createServiceResponse);
1692
1693                 certifyService(user, serviceDetails, null);
1694
1695         }
1696
1697         @Test
1698         public void createCascadeResource() {
1699
1700                 // TODO: to check after rebase
1701
1702                 User user = getUser();
1703                 ResourceReqDetails resource = getResource();
1704                 String newResourceNameSuffix = "aa";
1705
1706                 RestResponse createResourceResponse = null;
1707                 try {
1708
1709                         createResourceResponse = createResource(resource, user);
1710                         assertEquals("check invalid type", 201, createResourceResponse.getErrorCode().intValue());
1711                         String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1712
1713                         String resourceVersion = "0.1";
1714                         // resourceUtils.addResourceMandatoryArtifacts(user,
1715                         // createResourceResponse);
1716
1717                         String key = "AAA  AAA";
1718                         String value = "BBBB";
1719
1720                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1721
1722                         RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1723                         assertNotNull("check response object is not null after create property", createProperty);
1724                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1725                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1726
1727                         resource.setUniqueId(resourceId);
1728                         Resource certifiedResource = certifyResource(user, resource, resourceVersion, 1);
1729
1730                         ResourceReqDetails newResourceDetails = getResource();
1731                         String newResourceName = newResourceDetails.getName() + newResourceNameSuffix;
1732                         newResourceDetails.setName(newResourceName);
1733                         List<String> derivedFrom = new ArrayList<>();
1734                         derivedFrom.add(certifiedResource.getName());
1735                         newResourceDetails.setDerivedFrom(derivedFrom);
1736                         newResourceDetails.getTags().add(newResourceName);
1737
1738                         user.setUserId(UserRoleEnum.ADMIN.getUserId());
1739                         RestResponse newCreateResourceResponse = createResource(newResourceDetails, user);
1740                         assertEquals("Check response code after creating resource", 201, newCreateResourceResponse.getErrorCode().intValue());
1741                         Resource newResource = gson.fromJson(newCreateResourceResponse.getResponse(), Resource.class);
1742
1743                         RestResponse allAdditionalInformation = getResourceAllAdditionalInformation(newResource.getUniqueId(), user);
1744
1745                         assertNotNull("check response object is not null after update additional information", allAdditionalInformation);
1746                         assertNotNull("check error code exists in response after additional information", allAdditionalInformation.getErrorCode());
1747                         assertEquals("Check response code after additional information", 200, allAdditionalInformation.getErrorCode().intValue());
1748
1749                         AdditionalInformationDefinition updatedJson = gson.fromJson(allAdditionalInformation.getResponse(), AdditionalInformationDefinition.class);
1750                         assertEquals("check number of parameters", 0, updatedJson.getParameters().size());
1751                         // AdditionalInfoParameterInfo info =
1752                         // updatedJson.getParameters().iterator().next();
1753
1754                         String newResourceId = newResource.getUniqueId();
1755                         createProperty = createResourceAdditionalInformation(newResourceId, additionalInfoParameterInfo, user);
1756                         assertNotNull("check response object is not null after create property", createProperty);
1757                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1758                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1759
1760                         allAdditionalInformation = getResourceAllAdditionalInformation(newResourceId, user);
1761
1762                         assertNotNull("check response object is not null after update additional information", allAdditionalInformation);
1763                         assertNotNull("check error code exists in response after additional information", allAdditionalInformation.getErrorCode());
1764                         assertEquals("Check response code after additional information", 200, allAdditionalInformation.getErrorCode().intValue());
1765
1766                         updatedJson = gson.fromJson(allAdditionalInformation.getResponse(), AdditionalInformationDefinition.class);
1767                         assertEquals("check number of parameters", 1, updatedJson.getParameters().size());
1768
1769                 } catch (IOException e) {
1770                         assertTrue(false);
1771                 }
1772
1773         }
1774
1775         @Test
1776         public void createSamePropertyAfterCiCOResource() {
1777
1778                 User user = getUser();
1779                 ResourceReqDetails resource = getResource();
1780
1781                 RestResponse createResourceResponse = null;
1782                 try {
1783
1784                         createResourceResponse = createResource(resource, user);
1785                         assertEquals("check invalid type", 201, createResourceResponse.getErrorCode().intValue());
1786                         String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1787
1788                         String resourceVersion = "0.1";
1789                         // resourceUtils.addResourceMandatoryArtifacts(user,
1790                         // createResourceResponse);
1791
1792                         String key = "AAA  AAA";
1793                         String value = "BBBB";
1794
1795                         AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1796
1797                         RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1798                         assertNotNull("check response object is not null after create property", createProperty);
1799                         assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
1800                         assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
1801
1802                         resource.setUniqueId(resourceId);
1803                         RestResponse checkInResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKIN);
1804
1805                         assertNotNull("check response object is not null after create user", checkInResponse);
1806                         assertNotNull("check error code exists in response after create user", checkInResponse.getErrorCode());
1807                         assertEquals("Check response code after create user", 200, checkInResponse.getErrorCode().intValue());
1808
1809                         Resource resourceAfterOperation = gson.fromJson(checkInResponse.getResponse(), Resource.class);
1810                         assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().size());
1811                         assertEquals("check size of additional information", 1, resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
1812
1813                         RestResponse checkOutResponse = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT);
1814
1815                         assertNotNull("check response object is not null after create user", checkOutResponse);
1816                         assertNotNull("check error code exists in response after create user", checkOutResponse.getErrorCode());
1817                         assertEquals("Check response code after create user", 200, checkOutResponse.getErrorCode().intValue());
1818
1819                         Resource resourceAfterCoOperation = gson.fromJson(checkOutResponse.getResponse(), Resource.class);
1820                         assertEquals("check size of additional information", 1, resourceAfterCoOperation.getAdditionalInformation().size());
1821                         assertEquals("check size of additional information", 1, resourceAfterCoOperation.getAdditionalInformation().get(0).getParameters().size());
1822
1823                         String newResourceId = ResponseParser.getUniqueIdFromResponse(checkOutResponse);
1824
1825                         String key2 = "ZZZ";
1826                         String value2 = "BBBB";
1827
1828                         AdditionalInfoParameterInfo additionalInfoParameterInfo2 = new AdditionalInfoParameterInfo(null, key2, value2);
1829
1830                         RestResponse createProperty2 = createResourceAdditionalInformation(newResourceId, additionalInfoParameterInfo2, user);
1831                         assertNotNull("check response object is not null after create property", createProperty2);
1832                         assertNotNull("check error code exists in response after create property", createProperty2.getErrorCode());
1833                         assertEquals("Check response code after create property", 201, createProperty2.getErrorCode().intValue());
1834
1835                         RestResponse afterCreateAI = ResourceRestUtils.getResource(user, newResourceId);
1836                         Resource resourceNew = gson.fromJson(afterCreateAI.getResponse(), Resource.class);
1837                         assertEquals("check size of additional information", 1, resourceNew.getAdditionalInformation().size());
1838                         assertEquals("check size of additional information", 2, resourceNew.getAdditionalInformation().get(0).getParameters().size());
1839
1840                         resource.setUniqueId(newResourceId);
1841                         Resource certifiedResource = certifyResource(user, resource, resourceVersion, 2);
1842                         assertEquals("check size of additional information", 1, certifiedResource.getAdditionalInformation().size());
1843                         assertEquals("check size of additional information", 2, certifiedResource.getAdditionalInformation().get(0).getParameters().size());
1844
1845                         user.setUserId(UserRoleEnum.DESIGNER.getUserId());
1846                         resource.setUniqueId(certifiedResource.getUniqueId());
1847                         RestResponse checkOutResponseAfterCertify = LifecycleRestUtils.changeResourceState(resource, user, resourceVersion, LifeCycleStatesEnum.CHECKOUT);
1848
1849                         assertNotNull("check response object is not null after create user", checkOutResponseAfterCertify);
1850                         assertNotNull("check error code exists in response after create user", checkOutResponseAfterCertify.getErrorCode());
1851                         assertEquals("Check response code after create user", 200, checkOutResponseAfterCertify.getErrorCode().intValue());
1852
1853                         Resource resourceAfterCertifyCoOperation = gson.fromJson(checkOutResponseAfterCertify.getResponse(), Resource.class);
1854                         assertEquals("check size of additional information", 1, resourceAfterCertifyCoOperation.getAdditionalInformation().size());
1855                         assertEquals("check size of additional information", 2, resourceAfterCertifyCoOperation.getAdditionalInformation().get(0).getParameters().size());
1856
1857                 } catch (IOException e) {
1858                         assertTrue(false);
1859                 }
1860
1861         }
1862
1863         // public Resource certifyService(User user, ServiceReqDetails service,
1864         // String resourceVersion) throws Exception {
1865         //
1866         // RestResponse checkInResponse =
1867         // LifecycleRestUtils.changeServiceState(service, user, resourceVersion,
1868         // LifeCycleStates.CHECKIN);
1869         //
1870         // assertNotNull("check response object is not null after create user",
1871         // checkInResponse);
1872         // assertNotNull("check error code exists in response after create user",
1873         // checkInResponse.getErrorCode());
1874         // assertEquals("Check response code after create user", 200,
1875         // checkInResponse.getErrorCode().intValue());
1876         //
1877         // Resource resourceAfterOperation =
1878         // gson.fromJson(checkInResponse.getResponse(), Resource.class);
1879         // assertEquals("check size of additional information", 1,
1880         // resourceAfterOperation.getAdditionalInformation().size());
1881         // assertEquals("check size of additional information", 1,
1882         // resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
1883         //
1884         //// TODO Andrey
1885         // createAndAddCertResourceToService(service, user);
1886         //
1887         // RestResponse req4certResponse =
1888         // LifecycleRestUtils.changeServiceState(service, user, resourceVersion,
1889         // LifeCycleStates.CERTIFICATIONREQUEST);
1890         //
1891         // assertNotNull("check response object is not null after create user",
1892         // req4certResponse);
1893         // assertEquals("Check response code after checkout resource", 200,
1894         // req4certResponse.getErrorCode().intValue());
1895         //
1896         // resourceAfterOperation = gson.fromJson(req4certResponse.getResponse(),
1897         // Resource.class);
1898         // assertEquals("check size of additional information", 1,
1899         // resourceAfterOperation.getAdditionalInformation().size());
1900         // assertEquals("check size of additional information", 1,
1901         // resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
1902         //
1903         // //change modifier
1904         // user.setUserId(UserRoleEnum.TESTER.getUserId());
1905         //
1906         // //start certification
1907         // RestResponse startCertResourceResponse3 =
1908         // LifecycleRestUtils.changeServiceState(service, user, resourceVersion,
1909         // LifeCycleStates.STARTCERTIFICATION);
1910         // assertNotNull("check response object is not null after create user",
1911         // startCertResourceResponse3);
1912         // assertEquals("Check response code after checkout resource", 200,
1913         // startCertResourceResponse3.getErrorCode().intValue());
1914         //
1915         // resourceAfterOperation =
1916         // gson.fromJson(startCertResourceResponse3.getResponse(), Resource.class);
1917         // assertEquals("check size of additional information", 1,
1918         // resourceAfterOperation.getAdditionalInformation().size());
1919         // assertEquals("check size of additional information", 1,
1920         // resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
1921         //
1922         // //certify
1923         //
1924         // RestResponse certifyResponse =
1925         // LifecycleRestUtils.changeServiceState(service, user, resourceVersion,
1926         // LifeCycleStates.CERTIFY);
1927         // assertNotNull("check response object is not null after create user",
1928         // certifyResponse);
1929         // assertEquals("Check response code after checkout resource", 200,
1930         // certifyResponse.getErrorCode().intValue());
1931         //
1932         // resourceAfterOperation = gson.fromJson(certifyResponse.getResponse(),
1933         // Resource.class);
1934         // assertEquals("check size of additional information", 1,
1935         // resourceAfterOperation.getAdditionalInformation().size());
1936         // assertEquals("check size of additional information", 1,
1937         // resourceAfterOperation.getAdditionalInformation().get(0).getParameters().size());
1938         //
1939         // Resource certifyResource = gson.fromJson(certifyResponse.getResponse(),
1940         // Resource.class);
1941         // return certifyResource;
1942         // }
1943
1944         private void createAndAddCertResourceToService(ServiceReqDetails serviceDetails, User user) throws Exception {
1945
1946                 User sdncTesterUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
1947
1948                 ResourceReqDetails resourceDetails = ElementFactory.getDefaultResource();
1949                 ComponentInstanceReqDetails resourceInstanceReqDetails = ElementFactory.getDefaultComponentInstance();
1950
1951                 RestResponse response = ResourceRestUtils.createResource(resourceDetails, user);
1952                 assertTrue("create request returned status:" + response.getErrorCode(), response.getErrorCode() == 201);
1953                 assertNotNull("resource uniqueId is null:", resourceDetails.getUniqueId());
1954
1955                 ArtifactReqDetails heatArtifactDetails = ElementFactory.getDefaultDeploymentArtifactForType(ArtifactTypeEnum.HEAT.getType());
1956                 response = ArtifactRestUtils.addInformationalArtifactToResource(heatArtifactDetails, user, resourceDetails.getUniqueId());
1957                 assertTrue("add HEAT artifact to resource request returned status:" + response.getErrorCode(), response.getErrorCode() == 200);
1958
1959                 // certified resource
1960                 // response = LCSbaseTest.certifyResource(resourceDetails);
1961                 RestResponse restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, user, LifeCycleStatesEnum.CHECKIN);
1962                 assertTrue("certify resource request returned status:" + restResponseResource.getErrorCode(), response.getErrorCode() == 200);
1963                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, user, LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1964                 assertTrue("certify resource request returned status:" + restResponseResource.getErrorCode(), response.getErrorCode() == 200);
1965                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterUser, LifeCycleStatesEnum.STARTCERTIFICATION);
1966                 assertTrue("certify resource request returned status:" + restResponseResource.getErrorCode(), response.getErrorCode() == 200);
1967                 restResponseResource = LifecycleRestUtils.changeResourceState(resourceDetails, sdncTesterUser, LifeCycleStatesEnum.CERTIFY);
1968                 assertTrue("certify resource request returned status:" + restResponseResource.getErrorCode(), response.getErrorCode() == 200);
1969
1970                 // add resource instance with HEAT deployment artifact to the service
1971                 restResponseResource = LifecycleRestUtils.changeServiceState(serviceDetails, user, serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
1972                 assertTrue("certify resource request returned status:" + restResponseResource.getErrorCode(), response.getErrorCode() == 200);
1973                 resourceInstanceReqDetails.setComponentUid(resourceDetails.getUniqueId());
1974                 response = ComponentInstanceRestUtils.createComponentInstance(resourceInstanceReqDetails, user, serviceDetails.getUniqueId(), ComponentTypeEnum.SERVICE);
1975                 assertTrue("response code is not 201, returned: " + response.getErrorCode(), response.getErrorCode() == 201);
1976         }
1977
1978         @Test
1979         public void createResourceAdditionalInformationTestAddValue() throws Exception {
1980                 User user = getUser();
1981                 ResourceReqDetails resource = getResource();
1982
1983                 // deleteResource(resourceId, user);
1984                 RestResponse createResourceResponse = createResource(resource, user);
1985
1986                 String resourceId = ResponseParser.getUniqueIdFromResponse(createResourceResponse);
1987
1988                 assertNotNull("check response object is not null after create resource", createResourceResponse);
1989                 assertNotNull("check error code exists in response after create resource", createResourceResponse.getErrorCode());
1990                 assertEquals("Check response code after create resource", 201, createResourceResponse.getErrorCode().intValue());
1991
1992                 String key = "AAA  AAA";
1993                 String value = "\uC2B5";
1994
1995                 AdditionalInfoParameterInfo additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
1996
1997                 RestResponse createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
1998                 assertNotNull("check response object is not null after create property", createProperty);
1999                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
2000                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
2001
2002                 value = "";
2003
2004                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
2005
2006                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
2007                 assertNotNull("check response object is not null after create property", createProperty);
2008                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
2009                 assertEquals("Check response code after create property", 400, createProperty.getErrorCode().intValue());
2010
2011                 value = "----<b></b><>;";
2012
2013                 additionalInfoParameterInfo = new AdditionalInfoParameterInfo(null, key, value);
2014
2015                 createProperty = createResourceAdditionalInformation(resourceId, additionalInfoParameterInfo, user);
2016                 assertNotNull("check response object is not null after create property", createProperty);
2017                 assertNotNull("check error code exists in response after create property", createProperty.getErrorCode());
2018                 assertEquals("Check response code after create property", 201, createProperty.getErrorCode().intValue());
2019
2020         }
2021 }