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 static org.assertj.core.api.Assertions.assertThat;
  25 import static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.mock;
  28 import static org.mockito.Mockito.when;
  29
  30 import fj.data.Either;
  31 import java.util.ArrayList;
  32 import java.util.List;
  33 import org.apache.tinkerpop.gremlin.structure.T;
  34 import org.junit.jupiter.api.BeforeEach;
  35 import org.junit.jupiter.api.Test;
  36 import org.mockito.Mockito;
  37 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  38 import org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
  39 import org.openecomp.sdc.be.config.ConfigurationManager;
  40 import org.openecomp.sdc.be.dao.api.ActionStatus;
  41 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  42 import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
  43 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  44 import org.openecomp.sdc.be.dao.graph.datatype.AdditionalInformationEnum;
  45 import org.openecomp.sdc.be.datatypes.elements.AdditionalInfoParameterInfo;
  46 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  47 import org.openecomp.sdc.be.datatypes.enums.JsonPresentationFields;
  48 import org.openecomp.sdc.be.datatypes.enums.NodeTypeEnum;
  49 import org.openecomp.sdc.be.model.CapabilityTypeDefinition;
  50 import org.openecomp.sdc.be.model.Component;
  51 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  52 import org.openecomp.sdc.be.model.DataTypeDefinition;
  53 import org.openecomp.sdc.be.model.GroupTypeDefinition;
  54 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
  55 import org.openecomp.sdc.be.model.RequirementDefinition;
  56 import org.openecomp.sdc.be.model.Resource;
  57 import org.openecomp.sdc.be.model.User;
  58 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  59 import org.openecomp.sdc.be.model.tosca.constraints.EqualConstraint;
  60 import org.openecomp.sdc.be.model.tosca.constraints.GreaterOrEqualConstraint;
  61 import org.openecomp.sdc.be.model.tosca.constraints.InRangeConstraint;
  62 import org.openecomp.sdc.be.model.tosca.constraints.LengthConstraint;
  63 import org.openecomp.sdc.be.model.tosca.constraints.LessOrEqualConstraint;
  64 import org.openecomp.sdc.be.model.tosca.constraints.LessThanConstraint;
  65 import org.openecomp.sdc.be.model.tosca.constraints.MaxLengthConstraint;
  66 import org.openecomp.sdc.be.model.tosca.constraints.MinLengthConstraint;
  67 import org.openecomp.sdc.be.model.tosca.constraints.ValidValuesConstraint;
  68 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  69 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  70 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  71 import org.openecomp.sdc.be.tosca.ToscaError;
  72 import org.openecomp.sdc.common.api.ConfigurationSource;
  73 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  74 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  75 import org.openecomp.sdc.exception.ResponseFormat;
  76 import org.openecomp.sdc.test.utils.TestConfigurationProvider;
  77
  78 class ComponentsUtilsTest {
  79
  80     private ComponentsUtils createTestSubject() {
  81         return new ComponentsUtils(new AuditingManager(new AuditCassandraDao(mock(CassandraClient.class)), new TestConfigurationProvider()));
  82     }
  83
  84     @BeforeEach
  85     public void init() {
  86         String appConfigDir = "src/test/resources/config/catalog-be";
  87         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
  88         ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
  89         ComponentsUtils componentsUtils = new ComponentsUtils(Mockito.mock(AuditingManager.class));
  90     }
  91
  92     @Test
  93     void testGetAuditingManager() {
  94         ComponentsUtils testSubject;
  95         AuditingManager result;
  96
  97         // default test
  98         testSubject = createTestSubject();
  99         result = testSubject.getAuditingManager();
 100         assertThat(result).isInstanceOf(AuditingManager.class);
 101     }
 102
 103     @Test
 104     void testGetResponseFormat() {
 105         ComponentsUtils testSubject;
 106         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 107         String[] params = new String[]{""};
 108         ResponseFormat result;
 109
 110         // default test
 111         testSubject = createTestSubject();
 112         result = testSubject.getResponseFormat(actionStatus, params);
 113         assertThat(result).isInstanceOf(ResponseFormat.class);
 114         assertThat(result.getStatus().toString()).startsWith("2");
 115     }
 116
 117     @Test
 118     void testGetResponseFormat_1() {
 119         ComponentsUtils testSubject;
 120         StorageOperationStatus storageStatus = null;
 121         String[] params = new String[]{""};
 122         ResponseFormat result;
 123
 124         // default test
 125         testSubject = createTestSubject();
 126         result = testSubject.getResponseFormat(storageStatus, params);
 127         assertThat(result).isInstanceOf(ResponseFormat.class);
 128         assertThat(result.getStatus().toString()).startsWith("5");
 129     }
 130
 131     @Test
 132     void testConvertToResponseFormatOrNotFoundErrorToEmptyList() {
 133         ComponentsUtils testSubject;
 134         StorageOperationStatus storageOperationStatus = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 135         Either<List<T>, ResponseFormat> result;
 136
 137         // default test
 138         testSubject = createTestSubject();
 139         result = testSubject.convertToResponseFormatOrNotFoundErrorToEmptyList(storageOperationStatus);
 140         assertThat(result.isRight()).isTrue();
 141     }
 142
 143     @Test
 144     void testConvertToResponseFormatOrNotFoundErrorToEmptyList_1() {
 145         ComponentsUtils testSubject;
 146         StorageOperationStatus storageOperationStatus = StorageOperationStatus.NOT_FOUND;
 147         Either<List<T>, ResponseFormat> result;
 148
 149         // default test
 150         testSubject = createTestSubject();
 151         result = testSubject.convertToResponseFormatOrNotFoundErrorToEmptyList(storageOperationStatus);
 152         assertThat(result.isLeft()).isTrue();
 153     }
 154
 155     @Test
 156     void testGetResponseFormatByResource() {
 157         ComponentsUtils testSubject;
 158         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 159         ResponseFormat result;
 160         Resource resource = null;
 161         // test 1
 162         testSubject = createTestSubject();
 163         result = testSubject.getResponseFormatByResource(actionStatus, resource);
 164
 165         assertThat(result).isInstanceOf(ResponseFormat.class);
 166         assertThat(result.getStatus()).isEqualTo(202);
 167
 168         resource = new Resource();
 169         result = testSubject.getResponseFormatByResource(actionStatus, resource);
 170         assertThat(result).isInstanceOf(ResponseFormat.class);
 171         assertThat(result.getStatus()).isEqualTo(202);
 172
 173         result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, resource);
 174         assertThat(result).isInstanceOf(ResponseFormat.class);
 175         assertThat(result.getStatus()).isEqualTo(409);
 176
 177         result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resource);
 178         assertThat(result).isInstanceOf(ResponseFormat.class);
 179         assertThat(result.getStatus()).isEqualTo(404);
 180
 181         result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, resource);
 182         assertThat(result).isInstanceOf(ResponseFormat.class);
 183         assertThat(result.getStatus()).isEqualTo(409);
 184
 185         result = testSubject.getResponseFormatByResource(ActionStatus.COMPONENT_IN_USE, resource);
 186         assertThat(result).isInstanceOf(ResponseFormat.class);
 187         assertThat(result.getStatus()).isEqualTo(403);
 188     }
 189
 190     @Test
 191     void testGetResponseFormatByResource_1() {
 192         ComponentsUtils testSubject;
 193         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 194         String resourceName = "";
 195         ResponseFormat result;
 196
 197         // test 1
 198         testSubject = createTestSubject();
 199         resourceName = null;
 200         result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
 201         assertThat(result).isInstanceOf(ResponseFormat.class);
 202         assertThat(result.getStatus()).isEqualTo(202);
 203
 204         // test 2
 205         testSubject = createTestSubject();
 206         resourceName = "mock-name";
 207         result = testSubject.getResponseFormatByResource(actionStatus, resourceName);
 208         assertThat(result).isInstanceOf(ResponseFormat.class);
 209         assertThat(result.getStatus()).isEqualTo(202);
 210
 211         result = testSubject.getResponseFormatByResource(ActionStatus.RESOURCE_NOT_FOUND, resourceName);
 212         assertThat(result).isInstanceOf(ResponseFormat.class);
 213         assertThat(result.getStatus()).isEqualTo(404);
 214     }
 215
 216     @Test
 217     void testGetResponseFormatByCapabilityType() throws Exception {
 218         ComponentsUtils testSubject;
 219         CapabilityTypeDefinition capabilityType = new CapabilityTypeDefinition();
 220         ResponseFormat result;
 221
 222         // test 1
 223         testSubject = createTestSubject();
 224         result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, null);
 225         assertThat(result).isInstanceOf(ResponseFormat.class);
 226         assertThat(result.getStatus()).isEqualTo(409);
 227
 228         result = testSubject.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, capabilityType);
 229         assertThat(result).isInstanceOf(ResponseFormat.class);
 230         assertThat(result.getStatus()).isEqualTo(409);
 231
 232         result = testSubject.getResponseFormatByCapabilityType(ActionStatus.AAI_ARTIFACT_GENERATION_FAILED, capabilityType);
 233         assertThat(result).isInstanceOf(ResponseFormat.class);
 234         assertThat(result.getStatus()).isEqualTo(500);
 235     }
 236
 237     @Test
 238     void testGetResponseFormatByElement() throws Exception {
 239         ComponentsUtils testSubject;
 240         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 241         Object obj = null;
 242         ResponseFormat result;
 243
 244         // test 1
 245         testSubject = createTestSubject();
 246
 247         obj = null;
 248         result = testSubject.getResponseFormatByElement(actionStatus, obj);
 249         assertThat(result).isInstanceOf(ResponseFormat.class);
 250         assertThat(result.getStatus()).isEqualTo(202);
 251
 252         obj = new Object();
 253
 254         result = testSubject.getResponseFormatByElement(actionStatus, obj);
 255         assertThat(result).isInstanceOf(ResponseFormat.class);
 256         assertThat(result.getStatus()).isEqualTo(202);
 257
 258         List<Object> obj1 = new ArrayList<>();
 259         obj1.add(new RequirementDefinition());
 260
 261         result = testSubject.getResponseFormatByElement(ActionStatus.MISSING_CAPABILITY_TYPE, obj1);
 262         assertThat(result.getStatus()).isEqualTo(400);
 263     }
 264
 265     @Test
 266     void testGetResponseFormatByUser() {
 267         ComponentsUtils testSubject;
 268         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 269         User user = null;
 270         ResponseFormat result;
 271
 272         // test 1
 273         testSubject = createTestSubject();
 274         user = null;
 275         result = testSubject.getResponseFormatByUser(actionStatus, user);
 276         assertThat(result).isInstanceOf(ResponseFormat.class);
 277         assertThat(result.getStatus()).isEqualTo(202);
 278
 279         user = new User();
 280         result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_USER_ID, user);
 281         assertThat(result).isInstanceOf(ResponseFormat.class);
 282         assertThat(result.getStatus()).isEqualTo(400);
 283
 284         result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_EMAIL_ADDRESS, user);
 285         assertThat(result).isInstanceOf(ResponseFormat.class);
 286         assertThat(result.getStatus()).isEqualTo(400);
 287
 288         result = testSubject.getResponseFormatByUser(ActionStatus.INVALID_ROLE, user);
 289         assertThat(result).isInstanceOf(ResponseFormat.class);
 290         assertThat(result.getStatus()).isEqualTo(400);
 291
 292         result = testSubject.getResponseFormatByUser(ActionStatus.USER_NOT_FOUND, user);
 293         assertThat(result).isInstanceOf(ResponseFormat.class);
 294         assertThat(result.getStatus()).isEqualTo(404);
 295
 296         result = testSubject.getResponseFormatByUser(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED, user);
 297         assertThat(result).isInstanceOf(ResponseFormat.class);
 298         assertThat(result.getStatus()).isEqualTo(400);
 299     }
 300
 301     @Test
 302     void testGetResponseFormatByUserId() {
 303         ComponentsUtils testSubject;
 304         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 305         String userId = "";
 306         ResponseFormat result;
 307
 308         // default test
 309         testSubject = createTestSubject();
 310         result = testSubject.getResponseFormatByUserId(actionStatus, userId);
 311         assertThat(result).isInstanceOf(ResponseFormat.class);
 312         assertThat(result.getStatus()).isEqualTo(202);
 313     }
 314
 315     @Test
 316     void testGetResponseFormatByDE() {
 317         ComponentsUtils testSubject;
 318         String serviceId = "";
 319         String envName = "";
 320         ResponseFormat result;
 321
 322         // default test
 323         testSubject = createTestSubject();
 324         result = testSubject.getResponseFormatByDE(ActionStatus.ACCEPTED, serviceId);
 325         assertThat(result).isInstanceOf(ResponseFormat.class);
 326         assertThat(result.getStatus()).isEqualTo(202);
 327
 328         result = testSubject.getResponseFormatByDE(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE, serviceId);
 329         assertThat(result).isInstanceOf(ResponseFormat.class);
 330         assertThat(result.getStatus()).isEqualTo(500);
 331
 332         result = testSubject.getResponseFormatByDE(ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND, serviceId);
 333         assertThat(result).isInstanceOf(ResponseFormat.class);
 334         assertThat(result.getStatus()).isEqualTo(400);
 335     }
 336
 337     @Test
 338     void testGetResponseFormatByArtifactId() throws Exception {
 339         ComponentsUtils testSubject;
 340         String artifactId = "";
 341         ResponseFormat result;
 342
 343         // default test
 344         testSubject = createTestSubject();
 345
 346         result = testSubject.getResponseFormatByArtifactId(ActionStatus.ACCEPTED, artifactId);
 347         assertThat(result).isInstanceOf(ResponseFormat.class);
 348         assertThat(result.getStatus()).isEqualTo(202);
 349
 350         result = testSubject.getResponseFormatByArtifactId(ActionStatus.RESOURCE_NOT_FOUND, artifactId);
 351         assertThat(result).isInstanceOf(ResponseFormat.class);
 352         assertThat(result.getStatus()).isEqualTo(404);
 353     }
 354
 355     @Test
 356     void testAuditResource_1() throws Exception {
 357         ComponentsUtils testSubject;
 358         ResponseFormat responseFormat = new ResponseFormat();
 359         User modifier = null;
 360         String resourceName = "";
 361         AuditingActionEnum actionEnum = null;
 362
 363         // default test
 364         testSubject = createTestSubject();
 365         testSubject.auditResource(responseFormat, modifier, resourceName, actionEnum);
 366     }
 367
 368     @Test
 369     void testAuditResource_3() throws Exception {
 370         ComponentsUtils testSubject;
 371         ResponseFormat responseFormat = null;
 372         User modifier = null;
 373         Resource resource = null;
 374         String resourceName = "";
 375         AuditingActionEnum actionEnum = null;
 376
 377         // default test
 378         testSubject = createTestSubject();
 379         testSubject.auditResource(responseFormat, modifier, resource, resourceName, actionEnum);
 380     }
 381
 382     @Test
 383     void testAuditResource_4() throws Exception {
 384         ComponentsUtils testSubject;
 385         ResponseFormat responseFormat = null;
 386         User modifier = null;
 387         Resource resource = null;
 388         String resourceName = "";
 389         AuditingActionEnum actionEnum = null;
 390         ResourceVersionInfo prevResFields = null;
 391         String currentArtifactUuid = "";
 392         String artifactData = "";
 393
 394         // test 1
 395         testSubject = createTestSubject();
 396         actionEnum = null;
 397         testSubject.auditResource(responseFormat, modifier, resource, resourceName, actionEnum, prevResFields,
 398             currentArtifactUuid, null);
 399     }
 400
 401     @Test
 402     void testConvertFromStorageResponse() {
 403         ComponentsUtils testSubject;
 404         StorageOperationStatus storageResponse = null;
 405         ActionStatus result;
 406
 407         // default test
 408         testSubject = createTestSubject();
 409         result = testSubject.convertFromStorageResponse(storageResponse);
 410         assertThat(result)
 411             .isInstanceOf(ActionStatus.class)
 412             .isEqualTo(ActionStatus.GENERAL_ERROR);
 413     }
 414
 415     @Test
 416     void testConvertFromStorageResponse_1() {
 417         ComponentsUtils testSubject;
 418         StorageOperationStatus storageResponse = null;
 419         ComponentTypeEnum type = null;
 420         ActionStatus result;
 421
 422         // test 1
 423         testSubject = createTestSubject();
 424         storageResponse = null;
 425         result = testSubject.convertFromStorageResponse(storageResponse, type);
 426         assertThat(result)
 427             .isInstanceOf(ActionStatus.class)
 428             .isEqualTo(ActionStatus.GENERAL_ERROR);
 429         ;
 430     }
 431
 432     @Test
 433     void testConvertFromToscaError() {
 434         ComponentsUtils testSubject;
 435         ToscaError toscaError = null;
 436         ActionStatus result;
 437
 438         // test 1
 439         testSubject = createTestSubject();
 440         toscaError = null;
 441         result = testSubject.convertFromToscaError(toscaError);
 442         assertThat(result)
 443             .isInstanceOf(ActionStatus.class)
 444             .isEqualTo(ActionStatus.GENERAL_ERROR);
 445     }
 446
 447     @Test
 448     void testConvertFromStorageResponseForCapabilityType() {
 449         ComponentsUtils testSubject;
 450         StorageOperationStatus storageResponse = StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY;
 451         ActionStatus result;
 452
 453         // default test
 454         testSubject = createTestSubject();
 455         result = testSubject.convertFromStorageResponseForCapabilityType(storageResponse);
 456         assertThat(result)
 457             .isInstanceOf(ActionStatus.class)
 458             .isEqualTo(ActionStatus.GENERAL_ERROR);
 459     }
 460
 461     @Test
 462     void testConvertFromStorageResponseForLifecycleType() {
 463         ComponentsUtils testSubject;
 464         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 465         ActionStatus result;
 466
 467         // default test
 468         testSubject = createTestSubject();
 469         result = testSubject.convertFromStorageResponseForLifecycleType(storageResponse);
 470         assertThat(result)
 471             .isInstanceOf(ActionStatus.class)
 472             .isEqualTo(ActionStatus.GENERAL_ERROR);
 473     }
 474
 475     @Test
 476     void testConvertFromStorageResponseForResourceInstance() {
 477         ComponentsUtils testSubject;
 478         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 479         boolean isRelation = false;
 480         ActionStatus result;
 481
 482         // default test
 483         testSubject = createTestSubject();
 484         result = testSubject.convertFromStorageResponseForResourceInstance(storageResponse, isRelation);
 485         assertThat(result)
 486             .isInstanceOf(ActionStatus.class)
 487             .isEqualTo(ActionStatus.GENERAL_ERROR);
 488     }
 489
 490     @Test
 491     void testGetResponseFormatForResourceInstance() {
 492         ComponentsUtils testSubject;
 493         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 494         String serviceName = "";
 495         String resourceInstanceName = "";
 496         ResponseFormat result;
 497
 498         // default test
 499         testSubject = createTestSubject();
 500         result = testSubject.getResponseFormatForResourceInstance(actionStatus, serviceName, resourceInstanceName);
 501         assertThat(result).isInstanceOf(ResponseFormat.class);
 502         assertThat(result.getStatus()).isEqualTo(202);
 503     }
 504
 505     @Test
 506     void testGetResponseFormatForResourceInstanceProperty() {
 507         ComponentsUtils testSubject;
 508         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 509         String resourceInstanceName = "";
 510         ResponseFormat result;
 511
 512         // default test
 513         testSubject = createTestSubject();
 514         result = testSubject.getResponseFormatForResourceInstanceProperty(actionStatus, resourceInstanceName);
 515         assertThat(result).isInstanceOf(ResponseFormat.class);
 516         assertThat(result.getStatus()).isEqualTo(202);
 517     }
 518
 519     @Test
 520     void testConvertFromStorageResponseForResourceInstanceProperty() {
 521         ComponentsUtils testSubject;
 522         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 523         ActionStatus result;
 524
 525         // default test
 526         testSubject = createTestSubject();
 527         result = testSubject.convertFromStorageResponseForResourceInstanceProperty(storageResponse);
 528         assertThat(result)
 529             .isInstanceOf(ActionStatus.class)
 530             .isEqualTo(ActionStatus.GENERAL_ERROR);
 531     }
 532
 533     @Test
 534     void testAuditComponent() throws Exception {
 535         ComponentsUtils testSubject;
 536         ResponseFormat responseFormat = null;
 537         User modifier = null;
 538         Component component = null;
 539         AuditingActionEnum actionEnum = null;
 540         ComponentTypeEnum type = null;
 541         ResourceCommonInfo prevComponent = null;
 542         ResourceVersionInfo info = null;
 543         String comment = "";
 544
 545         // default test
 546         testSubject = createTestSubject();
 547         testSubject.auditComponent(responseFormat, modifier, component, actionEnum, prevComponent, info);
 548     }
 549
 550     @Test
 551     void testAuditComponent_1() throws Exception {
 552         ComponentsUtils testSubject;
 553         ResponseFormat responseFormat = null;
 554         User modifier = null;
 555         Component component = null;
 556         AuditingActionEnum actionEnum = null;
 557         ResourceCommonInfo type = null;
 558         ResourceVersionInfo prevComponent = null;
 559
 560         // default test
 561         testSubject = createTestSubject();
 562         testSubject.auditComponent(responseFormat, modifier, component, actionEnum, type, prevComponent);
 563     }
 564
 565     @Test
 566     void testConvertFromStorageResponseForAdditionalInformation() {
 567         ComponentsUtils testSubject;
 568         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 569         ActionStatus result;
 570
 571         // default test
 572         testSubject = createTestSubject();
 573         result = testSubject.convertFromStorageResponseForAdditionalInformation(storageResponse);
 574         assertThat(result)
 575             .isInstanceOf(ActionStatus.class)
 576             .isEqualTo(ActionStatus.GENERAL_ERROR);
 577     }
 578
 579     @Test
 580     void testConvertFromResultStatusEnum() {
 581         ComponentsUtils testSubject;
 582         ResultStatusEnum resultStatus = ResultStatusEnum.ELEMENT_NOT_FOUND;
 583         JsonPresentationFields elementType = null;
 584         ActionStatus result;
 585
 586         // default test
 587         testSubject = createTestSubject();
 588         result = testSubject.convertFromResultStatusEnum(resultStatus, elementType);
 589         assertThat(result)
 590             .isInstanceOf(ActionStatus.class)
 591             .isEqualTo(ActionStatus.GENERAL_ERROR);
 592     }
 593
 594     @Test
 595     void testGetResponseFormatAdditionalProperty() {
 596         ComponentsUtils testSubject;
 597         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 598         AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 599         NodeTypeEnum nodeType = null;
 600         AdditionalInformationEnum labelOrValue = null;
 601         ResponseFormat result;
 602
 603         // test 1
 604         testSubject = createTestSubject();
 605         additionalInfoParameterInfo = null;
 606         result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 607             labelOrValue);
 608         assertThat(result).isInstanceOf(ResponseFormat.class);
 609         assertThat(result.getStatus()).isEqualTo(202);
 610
 611         // test 2
 612         testSubject = createTestSubject();
 613         labelOrValue = null;
 614         result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 615             labelOrValue);
 616         assertThat(result).isInstanceOf(ResponseFormat.class);
 617         assertThat(result.getStatus()).isEqualTo(202);
 618     }
 619
 620     @Test
 621     void testGetResponseFormatAdditionalProperty_1() {
 622         ComponentsUtils testSubject;
 623         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 624         ResponseFormat result;
 625
 626         // default test
 627         testSubject = createTestSubject();
 628         result = testSubject.getResponseFormatAdditionalProperty(actionStatus);
 629         assertThat(result).isInstanceOf(ResponseFormat.class);
 630         assertThat(result.getStatus()).isEqualTo(202);
 631     }
 632
 633     @Test
 634     void testConvertFromStorageResponseForConsumer() {
 635         ComponentsUtils testSubject;
 636         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 637         ActionStatus result;
 638
 639         // default test
 640         testSubject = createTestSubject();
 641         result = testSubject.convertFromStorageResponseForConsumer(storageResponse);
 642         assertThat(result)
 643             .isInstanceOf(ActionStatus.class)
 644             .isEqualTo(ActionStatus.GENERAL_ERROR);
 645     }
 646
 647     @Test
 648     void testConvertFromStorageResponseForGroupType() {
 649         ComponentsUtils testSubject;
 650         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 651         ActionStatus result;
 652
 653         // default test
 654         testSubject = createTestSubject();
 655         result = testSubject.convertFromStorageResponseForGroupType(storageResponse);
 656         assertThat(result)
 657             .isInstanceOf(ActionStatus.class)
 658             .isEqualTo(ActionStatus.GENERAL_ERROR);
 659     }
 660
 661     @Test
 662     void testConvertFromStorageResponseForDataType() {
 663         ComponentsUtils testSubject;
 664         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 665         ActionStatus result;
 666
 667         // default test
 668         testSubject = createTestSubject();
 669         result = testSubject.convertFromStorageResponseForDataType(storageResponse);
 670         assertThat(result)
 671             .isInstanceOf(ActionStatus.class)
 672             .isEqualTo(ActionStatus.GENERAL_ERROR);
 673     }
 674
 675     @Test
 676     void testGetResponseFormatByGroupType() {
 677         ComponentsUtils testSubject;
 678         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 679         GroupTypeDefinition groupType = null;
 680         ResponseFormat result;
 681
 682         // test 1
 683         testSubject = createTestSubject();
 684         groupType = null;
 685         result = testSubject.getResponseFormatByGroupType(actionStatus, groupType);
 686         assertThat(result).isInstanceOf(ResponseFormat.class);
 687         assertThat(result.getStatus()).isEqualTo(202);
 688     }
 689
 690     @Test
 691     void testGetResponseFormatByPolicyType() {
 692         ComponentsUtils testSubject;
 693         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 694         PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 695         ResponseFormat result;
 696
 697         // test 1
 698         testSubject = createTestSubject();
 699         result = testSubject.getResponseFormatByPolicyType(actionStatus, policyType);
 700         assertThat(result).isInstanceOf(ResponseFormat.class);
 701         assertThat(result.getStatus()).isEqualTo(202);
 702     }
 703
 704     @Test
 705     void testGetResponseFormatByDataType() {
 706         ComponentsUtils testSubject;
 707         ActionStatus actionStatus = ActionStatus.AAI_ARTIFACT_GENERATION_FAILED;
 708         DataTypeDefinition dataType = null;
 709         List<String> properties = null;
 710         ResponseFormat result;
 711
 712         // test 1
 713         testSubject = createTestSubject();
 714         dataType = null;
 715         result = testSubject.getResponseFormatByDataType(actionStatus, dataType, properties);
 716         assertThat(result).isInstanceOf(ResponseFormat.class);
 717         assertThat(result.getStatus()).isEqualTo(500);
 718     }
 719
 720     @Test
 721     void testconvertJsonToObject() {
 722
 723         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 724         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 725         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 726
 727         User user = new User();
 728         ComponentsUtils testSubject = createTestSubject();
 729         String data = "{ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 730
 731         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 732         User assertuser = new User("xyz", "xyz", "12", "demo.z@ymail.com", "123", null);
 733
 734         assertThat(response.isLeft()).isTrue();
 735         assertThat(response.left().value()).isEqualTo(assertuser);
 736     }
 737
 738     @Test
 739     void testconvertJsonToObjectUsingObjectMapper() {
 740
 741         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 742         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 743         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 744
 745         User user = new User();
 746         String data =
 747             "[{\"constraints\":[{\"equal\":\"value\"}]},"
 748                 + "{\"constraints\":[{\"greaterOrEqual\":5}]},"
 749                 + "{\"constraints\":[{\"lessThan\":7}]},"
 750                 + "{\"constraints\":[{\"lessOrEqual\":9}]},"
 751                 + "{\"constraints\":[{\"inRange\":[\"5\", \"10\"]}]},"
 752                 + "{\"constraints\":[{\"validValues\":[\"abc\", \"def\", \"hij\"]}]},"
 753                 + "{\"constraints\":[{\"length\":11}]},"
 754                 + "{\"constraints\":[{\"minLength\":13}]},"
 755                 + "{\"constraints\":[{\"maxLength\":15}]}"
 756                 + "]";
 757
 758         Either<ComponentInstanceProperty[], ResponseFormat> response = compUtils.convertJsonToObjectUsingObjectMapper(data, user,
 759             ComponentInstanceProperty[].class, null, ComponentTypeEnum.RESOURCE_INSTANCE);
 760
 761         assertThat(response.isLeft()).isTrue();
 762         ComponentInstanceProperty[] properties = response.left().value();
 763         assertEquals(9, properties.length);
 764         assertEquals("value", ((EqualConstraint) properties[0].getConstraints().iterator().next()).getEqual());
 765         assertEquals(5, ((GreaterOrEqualConstraint) properties[1].getConstraints().iterator().next()).getGreaterOrEqual());
 766         assertEquals(7, ((LessThanConstraint) properties[2].getConstraints().iterator().next()).getLessThan());
 767         assertEquals(9, ((LessOrEqualConstraint) properties[3].getConstraints().iterator().next()).getLessOrEqual());
 768         assertEquals("5", ((InRangeConstraint) properties[4].getConstraints().iterator().next()).getInRange().get(0).toString());
 769         assertEquals("10", ((InRangeConstraint) properties[4].getConstraints().iterator().next()).getInRange().get(1).toString());
 770         assertEquals(3, ((ValidValuesConstraint) properties[5].getConstraints().iterator().next()).getValidValues().size());
 771         assertEquals(11, ((LengthConstraint) properties[6].getConstraints().iterator().next()).getLength());
 772         assertEquals(13, ((MinLengthConstraint) properties[7].getConstraints().iterator().next()).getMinLength());
 773         assertEquals(15, ((MaxLengthConstraint) properties[8].getConstraints().iterator().next()).getMaxLength());
 774     }
 775
 776     @Test
 777     void testconvertJsonToObject_NllData() {
 778
 779         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 780         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 781         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 782         User user = new User();
 783         String data = null;
 784         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 785
 786         assertThat(response.isRight()).isTrue();
 787     }
 788
 789     @Test
 790     void testconvertJsonToObjectInvalidData() {
 791
 792         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 793         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 794         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 795
 796         User user = new User();
 797
 798         String data = "{ User [ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 799
 800         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 801
 802         assertThat(response.isRight()).isTrue();
 803     }
 804
 805     @Test
 806     void testconvertToStorageOperationStatus() {
 807         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 808         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 809         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 810         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.OK)).isEqualTo(StorageOperationStatus.OK);
 811         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.NOT_FOUND)).isEqualTo(StorageOperationStatus.NOT_FOUND);
 812         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.GENERAL_ERROR)).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
 813         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.CLUSTER_NOT_CONNECTED)).isEqualTo(
 814             StorageOperationStatus.CONNECTION_FAILURE);
 815         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.KEYSPACE_NOT_CONNECTED)).isEqualTo(
 816             StorageOperationStatus.CONNECTION_FAILURE);
 817     }
 818
 819     @Test
 820     void testgetResponseFormatByDataType() {
 821         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 822         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 823         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 824         DataTypeDefinition dataType = new DataTypeDefinition();
 825         dataType.setName("demo");
 826         List<String> properties;
 827         ResponseFormat result = compUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_ALREADY_EXIST, dataType, null);
 828
 829         assertThat(result).isInstanceOf(ResponseFormat.class);
 830         assertThat(result.getStatus()).isEqualTo(409);
 831     }
 832
 833     @Test
 834     void testGetResponseFormatByPolicyType_POLICY_TYPE_ALREADY_EXIST() {
 835
 836         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 837         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 838         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 839         PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 840         policyType.setType("Demo");
 841         ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, policyType);
 842
 843         assertThat(result).isInstanceOf(ResponseFormat.class);
 844         assertThat(result.getStatus()).isEqualTo(409);
 845     }
 846
 847     @Test
 848     void testGetResponseFormatByPolicyType_PolicyID_NULL() {
 849
 850         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 851         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 852         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 853         ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, null);
 854
 855         assertThat(result).isInstanceOf(ResponseFormat.class);
 856         assertThat(result.getStatus()).isEqualTo(409);
 857     }
 858
 859     @Test
 860     void testGetResponseFormatByGroupType_GROUP_MEMBER_EMPTY() {
 861
 862         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 863         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 864         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 865         GroupTypeDefinition groupType = new GroupTypeDefinition();
 866         groupType.setType("Demo");
 867
 868         ResponseFormat result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_MEMBER_EMPTY, groupType);
 869         assertThat(result).isInstanceOf(ResponseFormat.class);
 870         assertThat(result.getStatus()).isEqualTo(400);
 871
 872         result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_TYPE_ALREADY_EXIST, groupType);
 873         assertThat(result).isInstanceOf(ResponseFormat.class);
 874         assertThat(result.getStatus()).isEqualTo(409);
 875     }
 876
 877     @Test
 878     void testConvertFromStorageResponseForDataType_ALL() {
 879
 880         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 881         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 882         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 883
 884         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 885         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 886         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 887         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 888         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 889             ActionStatus.DATA_TYPE_ALREADY_EXIST);
 890         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 891             ActionStatus.DATA_TYPE_ALREADY_EXIST);
 892         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY)).isEqualTo(
 893             ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST);
 894     }
 895
 896     @Test
 897     void testConvertFromStorageResponseForGroupType_ALL() {
 898
 899         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 900         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 901         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 902
 903         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 904         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 905         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 906         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 907         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 908             ActionStatus.GROUP_TYPE_ALREADY_EXIST);
 909         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 910             ActionStatus.GROUP_TYPE_ALREADY_EXIST);
 911     }
 912
 913     @Test
 914     void testConvertFromStorageResponseForConsumer_ALL() {
 915         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 916         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 917         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 918
 919         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 920         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 921         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 922         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 923         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 924             ActionStatus.CONSUMER_ALREADY_EXISTS);
 925         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 926             ActionStatus.CONSUMER_ALREADY_EXISTS);
 927         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.NOT_FOUND)).isEqualTo(ActionStatus.ECOMP_USER_NOT_FOUND);
 928     }
 929
 930     @Test
 931     void testGetResponseFormatAdditionalProperty_ALL() {
 932         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 933         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 934         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 935
 936         AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 937         NodeTypeEnum nodeType = null;
 938         AdditionalInformationEnum labelOrValue = null;
 939
 940         ResponseFormat result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, additionalInfoParameterInfo,
 941             nodeType,
 942             labelOrValue);
 943         assertThat(result).isInstanceOf(ResponseFormat.class);
 944         assertThat(result.getStatus()).isEqualTo(409);
 945
 946         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo,
 947             nodeType,
 948             labelOrValue);
 949         assertThat(result).isInstanceOf(ResponseFormat.class);
 950         assertThat(result.getStatus()).isEqualTo(400);
 951
 952         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo,
 953             NodeTypeEnum.Group,
 954             labelOrValue);
 955         assertThat(result).isInstanceOf(ResponseFormat.class);
 956         assertThat(result.getStatus()).isEqualTo(409);
 957
 958         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED,
 959             additionalInfoParameterInfo, nodeType,
 960             labelOrValue);
 961         assertThat(result).isInstanceOf(ResponseFormat.class);
 962         assertThat(result.getStatus()).isEqualTo(400);
 963
 964         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_KEY_NOT_ALLOWED_CHARACTERS,
 965             additionalInfoParameterInfo, nodeType,
 966             labelOrValue);
 967         assertThat(result).isInstanceOf(ResponseFormat.class);
 968         assertThat(result.getStatus()).isEqualTo(400);
 969
 970         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS,
 971             additionalInfoParameterInfo, nodeType,
 972             labelOrValue);
 973         assertThat(result).isInstanceOf(ResponseFormat.class);
 974         assertThat(result.getStatus()).isEqualTo(400);
 975
 976         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND, additionalInfoParameterInfo, nodeType,
 977             labelOrValue);
 978         assertThat(result).isInstanceOf(ResponseFormat.class);
 979         assertThat(result.getStatus()).isEqualTo(409);
 980
 981     }
 982
 983     @Test
 984     void testConvertFromResultStatusEnum_ALL() {
 985
 986         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 987         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 988         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 989         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.OK, null)).isEqualTo(ActionStatus.OK);
 990         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_DEFAULT_VALUE, null)).isEqualTo(
 991             ActionStatus.INVALID_PROPERTY);
 992         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
 993         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_VALUE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
 994         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
 995         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.MISSING_ENTRY_SCHEMA_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
 996     }
 997
 998     @Test
 999     void testconvertFromStorageResponseForAdditionalInformation() {
1000         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1001         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1002         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1003         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
1004         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
1005             ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
1006         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.INVALID_ID)).isEqualTo(
1007             ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND);
1008     }
1009
1010     @Test
1011     void testgetResponseFormatByComponent() {
1012         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1013         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1014         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1015         Component component = new Resource();
1016         ResponseFormat result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, component,
1017             ComponentTypeEnum.RESOURCE);
1018         assertThat(result).isInstanceOf(ResponseFormat.class);
1019         assertThat(result.getStatus()).isEqualTo(409);
1020
1021         result = compUtils.getResponseFormatByComponent(ActionStatus.RESOURCE_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
1022         assertThat(result).isInstanceOf(ResponseFormat.class);
1023         assertThat(result.getStatus()).isEqualTo(404);
1024
1025         result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
1026         assertThat(result).isInstanceOf(ResponseFormat.class);
1027         assertThat(result.getStatus()).isEqualTo(409);
1028
1029         result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_IN_USE, component, ComponentTypeEnum.RESOURCE);
1030         assertThat(result).isInstanceOf(ResponseFormat.class);
1031         assertThat(result.getStatus()).isEqualTo(403);
1032
1033         result = compUtils.getResponseFormatByComponent(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
1034         assertThat(result).isInstanceOf(ResponseFormat.class);
1035         assertThat(result.getStatus()).isEqualTo(403);
1036
1037         result = compUtils.getResponseFormatByComponent(ActionStatus.ACCEPTED, component, ComponentTypeEnum.RESOURCE);
1038         assertThat(result).isInstanceOf(ResponseFormat.class);
1039         assertThat(result.getStatus()).isEqualTo(202);
1040     }
1041
1042     @Test
1043     void testConvertFromStorageResponseForResourceInstanceProperty_ALL() {
1044         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1045         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1046         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1047
1048         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
1049         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.INVALID_ID)).isEqualTo(
1050             ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
1051         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(
1052             ActionStatus.GENERAL_ERROR);
1053         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.BAD_REQUEST)).isEqualTo(
1054             ActionStatus.INVALID_CONTENT);
1055         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.MATCH_NOT_FOUND)).isEqualTo(
1056             ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
1057         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
1058             ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
1059         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.NOT_FOUND)).isEqualTo(
1060             ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
1061     }
1062
1063     @Test
1064     void testConvertFromStorageResponseForResourceInstance_ALL() {
1065         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1066         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1067         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1068
1069         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.ARTIFACT_NOT_FOUND, false)).isEqualTo(
1070             ActionStatus.GENERAL_ERROR);
1071         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_ID, false)).isEqualTo(
1072             ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
1073         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_PROPERTY, false)).isEqualTo(
1074             ActionStatus.INVALID_PROPERTY);
1075         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.GRAPH_IS_LOCK, false)).isEqualTo(
1076             ActionStatus.GENERAL_ERROR);
1077         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, false)).isEqualTo(
1078             ActionStatus.INVALID_CONTENT);
1079         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.MATCH_NOT_FOUND, false)).isEqualTo(
1080             ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
1081         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.SCHEMA_VIOLATION, false)).isEqualTo(
1082             ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
1083         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, true)).isEqualTo(
1084             ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND);
1085         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, false)).isEqualTo(
1086             ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
1087     }
1088
1089     @Test
1090     void testConvertFromStorageResponse_ALL() {
1091
1092         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1093         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1094         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1095
1096         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CONNECTION_FAILURE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1097             ActionStatus.GENERAL_ERROR);
1098         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.GRAPH_IS_LOCK, ComponentTypeEnum.RESOURCE)).isEqualTo(
1099             ActionStatus.GENERAL_ERROR);
1100         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST, ComponentTypeEnum.RESOURCE)).isEqualTo(
1101             ActionStatus.INVALID_CONTENT);
1102         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.ENTITY_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(
1103             ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
1104         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1105             ActionStatus.PARENT_RESOURCE_NOT_FOUND);
1106         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1107             ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND);
1108         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT, ComponentTypeEnum.RESOURCE)).isEqualTo(
1109             ActionStatus.COMPONENT_IN_USE);
1110         assertThat(
1111             compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1112             ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE);
1113         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1114             ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND);
1115         assertThat(
1116             compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, ComponentTypeEnum.RESOURCE)).isEqualTo(
1117             ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID);
1118         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_TYPE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1119             ActionStatus.INVALID_CONTENT);
1120         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1121             ActionStatus.INVALID_CONTENT);
1122         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CSAR_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1123             ActionStatus.CSAR_NOT_FOUND);
1124         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(
1125             ActionStatus.PROPERTY_NAME_ALREADY_EXISTS);
1126         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MATCH_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1127             ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY);
1128         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CATEGORY_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1129             ActionStatus.COMPONENT_CATEGORY_NOT_FOUND);
1130         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_PROPERTY, ComponentTypeEnum.RESOURCE)).isEqualTo(
1131             ActionStatus.INVALID_PROPERTY);
1132         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_ARCHIVED, ComponentTypeEnum.RESOURCE)).isEqualTo(
1133             ActionStatus.COMPONENT_IS_ARCHIVED);
1134     }
1135 }