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