gerrit.onap Code Review - sdc.git/blob

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