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 testValidateStringNotEmpty() {
 567         ComponentsUtils testSubject;
 568         String value = "";
 569         boolean result;
 570
 571         // default test
 572         testSubject = createTestSubject();
 573         result = testSubject.validateStringNotEmpty(value);
 574         assertThat(result).isFalse();
 575     }
 576
 577     @Test
 578     void testConvertFromStorageResponseForAdditionalInformation() {
 579         ComponentsUtils testSubject;
 580         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 581         ActionStatus result;
 582
 583         // default test
 584         testSubject = createTestSubject();
 585         result = testSubject.convertFromStorageResponseForAdditionalInformation(storageResponse);
 586         assertThat(result)
 587             .isInstanceOf(ActionStatus.class)
 588             .isEqualTo(ActionStatus.GENERAL_ERROR);
 589     }
 590
 591     @Test
 592     void testConvertFromResultStatusEnum() {
 593         ComponentsUtils testSubject;
 594         ResultStatusEnum resultStatus = ResultStatusEnum.ELEMENT_NOT_FOUND;
 595         JsonPresentationFields elementType = null;
 596         ActionStatus result;
 597
 598         // default test
 599         testSubject = createTestSubject();
 600         result = testSubject.convertFromResultStatusEnum(resultStatus, elementType);
 601         assertThat(result)
 602             .isInstanceOf(ActionStatus.class)
 603             .isEqualTo(ActionStatus.GENERAL_ERROR);
 604     }
 605
 606     @Test
 607     void testGetResponseFormatAdditionalProperty() {
 608         ComponentsUtils testSubject;
 609         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 610         AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 611         NodeTypeEnum nodeType = null;
 612         AdditionalInformationEnum labelOrValue = null;
 613         ResponseFormat result;
 614
 615         // test 1
 616         testSubject = createTestSubject();
 617         additionalInfoParameterInfo = null;
 618         result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 619             labelOrValue);
 620         assertThat(result).isInstanceOf(ResponseFormat.class);
 621         assertThat(result.getStatus()).isEqualTo(202);
 622
 623         // test 2
 624         testSubject = createTestSubject();
 625         labelOrValue = null;
 626         result = testSubject.getResponseFormatAdditionalProperty(actionStatus, additionalInfoParameterInfo, nodeType,
 627             labelOrValue);
 628         assertThat(result).isInstanceOf(ResponseFormat.class);
 629         assertThat(result.getStatus()).isEqualTo(202);
 630     }
 631
 632     @Test
 633     void testGetResponseFormatAdditionalProperty_1() {
 634         ComponentsUtils testSubject;
 635         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 636         ResponseFormat result;
 637
 638         // default test
 639         testSubject = createTestSubject();
 640         result = testSubject.getResponseFormatAdditionalProperty(actionStatus);
 641         assertThat(result).isInstanceOf(ResponseFormat.class);
 642         assertThat(result.getStatus()).isEqualTo(202);
 643     }
 644
 645     @Test
 646     void testConvertFromStorageResponseForConsumer() {
 647         ComponentsUtils testSubject;
 648         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 649         ActionStatus result;
 650
 651         // default test
 652         testSubject = createTestSubject();
 653         result = testSubject.convertFromStorageResponseForConsumer(storageResponse);
 654         assertThat(result)
 655             .isInstanceOf(ActionStatus.class)
 656             .isEqualTo(ActionStatus.GENERAL_ERROR);
 657     }
 658
 659     @Test
 660     void testConvertFromStorageResponseForGroupType() {
 661         ComponentsUtils testSubject;
 662         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 663         ActionStatus result;
 664
 665         // default test
 666         testSubject = createTestSubject();
 667         result = testSubject.convertFromStorageResponseForGroupType(storageResponse);
 668         assertThat(result)
 669             .isInstanceOf(ActionStatus.class)
 670             .isEqualTo(ActionStatus.GENERAL_ERROR);
 671     }
 672
 673     @Test
 674     void testConvertFromStorageResponseForDataType() {
 675         ComponentsUtils testSubject;
 676         StorageOperationStatus storageResponse = StorageOperationStatus.ARTIFACT_NOT_FOUND;
 677         ActionStatus result;
 678
 679         // default test
 680         testSubject = createTestSubject();
 681         result = testSubject.convertFromStorageResponseForDataType(storageResponse);
 682         assertThat(result)
 683             .isInstanceOf(ActionStatus.class)
 684             .isEqualTo(ActionStatus.GENERAL_ERROR);
 685     }
 686
 687     @Test
 688     void testGetResponseFormatByGroupType() {
 689         ComponentsUtils testSubject;
 690         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 691         GroupTypeDefinition groupType = null;
 692         ResponseFormat result;
 693
 694         // test 1
 695         testSubject = createTestSubject();
 696         groupType = null;
 697         result = testSubject.getResponseFormatByGroupType(actionStatus, groupType);
 698         assertThat(result).isInstanceOf(ResponseFormat.class);
 699         assertThat(result.getStatus()).isEqualTo(202);
 700     }
 701
 702     @Test
 703     void testGetResponseFormatByPolicyType() {
 704         ComponentsUtils testSubject;
 705         ActionStatus actionStatus = ActionStatus.ACCEPTED;
 706         PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 707         ResponseFormat result;
 708
 709         // test 1
 710         testSubject = createTestSubject();
 711         result = testSubject.getResponseFormatByPolicyType(actionStatus, policyType);
 712         assertThat(result).isInstanceOf(ResponseFormat.class);
 713         assertThat(result.getStatus()).isEqualTo(202);
 714     }
 715
 716     @Test
 717     void testGetResponseFormatByDataType() {
 718         ComponentsUtils testSubject;
 719         ActionStatus actionStatus = ActionStatus.AAI_ARTIFACT_GENERATION_FAILED;
 720         DataTypeDefinition dataType = null;
 721         List<String> properties = null;
 722         ResponseFormat result;
 723
 724         // test 1
 725         testSubject = createTestSubject();
 726         dataType = null;
 727         result = testSubject.getResponseFormatByDataType(actionStatus, dataType, properties);
 728         assertThat(result).isInstanceOf(ResponseFormat.class);
 729         assertThat(result.getStatus()).isEqualTo(500);
 730     }
 731
 732     @Test
 733     void testconvertJsonToObject() {
 734
 735         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 736         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 737         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 738
 739         User user = new User();
 740         ComponentsUtils testSubject = createTestSubject();
 741         String data = "{ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 742
 743         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 744         User assertuser = new User("xyz", "xyz", "12", "demo.z@ymail.com", "123", null);
 745
 746         assertThat(response.isLeft()).isTrue();
 747         assertThat(response.left().value()).isEqualTo(assertuser);
 748     }
 749
 750     @Test
 751     void testconvertJsonToObjectUsingObjectMapper() {
 752
 753         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 754         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 755         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 756
 757         User user = new User();
 758         String data =
 759             "[{\"constraints\":[{\"equal\":\"value\"}]},"
 760                 + "{\"constraints\":[{\"greaterOrEqual\":5}]},"
 761                 + "{\"constraints\":[{\"lessThan\":7}]},"
 762                 + "{\"constraints\":[{\"lessOrEqual\":9}]},"
 763                 + "{\"constraints\":[{\"inRange\":[\"5\", \"10\"]}]},"
 764                 + "{\"constraints\":[{\"validValues\":[\"abc\", \"def\", \"hij\"]}]},"
 765                 + "{\"constraints\":[{\"length\":11}]},"
 766                 + "{\"constraints\":[{\"minLength\":13}]},"
 767                 + "{\"constraints\":[{\"maxLength\":15}]}"
 768                 + "]";
 769
 770         Either<ComponentInstanceProperty[], ResponseFormat> response = compUtils.convertJsonToObjectUsingObjectMapper(data, user,
 771             ComponentInstanceProperty[].class, null, ComponentTypeEnum.RESOURCE_INSTANCE);
 772
 773         assertThat(response.isLeft()).isTrue();
 774         ComponentInstanceProperty[] properties = response.left().value();
 775         assertEquals(9, properties.length);
 776         assertEquals("value", ((EqualConstraint) properties[0].getConstraints().iterator().next()).getEqual());
 777         assertEquals(5, ((GreaterOrEqualConstraint) properties[1].getConstraints().iterator().next()).getGreaterOrEqual());
 778         assertEquals(7, ((LessThanConstraint) properties[2].getConstraints().iterator().next()).getLessThan());
 779         assertEquals(9, ((LessOrEqualConstraint) properties[3].getConstraints().iterator().next()).getLessOrEqual());
 780         assertEquals("5", ((InRangeConstraint) properties[4].getConstraints().iterator().next()).getInRange().get(0).toString());
 781         assertEquals("10", ((InRangeConstraint) properties[4].getConstraints().iterator().next()).getInRange().get(1).toString());
 782         assertEquals(3, ((ValidValuesConstraint) properties[5].getConstraints().iterator().next()).getValidValues().size());
 783         assertEquals(11, ((LengthConstraint) properties[6].getConstraints().iterator().next()).getLength());
 784         assertEquals(13, ((MinLengthConstraint) properties[7].getConstraints().iterator().next()).getMinLength());
 785         assertEquals(15, ((MaxLengthConstraint) properties[8].getConstraints().iterator().next()).getMaxLength());
 786     }
 787
 788     @Test
 789     void testconvertJsonToObject_NllData() {
 790
 791         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 792         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 793         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 794         User user = new User();
 795         String data = null;
 796         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 797
 798         assertThat(response.isRight()).isTrue();
 799     }
 800
 801     @Test
 802     void testconvertJsonToObjectInvalidData() {
 803
 804         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 805         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 806         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 807
 808         User user = new User();
 809
 810         String data = "{ User [ firstName=\"xyz\", lastName=\"xyz\", userId=\"12\", email=\"demo.z@ymail.com\",role=\"123\", lastlogintime=20180201233412 }";
 811
 812         Either<User, ResponseFormat> response = compUtils.convertJsonToObject(data, user, User.class, AuditingActionEnum.ADD_USER);
 813
 814         assertThat(response.isRight()).isTrue();
 815     }
 816
 817     @Test
 818     void testconvertToStorageOperationStatus() {
 819         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 820         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 821         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 822         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.OK)).isEqualTo(StorageOperationStatus.OK);
 823         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.NOT_FOUND)).isEqualTo(StorageOperationStatus.NOT_FOUND);
 824         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.GENERAL_ERROR)).isEqualTo(StorageOperationStatus.GENERAL_ERROR);
 825         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.CLUSTER_NOT_CONNECTED)).isEqualTo(
 826             StorageOperationStatus.CONNECTION_FAILURE);
 827         assertThat(compUtils.convertToStorageOperationStatus(CassandraOperationStatus.KEYSPACE_NOT_CONNECTED)).isEqualTo(
 828             StorageOperationStatus.CONNECTION_FAILURE);
 829     }
 830
 831     @Test
 832     void testgetResponseFormatByDataType() {
 833         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 834         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 835         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 836         DataTypeDefinition dataType = new DataTypeDefinition();
 837         dataType.setName("demo");
 838         List<String> properties;
 839         ResponseFormat result = compUtils.getResponseFormatByDataType(ActionStatus.DATA_TYPE_ALREADY_EXIST, dataType, null);
 840
 841         assertThat(result).isInstanceOf(ResponseFormat.class);
 842         assertThat(result.getStatus()).isEqualTo(409);
 843     }
 844
 845     @Test
 846     void testGetResponseFormatByPolicyType_POLICY_TYPE_ALREADY_EXIST() {
 847
 848         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 849         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 850         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 851         PolicyTypeDefinition policyType = new PolicyTypeDefinition();
 852         policyType.setType("Demo");
 853         ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, policyType);
 854
 855         assertThat(result).isInstanceOf(ResponseFormat.class);
 856         assertThat(result.getStatus()).isEqualTo(409);
 857     }
 858
 859     @Test
 860     void testGetResponseFormatByPolicyType_PolicyID_NULL() {
 861
 862         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 863         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 864         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 865         ResponseFormat result = compUtils.getResponseFormatByPolicyType(ActionStatus.POLICY_TYPE_ALREADY_EXIST, null);
 866
 867         assertThat(result).isInstanceOf(ResponseFormat.class);
 868         assertThat(result.getStatus()).isEqualTo(409);
 869     }
 870
 871     @Test
 872     void testGetResponseFormatByGroupType_GROUP_MEMBER_EMPTY() {
 873
 874         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 875         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 876         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 877         GroupTypeDefinition groupType = new GroupTypeDefinition();
 878         groupType.setType("Demo");
 879
 880         ResponseFormat result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_MEMBER_EMPTY, groupType);
 881         assertThat(result).isInstanceOf(ResponseFormat.class);
 882         assertThat(result.getStatus()).isEqualTo(400);
 883
 884         result = compUtils.getResponseFormatByGroupType(ActionStatus.GROUP_TYPE_ALREADY_EXIST, groupType);
 885         assertThat(result).isInstanceOf(ResponseFormat.class);
 886         assertThat(result.getStatus()).isEqualTo(409);
 887     }
 888
 889     @Test
 890     void testConvertFromStorageResponseForDataType_ALL() {
 891
 892         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 893         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 894         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 895
 896         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 897         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 898         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 899         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 900         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 901             ActionStatus.DATA_TYPE_ALREADY_EXIST);
 902         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 903             ActionStatus.DATA_TYPE_ALREADY_EXIST);
 904         assertThat(compUtils.convertFromStorageResponseForDataType(StorageOperationStatus.CANNOT_UPDATE_EXISTING_ENTITY)).isEqualTo(
 905             ActionStatus.DATA_TYPE_CANNOT_BE_UPDATED_BAD_REQUEST);
 906     }
 907
 908     @Test
 909     void testConvertFromStorageResponseForGroupType_ALL() {
 910
 911         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 912         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 913         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 914
 915         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 916         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 917         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 918         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 919         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 920             ActionStatus.GROUP_TYPE_ALREADY_EXIST);
 921         assertThat(compUtils.convertFromStorageResponseForGroupType(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 922             ActionStatus.GROUP_TYPE_ALREADY_EXIST);
 923     }
 924
 925     @Test
 926     void testConvertFromStorageResponseForConsumer_ALL() {
 927         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 928         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 929         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 930
 931         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
 932         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.CONNECTION_FAILURE)).isEqualTo(ActionStatus.GENERAL_ERROR);
 933         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(ActionStatus.GENERAL_ERROR);
 934         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.BAD_REQUEST)).isEqualTo(ActionStatus.INVALID_CONTENT);
 935         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
 936             ActionStatus.CONSUMER_ALREADY_EXISTS);
 937         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
 938             ActionStatus.CONSUMER_ALREADY_EXISTS);
 939         assertThat(compUtils.convertFromStorageResponseForConsumer(StorageOperationStatus.NOT_FOUND)).isEqualTo(ActionStatus.ECOMP_USER_NOT_FOUND);
 940     }
 941
 942     @Test
 943     void testGetResponseFormatAdditionalProperty_ALL() {
 944         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 945         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
 946         when(auditingmanager.auditEvent(any())).thenReturn("OK");
 947
 948         AdditionalInfoParameterInfo additionalInfoParameterInfo = null;
 949         NodeTypeEnum nodeType = null;
 950         AdditionalInformationEnum labelOrValue = null;
 951
 952         ResponseFormat result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, additionalInfoParameterInfo,
 953             nodeType,
 954             labelOrValue);
 955         assertThat(result).isInstanceOf(ResponseFormat.class);
 956         assertThat(result.getStatus()).isEqualTo(409);
 957
 958         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EXCEEDS_LIMIT, additionalInfoParameterInfo,
 959             nodeType,
 960             labelOrValue);
 961         assertThat(result).isInstanceOf(ResponseFormat.class);
 962         assertThat(result.getStatus()).isEqualTo(400);
 963
 964         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_MAX_NUMBER_REACHED, additionalInfoParameterInfo,
 965             NodeTypeEnum.Group,
 966             labelOrValue);
 967         assertThat(result).isInstanceOf(ResponseFormat.class);
 968         assertThat(result.getStatus()).isEqualTo(409);
 969
 970         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_EMPTY_STRING_NOT_ALLOWED,
 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_KEY_NOT_ALLOWED_CHARACTERS,
 977             additionalInfoParameterInfo, nodeType,
 978             labelOrValue);
 979         assertThat(result).isInstanceOf(ResponseFormat.class);
 980         assertThat(result.getStatus()).isEqualTo(400);
 981
 982         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_VALUE_NOT_ALLOWED_CHARACTERS,
 983             additionalInfoParameterInfo, nodeType,
 984             labelOrValue);
 985         assertThat(result).isInstanceOf(ResponseFormat.class);
 986         assertThat(result.getStatus()).isEqualTo(400);
 987
 988         result = compUtils.getResponseFormatAdditionalProperty(ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND, additionalInfoParameterInfo, nodeType,
 989             labelOrValue);
 990         assertThat(result).isInstanceOf(ResponseFormat.class);
 991         assertThat(result.getStatus()).isEqualTo(409);
 992
 993     }
 994
 995     @Test
 996     void testConvertFromResultStatusEnum_ALL() {
 997
 998         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
 999         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1000         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1001         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.OK, null)).isEqualTo(ActionStatus.OK);
1002         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_DEFAULT_VALUE, null)).isEqualTo(
1003             ActionStatus.INVALID_PROPERTY);
1004         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
1005         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_VALUE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
1006         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.INVALID_PROPERTY_NAME, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
1007         assertThat(compUtils.convertFromResultStatusEnum(ResultStatusEnum.MISSING_ENTRY_SCHEMA_TYPE, null)).isEqualTo(ActionStatus.INVALID_PROPERTY);
1008     }
1009
1010     @Test
1011     void testconvertFromStorageResponseForAdditionalInformation() {
1012         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1013         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1014         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1015         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
1016         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.ENTITY_ALREADY_EXISTS)).isEqualTo(
1017             ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
1018         assertThat(compUtils.convertFromStorageResponseForAdditionalInformation(StorageOperationStatus.INVALID_ID)).isEqualTo(
1019             ActionStatus.ADDITIONAL_INFORMATION_NOT_FOUND);
1020     }
1021
1022     @Test
1023     void testgetResponseFormatByComponent() {
1024         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1025         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1026         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1027         Component component = new Resource();
1028         ResponseFormat result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_VERSION_ALREADY_EXIST, component,
1029             ComponentTypeEnum.RESOURCE);
1030         assertThat(result).isInstanceOf(ResponseFormat.class);
1031         assertThat(result.getStatus()).isEqualTo(409);
1032
1033         result = compUtils.getResponseFormatByComponent(ActionStatus.RESOURCE_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
1034         assertThat(result).isInstanceOf(ResponseFormat.class);
1035         assertThat(result.getStatus()).isEqualTo(404);
1036
1037         result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_NAME_ALREADY_EXIST, component, ComponentTypeEnum.RESOURCE);
1038         assertThat(result).isInstanceOf(ResponseFormat.class);
1039         assertThat(result.getStatus()).isEqualTo(409);
1040
1041         result = compUtils.getResponseFormatByComponent(ActionStatus.COMPONENT_IN_USE, component, ComponentTypeEnum.RESOURCE);
1042         assertThat(result).isInstanceOf(ResponseFormat.class);
1043         assertThat(result.getStatus()).isEqualTo(403);
1044
1045         result = compUtils.getResponseFormatByComponent(ActionStatus.SERVICE_DEPLOYMENT_ARTIFACT_NOT_FOUND, component, ComponentTypeEnum.RESOURCE);
1046         assertThat(result).isInstanceOf(ResponseFormat.class);
1047         assertThat(result.getStatus()).isEqualTo(403);
1048
1049         result = compUtils.getResponseFormatByComponent(ActionStatus.ACCEPTED, component, ComponentTypeEnum.RESOURCE);
1050         assertThat(result).isInstanceOf(ResponseFormat.class);
1051         assertThat(result.getStatus()).isEqualTo(202);
1052     }
1053
1054     @Test
1055     void testConvertFromStorageResponseForResourceInstanceProperty_ALL() {
1056         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1057         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1058         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1059
1060         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.OK)).isEqualTo(ActionStatus.OK);
1061         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.INVALID_ID)).isEqualTo(
1062             ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
1063         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.GRAPH_IS_LOCK)).isEqualTo(
1064             ActionStatus.GENERAL_ERROR);
1065         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.BAD_REQUEST)).isEqualTo(
1066             ActionStatus.INVALID_CONTENT);
1067         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.MATCH_NOT_FOUND)).isEqualTo(
1068             ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
1069         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.SCHEMA_VIOLATION)).isEqualTo(
1070             ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
1071         assertThat(compUtils.convertFromStorageResponseForResourceInstanceProperty(StorageOperationStatus.NOT_FOUND)).isEqualTo(
1072             ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
1073     }
1074
1075     @Test
1076     void testConvertFromStorageResponseForResourceInstance_ALL() {
1077         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1078         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1079         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1080
1081         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.ARTIFACT_NOT_FOUND, false)).isEqualTo(
1082             ActionStatus.GENERAL_ERROR);
1083         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_ID, false)).isEqualTo(
1084             ActionStatus.RESOURCE_INSTANCE_BAD_REQUEST);
1085         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.INVALID_PROPERTY, false)).isEqualTo(
1086             ActionStatus.INVALID_PROPERTY);
1087         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.GRAPH_IS_LOCK, false)).isEqualTo(
1088             ActionStatus.GENERAL_ERROR);
1089         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.BAD_REQUEST, false)).isEqualTo(
1090             ActionStatus.INVALID_CONTENT);
1091         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.MATCH_NOT_FOUND, false)).isEqualTo(
1092             ActionStatus.RESOURCE_INSTANCE_MATCH_NOT_FOUND);
1093         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.SCHEMA_VIOLATION, false)).isEqualTo(
1094             ActionStatus.RESOURCE_INSTANCE_ALREADY_EXIST);
1095         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, true)).isEqualTo(
1096             ActionStatus.RESOURCE_INSTANCE_RELATION_NOT_FOUND);
1097         assertThat(compUtils.convertFromStorageResponseForResourceInstance(StorageOperationStatus.NOT_FOUND, false)).isEqualTo(
1098             ActionStatus.RESOURCE_INSTANCE_NOT_FOUND);
1099     }
1100
1101     @Test
1102     void testConvertFromStorageResponse_ALL() {
1103
1104         AuditingManager auditingmanager = Mockito.mock(AuditingManager.class);
1105         ComponentsUtils compUtils = new ComponentsUtils(auditingmanager);
1106         when(auditingmanager.auditEvent(any())).thenReturn("OK");
1107
1108         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CONNECTION_FAILURE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1109             ActionStatus.GENERAL_ERROR);
1110         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.GRAPH_IS_LOCK, ComponentTypeEnum.RESOURCE)).isEqualTo(
1111             ActionStatus.GENERAL_ERROR);
1112         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.BAD_REQUEST, ComponentTypeEnum.RESOURCE)).isEqualTo(
1113             ActionStatus.INVALID_CONTENT);
1114         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.ENTITY_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(
1115             ActionStatus.COMPONENT_NAME_ALREADY_EXIST);
1116         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PARENT_RESOURCE_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1117             ActionStatus.PARENT_RESOURCE_NOT_FOUND);
1118         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MULTIPLE_PARENT_RESOURCE_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1119             ActionStatus.MULTIPLE_PARENT_RESOURCE_FOUND);
1120         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.FAILED_TO_LOCK_ELEMENT, ComponentTypeEnum.RESOURCE)).isEqualTo(
1121             ActionStatus.COMPONENT_IN_USE);
1122         assertThat(
1123             compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_AVAILABLE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1124             ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_AVAILABLE);
1125         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1126             ActionStatus.DISTRIBUTION_ENVIRONMENT_NOT_FOUND);
1127         assertThat(
1128             compUtils.convertFromStorageResponse(StorageOperationStatus.DISTR_ENVIRONMENT_SENT_IS_INVALID, ComponentTypeEnum.RESOURCE)).isEqualTo(
1129             ActionStatus.DISTRIBUTION_ENVIRONMENT_INVALID);
1130         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_TYPE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1131             ActionStatus.INVALID_CONTENT);
1132         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_VALUE, ComponentTypeEnum.RESOURCE)).isEqualTo(
1133             ActionStatus.INVALID_CONTENT);
1134         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CSAR_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1135             ActionStatus.CSAR_NOT_FOUND);
1136         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.PROPERTY_NAME_ALREADY_EXISTS, ComponentTypeEnum.RESOURCE)).isEqualTo(
1137             ActionStatus.PROPERTY_NAME_ALREADY_EXISTS);
1138         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.MATCH_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1139             ActionStatus.COMPONENT_SUB_CATEGORY_NOT_FOUND_FOR_CATEGORY);
1140         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.CATEGORY_NOT_FOUND, ComponentTypeEnum.RESOURCE)).isEqualTo(
1141             ActionStatus.COMPONENT_CATEGORY_NOT_FOUND);
1142         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.INVALID_PROPERTY, ComponentTypeEnum.RESOURCE)).isEqualTo(
1143             ActionStatus.INVALID_PROPERTY);
1144         assertThat(compUtils.convertFromStorageResponse(StorageOperationStatus.COMPONENT_IS_ARCHIVED, ComponentTypeEnum.RESOURCE)).isEqualTo(
1145             ActionStatus.COMPONENT_IS_ARCHIVED);
1146     }
1147 }