test-apis-ci/src/main/java/org/openecomp/sdc/ci/tests/execute/service/CreateServiceMetadataApiTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.ci.tests.execute.service;
  22
  23 import static org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils.STATUS_CODE_SUCCESS;
  24 import static org.testng.AssertJUnit.assertEquals;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.List;
  30 import java.util.Map;
  31
  32 import org.json.JSONObject;
  33 import org.junit.Rule;
  34 import org.junit.rules.TestName;
  35 import org.openecomp.sdc.be.dao.api.ActionStatus;
  36 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  37 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  38 import org.openecomp.sdc.be.model.Component;
  39 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  40 import org.openecomp.sdc.be.model.Resource;
  41 import org.openecomp.sdc.be.model.Service;
  42 import org.openecomp.sdc.be.model.User;
  43 import org.openecomp.sdc.ci.tests.api.ComponentBaseTest;
  44 import org.openecomp.sdc.ci.tests.api.Urls;
  45 import org.openecomp.sdc.ci.tests.config.Config;
  46 import org.openecomp.sdc.ci.tests.datatypes.ComponentInstanceReqDetails;
  47 import org.openecomp.sdc.ci.tests.datatypes.ProductReqDetails;
  48 import org.openecomp.sdc.ci.tests.datatypes.ServiceReqDetails;
  49 import org.openecomp.sdc.ci.tests.datatypes.enums.ArtifactTypeEnum;
  50 import org.openecomp.sdc.ci.tests.datatypes.enums.ErrorInfo;
  51 import org.openecomp.sdc.ci.tests.datatypes.enums.LifeCycleStatesEnum;
  52 import org.openecomp.sdc.ci.tests.datatypes.enums.ServiceCategoriesEnum;
  53 import org.openecomp.sdc.ci.tests.datatypes.enums.UserRoleEnum;
  54 import org.openecomp.sdc.ci.tests.datatypes.expected.ExpectedResourceAuditJavaObject;
  55 import org.openecomp.sdc.ci.tests.datatypes.http.HttpHeaderEnum;
  56 import org.openecomp.sdc.ci.tests.datatypes.http.HttpRequest;
  57 import org.openecomp.sdc.ci.tests.datatypes.http.RestResponse;
  58 import org.openecomp.sdc.ci.tests.utils.DbUtils;
  59 import org.openecomp.sdc.ci.tests.utils.Utils;
  60 import org.openecomp.sdc.ci.tests.utils.general.AtomicOperationUtils;
  61 import org.openecomp.sdc.ci.tests.utils.general.ElementFactory;
  62 import org.openecomp.sdc.ci.tests.utils.rest.BaseRestUtils;
  63 import org.openecomp.sdc.ci.tests.utils.rest.ComponentInstanceRestUtils;
  64 import org.openecomp.sdc.ci.tests.utils.rest.LifecycleRestUtils;
  65 import org.openecomp.sdc.ci.tests.utils.rest.ProductRestUtils;
  66 import org.openecomp.sdc.ci.tests.utils.rest.ResourceRestUtils;
  67 import org.openecomp.sdc.ci.tests.utils.rest.ResponseParser;
  68 import org.openecomp.sdc.ci.tests.utils.rest.ServiceRestUtils;
  69 import org.openecomp.sdc.ci.tests.utils.validation.AuditValidationUtils;
  70 import org.openecomp.sdc.ci.tests.utils.validation.ErrorValidationUtils;
  71 import org.openecomp.sdc.ci.tests.utils.validation.ServiceValidationUtils;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74 import org.testng.annotations.Test;
  75
  76 import com.fasterxml.jackson.annotation.JsonIgnore;
  77
  78 public class CreateServiceMetadataApiTest extends ComponentBaseTest {
  79         private static Logger logger = LoggerFactory.getLogger(CreateServiceMetadataApiTest.class.getName());
  80
  81         String serviceBaseVersion = "0.1";
  82
  83         @Rule
  84         public static TestName name = new TestName();
  85
  86         public CreateServiceMetadataApiTest() {
  87                 super(name, CreateServiceMetadataApiTest.class.getName());
  88         }
  89
  90         @Test
  91         public void createDefaultService() throws Exception {
  92
  93                 // choose the user to create service
  94                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
  95                 // String creator =
  96                 // ElementFactory.getDefaultUser(UserRoleEnum.ADMIN).getUserId();
  97
  98                 // fill new service details
  99                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 100
 101                 // clean audit DB before service creation
 102                 DbUtils.cleanAllAudits();
 103
 104                 // send create service toward BE
 105                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 106
 107                 assertNotNull("check response object is not null after create service", restResponse);
 108                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 109                 assertEquals("Check response code after create service", 201, restResponse.getErrorCode().intValue());
 110
 111                 // validate create service response vs actual
 112
 113                 Service service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 114                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, service, sdncUserDetails,
 115                                 (LifecycleStateEnum) null);
 116
 117                 // validate get service response vs actual
 118                 restResponse = ServiceRestUtils.getService(serviceDetails, sdncUserDetails);
 119                 service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 120                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, service, sdncUserDetails,
 121                                 (LifecycleStateEnum) null);
 122
 123                 // validate audit
 124
 125                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 126                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 127
 128                 String auditAction = "Create";
 129                 expectedResourceAuditJavaObject.setAction(auditAction);
 130                 expectedResourceAuditJavaObject.setPrevState("");
 131                 expectedResourceAuditJavaObject.setPrevVersion("");
 132                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 133                 expectedResourceAuditJavaObject.setStatus("201");
 134                 expectedResourceAuditJavaObject.setDesc("OK");
 135
 136                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 137
 138         }
 139
 140         @Test
 141         public void createDefaultServiceUserDesigner() throws Exception {
 142
 143                 // choose the user to create service
 144                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
 145
 146                 // fill new service details
 147                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 148
 149                 // clean audit DB before service creation
 150                 DbUtils.cleanAllAudits();
 151
 152                 // send create service toward BE
 153                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 154
 155                 assertNotNull("check response object is not null after create service", restResponse);
 156                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 157                 assertEquals("Check response code after create service", 201, restResponse.getErrorCode().intValue());
 158
 159                 // validate create service response vs actual
 160
 161                 Service service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 162                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, service, sdncUserDetails,
 163                                 (LifecycleStateEnum) null);
 164
 165                 // validate get service response vs actual
 166                 restResponse = ServiceRestUtils.getService(serviceDetails, sdncUserDetails);
 167                 service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 168
 169                 // validate audit
 170
 171                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 172                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 173
 174                 String auditAction = "Create";
 175                 expectedResourceAuditJavaObject.setAction(auditAction);
 176                 expectedResourceAuditJavaObject.setPrevState("");
 177                 expectedResourceAuditJavaObject.setPrevVersion("");
 178                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 179                 expectedResourceAuditJavaObject.setStatus("201");
 180                 expectedResourceAuditJavaObject.setDesc("OK");
 181
 182                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 183
 184         }
 185
 186         @Test
 187         public void createServiceUserNotFound() throws Exception {
 188
 189                 // choose the user to create service
 190                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 191                 sdncUserDetails.setUserId("no1234");
 192
 193                 // fill new service details
 194                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 195
 196                 // clean audit DB before service creation
 197                 DbUtils.cleanAllAudits();
 198
 199                 // send create service toward BE
 200                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 201
 202                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 203
 204                 assertNotNull("check response object is not null after create service", restResponse);
 205                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 206                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 207
 208                 // validate create service response vs actual
 209
 210                 List<String> variables = Arrays.asList();
 211                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), variables,
 212                                 restResponse.getResponse());
 213
 214                 // validate audit
 215
 216                 sdncUserDetails.setFirstName("");
 217                 sdncUserDetails.setLastName("");
 218                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 219                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 220
 221                 String auditAction = "Create";
 222                 expectedResourceAuditJavaObject.setAction(auditAction);
 223                 expectedResourceAuditJavaObject.setPrevState("");
 224                 expectedResourceAuditJavaObject.setPrevVersion("");
 225                 expectedResourceAuditJavaObject.setCurrVersion("");
 226                 expectedResourceAuditJavaObject.setCurrState("");
 227                 expectedResourceAuditJavaObject.setModifierName("");
 228                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 229
 230                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 231                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 232
 233                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 234
 235         }
 236
 237         @Test
 238         public void createServiceUserNotAllowed() throws Exception {
 239
 240                 // choose the user to create service
 241                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
 242
 243                 // fill new service details
 244                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 245
 246                 // clean audit DB before service creation
 247                 DbUtils.cleanAllAudits();
 248
 249                 // send create service toward BE
 250                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 251
 252                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.RESTRICTED_OPERATION.name());
 253
 254                 assertNotNull("check response object is not null after create service", restResponse);
 255                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 256                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 257
 258                 // validate create service response vs actual
 259
 260                 List<String> variables = Arrays.asList();
 261                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.RESTRICTED_OPERATION.name(), variables,
 262                                 restResponse.getResponse());
 263
 264                 // validate audit
 265
 266                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 267                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 268
 269                 String auditAction = "Create";
 270                 expectedResourceAuditJavaObject.setAction(auditAction);
 271                 expectedResourceAuditJavaObject.setPrevState("");
 272                 expectedResourceAuditJavaObject.setPrevVersion("");
 273                 expectedResourceAuditJavaObject.setCurrVersion("");
 274                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 275                 expectedResourceAuditJavaObject.setCurrState("");
 276                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 277
 278                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 279                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 280
 281                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 282
 283         }
 284
 285         @Test
 286         public void createServiceEmptyName() throws Exception {
 287
 288                 // choose the user to create service
 289                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 290
 291                 // fill new service details
 292                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 293                 String serviceName = "";
 294                 serviceDetails.setName(serviceName);
 295
 296                 // clean audit DB before service creation
 297                 DbUtils.cleanAllAudits();
 298
 299                 // send create service toward BE
 300                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 301
 302                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_COMPONENT_NAME.name());
 303
 304                 assertNotNull("check response object is not null after create service", restResponse);
 305                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 306                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 307
 308                 // validate create service response vs actual
 309
 310                 List<String> variables = Arrays.asList("Service");
 311                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_COMPONENT_NAME.name(), variables,
 312                                 restResponse.getResponse());
 313
 314                 // validate audit
 315
 316                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 317                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 318
 319                 String auditAction = "Create";
 320                 expectedResourceAuditJavaObject.setAction(auditAction);
 321                 expectedResourceAuditJavaObject.setPrevState("");
 322                 expectedResourceAuditJavaObject.setPrevVersion("");
 323                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 324                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 325
 326                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 327                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 328
 329                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 330
 331         }
 332
 333         @Test
 334         public void createServiceEmptyCategory() throws Exception {
 335
 336                 // choose the user to create service
 337                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 338
 339                 // fill new service details
 340                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 341                 String category = "";
 342
 343                 serviceDetails.setCategories(null);
 344                 // serviceDetails.addCategory(category);
 345
 346                 // clean audit DB before service creation
 347                 DbUtils.cleanAllAudits();
 348
 349                 // send create service toward BE
 350                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 351
 352                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_CATEGORY.name());
 353
 354                 assertNotNull("check response object is not null after create service", restResponse);
 355                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 356                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 357
 358                 // validate create service response vs actual
 359
 360                 List<String> variables = Arrays.asList("Service");
 361                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_CATEGORY.name(), variables,
 362                                 restResponse.getResponse());
 363
 364                 // validate audit
 365
 366                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 367                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 368
 369                 String auditAction = "Create";
 370                 expectedResourceAuditJavaObject.setAction(auditAction);
 371                 expectedResourceAuditJavaObject.setPrevState("");
 372                 expectedResourceAuditJavaObject.setPrevVersion("");
 373                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 374                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 375
 376                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 377                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 378
 379                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 380
 381         }
 382
 383         @Test
 384         public void createServiceEmptyTag() throws Exception {
 385
 386                 // choose the user to create service
 387                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 388
 389                 // fill new service details
 390                 ArrayList<String> tags = new ArrayList<String>();
 391                 tags.add("");
 392                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 393                 serviceDetails.setTags(tags);
 394
 395                 // clean audit DB before service creation
 396                 DbUtils.cleanAllAudits();
 397
 398                 // send create service toward BE
 399                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 400
 401                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FIELD_FORMAT.name());
 402
 403                 assertNotNull("check response object is not null after create service", restResponse);
 404                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 405                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 406
 407                 // validate create service response vs actual
 408
 409                 List<String> variables = Arrays.asList("Service", "tag");
 410                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FIELD_FORMAT.name(), variables,
 411                                 restResponse.getResponse());
 412
 413                 // validate audit
 414
 415                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 416                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 417
 418                 String auditAction = "Create";
 419                 expectedResourceAuditJavaObject.setAction(auditAction);
 420                 expectedResourceAuditJavaObject.setPrevState("");
 421                 expectedResourceAuditJavaObject.setPrevVersion("");
 422                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 423                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 424
 425                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 426                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 427
 428                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 429
 430         }
 431
 432         @Test
 433         public void createServiceEmptyDescription() throws Exception {
 434
 435                 // choose the user to create service
 436                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 437
 438                 // fill new service details
 439                 String description = "";
 440                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 441                 serviceDetails.setDescription(description);
 442
 443                 // clean audit DB before service creation
 444                 DbUtils.cleanAllAudits();
 445
 446                 // send create service toward BE
 447                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 448
 449                 ErrorInfo errorInfo = ErrorValidationUtils
 450                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name());
 451
 452                 assertNotNull("check response object is not null after create service", restResponse);
 453                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 454                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 455
 456                 // validate create service response vs actual
 457
 458                 List<String> variables = Arrays.asList("Service");
 459                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_MISSING_DESCRIPTION.name(), variables,
 460                                 restResponse.getResponse());
 461
 462                 // validate audit
 463
 464                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 465                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 466
 467                 String auditAction = "Create";
 468                 expectedResourceAuditJavaObject.setAction(auditAction);
 469                 expectedResourceAuditJavaObject.setPrevState("");
 470                 expectedResourceAuditJavaObject.setPrevVersion("");
 471                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 472                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 473
 474                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 475                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 476
 477                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 478
 479         }
 480
 481         @Test
 482         public void createServiceEmptyTags() throws Exception {
 483
 484                 // choose the user to create service
 485                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 486
 487                 // fill new service details
 488                 ArrayList<String> tags = new ArrayList<String>();
 489                 tags.add("");
 490                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 491                 serviceDetails.setTags(tags);
 492
 493                 // clean audit DB before service creation
 494                 DbUtils.cleanAllAudits();
 495
 496                 // send create service toward BE
 497                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 498
 499                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.INVALID_FIELD_FORMAT.name());
 500
 501                 assertNotNull("check response object is not null after create service", restResponse);
 502                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 503                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 504
 505                 // validate create service response vs actual
 506
 507                 List<String> variables = Arrays.asList("Service", "tag");
 508                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.INVALID_FIELD_FORMAT.name(), variables,
 509                                 restResponse.getResponse());
 510
 511                 // validate audit
 512
 513                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 514                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 515
 516                 String auditAction = "Create";
 517                 expectedResourceAuditJavaObject.setAction(auditAction);
 518                 expectedResourceAuditJavaObject.setPrevState("");
 519                 expectedResourceAuditJavaObject.setPrevVersion("");
 520                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 521                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 522
 523                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 524                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 525
 526                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 527
 528         }
 529
 530         @Test
 531         public void createServiceByPutHttpMethod() throws Exception {
 532
 533                 String method = "PUT";
 534
 535                 // choose the user to create service
 536                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 537
 538                 // fill new service details
 539                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 540
 541                 // clean audit DB before service creation
 542                 DbUtils.cleanAllAudits();
 543
 544                 // send create service toward BE
 545
 546                 RestResponse restResponse = ServiceRestUtils.createServiceByHttpMethod(serviceDetails, sdncUserDetails, method,
 547                                 Urls.CREATE_SERVICE);
 548
 549                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.NOT_ALLOWED.name());
 550
 551                 assertNotNull("check response object is not null after create service", restResponse);
 552                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 553                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 554
 555                 // validate create service response vs actual
 556
 557                 List<String> variables = Arrays.asList();
 558                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_ALLOWED.name(), variables,
 559                                 restResponse.getResponse());
 560
 561                 // //validate audit
 562                 //
 563                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 564                 // resourceUtils.constructFieldsForAuditValidation(serviceDetails,
 565                 // serviceBaseVersion, sdncUserDetails);
 566                 //
 567                 // String auditAction="Create";
 568                 // expectedResourceAuditJavaObject.setAction(auditAction);
 569                 // expectedResourceAuditJavaObject.setPrevState("");
 570                 // expectedResourceAuditJavaObject.setPrevVersion("");
 571                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 572                 // expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 573                 //
 574                 // String auditDesc =
 575                 // AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 576                 // expectedResourceAuditJavaObject.setDesc(auditDesc);
 577                 //
 578                 // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 579                 // auditAction);
 580
 581         }
 582
 583         @Test
 584         public void createServiceByDeleteHttpMethod() throws Exception {
 585
 586                 String method = "DELETE";
 587
 588                 // choose the user to create service
 589                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 590
 591                 // fill new service details
 592                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 593
 594                 // clean audit DB before service creation
 595                 DbUtils.cleanAllAudits();
 596
 597                 // send create service toward BE
 598
 599                 RestResponse restResponse = ServiceRestUtils.createServiceByHttpMethod(serviceDetails, sdncUserDetails, method,
 600                                 Urls.CREATE_SERVICE);
 601
 602                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.NOT_ALLOWED.name());
 603
 604                 assertNotNull("check response object is not null after create service", restResponse);
 605                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 606                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 607
 608                 // validate create service response vs actual
 609
 610                 List<String> variables = Arrays.asList();
 611                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.NOT_ALLOWED.name(), variables,
 612                                 restResponse.getResponse());
 613
 614                 // //validate audit
 615                 //
 616                 // ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 617                 // resourceUtils.constructFieldsForAuditValidation(serviceDetails,
 618                 // serviceBaseVersion, sdncUserDetails);
 619                 //
 620                 // String auditAction="Create";
 621                 // expectedResourceAuditJavaObject.setAction(auditAction);
 622                 // expectedResourceAuditJavaObject.setPrevState("");
 623                 // expectedResourceAuditJavaObject.setPrevVersion("");
 624                 // expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 625                 // expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 626                 //
 627                 // String auditDesc =
 628                 // AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 629                 // expectedResourceAuditJavaObject.setDesc(auditDesc);
 630                 //
 631                 // AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 632                 // auditAction);
 633
 634         }
 635
 636         @Test
 637         public void createServiceTagLengthExceedLimit() throws Exception {
 638
 639                 // choose the user to create service
 640                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 641
 642                 // fill new service details
 643                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 644                 StringBuffer tagBuffer = new StringBuffer();
 645                 for (int i = 0; i < 1025; i++) {
 646                         tagBuffer.append("a");
 647                 }
 648                 ArrayList<String> tags = new ArrayList<String>();
 649                 tags.add(tagBuffer.toString());
 650                 serviceDetails.setTags(tags);
 651
 652                 // clean audit DB before service creation
 653                 DbUtils.cleanAllAudits();
 654
 655                 // send create service toward BE
 656
 657                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 658
 659                 ErrorInfo errorInfo = ErrorValidationUtils
 660                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT.name());
 661
 662                 assertNotNull("check response object is not null after create service", restResponse);
 663                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 664                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 665
 666                 // validate create service response vs actual
 667
 668                 List<String> variables = Arrays.asList("50");
 669                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_SINGLE_TAG_EXCEED_LIMIT.name(), variables,
 670                                 restResponse.getResponse());
 671
 672                 // validate audit
 673                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 674                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 675                 String auditAction = "Create";
 676                 expectedResourceAuditJavaObject.setAction(auditAction);
 677                 expectedResourceAuditJavaObject.setPrevState("");
 678                 expectedResourceAuditJavaObject.setPrevVersion("");
 679                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 680                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 681                 expectedResourceAuditJavaObject.setDesc(errorInfo.getAuditDesc("50"));
 682                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 683
 684                 /*
 685                  * ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject =
 686                  * ServiceValidationUtils.constructFieldsForAuditValidation(
 687                  * serviceDetails, serviceBaseVersion, sdncUserDetails);
 688                  *
 689                  * String auditAction="Create";
 690                  * expectedResourceAuditJavaObject.setAction(auditAction);
 691                  * expectedResourceAuditJavaObject.setPrevState("");
 692                  * expectedResourceAuditJavaObject.setPrevVersion("");
 693                  * expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.
 694                  * NOT_CERTIFIED_CHECKOUT).toString());
 695                  * expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().
 696                  * toString()); expectedResourceAuditJavaObject.setDesc(auditDesc);
 697                  *
 698                  * AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject,
 699                  * auditAction, null);
 700                  */
 701
 702         }
 703
 704         @Test
 705         public void createServiceAlreadyExistException() throws Exception {
 706
 707                 // choose the user to create service
 708                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 709
 710                 // fill new service details
 711                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 712
 713                 // clean audit DB before service creation
 714                 DbUtils.cleanAllAudits();
 715
 716                 // send create service toward BE
 717                 ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 718
 719                 // clean audit DB before service creation
 720                 DbUtils.cleanAllAudits();
 721
 722                 // create service with the same name
 723                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 724
 725                 ErrorInfo errorInfo = ErrorValidationUtils
 726                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name());
 727
 728                 assertNotNull("check response object is not null after create service", restResponse);
 729                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 730                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 731
 732                 // validate create service response vs actual
 733
 734                 List<String> variables = Arrays.asList("Service", serviceDetails.getName());
 735                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.COMPONENT_NAME_ALREADY_EXIST.name(), variables,
 736                                 restResponse.getResponse());
 737
 738                 // validate audit
 739
 740                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 741                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 742
 743                 String auditAction = "Create";
 744                 expectedResourceAuditJavaObject.setAction(auditAction);
 745                 expectedResourceAuditJavaObject.setPrevState("");
 746                 expectedResourceAuditJavaObject.setPrevVersion("");
 747                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 748                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 749
 750                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 751                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 752
 753                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 754
 755         }
 756
 757         @Test
 758         public void createServiceWrongContactId() throws Exception {
 759
 760                 // choose the user to create service
 761                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 762
 763                 // fill new service details
 764                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 765                 serviceDetails.setContactId("123as");
 766
 767                 // clean audit DB before service creation
 768                 DbUtils.cleanAllAudits();
 769
 770                 // send create service toward BE
 771                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 772
 773                 ErrorInfo errorInfo = ErrorValidationUtils
 774                                 .parseErrorConfigYaml(ActionStatus.COMPONENT_INVALID_CONTACT.name());
 775
 776                 assertNotNull("check response object is not null after create service", restResponse);
 777                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 778                 assertEquals("Check response code after create service", errorInfo.getCode(), restResponse.getErrorCode());
 779         }
 780
 781         @Test
 782         public void createServiceProjectName() throws Exception {
 783
 784                 // choose the user to create service
 785                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 786
 787                 // fill new service details
 788                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 789                 serviceDetails.setProjectCode("12345");
 790
 791                 // clean audit DB before service creation
 792                 DbUtils.cleanAllAudits();
 793
 794                 // send create service toward BE
 795                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 796
 797                 Integer expectedCode = 201;
 798
 799                 assertNotNull("check response object is not null after create service", restResponse);
 800                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 801                 assertEquals("Check response code after create service", expectedCode, restResponse.getErrorCode());
 802                 Service service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 803
 804                 assertEquals("12345", service.getProjectCode());
 805         }
 806
 807         @Test
 808         public void createAndGetByNameAndVersion() throws Exception {
 809
 810                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 811
 812                 // create
 813                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 814                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 815                 assertEquals("Check response code after create service", 201, restResponse.getErrorCode().intValue());
 816
 817                 // get
 818                 restResponse = ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails, serviceDetails.getName(),
 819                                 serviceBaseVersion);
 820                 assertEquals("Check response code after get service", 200, restResponse.getErrorCode().intValue());
 821
 822                 Service service = ResponseParser.convertServiceResponseToJavaObject(restResponse.getResponse());
 823                 String uniqueId = service.getUniqueId();
 824                 serviceDetails.setUniqueId(uniqueId);
 825                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, service, sdncUserDetails,
 826                                 (LifecycleStateEnum) null);
 827         }
 828
 829         //// US553874
 830
 831         @JsonIgnore
 832         @Test
 833         public void createServiceIsVNF_isFalse() throws Exception {
 834
 835                 // choose the user to create service
 836                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 837                 // new service details
 838                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 839
 840                 // clean audit DB before service creation
 841                 DbUtils.cleanAllAudits();
 842
 843                 // send create service toward BE
 844                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 845                 assertNotNull("check response object is not null after create service", restResponse);
 846                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 847                 assertEquals("Check response code after updating Interface Artifact", 201,
 848                                 restResponse.getErrorCode().intValue());
 849
 850                 // get service and verify that service created with isVNF defined in
 851                 // serviceDetails
 852                 RestResponse serviceByNameAndVersion = ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
 853                                 serviceDetails.getName(), serviceBaseVersion);
 854                 Service serviceObject = ResponseParser
 855                                 .convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
 856                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, serviceObject, sdncUserDetails,
 857                                 LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 858
 859                 // validate audit
 860                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 861                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 862                 String auditAction = "Create";
 863                 expectedResourceAuditJavaObject.setPrevState("");
 864                 expectedResourceAuditJavaObject.setPrevVersion("");
 865                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 866                 expectedResourceAuditJavaObject.setStatus("201");
 867                 expectedResourceAuditJavaObject.setDesc("OK");
 868                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 869         }
 870
 871         @JsonIgnore
 872         @Test
 873         public void createServiceIsVNF_isTrue() throws Exception {
 874
 875                 // choose the user to create service
 876                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 877                 // new service details
 878                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 879
 880                 // clean audit DB before service creation
 881                 DbUtils.cleanAllAudits();
 882
 883                 // send create service toward BE
 884                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 885                 assertNotNull("check response object is not null after create service", restResponse);
 886                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 887                 assertEquals("Check response code after updating Interface Artifact", 201,
 888                                 restResponse.getErrorCode().intValue());
 889
 890                 // get service and verify that service created with isVNF defined in
 891                 // serviceDetails
 892                 RestResponse serviceByNameAndVersion = ServiceRestUtils.getServiceByNameAndVersion(sdncUserDetails,
 893                                 serviceDetails.getName(), serviceBaseVersion);
 894                 Service serviceObject = ResponseParser
 895                                 .convertServiceResponseToJavaObject(serviceByNameAndVersion.getResponse());
 896                 ServiceValidationUtils.validateServiceResponseMetaData(serviceDetails, serviceObject, sdncUserDetails,
 897                                 LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT);
 898
 899                 // validate audit
 900                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 901                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 902                 String auditAction = "Create";
 903                 expectedResourceAuditJavaObject.setPrevState("");
 904                 expectedResourceAuditJavaObject.setPrevVersion("");
 905                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 906                 expectedResourceAuditJavaObject.setStatus("201");
 907                 expectedResourceAuditJavaObject.setDesc("OK");
 908                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 909         }
 910
 911         @JsonIgnore
 912         @Test(enabled = false)
 913         public void createServiceIsVNF_isNull() throws Exception {
 914
 915                 // choose the user to create service
 916                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 917                 // new service details
 918                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 919
 920                 // clean audit DB before service creation
 921                 DbUtils.cleanAllAudits();
 922                 // send create service toward BE
 923                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 924                 assertNotNull("check response object is not null after create service", restResponse);
 925                 assertEquals("Check response code after updating Interface Artifact", 400,
 926                                 restResponse.getErrorCode().intValue());
 927                 List<String> variables = Arrays.asList("VNF Service Indicator");
 928                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_DATA.name(), variables,
 929                                 restResponse.getResponse());
 930
 931                 // validate audit
 932                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 933                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 934                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 935                 String auditAction = "Create";
 936                 expectedResourceAuditJavaObject.setAction(auditAction);
 937                 expectedResourceAuditJavaObject.setPrevState("");
 938                 expectedResourceAuditJavaObject.setPrevVersion("");
 939                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 940                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 941                 expectedResourceAuditJavaObject.setDesc(errorInfo.getAuditDesc("VNF Service Indicator"));
 942                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 943         }
 944
 945         @JsonIgnore
 946         @Test(enabled = false)
 947         public void createServiceEmptyIsVNF() throws Exception {
 948
 949                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
 950
 951                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
 952
 953                 DbUtils.cleanAllAudits();
 954
 955                 // send create service toward BE
 956                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
 957
 958                 assertNotNull("check response object is not null after create service", restResponse);
 959                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
 960                 assertEquals("Check response code after create service", restResponse.getErrorCode(),
 961                                 restResponse.getErrorCode());
 962
 963                 // validate create service response vs actual
 964                 List<String> variables = Arrays.asList("VNF Service Indicator");
 965                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_DATA.name(), variables,
 966                                 restResponse.getResponse());
 967
 968                 // validate audit
 969                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
 970                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
 971                                 .constructFieldsForAuditValidation(serviceDetails, serviceBaseVersion, sdncUserDetails);
 972
 973                 String auditAction = "Create";
 974                 expectedResourceAuditJavaObject.setAction(auditAction);
 975                 expectedResourceAuditJavaObject.setPrevState("");
 976                 expectedResourceAuditJavaObject.setPrevVersion("");
 977                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
 978                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
 979                 String auditDesc = AuditValidationUtils.buildAuditDescription(errorInfo, variables);
 980                 expectedResourceAuditJavaObject.setDesc(auditDesc);
 981
 982                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
 983
 984         }
 985
 986         private RestResponse createServiceWithMissingAttribute(String serviceDetails, User sdncModifierDetails)
 987                         throws Exception {
 988
 989                 Config config = Utils.getConfig();
 990
 991                 Map<String, String> headersMap = ServiceRestUtils.prepareHeadersMap(sdncModifierDetails, false);
 992                 headersMap.put(HttpHeaderEnum.CACHE_CONTROL.getValue(), "no-cache");
 993
 994                 HttpRequest http = new HttpRequest();
 995                 String url = String.format(Urls.CREATE_SERVICE, config.getCatalogBeHost(), config.getCatalogBePort());
 996                 // TODO: ADD AUTHENTICATION IN REQUEST
 997                 logger.debug(url);
 998                 logger.debug("Send POST request to create service: {}", url);
 999                 logger.debug("Service body: {}", serviceDetails);
1000                 logger.debug("Service headers: {}", headersMap);
1001                 RestResponse sendCreateUserRequest = http.httpSendPost(url, serviceDetails, headersMap);
1002
1003                 return sendCreateUserRequest;
1004
1005         }
1006
1007         @JsonIgnore
1008         @Test(enabled = false)
1009         public void createServiceVersion_isVNFDoesNotExistInJson() throws Exception {
1010
1011                 // choose the user to create service
1012                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1013                 // new service details
1014                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1015                 // clean audit DB before updating service
1016                 DbUtils.cleanAllAudits();
1017
1018                 // remove isVNF from json sent to create service
1019                 JSONObject jObject = new JSONObject(serviceDetails);
1020                 jObject.remove("VNF");
1021
1022                 // send create service toward BE
1023                 RestResponse restResponse = createServiceWithMissingAttribute(jObject.toString(), sdncUserDetails);
1024                 assertNotNull("check error code exists in response after create service", restResponse.getErrorCode());
1025                 assertEquals("Check response code after updating Interface Artifact", 400,
1026                                 restResponse.getErrorCode().intValue());
1027                 List<String> variables = new ArrayList<String>();
1028                 variables.add("VNF Service Indicator");
1029                 ErrorValidationUtils.checkBodyResponseOnError(ActionStatus.MISSING_DATA.name(), variables,
1030                                 restResponse.getResponse());
1031
1032                 // validate audit
1033                 ErrorInfo errorInfo = ErrorValidationUtils.parseErrorConfigYaml(ActionStatus.MISSING_DATA.name());
1034                 ExpectedResourceAuditJavaObject expectedResourceAuditJavaObject = ServiceValidationUtils
1035                                 .constructFieldsForAuditValidation(serviceDetails, "0.1", sdncUserDetails);
1036                 String auditAction = "Create";
1037                 expectedResourceAuditJavaObject.setPrevState("");
1038                 expectedResourceAuditJavaObject.setPrevVersion("");
1039                 expectedResourceAuditJavaObject.setCurrState((LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT).toString());
1040                 // expectedResourceAuditJavaObject.setStatus("201");
1041                 expectedResourceAuditJavaObject.setStatus(errorInfo.getCode().toString());
1042                 expectedResourceAuditJavaObject.setDesc(errorInfo.getAuditDesc("VNF Service Indicator"));
1043                 AuditValidationUtils.validateAudit(expectedResourceAuditJavaObject, auditAction, null, false);
1044
1045         }
1046
1047         @Test
1048         public void checkInvariantUuidIsImmutable() throws Exception {
1049                 // choose the user to create service
1050                 User sdncUserDetails = ElementFactory.getDefaultUser(UserRoleEnum.ADMIN);
1051                 Component resourceDetailsVFCcomp = AtomicOperationUtils
1052                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.ADMIN, true).left().value();
1053                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.HEAT, resourceDetailsVFCcomp, UserRoleEnum.ADMIN,
1054                                 true, true);
1055                 AtomicOperationUtils.changeComponentState(resourceDetailsVFCcomp, UserRoleEnum.ADMIN,
1056                                 LifeCycleStatesEnum.CERTIFY, true);
1057
1058                 // fill new service details
1059                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1060                 String invariantUuidDefinedByUser = "!!!!!!!!!!!!!!!!!!!!!!!!";
1061                 serviceDetails.setInvariantUUID(invariantUuidDefinedByUser);
1062
1063                 // create service
1064                 RestResponse restResponseCreation = ServiceRestUtils.createService(serviceDetails, sdncUserDetails);
1065                 BaseRestUtils.checkStatusCode(restResponseCreation, "create request failed", false, 201);
1066                 Service service = ResponseParser.convertServiceResponseToJavaObject(restResponseCreation.getResponse());
1067                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceDetailsVFCcomp, service,
1068                                 UserRoleEnum.ADMIN, true);
1069
1070                 String invariantUUIDcreation = service.getInvariantUUID();
1071
1072                 // validate get service response vs actual
1073                 RestResponse restResponseGetting = ServiceRestUtils.getService(serviceDetails, sdncUserDetails);
1074                 BaseRestUtils.checkSuccess(restResponseGetting);
1075                 service = ResponseParser.convertServiceResponseToJavaObject(restResponseGetting.getResponse());
1076                 String invariantUUIDgetting = service.getInvariantUUID();
1077
1078                 assertEquals(invariantUUIDcreation, invariantUUIDgetting);
1079
1080                 // Update service with new invariant UUID
1081                 RestResponse restResponseUpdate = ServiceRestUtils.updateService(serviceDetails, sdncUserDetails);
1082                 BaseRestUtils.checkSuccess(restResponseUpdate);
1083                 Service updatedService = ResponseParser.convertServiceResponseToJavaObject(restResponseUpdate.getResponse());
1084                 String invariantUUIDupdating = updatedService.getInvariantUUID();
1085                 assertEquals(invariantUUIDcreation, invariantUUIDupdating);
1086
1087                 // Do checkin
1088                 RestResponse restResponseCheckin = LifecycleRestUtils.changeServiceState(serviceDetails, sdncUserDetails,
1089                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKIN);
1090                 BaseRestUtils.checkSuccess(restResponseCheckin);
1091                 Service checkinService = ResponseParser.convertServiceResponseToJavaObject(restResponseCheckin.getResponse());
1092                 String invariantUUIDcheckin = checkinService.getInvariantUUID();
1093                 String version = checkinService.getVersion();
1094                 assertEquals(invariantUUIDcreation, invariantUUIDcheckin);
1095                 assertEquals(version, "0.1");
1096
1097                 // Do checkout
1098                 RestResponse restResponseCheckout = LifecycleRestUtils.changeServiceState(serviceDetails, sdncUserDetails,
1099                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CHECKOUT);
1100                 BaseRestUtils.checkSuccess(restResponseCheckout);
1101                 Service checkoutService = ResponseParser.convertServiceResponseToJavaObject(restResponseCheckout.getResponse());
1102                 String invariantUUIDcheckout = checkoutService.getInvariantUUID();
1103                 version = checkoutService.getVersion();
1104                 assertEquals(invariantUUIDcreation, invariantUUIDcheckout);
1105                 assertEquals(version, "0.2");
1106
1107                 // do certification request
1108                 RestResponse restResponseCertificationRequest = LifecycleRestUtils.changeServiceState(serviceDetails,
1109                                 sdncUserDetails, serviceDetails.getVersion(), LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1110                 BaseRestUtils.checkSuccess(restResponseCertificationRequest);
1111                 Service certificationRequestService = ResponseParser
1112                                 .convertServiceResponseToJavaObject(restResponseCertificationRequest.getResponse());
1113                 String invariantUUIDcertificationRequest = certificationRequestService.getInvariantUUID();
1114                 version = certificationRequestService.getVersion();
1115                 assertEquals(invariantUUIDcreation, invariantUUIDcertificationRequest);
1116                 assertEquals(version, "0.2");
1117
1118                 // start certification
1119                 RestResponse restResponseStartCertification = LifecycleRestUtils.changeServiceState(serviceDetails,
1120                                 sdncUserDetails, serviceDetails.getVersion(), LifeCycleStatesEnum.STARTCERTIFICATION);
1121                 BaseRestUtils.checkSuccess(restResponseStartCertification);
1122                 Service startCertificationRequestService = ResponseParser
1123                                 .convertServiceResponseToJavaObject(restResponseStartCertification.getResponse());
1124                 String invariantUUIDStartCertification = startCertificationRequestService.getInvariantUUID();
1125                 version = startCertificationRequestService.getVersion();
1126                 assertEquals(invariantUUIDcreation, invariantUUIDStartCertification);
1127                 assertEquals(version, "0.2");
1128
1129                 // certify
1130                 RestResponse restResponseCertify = LifecycleRestUtils.changeServiceState(serviceDetails, sdncUserDetails,
1131                                 serviceDetails.getVersion(), LifeCycleStatesEnum.CERTIFY);
1132                 BaseRestUtils.checkSuccess(restResponseCertify);
1133                 Service certifyService = ResponseParser.convertServiceResponseToJavaObject(restResponseCertify.getResponse());
1134                 String invariantUUIDcertify = certifyService.getInvariantUUID();
1135                 version = certifyService.getVersion();
1136                 assertEquals(invariantUUIDcreation, invariantUUIDcertify);
1137                 assertEquals(version, "1.0");
1138
1139         }
1140
1141         // US672129 Benny
1142         private void getServiceValidateInvariantUuid(String serviceUniqueId, String invariantUUIDcreation)
1143                         throws Exception {
1144                 RestResponse getService = ServiceRestUtils.getService(serviceUniqueId,
1145                                 ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER));
1146                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, getService.getErrorCode().intValue());
1147                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(getService));
1148         }
1149
1150         @Test // invariantUUID generated when the component is created and never
1151                         // changed
1152         public void serviceInvariantUuid() throws Exception {
1153                 User designerUser = ElementFactory.getDefaultUser(UserRoleEnum.DESIGNER);
1154                 User testerUser = ElementFactory.getDefaultUser(UserRoleEnum.TESTER);
1155                 User pmUser = ElementFactory.getDefaultUser(UserRoleEnum.PRODUCT_MANAGER1);
1156                 Component resourceDetailsVFCcomp = AtomicOperationUtils
1157                                 .createResourceByType(ResourceTypeEnum.VFC, UserRoleEnum.DESIGNER, true).left().value();
1158                 AtomicOperationUtils.uploadArtifactByType(ArtifactTypeEnum.HEAT, resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
1159                                 true, true);
1160                 AtomicOperationUtils.changeComponentState(resourceDetailsVFCcomp, UserRoleEnum.DESIGNER,
1161                                 LifeCycleStatesEnum.CERTIFY, true);
1162                 // create service
1163                 ServiceReqDetails serviceDetails = ElementFactory.getDefaultService();
1164                 serviceDetails.setInvariantUUID("123456");
1165                 RestResponse restResponse = ServiceRestUtils.createService(serviceDetails, designerUser);
1166                 assertEquals("Check response code after create resource", BaseRestUtils.STATUS_CODE_CREATED,
1167                                 restResponse.getErrorCode().intValue());
1168                 Service service = ResponseParser.parseToObjectUsingMapper(restResponse.getResponse(), Service.class);
1169                 // invariantUUID generated when the component is created and never
1170                 // changed
1171                 String invariantUUIDcreation = ResponseParser.getInvariantUuid(restResponse);
1172                 // Add VF instance to service
1173                 AtomicOperationUtils.addComponentInstanceToComponentContainer(resourceDetailsVFCcomp, service,
1174                                 UserRoleEnum.DESIGNER, true);
1175                 // get resource and verify InvariantUuid is not changed
1176                 getServiceValidateInvariantUuid(service.getUniqueId(), invariantUUIDcreation);
1177
1178                 // Update service with new invariant UUID
1179                 restResponse = ServiceRestUtils.updateService(serviceDetails, designerUser);
1180                 assertEquals("Check response code after create resource", BaseRestUtils.STATUS_CODE_SUCCESS,
1181                                 restResponse.getErrorCode().intValue());
1182                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1183                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1184
1185                 // Checkin
1186                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser, LifeCycleStatesEnum.CHECKIN);
1187                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1188                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1189                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1190
1191                 // Checkout
1192                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1193                                 LifeCycleStatesEnum.CHECKOUT);
1194                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1195                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1196                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1197
1198                 // certification request
1199                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1200                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1201                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1202                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1203                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1204
1205                 // start certification
1206                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser,
1207                                 LifeCycleStatesEnum.STARTCERTIFICATION);
1208                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1209                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1210                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1211
1212                 // certify
1213                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser, LifeCycleStatesEnum.CERTIFY);
1214                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1215                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1216                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1217
1218                 // update resource
1219                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1220                                 LifeCycleStatesEnum.CHECKOUT);
1221                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1222                 serviceDetails.setDescription("updatedDescription");
1223                 restResponse = ServiceRestUtils.updateService(serviceDetails, designerUser);
1224                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1225                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1226                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1227
1228                 // certification request
1229                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1230                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1231                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1232                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1233                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1234
1235                 // Checkout
1236                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1237                                 LifeCycleStatesEnum.CHECKOUT);
1238                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1239                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1240                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1241
1242                 // certification request
1243                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1244                                 LifeCycleStatesEnum.CERTIFICATIONREQUEST);
1245                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1246                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1247                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1248
1249                 // start certification
1250                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser,
1251                                 LifeCycleStatesEnum.STARTCERTIFICATION);
1252                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1253                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1254                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1255
1256                 // cancel certification
1257                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser,
1258                                 LifeCycleStatesEnum.CANCELCERTIFICATION);
1259                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1260                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1261                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1262
1263                 // start certification
1264                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser,
1265                                 LifeCycleStatesEnum.STARTCERTIFICATION);
1266                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1267                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1268                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1269
1270                 // failure
1271                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, testerUser,
1272                                 LifeCycleStatesEnum.FAILCERTIFICATION);
1273                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1274                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1275                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1276
1277                 // Checkout
1278                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser,
1279                                 LifeCycleStatesEnum.CHECKOUT);
1280                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1281                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1282                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1283
1284                 // Checkin
1285                 restResponse = LifecycleRestUtils.changeServiceState(serviceDetails, designerUser, LifeCycleStatesEnum.CHECKIN);
1286                 assertEquals(BaseRestUtils.STATUS_CODE_SUCCESS, restResponse.getErrorCode().intValue());
1287                 assertEquals(invariantUUIDcreation, ResponseParser.getInvariantUuid(restResponse));
1288                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1289
1290                 // create instance
1291                 ProductReqDetails productDetails = ElementFactory.getDefaultProduct();
1292                 RestResponse createProductResponse = ProductRestUtils.createProduct(productDetails, pmUser);
1293                 assertEquals(BaseRestUtils.STATUS_CODE_CREATED, createProductResponse.getErrorCode().intValue());
1294                 ComponentInstanceReqDetails serviceInstanceReqDetails = ElementFactory
1295                                 .getComponentResourceInstance(serviceDetails);
1296                 RestResponse createServiceInstanceResponse = ComponentInstanceRestUtils.createComponentInstance(
1297                                 serviceInstanceReqDetails, pmUser, productDetails.getUniqueId(), ComponentTypeEnum.PRODUCT);
1298                 assertEquals("Check response code ", BaseRestUtils.STATUS_CODE_CREATED,
1299                                 createServiceInstanceResponse.getErrorCode().intValue());
1300                 getServiceValidateInvariantUuid(serviceDetails.getUniqueId(), invariantUUIDcreation);
1301
1302         }
1303
1304 }