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