catalog-be/src/test/java/org/openecomp/sdc/be/impl/ComponentsUtilsTest.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  * Modifications copyright (c) 2019 Nokia
  20  * ================================================================================
  21  */
  22 package org.openecomp.sdc.be.impl;
  23
  24 import fj.data.Either;
  25 import junit.framework.Assert;
  26 import org.apache.tinkerpop.gremlin.structure.T;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.Mockito;
  30 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  31 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  32 import org.openecomp.sdc.be.config.ConfigurationManager;
  33 import org.openecomp.sdc.be.dao.api.ActionStatus;
  34 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  35 import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
  36 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  37 import org.openecomp.sdc.be.dao.graph.datatype.AdditionalInformationEnum;
  38 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  39 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  40 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  41 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  42 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  43 import org.openecomp.sdc.be.model.Component;
  44 import org.openecomp.sdc.be.model.DataTypeDefinition;
  45 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  46 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  47 import org.openecomp.sdc.be.model.Resource;
  48 import org.openecomp.sdc.be.model.User;
  49 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  50 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  51 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  52 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  53 import org.openecomp.sdc.be.tosca.ToscaError;
  54 import org.openecomp.sdc.common.api.ConfigurationSource;
  55 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  56 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  57 import org.openecomp.sdc.exception.ResponseFormat;
  58 import org.openecomp.sdc.test.utils.TestConfigurationProvider;
  59
  60 import java.util.List;
  61
  62 import static org.mockito.ArgumentMatchers.any;
  63 import static org.mockito.Mockito.mock;
  64 import static org.mockito.Mockito.when;
  65
  66 public class ComponentsUtilsTest {
  67
  68         private ComponentsUtils createTestSubject() {
  69                 return new ComponentsUtils(new AuditingManager(new AuditCassandraDao(mock(CassandraClient.class)), new TestConfigurationProvider()));
  70         }
  71
  72         @Before
  73         public void init(){
  74                 String appConfigDir = "src/test/resources/config/catalog-be";
  75                 ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
  76                 ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  77                 ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  78         }
  79
  80         @Test
  81         public void testGetAuditingManager() throws Exception {
  82                 ComponentsUtils testSubject;
  83                 AuditingManager result;
  84
  85                 // default test
  86                 testSubject = createTestSubject();
  87                 result = testSubject.getAuditingManager();
  88         }
  89
  90
  91         @Test
  92         public void testGetResponseFormat() throws Exception {
  93                 ComponentsUtils testSubject;
  94                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
  95                 String[] params = new String[] { "" };
  96                 ResponseFormat result;
  97
  98                 // default test
  99                 testSubject = createTestSubject();
 100                 result = testSubject.getResponseFormat(actionStatus, params);
 101         }
 102
 103
 104         @Test
 105         public void testGetResponseFormat_1() throws Exception {
 106                 ComponentsUtils testSubject;
 107                 StorageOperationStatus storageStatus = null;
 108                 String[] params = new String[] { "" };
 109                 ResponseFormat result;
 110
 111                 // default test
 112                 testSubject = createTestSubject();
 113                 result = testSubject.getResponseFormat(storageStatus, params);
 114         }
 115
 116
 117         @Test
 118         public void testConvertToResponseFormatOrNotFoundErrorToEmptyList() throws Exception {
 119                 ComponentsUtils testSubject;
 120                 StorageOperationStatus storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 121                 Either<List<T>, ResponseFormat> result;
 122
 123                 // default test
 124                 testSubject = createTestSubject();
 125                 result = testSubject.convertToResponseFormatOrNotFoundErrorToEmptyList(storageOperationStatus);
 126         }
 127
 128
 129         @Test
 130         public void testGetResponseFormatByResource() throws Exception {
 131                 ComponentsUtils testSubject;
 132                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 133                 ResponseFormat result;
 134                 Resource resource = null;
 135                 // test 1
 136                 testSubject = createTestSubject();
 137                 result = testSubject.getResponseFormatByResource(actionStatus, resource);
 138                 resource = new Resource();
 139                 result = testSubject.getResponseFormatByResource(actionStatus, resource);
 140                 result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, resource);
 141                 result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resource);
 142                 result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, resource);
 143                 result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_IN_USE, resource);
 144         }
 145
 146
 147         @Test
 148         public void testGetResponseFormatByResource_1() throws Exception {
 149                 ComponentsUtils testSubject;
 150                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 151                 String resourceName = "";
 152                 ResponseFormat result;
 153
 154                 // test 1
 155                 testSubject = createTestSubject();
 156                 resourceName = null;
 157                 result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
 158
 159                 // test 2
 160                 testSubject = createTestSubject();
 161                 resourceName = "";
 162                 result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
 163                 result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resourceName);
 164         }
 165
 166
 167         @Test
 168         public void testGetResponseFormatByCapabilityType() throws Exception {
 169                 ComponentsUtils testSubject;
 170                 CapabilityTypeDefinition capabilityType = new CapabilityTypeDefinition();
 171                 ResponseFormat result;
 172
 173                 // test 1
 174                 testSubject = createTestSubject();
 175                 result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, null);
 176                 result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, capabilityType);
 177                 result = testSubject.getResponseFormatByCapabilityType(ActionStatus.AAI_ARTIFACT_GENERATION_FAILED, capabilityType);
 178         }
 179
 180
 181         @Test
 182         public void testGetResponseFormatByElement() throws Exception {
 183                 ComponentsUtils testSubject;
 184                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 185                 Object obj = null;
 186                 ResponseFormat result;
 187
 188                 // test 1
 189                 testSubject = createTestSubject();
 190                 obj = null;
 191                 result = testSubject.getResponseFormatByElement(actionStatus, obj);
 192                 obj = new Object();
 193                 result = testSubject.getResponseFormatByElement(actionStatus, obj);
 194                 result = testSubject.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE, obj);
 195         }
 196
 197
 198         @Test
 199         public void testGetResponseFormatByUser() throws Exception {
 200                 ComponentsUtils testSubject;
 201                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 202                 User user = null;
 203                 ResponseFormat result;
 204
 205                 // test 1
 206                 testSubject = createTestSubject();
 207                 user = null;
 208                 result = testSubject.getResponseFormatByUser(actionStatus, user);
 209                 user = new User();
 210                 result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_USER_ID, user);
 211                 result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_EMAIL_ADDRESS, user);
 212                 result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_ROLE, user);
 213                 result = testSubject.getResponseFormatByUser(ActionStatus.USER_NOT_FOUND, user);
 214                 result = testSubject.getResponseFormatByUser(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, user);
 215         }
 216
 217
 218         @Test
 219         public void testGetResponseFormatByUserId() throws Exception {
 220                 ComponentsUtils testSubject;
 221                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 222                 String userId = "";
 223                 ResponseFormat result;
 224
 225                 // default test
 226                 testSubject = createTestSubject();
 227                 result = testSubject.getResponseFormatByUserId(actionStatus, userId);
 228         }
 229
 230
 231         @Test
 232         public void testGetResponseFormatByDE() throws Exception {
 233                 ComponentsUtils testSubject;
 234                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 235                 String serviceId = "";
 236                 String envName = "";
 237                 ResponseFormat result;
 238
 239                 // default test
 240                 testSubject = createTestSubject();
 241                 result = testSubject.getResponseFormatByDE(actionStatus, serviceId);
 242         }
 243
 244
 245         @Test
 246         public void testGetResponseFormatByArtifactId() throws Exception {
 247                 ComponentsUtils testSubject;
 248                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 249                 String artifactId = "";
 250                 ResponseFormat result;
 251
 252                 // default test
 253                 testSubject = createTestSubject();
 254                 result = testSubject.getResponseFormatByArtifactId(actionStatus, artifactId);
 255                 result = testSubject.getResponseFormatByArtifactId(ActionStatus.RESOURCE_NOT_FOUND, artifactId);
 256         }
 257
 258         @Test
 259         public void testAuditResource_1() throws Exception {
 260                 ComponentsUtils testSubject;
 261                 ResponseFormat responseFormat = new ResponseFormat();
 262                 User modifier = null;
 263                 String resourceName = "";
 264                 AuditingActionEnum actionEnum = null;
 265
 266                 // default test
 267                 testSubject = createTestSubject();
 268                 testSubject.auditResource(responseFormat, modifier, resourceName, actionEnum);
 269         }
 270
 271
 272
 273         @Test
 274         public void testAuditResource_3() throws Exception {
 275                 ComponentsUtils testSubject;
 276                 ResponseFormat responseFormat = null;
 277                 User modifier = null;
 278                 Resource resource = null;
 279                 String resourceName = "";
 280                 AuditingActionEnum actionEnum = null;
 281
 282                 // default test
 283                 testSubject = createTestSubject();
 284                 testSubject.auditResource(responseFormat, modifier, resource, resourceName, actionEnum);
 285         }
 286
 287
 288         @Test
 289         public void testAuditResource_4() throws Exception {
 290                 ComponentsUtils testSubject;
 291                 ResponseFormat responseFormat = null;
 292                 User modifier = null;
 293                 Resource resource = null;
 294                 String resourceName = "";
 295                 AuditingActionEnum actionEnum = null;
 296                 ResourceVersionInfo prevResFields = null;
 297                 String currentArtifactUuid = "";
 298                 String artifactData = "";
 299
 300                 // test 1
 301                 testSubject = createTestSubject();
 302                 actionEnum = null;
 303                 testSubject.auditResource(responseFormat, modifier, resource, resourceName, actionEnum, prevResFields,
 304                                 currentArtifactUuid, null);
 305         }
 306
 307         @Test
 308         public void testConvertFromStorageResponse() throws Exception {
 309                 ComponentsUtils testSubject;
 310                 StorageOperationStatus storageResponse = null;
 311                 ActionStatus result;
 312
 313                 // default test
 314                 testSubject = createTestSubject();
 315                 result = testSubject.convertFromStorageResponse(storageResponse);
 316         }
 317
 318
 319         @Test
 320         public void testConvertFromStorageResponse_1() throws Exception {
 321                 ComponentsUtils testSubject;
 322                 StorageOperationStatus storageResponse = null;
 323                 ComponentTypeEnum type = null;
 324                 ActionStatus result;
 325
 326                 // test 1
 327                 testSubject = createTestSubject();
 328                 storageResponse = null;
 329                 result = testSubject.convertFromStorageResponse(storageResponse, type);
 330         }
 331
 332
 333         @Test
 334         public void testConvertFromToscaError() throws Exception {
 335                 ComponentsUtils testSubject;
 336                 ToscaError toscaError = null;
 337                 ActionStatus result;
 338
 339                 // test 1
 340                 testSubject = createTestSubject();
 341                 toscaError = null;
 342                 result = testSubject.convertFromToscaError(toscaError);
 343         }
 344
 345
 346         @Test
 347         public void testConvertFromStorageResponseForCapabilityType() throws Exception {
 348                 ComponentsUtils testSubject;
 349                 StorageOperationStatus storageResponse = StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY;
 350                 ActionStatus result;
 351
 352                 // default test
 353                 testSubject = createTestSubject();
 354                 result = testSubject.convertFromStorageResponseForCapabilityType(storageResponse);
 355         }
 356
 357
 358         @Test
 359         public void testConvertFromStorageResponseForLifecycleType() throws Exception {
 360                 ComponentsUtils testSubject;
 361                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 362                 ActionStatus result;
 363
 364                 // default test
 365                 testSubject = createTestSubject();
 366                 result = testSubject.convertFromStorageResponseForLifecycleType(storageResponse);
 367         }
 368
 369
 370         @Test
 371         public void testConvertFromStorageResponseForResourceInstance() throws Exception {
 372                 ComponentsUtils testSubject;
 373                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 374                 boolean isRelation = false;
 375                 ActionStatus result;
 376
 377                 // default test
 378                 testSubject = createTestSubject();
 379                 result = testSubject.convertFromStorageResponseForResourceInstance(storageResponse, isRelation);
 380         }
 381
 382
 383         @Test
 384         public void testGetResponseFormatForResourceInstance() throws Exception {
 385                 ComponentsUtils testSubject;
 386                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 387                 String serviceName = "";
 388                 String resourceInstanceName = "";
 389                 ResponseFormat result;
 390
 391                 // default test
 392                 testSubject = createTestSubject();
 393                 result = testSubject.getResponseFormatForResourceInstance(actionStatus, serviceName, resourceInstanceName);
 394         }
 395
 396
 397         @Test
 398         public void testGetResponseFormatForResourceInstanceProperty() throws Exception {
 399                 ComponentsUtils testSubject;
 400                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 401                 String resourceInstanceName = "";
 402                 ResponseFormat result;
 403
 404                 // default test
 405                 testSubject = createTestSubject();
 406                 result = testSubject.getResponseFormatForResourceInstanceProperty(actionStatus, resourceInstanceName);
 407         }
 408
 409
 410         @Test
 411         public void testConvertFromStorageResponseForResourceInstanceProperty() throws Exception {
 412                 ComponentsUtils testSubject;
 413                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 414                 ActionStatus result;
 415
 416                 // default test
 417                 testSubject = createTestSubject();
 418                 result = testSubject.convertFromStorageResponseForResourceInstanceProperty(storageResponse);
 419         }
 420
 421
 422         @Test
 423         public void testAuditComponent() throws Exception {
 424                 ComponentsUtils testSubject;
 425                 ResponseFormat responseFormat = null;
 426                 User modifier = null;
 427                 Component component = null;
 428                 AuditingActionEnum actionEnum = null;
 429                 ComponentTypeEnum type = null;
 430                 ResourceCommonInfo prevComponent = null;
 431                 ResourceVersionInfo info = null;
 432                 String comment = "";
 433
 434                 // default test
 435                 testSubject = createTestSubject();
 436                 testSubject.auditComponent(responseFormat, modifier, component, actionEnum, prevComponent,info);
 437         }
 438
 439
 440         @Test
 441         public void testAuditComponent_1() throws Exception {
 442                 ComponentsUtils testSubject;
 443                 ResponseFormat responseFormat = null;
 444                 User modifier = null;
 445                 Component component = null;
 446                 AuditingActionEnum actionEnum = null;
 447                 ResourceCommonInfo type = null;
 448                 ResourceVersionInfo prevComponent = null;
 449
 450                 // default test
 451                 testSubject = createTestSubject();
 452                 testSubject.auditComponent(responseFormat, modifier, component, actionEnum, type, prevComponent);
 453         }
 454
 455
 456         @Test
 457         public void testValidateStringNotEmpty() throws Exception {
 458                 ComponentsUtils testSubject;
 459                 String value = "";
 460                 boolean result;
 461
 462                 // default test
 463                 testSubject = createTestSubject();
 464                 result = testSubject.validateStringNotEmpty(value);
 465         }
 466
 467
 468         @Test
 469         public void testConvertFromStorageResponseForAdditionalInformation() throws Exception {
 470                 ComponentsUtils testSubject;
 471                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 472                 ActionStatus result;
 473
 474                 // default test
 475                 testSubject = createTestSubject();
 476                 result = testSubject.convertFromStorageResponseForAdditionalInformation(storageResponse);
 477         }
 478
 479
 480         @Test
 481         public void testConvertFromResultStatusEnum() throws Exception {
 482                 ComponentsUtils testSubject;
 483                 ResultStatusEnum resultStatus = ResultStatusEnum.ELEMENT_NOT_FOUND;
 484                 JsonPresentationFields elementType = null;
 485                 ActionStatus result;
 486
 487                 // default test
 488                 testSubject = createTestSubject();
 489                 result = testSubject.convertFromResultStatusEnum(resultStatus, elementType);
 490         }
 491
 492
 493         @Test
 494         public void testGetResponseFormatAdditionalProperty() throws Exception {
 495                 ComponentsUtils testSubject;
 496                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 497                 AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 498                 NodeTypeEnum nodeType = null;
 499                 AdditionalInformationEnum labelOrValue = null;
 500                 ResponseFormat result;
 501
 502                 // test 1
 503                 testSubject = createTestSubject();
 504                 additionalInfoParameterInfo = null;
 505                 result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 506                                 labelOrValue);
 507
 508                 // test 2
 509                 testSubject = createTestSubject();
 510                 labelOrValue = null;
 511                 result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 512                                 labelOrValue);
 513         }
 514
 515
 516         @Test
 517         public void testGetResponseFormatAdditionalProperty_1() throws Exception {
 518                 ComponentsUtils testSubject;
 519                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 520                 ResponseFormat result;
 521
 522                 // default test
 523                 testSubject = createTestSubject();
 524                 result = testSubject.getResponseFormatAdditionalProperty(actionStatus);
 525         }
 526
 527
 528         @Test
 529         public void testConvertFromStorageResponseForConsumer() throws Exception {
 530                 ComponentsUtils testSubject;
 531                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 532                 ActionStatus result;
 533
 534                 // default test
 535                 testSubject = createTestSubject();
 536                 result = testSubject.convertFromStorageResponseForConsumer(storageResponse);
 537         }
 538
 539
 540         @Test
 541         public void testConvertFromStorageResponseForGroupType() throws Exception {
 542                 ComponentsUtils testSubject;
 543                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 544                 ActionStatus result;
 545
 546                 // default test
 547                 testSubject = createTestSubject();
 548                 result = testSubject.convertFromStorageResponseForGroupType(storageResponse);
 549         }
 550
 551
 552         @Test
 553         public void testConvertFromStorageResponseForDataType() throws Exception {
 554                 ComponentsUtils testSubject;
 555                 StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 556                 ActionStatus result;
 557
 558                 // default test
 559                 testSubject = createTestSubject();
 560                 result = testSubject.convertFromStorageResponseForDataType(storageResponse);
 561         }
 562
 563
 564         @Test
 565         public void testGetResponseFormatByGroupType() throws Exception {
 566                 ComponentsUtils testSubject;
 567                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 568                 GroupTypeDefinition groupType = null;
 569                 ResponseFormat result;
 570
 571                 // test 1
 572                 testSubject = createTestSubject();
 573                 groupType = null;
 574                 result = testSubject.getResponseFormatByGroupType(actionStatus, groupType);
 575         }
 576
 577
 578         @Test
 579         public void testGetResponseFormatByPolicyType() throws Exception {
 580                 ComponentsUtils testSubject;
 581                 ActionStatus actionStatus = ActionStatus.ACCEPTED;
 582                 PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 583                 ResponseFormat result;
 584
 585                 // test 1
 586                 testSubject = createTestSubject();
 587                 result = testSubject.getResponseFormatByPolicyType(actionStatus, policyType);
 588         }
 589
 590
 591         @Test
 592         public void testGetResponseFormatByDataType() throws Exception {
 593                 ComponentsUtils testSubject;
 594                 ActionStatus actionStatus = ActionStatus.AAI_ARTIFACT_GENERATION_FAILED;
 595                 DataTypeDefinition dataType = null;
 596                 List<String> properties = null;
 597                 ResponseFormat result;
 598
 599                 // test 1
 600                 testSubject = createTestSubject();
 601                 dataType = null;
 602                 result = testSubject.getResponseFormatByDataType(actionStatus, dataType, properties);
 603         }
 604
 605         @Test
 606         public void testconvertJsonToObject() throws Exception {
 607
 608                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 609                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 610                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 611
 612                 User user = new User();
 613                 ComponentsUtils testSubject = createTestSubject();
 614                 String data="{ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 615
 616                 Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
 617                 User assertuser = new User("xyz","xyz","12","demo.z@ymail.com","123",null);
 618
 619                 Assert.assertEquals(assertuser,response.left().value());
 620         }
 621
 622         @Test
 623         public void testconvertJsonToObject_NllData() throws Exception {
 624
 625                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 626                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 627                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 628                 User user = new User();
 629                 String data=null;
 630                 Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
 631
 632                 Assert.assertEquals(true,response.isRight());
 633         }
 634
 635         @Test
 636         public void testconvertJsonToObjectInvalidData() throws Exception {
 637
 638                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 639                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 640                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 641
 642                 User user = new User();
 643
 644                 String data="{ User [ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 645
 646                 Either<User,ResponseFormat> response=compUtils.convertJsonToObject(data,user,User.class,AuditingActionEnum.ADD_USER);
 647
 648
 649                 Assert.assertEquals(true,response.isRight());
 650         }
 651
 652         @Test
 653         public void testconvertToStorageOperationStatus() {
 654                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 655                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 656                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 657                 Assert.assertEquals(StorageOperationStatus.OK,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.OK));
 658                 Assert.assertEquals(StorageOperationStatus.NOT_FOUND,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.NOT_FOUND));
 659                 Assert.assertEquals(StorageOperationStatus.GENERAL_ERROR,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.GENERAL_ERROR));
 660                 Assert.assertEquals(StorageOperationStatus.CONNECTION_FAILURE,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.CLUSTER_NOT_CONNECTED));
 661                 Assert.assertEquals(StorageOperationStatus.CONNECTION_FAILURE,compUtils.convertToStorageOperationStatus(CassandraOperationStatus.KEYSPACE_NOT_CONNECTED));
 662         }
 663
 664         @Test
 665         public void testgetResponseFormatByDataType() {
 666                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 667                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 668                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 669                 DataTypeDefinition dataType = new DataTypeDefinition();
 670                 dataType.setName("demo");
 671                 List<String> properties;
 672                 ResponseFormat responseFormat = compUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_ALREADY_EXIST, dataType,  null);
 673                 Assert.assertNotNull(responseFormat);
 674                 Assert.assertEquals((Integer) 409,responseFormat.getStatus());
 675         }
 676
 677         @Test
 678         public void testGetResponseFormatByPolicyType_POLICY_TYPE_ALREADY_EXIST() throws Exception {
 679
 680                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 681                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 682                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 683                 PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 684                 policyType.setType("Demo");
 685                 ResponseFormat responseFormat = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, policyType);
 686                 Assert.assertNotNull(responseFormat);
 687                 Assert.assertEquals((Integer) 409,responseFormat.getStatus());
 688         }
 689
 690         @Test
 691         public void testGetResponseFormatByPolicyType_PolicyID_NULL() throws Exception {
 692
 693                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 694                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 695                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 696                 ResponseFormat responseFormat = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST,  null);
 697                 Assert.assertNotNull(responseFormat);
 698                 Assert.assertEquals((Integer) 409,responseFormat.getStatus());
 699         }
 700
 701         @Test
 702         public void testGetResponseFormatByGroupType_GROUP_MEMBER_EMPTY() throws Exception {
 703
 704                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 705                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 706                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 707                 GroupTypeDefinition groupType = new GroupTypeDefinition();
 708                 groupType.setType("Demo");
 709                 ResponseFormat responseFormat = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_MEMBER_EMPTY, groupType);
 710                 Assert.assertNotNull(responseFormat);
 711                 responseFormat = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_TYPE_ALREADY_EXIST, groupType);
 712                 Assert.assertNotNull(responseFormat);
 713         }
 714
 715         @Test
 716         public void testConvertFromStorageResponseForDataType_ALL() throws Exception {
 717
 718                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 719                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 720                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 721
 722                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.OK));
 723                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CONNECTION_FAILURE));
 724                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.GRAPH_IS_LOCK));
 725                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.BAD_REQUEST));
 726                 Assert.assertEquals(ActionStatus.DATA_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
 727                 Assert.assertEquals(ActionStatus.DATA_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.SCHEMA_VIOLATION));
 728                 Assert.assertEquals(ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST,compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY));
 729
 730         }
 731
 732         @Test
 733         public void testConvertFromStorageResponseForGroupType_ALL() throws Exception {
 734
 735                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 736                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 737                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 738
 739                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.OK));
 740                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.CONNECTION_FAILURE));
 741                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.GRAPH_IS_LOCK));
 742                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.BAD_REQUEST));
 743                 Assert.assertEquals(ActionStatus.GROUP_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
 744                 Assert.assertEquals(ActionStatus.GROUP_TYPE_ALREADY_EXIST,compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.SCHEMA_VIOLATION));
 745         }
 746
 747         @Test
 748         public void testConvertFromStorageResponseForConsumer_ALL() throws Exception {
 749                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 750                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 751                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 752
 753                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.OK));
 754                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.CONNECTION_FAILURE));
 755                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.GRAPH_IS_LOCK));
 756                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.BAD_REQUEST));
 757                 Assert.assertEquals(ActionStatus.CONSUMER_ALREADY_EXISTS,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
 758                 Assert.assertEquals(ActionStatus.CONSUMER_ALREADY_EXISTS,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.SCHEMA_VIOLATION));
 759                 Assert.assertEquals(ActionStatus.ECOMP_USER_NOT_FOUND,compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.NOT_FOUND));
 760         }
 761
 762         @Test
 763         public void testGetResponseFormatAdditionalProperty_ALL() throws Exception {
 764                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 765                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 766                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 767
 768                 AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 769                 NodeTypeEnum nodeType = null;
 770                 AdditionalInformationEnum labelOrValue = null;
 771
 772                 ResponseFormat responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, additionalInfoParameterInfo, nodeType,
 773                                 labelOrValue);
 774                 Assert.assertNotNull(responseFormat);
 775                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo, nodeType,
 776                                 labelOrValue);
 777                 Assert.assertNotNull(responseFormat);
 778                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo, NodeTypeEnum.Group,
 779                                 labelOrValue);
 780                 Assert.assertNotNull(responseFormat);
 781                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, additionalInfoParameterInfo, nodeType,
 782                                 labelOrValue);
 783                 Assert.assertNotNull(responseFormat);
 784                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
 785                                 labelOrValue);
 786                 Assert.assertNotNull(responseFormat);
 787                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS, additionalInfoParameterInfo, nodeType,
 788                                 labelOrValue);
 789                 Assert.assertNotNull(responseFormat);
 790                 responseFormat = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND, additionalInfoParameterInfo, nodeType,
 791                                 labelOrValue);
 792                 Assert.assertNotNull(responseFormat);
 793
 794         }
 795
 796         @Test
 797         public void testConvertFromResultStatusEnum_ALL() throws Exception {
 798
 799                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 800                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 801                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 802                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromResultStatusEnum(ResultStatusEnum.OK, null));
 803                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_DEFAULT_VALUE, null));
 804                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_TYPE, null));
 805                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_VALUE, null));
 806                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, null));
 807                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromResultStatusEnum(ResultStatusEnum.MISSING_ENTRY_SCHEMA_TYPE, null));
 808         }
 809
 810         @Test
 811         public void testconvertFromStorageResponseForAdditionalInformation() throws Exception{
 812                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 813                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 814                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 815                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.OK));
 816                 Assert.assertEquals(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.ENTITY_ALREADY_EXISTS));
 817                 Assert.assertEquals(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND,compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.INVALID_ID));
 818         }
 819
 820         @Test
 821         public void testgetResponseFormatByComponent() throws Exception{
 822                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 823                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 824                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 825                 Component component = new Resource();
 826                 ResponseFormat responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
 827                 Assert.assertNotNull(responseFormat);
 828                 responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.RESOURCE_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
 829                 Assert.assertNotNull(responseFormat);
 830                 responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
 831                 Assert.assertNotNull(responseFormat);
 832                 responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_IN_USE, component, ComponentTypeEnum.RESOURCE);
 833                 Assert.assertNotNull(responseFormat);
 834                 responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
 835                 Assert.assertNotNull(responseFormat);
 836                 responseFormat = compUtils.getResponseFormatByComponent(ActionStatus.ACCEPTED, component, ComponentTypeEnum.RESOURCE);
 837                 Assert.assertNotNull(responseFormat);
 838         }
 839
 840
 841         @Test
 842         public void testConvertFromStorageResponseForResourceInstanceProperty_ALL() throws Exception {
 843                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 844                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 845                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 846                 Assert.assertEquals(ActionStatus.OK,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.OK));
 847                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.INVALID_ID));
 848                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.GRAPH_IS_LOCK));
 849                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.BAD_REQUEST));
 850                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.MATCH_NOT_FOUND));
 851                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.SCHEMA_VIOLATION));
 852                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.NOT_FOUND));
 853         }
 854
 855         @Test
 856         public void testConvertFromStorageResponseForResourceInstance_ALL() throws Exception {
 857                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 858                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 859                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 860                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.ARTIFACT_NOT_FOUND, false));
 861                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_ID, false));
 862                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_PROPERTY, false));
 863                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.GRAPH_IS_LOCK, false));
 864                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, false));
 865                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.MATCH_NOT_FOUND, false));
 866                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.SCHEMA_VIOLATION, false));
 867                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, true));
 868                 Assert.assertEquals(ActionStatus.RESOURCE_INSTANCE_NOT_FOUND,compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, false));
 869         }
 870
 871         @Test
 872         public void testConvertFromStorageResponse_ALL() throws Exception {
 873
 874                 AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 875                 ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 876                 when(auditingmanager.auditEvent(any())).thenReturn("OK");
 877                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponse(StorageOperationStatus.CONNECTION_FAILURE, ComponentTypeEnum.RESOURCE));
 878                 Assert.assertEquals(ActionStatus.GENERAL_ERROR,compUtils.convertFromStorageResponse(StorageOperationStatus.GRAPH_IS_LOCK, ComponentTypeEnum.RESOURCE));
 879                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST, ComponentTypeEnum.RESOURCE));
 880                 Assert.assertEquals(ActionStatus.COMPONENT_NAME_ALREADY_EXIST,compUtils.convertFromStorageResponse(StorageOperationStatus.ENTITY_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE));
 881                 Assert.assertEquals(ActionStatus.PARENT_RESOURCE_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND, ComponentTypeEnum.RESOURCE));
 882                 Assert.assertEquals(ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND, ComponentTypeEnum.RESOURCE));
 883                 Assert.assertEquals(ActionStatus.COMPONENT_IN_USE,compUtils.convertFromStorageResponse(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT, ComponentTypeEnum.RESOURCE));
 884                 Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE, ComponentTypeEnum.RESOURCE));
 885                 Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, ComponentTypeEnum.RESOURCE));
 886                 Assert.assertEquals(ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID,compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, ComponentTypeEnum.RESOURCE));
 887                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_TYPE, ComponentTypeEnum.RESOURCE));
 888                 Assert.assertEquals(ActionStatus.INVALID_CONTENT,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE, ComponentTypeEnum.RESOURCE));
 889                 Assert.assertEquals(ActionStatus.CSAR_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.CSAR_NOT_FOUND, ComponentTypeEnum.RESOURCE));
 890                 Assert.assertEquals(ActionStatus.PROPERTY_NAME_ALREADY_EXISTS,compUtils.convertFromStorageResponse(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE));
 891                 Assert.assertEquals(ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY,compUtils.convertFromStorageResponse(StorageOperationStatus.MATCH_NOT_FOUND, ComponentTypeEnum.RESOURCE));
 892                 Assert.assertEquals(ActionStatus.COMPONENT_CATEGORY_NOT_FOUND,compUtils.convertFromStorageResponse(StorageOperationStatus.CATEGORY_NOT_FOUND, ComponentTypeEnum.RESOURCE));
 893                 Assert.assertEquals(ActionStatus.INVALID_PROPERTY,compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_PROPERTY, ComponentTypeEnum.RESOURCE));
 894                 Assert.assertEquals(ActionStatus.COMPONENT_IS_ARCHIVED,compUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_ARCHIVED, ComponentTypeEnum.RESOURCE));
 895         }
 896 }