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