catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ComponentsUtilsTest.java

   1 package org.openecomp.sdc.be.components.impl;
   2
   3 import org.junit.Before;
   4 import org.junit.BeforeClass;
   5 import org.junit.Test;
   6 import org.junit.runner.RunWith;
   7 import org.mockito.ArgumentCaptor;
   8 import org.mockito.Captor;
   9 import org.mockito.InjectMocks;
  10 import org.mockito.Mock;
  11 import org.mockito.junit.MockitoJUnitRunner;
  12 import org.openecomp.sdc.be.auditing.api.AuditEventFactory;
  13 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  14 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditChangeLifecycleExternalApiEventFactory;
  15 import org.openecomp.sdc.be.auditing.impl.externalapi.AuditCreateResourceExternalApiEventFactory;
  16 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  17 import org.openecomp.sdc.be.impl.ComponentsUtils;
  18 import org.openecomp.sdc.be.model.*;
  19 import org.openecomp.sdc.be.resources.data.auditing.*;
  20 import org.openecomp.sdc.be.resources.data.auditing.model.DistributionData;
  21 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  22 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  23 import org.openecomp.sdc.common.api.Constants;
  24 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  25 import org.openecomp.sdc.exception.ResponseFormat;
  26
  27 import javax.servlet.http.HttpServletRequest;
  28
  29 import static org.assertj.core.api.Assertions.assertThat;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.*;
  33
  34 @RunWith(MockitoJUnitRunner.class)
  35 public class ComponentsUtilsTest {
  36
  37     private static User modifier = new User();
  38     private Component service = new Service();
  39     private Resource resource = new Resource();
  40
  41     @Mock
  42     private AuditingManager manager;
  43     @Mock
  44     private ResponseFormat responseFormat;
  45     @Mock
  46     private HttpServletRequest request;
  47
  48     private ArtifactDefinition artifactDefinition = null;
  49
  50     @Captor
  51     private ArgumentCaptor<AuditEventFactory> factoryCaptor;
  52
  53     @InjectMocks
  54     private static ComponentsUtils utils;
  55
  56     @BeforeClass
  57     public static void setUpClass() {
  58         modifier.setFirstName(MODIFIER_FIRST_NAME);
  59         modifier.setLastName(MODIFIER_LAST_NAME);
  60         modifier.setUserId(MODIFIER_ID);
  61     }
  62
  63
  64     @Before
  65     public void setUp() {
  66         ThreadLocalsHolder.setUuid(REQUEST_ID);
  67         utils = new ComponentsUtils(manager);
  68     }
  69
  70     @Test
  71     public void auditComponentWhenAllParamsPassed() {
  72         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
  73         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
  74         service.setUUID(SERVICE_INSTANCE_ID);
  75         service.setInvariantUUID(INVARIANT_UUID);
  76
  77         utils.auditComponent(responseFormat, modifier, service, AuditingActionEnum.ARTIFACT_DELETE,
  78                 new ResourceCommonInfo(RESOURCE_NAME, service.getComponentType().getValue()),
  79                 ResourceVersionInfo.newBuilder()
  80                         .state(PREV_RESOURCE_STATE)
  81                         .version(PREV_RESOURCE_VERSION)
  82                         .artifactUuid(ARTIFACT_UUID)
  83                         .distributionStatus(DPREV_STATUS).build(),
  84                 ResourceVersionInfo.newBuilder()
  85                         .state(CURRENT_STATE)
  86                         .version(CURRENT_VERSION)
  87                         .artifactUuid(ARTIFACT_UUID)
  88                         .distributionStatus(DCURR_STATUS).build(),
  89                 COMMENT, artifactDefinition, DIST_ID);
  90         verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_DELETE.getName(), STATUS_OK, DESCRIPTION, service.getComponentType().getValue(),
  91                 false, true, true, false, true, true, true);
  92     }
  93
  94     @Test
  95     public void auditComponentWhenAllParamsPassedAndMostFromComponent() {
  96         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
  97         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
  98
  99         service.setUUID(SERVICE_INSTANCE_ID);
 100         service.setInvariantUUID(INVARIANT_UUID);
 101         service.setState(LifecycleStateEnum.CERTIFIED);
 102         service.setVersion(CURRENT_VERSION);
 103         utils.auditComponent(responseFormat, modifier, service, AuditingActionEnum.CREATE_RESOURCE,
 104                 new ResourceCommonInfo(RESOURCE_NAME, service.getComponentType().getValue()),
 105                 ResourceVersionInfo.newBuilder()
 106                         .state(PREV_RESOURCE_STATE)
 107                         .version(PREV_RESOURCE_VERSION)
 108                         .artifactUuid(ARTIFACT_UUID)
 109                         .distributionStatus(DPREV_STATUS).build(),
 110                 ResourceVersionInfo.newBuilder()
 111                         .artifactUuid(ARTIFACT_UUID)
 112                         .distributionStatus(DCURR_STATUS).build(),
 113                 COMMENT, artifactDefinition, DIST_ID);
 114         verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName(), STATUS_OK, DESCRIPTION, service.getComponentType().getValue(),
 115                 false, true, true, false, true, true, true);
 116
 117     }
 118
 119     @Test
 120     public void auditComponentDistStateWithoutArtDataCommentAndDid() {
 121         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 122         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 123
 124         service.setUUID(SERVICE_INSTANCE_ID);
 125         service.setInvariantUUID(INVARIANT_UUID);
 126         service.setState(LifecycleStateEnum.CERTIFIED);
 127         service.setName(RESOURCE_NAME);
 128         service.setVersion(CURRENT_VERSION);
 129         utils.auditComponent(responseFormat, modifier, service, AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST,
 130                 new ResourceCommonInfo(service.getComponentType().getValue()),
 131                 ResourceVersionInfo.newBuilder()
 132                         .state(PREV_RESOURCE_STATE)
 133                         .version(PREV_RESOURCE_VERSION)
 134                         .artifactUuid(ARTIFACT_UUID)
 135                         .distributionStatus(DPREV_STATUS).build(),
 136                 ResourceVersionInfo.newBuilder()
 137                         .artifactUuid(ARTIFACT_UUID)
 138                         .distributionStatus(DCURR_STATUS).build());
 139         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName(),
 140                 STATUS_OK, DESCRIPTION, service.getComponentType().getValue(),
 141                 false, true, true, false, false, true, false);
 142     }
 143
 144     @Test
 145     public void auditComponentWhenError() {
 146         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 147         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 148
 149         service.setUUID(SERVICE_INSTANCE_ID);
 150         service.setInvariantUUID(INVARIANT_UUID);
 151         service.setState(LifecycleStateEnum.CERTIFIED);
 152         service.setName(RESOURCE_NAME);
 153         service.setVersion(CURRENT_VERSION);
 154
 155         utils.auditComponent(responseFormat, modifier, service, AuditingActionEnum.CERTIFICATION_REQUEST_RESOURCE,
 156                 new ResourceCommonInfo(ComponentTypeEnum.SERVICE.getValue()),
 157                 ResourceVersionInfo.newBuilder().state(PREV_RESOURCE_STATE).version(PREV_RESOURCE_VERSION).artifactUuid(ARTIFACT_UUID).build());
 158         verifyResourceAdminEvent(AuditingActionEnum.CERTIFICATION_REQUEST_RESOURCE.getName(), STATUS_500, DESC_ERROR,
 159                 service.getComponentType().getValue(), false, true, false, false, false, false, false);
 160     }
 161
 162     @Test
 163     public void auditComponentWhenCompIsNull() {
 164         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 165         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 166
 167         utils.auditComponent(responseFormat, modifier, AuditingActionEnum.START_CERTIFICATION_RESOURCE,
 168                 new ResourceCommonInfo(RESOURCE_NAME, ComponentTypeEnum.SERVICE.getValue()), COMMENT);
 169         verifyResourceAdminEvent(AuditingActionEnum.START_CERTIFICATION_RESOURCE.getName(), STATUS_500, DESC_ERROR, service.getComponentType().getValue(),
 170                 true, false, false, false, true, false, false);
 171     }
 172
 173     @Test
 174     public void auditComponentAdmin() {
 175         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 176         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 177
 178         service.setUUID(SERVICE_INSTANCE_ID);
 179         service.setInvariantUUID(INVARIANT_UUID);
 180         service.setName(RESOURCE_NAME);
 181         service.setState(LifecycleStateEnum.CERTIFIED);
 182         service.setVersion(CURRENT_VERSION);
 183         utils.auditComponentAdmin(responseFormat, modifier, service, AuditingActionEnum.CREATE_RESOURCE, service.getComponentType());
 184         verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName(), STATUS_500, DESC_ERROR, service.getComponentType().getValue(),
 185                 false, false, false, false, false, false, false);
 186     }
 187
 188     @Test
 189     public void auditResourceWhenAllParamsPassed() {
 190         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 191         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 192
 193         resource.setUUID(SERVICE_INSTANCE_ID);
 194         resource.setInvariantUUID(INVARIANT_UUID);
 195         resource.setName(RESOURCE_NAME);
 196         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 197         resource.setVersion(CURRENT_VERSION);
 198         resource.setToscaResourceName(TOSCA_NODE_TYPE);
 199         utils.auditResource(responseFormat, modifier, resource, null, AuditingActionEnum.IMPORT_RESOURCE,
 200                 ResourceVersionInfo.newBuilder()
 201                         .state(PREV_RESOURCE_STATE)
 202                         .version(PREV_RESOURCE_VERSION)
 203                         .artifactUuid(ARTIFACT_UUID)
 204                         .build(),
 205                 ARTIFACT_UUID, artifactDefinition);
 206         verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName(), STATUS_OK, DESCRIPTION, resource.getResourceType().name(),
 207                 false, true, true, false, false, false, false);
 208     }
 209
 210     @Test
 211     public void auditResourceWithoutPrevFields() {
 212         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 213         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 214
 215         resource.setUUID(SERVICE_INSTANCE_ID);
 216         resource.setInvariantUUID(INVARIANT_UUID);
 217         resource.setName(RESOURCE_NAME);
 218         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
 219         resource.setVersion(CURRENT_VERSION);
 220
 221         utils.auditResource(responseFormat, modifier, resource, AuditingActionEnum.UPDATE_RESOURCE_METADATA);
 222         verifyResourceAdminEvent(AuditingActionEnum.UPDATE_RESOURCE_METADATA.getName(), STATUS_500, DESC_ERROR, resource.getResourceType().name(),
 223                 false, false, false, false, false, false, false);
 224     }
 225
 226     @Test
 227     public void auditResourceWhenResourceIsNull() {
 228         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 229         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 230
 231         utils.auditResource(responseFormat, modifier, RESOURCE_NAME, AuditingActionEnum.CHECKOUT_RESOURCE);
 232         verifyResourceAdminEvent(AuditingActionEnum.CHECKOUT_RESOURCE.getName(), STATUS_500, DESC_ERROR, ComponentTypeEnum.RESOURCE.getValue(),
 233                 true, false, false, false, false, false, false);
 234     }
 235
 236     @Test
 237     public void auditUserAdminEvent() {
 238         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 239         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 240
 241         User userAfter = new User();
 242         userAfter.setFirstName(USER_FIRST_NAME);
 243         userAfter.setUserId(USER_ID);
 244         userAfter.setLastName(USER_LAST_NAME);
 245         userAfter.setRole(TESTER_USER_ROLE);
 246         userAfter.setEmail(USER_EMAIL);
 247
 248         utils.auditAdminUserAction(AuditingActionEnum.ADD_USER, modifier, null, userAfter, responseFormat);
 249         verify(manager).auditEvent(factoryCaptor.capture());
 250         AuditEventFactory factory = factoryCaptor.getValue();
 251         UserAdminEvent event = (UserAdminEvent)factory.getDbEvent();
 252         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 253         assertThat(event.getStatus()).isEqualTo(STATUS_OK);
 254         assertThat(event.getDesc()).isEqualTo(DESCRIPTION);
 255         assertThat(event.getRequestId()).isEqualTo(REQUEST_ID);
 256         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.ADD_USER.getName());
 257         assertThat(event.getUserBefore()).isNull();
 258         assertThat(event.getUserAfter()).isEqualTo(UPDATED_USER_EXTENDED_NAME);
 259     }
 260
 261     @Test
 262     public void auditEcompOpEnvEvent() {
 263         utils.auditEnvironmentEngine(AuditingActionEnum.CREATE_ENVIRONMENT, OP_ENV_ID, OP_ENV_TYPE, OP_ENV_ACTION, OP_ENV_NAME, TENANT_CONTEXT);
 264         verify(manager).auditEvent(factoryCaptor.capture());
 265         AuditEventFactory factory = factoryCaptor.getValue();
 266         EcompOperationalEnvironmentEvent event = (EcompOperationalEnvironmentEvent)factory.getDbEvent();
 267         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.CREATE_ENVIRONMENT.getName());
 268         assertThat(event.getOperationalEnvironmentId()).isEqualTo(OP_ENV_ID);
 269         assertThat(event.getOperationalEnvironmentType()).isEqualTo(OP_ENV_TYPE);
 270         assertThat(event.getOperationalEnvironmentName()).isEqualTo(OP_ENV_NAME);
 271         assertThat(event.getOperationalEnvironmentAction()).isEqualTo(OP_ENV_ACTION);
 272         assertThat(event.getTenantContext()).isEqualTo(TENANT_CONTEXT);
 273     }
 274
 275     @Test
 276     public void auditDistrDownloadEvent(){
 277         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 278         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 279
 280         utils.auditDistributionDownload(responseFormat, new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL));
 281
 282         verify(manager).auditEvent(factoryCaptor.capture());
 283         AuditEventFactory factory = factoryCaptor.getValue();
 284         DistributionDownloadEvent event = (DistributionDownloadEvent)factory.getDbEvent();
 285         assertThat(event.getResourceUrl()).isEqualTo(DIST_RESOURCE_URL);
 286         assertThat(event.getConsumerId()).isEqualTo(DIST_CONSUMER_ID);
 287         assertThat(event.getStatus()).isEqualTo(STATUS_OK);
 288         assertThat(event.getDesc()).isEqualTo(DESCRIPTION);
 289         assertThat(event.getRequestId()).isEqualTo(REQUEST_ID);
 290         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.DISTRIBUTION_ARTIFACT_DOWNLOAD.getName());
 291     }
 292
 293     private void verifyResourceAdminEvent(String action, String status, String desc, String resourceType, boolean isComponentNull,
 294             boolean isPrevStateAndVersionSet, boolean isCurrFieldsProvided, boolean isArtDataProvided, boolean isCommentProvided,
 295             boolean isDistStatusProvided, boolean isDidProvided) {
 296         verify(manager).auditEvent(factoryCaptor.capture());
 297         AuditEventFactory factory = factoryCaptor.getValue();
 298         ResourceAdminEvent event = (ResourceAdminEvent)factory.getDbEvent();
 299         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 300         assertThat(event.getStatus()).isEqualTo(status);
 301         assertThat(event.getDesc()).isEqualTo(desc);
 302         assertThat(event.getRequestId()).isEqualTo(REQUEST_ID);
 303         assertThat(event.getAction()).isEqualTo(action);
 304         assertThat(event.getResourceName()).isEqualTo(RESOURCE_NAME);
 305
 306         if (isComponentNull) {
 307             assertThat(event.getServiceInstanceId()).isNull();
 308             assertThat(event.getCurrState()).isNull();
 309             assertThat(event.getCurrVersion()).isNull();
 310             assertThat(event.getInvariantUUID()).isNull();
 311             assertThat(event.getResourceType()).isEqualTo(resourceType);
 312         }
 313         else {
 314             assertThat(event.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID);
 315             assertThat(event.getCurrState()).isEqualTo(CURRENT_STATE);
 316             assertThat(event.getCurrVersion()).isEqualTo(CURRENT_VERSION);
 317             assertThat(event.getInvariantUUID()).isEqualTo(INVARIANT_UUID);
 318         }
 319         if (action.equals(AuditingActionEnum.IMPORT_RESOURCE.getName())) {
 320             assertThat(event.getToscaNodeType()).isEqualTo(TOSCA_NODE_TYPE);
 321         }
 322         else {
 323             assertThat(event.getToscaNodeType()).isEmpty();
 324         }
 325         if (isPrevStateAndVersionSet) {
 326             assertThat(event.getPrevState()).isEqualTo(PREV_RESOURCE_STATE);
 327             assertThat(event.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION);
 328             assertThat(event.getPrevArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 329         }
 330         else {
 331             assertThat(event.getPrevState()).isNull();
 332             assertThat(event.getPrevVersion()).isNull();
 333             assertThat(event.getPrevArtifactUUID()).isNull();
 334         }
 335         if (isCurrFieldsProvided) {
 336             assertThat(event.getCurrArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 337         }
 338         else {
 339             assertThat(event.getCurrArtifactUUID()).isNull();
 340         }
 341         if (isArtDataProvided) {
 342             assertThat(event.getArtifactData()).isEqualTo(ARTIFACT_DATA);
 343         }
 344         else {
 345             assertThat(event.getArtifactData()).isEmpty();
 346         }
 347         if (isDidProvided) {
 348             assertThat(event.getDid()).isEqualTo(DIST_ID);
 349         }
 350         else {
 351             assertThat(event.getDid()).isNull();
 352         }
 353         if (isCommentProvided) {
 354             assertThat(event.getComment()).isEqualTo(COMMENT);
 355         }
 356         else {
 357             assertThat(event.getComment()).isEmpty();
 358         }
 359         if (isDistStatusProvided) {
 360             assertThat(event.getDcurrStatus()).isEqualTo(DCURR_STATUS);
 361             assertThat(event.getDprevStatus()).isEqualTo(DPREV_STATUS);
 362         }
 363         else {
 364             assertThat(event.getDcurrStatus()).isNull();
 365             assertThat(event.getDprevStatus()).isNull();
 366         }
 367     }
 368
 369     @Test
 370     public void auditChangeLifeCycleExternalApiEventWhenComponentAndResponseObjectAreNull() {
 371         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 372         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 373
 374         utils.auditChangeLifecycleAction(responseFormat, ComponentTypeEnum.RESOURCE, REQUEST_ID,
 375                 null, null, new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL), modifier);
 376
 377         verify(manager).auditEvent(factoryCaptor.capture());
 378         AuditChangeLifecycleExternalApiEventFactory factory = (AuditChangeLifecycleExternalApiEventFactory)factoryCaptor.getValue();
 379
 380         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 381         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 382         verifyCommonDataForExternalApiEvent(event, false);
 383         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 384         verifyCurrentResourceVersionInfoForExternalApiEvent(event, true);
 385         verifyDistributionDataForExternalApiEvent(event);
 386         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 387         assertThat(event.getInvariantUuid()).isEmpty();
 388         assertThat(event.getResourceName()).isNull();
 389         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 390     }
 391
 392     @Test
 393     public void auditChangeLifeCycleExternalApiEventWhenComponentIsNullAndResponseObjectIsNotNull() {
 394         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 395         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 396         Component responseObject = new Resource();
 397         responseObject.setVersion(CURRENT_VERSION);
 398         responseObject.setState(LifecycleStateEnum.CERTIFIED);
 399         responseObject.setInvariantUUID(INVARIANT_UUID);
 400         responseObject.setUUID(SERVICE_INSTANCE_ID);
 401
 402         utils.auditChangeLifecycleAction(responseFormat, ComponentTypeEnum.RESOURCE, REQUEST_ID,
 403                 null, responseObject, new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL), modifier);
 404
 405         verify(manager).auditEvent(factoryCaptor.capture());
 406         AuditChangeLifecycleExternalApiEventFactory factory = (AuditChangeLifecycleExternalApiEventFactory)factoryCaptor.getValue();
 407
 408         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 409         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 410         verifyCommonDataForExternalApiEvent(event, true);
 411         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 412         verifyCurrentResourceVersionInfoForExternalApiEvent(event, false);
 413         verifyDistributionDataForExternalApiEvent(event);
 414         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 415         assertThat(event.getInvariantUuid()).isEqualTo(INVARIANT_UUID);
 416         assertThat(event.getResourceName()).isNull();
 417         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 418     }
 419
 420     @Test
 421     public void auditChangeLifeCycleExternalApiEventWhenComponentIsNotNullAndResponseObjectIsNull() {
 422         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 423         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 424         Component component = new Resource();
 425         component.setVersion(PREV_RESOURCE_VERSION);
 426         component.setState(LifecycleStateEnum.READY_FOR_CERTIFICATION);
 427         component.setInvariantUUID(INVARIANT_UUID);
 428         component.setName(RESOURCE_NAME);
 429
 430         utils.auditChangeLifecycleAction(responseFormat, ComponentTypeEnum.RESOURCE, REQUEST_ID,
 431                 component, null, new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL), modifier);
 432
 433         verify(manager).auditEvent(factoryCaptor.capture());
 434         AuditChangeLifecycleExternalApiEventFactory factory = (AuditChangeLifecycleExternalApiEventFactory)factoryCaptor.getValue();
 435
 436         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 437         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 438
 439         verifyCommonDataForExternalApiEvent(event, false);
 440         verifyPreviousResourceVersionInfoForExternalApiEvent(event, false);
 441         verifyDistributionDataForExternalApiEvent(event);
 442         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 443         assertThat(event.getInvariantUuid()).isEqualTo(INVARIANT_UUID);
 444         assertThat(event.getResourceName()).isEqualTo(RESOURCE_NAME);
 445         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 446     }
 447
 448     @Test
 449     public void auditChangeLifeCycleExternalApiEventWhenComponentAndResponseObjectAreNotNull() {
 450         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 451         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 452         Component responseObject = new Resource();
 453         responseObject.setVersion(CURRENT_VERSION);
 454         responseObject.setState(LifecycleStateEnum.CERTIFIED);
 455         responseObject.setInvariantUUID(INVARIANT_UUID);
 456         responseObject.setUUID(SERVICE_INSTANCE_ID);
 457
 458         Component component = new Resource();
 459         component.setVersion(PREV_RESOURCE_VERSION);
 460         component.setState(LifecycleStateEnum.READY_FOR_CERTIFICATION);
 461         component.setInvariantUUID(INVARIANT_UUID);
 462         component.setUUID(SERVICE_INSTANCE_ID);
 463         component.setName(RESOURCE_NAME);
 464
 465         utils.auditChangeLifecycleAction(responseFormat, ComponentTypeEnum.RESOURCE, REQUEST_ID,
 466                 null, responseObject, new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL), modifier);
 467
 468         verify(manager).auditEvent(factoryCaptor.capture());
 469         AuditChangeLifecycleExternalApiEventFactory factory = (AuditChangeLifecycleExternalApiEventFactory)factoryCaptor.getValue();
 470
 471         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 472         assertThat(event.getAction()).isEqualTo(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 473         verifyCommonDataForExternalApiEvent(event, true);
 474         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 475         verifyCurrentResourceVersionInfoForExternalApiEvent(event, false);
 476         verifyDistributionDataForExternalApiEvent(event);
 477         assertThat(event.getModifier()).isEqualTo(MODIFIER_UID);
 478         assertThat(event.getInvariantUuid()).isEqualTo(INVARIANT_UUID);
 479         assertThat(event.getResourceName()).isNull();
 480         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 481
 482     }
 483
 484     private void verifyDistributionDataForExternalApiEvent(ExternalApiEvent event) {
 485         assertThat(event.getConsumerId()).isEqualTo(DIST_CONSUMER_ID);
 486         assertThat(event.getResourceURL()).isEqualTo(DIST_RESOURCE_URL);
 487     }
 488
 489     private void verifyDistributionDataNotSetForExternalApiEvent(ExternalApiEvent event) {
 490         assertThat(event.getConsumerId()).isNull();
 491         assertThat(event.getResourceURL()).isNull();
 492     }
 493
 494     private void verifyCommonDataForExternalApiEvent(ExternalApiEvent event, boolean isSucceeded) {
 495         if (isSucceeded) {
 496             assertThat(event.getDesc()).isEqualTo(DESCRIPTION);
 497             assertThat(event.getStatus()).isEqualTo(STATUS_OK);
 498             assertThat(event.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID);
 499         }
 500         else {
 501             assertThat(event.getDesc()).isEqualTo(DESC_ERROR);
 502             assertThat(event.getStatus()).isEqualTo(STATUS_500);
 503             assertThat(event.getServiceInstanceId()).isNullOrEmpty();
 504         }
 505         assertThat(event.getRequestId()).isEqualTo(REQUEST_ID);
 506     }
 507
 508     private void verifyCurrentResourceVersionInfoForExternalApiEvent(ExternalApiEvent event, boolean isNull) {
 509         assertThat(event.getCurrArtifactUuid()).isNull();
 510         if (isNull) {
 511             assertThat(event.getCurrState()).isNull();
 512             assertThat(event.getCurrVersion()).isNull();
 513         }
 514         else {
 515             assertThat(event.getCurrState()).isEqualTo(LifecycleStateEnum.CERTIFIED.name());
 516             assertThat(event.getCurrVersion()).isEqualTo(CURRENT_VERSION);
 517         }
 518     }
 519
 520     private void verifyPreviousResourceVersionInfoForExternalApiEvent(ExternalApiEvent event, boolean isNull) {
 521         assertThat(event.getPrevArtifactUuid()).isNull();
 522         if (isNull) {
 523             assertThat(event.getPrevState()).isNull();
 524             assertThat(event.getPrevVersion()).isNull();
 525         }
 526         else {
 527             assertThat(event.getPrevState()).isEqualTo(LifecycleStateEnum.READY_FOR_CERTIFICATION.name());
 528             assertThat(event.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION);
 529         }
 530     }
 531
 532     @Test
 533     public void auditExternalCreateResourceEventWhenResourceObjectIsNull() {
 534         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 535         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 536
 537         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn(USER_ID);
 538         when(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER)).thenReturn(DIST_CONSUMER_ID);
 539         when(request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER)).thenReturn(REQUEST_ID);
 540         when(request.getRequestURI()).thenReturn(DIST_RESOURCE_URL);
 541
 542         utils.auditCreateResourceExternalApi(responseFormat, new ResourceCommonInfo(RESOURCE_NAME, ComponentTypeEnum.RESOURCE.getValue()),
 543                                 request, null);
 544
 545         verify(manager).auditEvent(factoryCaptor.capture());
 546         AuditCreateResourceExternalApiEventFactory factory = (AuditCreateResourceExternalApiEventFactory)factoryCaptor.getValue();
 547
 548         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 549         verifyCommonDataForExternalApiEvent(event, false);
 550         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 551         verifyCurrentResourceVersionInfoForExternalApiEvent(event, true);
 552         verifyDistributionDataForExternalApiEvent(event);
 553         assertThat(event.getModifier()).isEqualTo("(" + USER_ID + ")");
 554         assertThat(event.getInvariantUuid()).isNull();
 555         assertThat(event.getResourceName()).isEqualTo(RESOURCE_NAME);
 556         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 557     }
 558
 559     @Test
 560     public void auditExternalCreateResourceEventWhenResourceObjectIsNullAndRequestDataIsNotProvided() {
 561         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_500));
 562         when(responseFormat.getFormattedMessage()).thenReturn(DESC_ERROR);
 563
 564         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn(null);
 565         when(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER)).thenReturn(null);
 566         when(request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER)).thenReturn(REQUEST_ID);
 567         when(request.getRequestURI()).thenReturn(null);
 568
 569         utils.auditCreateResourceExternalApi(responseFormat, new ResourceCommonInfo(ComponentTypeEnum.RESOURCE.getValue()),
 570                 request, null);
 571
 572         verify(manager).auditEvent(factoryCaptor.capture());
 573         AuditCreateResourceExternalApiEventFactory factory = (AuditCreateResourceExternalApiEventFactory)factoryCaptor.getValue();
 574
 575         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 576         verifyCommonDataForExternalApiEvent(event, false);
 577         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 578         verifyCurrentResourceVersionInfoForExternalApiEvent(event, true);
 579         verifyDistributionDataNotSetForExternalApiEvent(event);
 580         assertThat(event.getModifier()).isEmpty();
 581         assertThat(event.getInvariantUuid()).isNull();
 582         assertThat(event.getResourceName()).isNull();
 583         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 584     }
 585
 586     @Test
 587     public void auditExternalCreateResourceEventWhenResourceObjectAndRequestDataProvided() {
 588         when(responseFormat.getStatus()).thenReturn(Integer.valueOf(STATUS_OK));
 589         when(responseFormat.getFormattedMessage()).thenReturn(DESCRIPTION);
 590
 591         when(request.getHeader(Constants.USER_ID_HEADER)).thenReturn(USER_ID);
 592         when(request.getHeader(Constants.X_ECOMP_INSTANCE_ID_HEADER)).thenReturn(DIST_CONSUMER_ID);
 593         when(request.getHeader(Constants.X_ECOMP_REQUEST_ID_HEADER)).thenReturn(REQUEST_ID);
 594         when(request.getRequestURI()).thenReturn(DIST_RESOURCE_URL);
 595
 596         Resource resource = new Resource();
 597         resource.setName(RESOURCE_NAME);
 598         resource.setInvariantUUID(INVARIANT_UUID);
 599         resource.setUUID(SERVICE_INSTANCE_ID);
 600
 601         utils.auditCreateResourceExternalApi(responseFormat, new ResourceCommonInfo(ComponentTypeEnum.RESOURCE.getValue()),
 602                 request, resource);
 603
 604         verify(manager).auditEvent(factoryCaptor.capture());
 605         AuditCreateResourceExternalApiEventFactory factory = (AuditCreateResourceExternalApiEventFactory)factoryCaptor.getValue();
 606
 607         ExternalApiEvent event = (ExternalApiEvent)factory.getDbEvent();
 608         verifyCommonDataForExternalApiEvent(event, true);
 609         verifyPreviousResourceVersionInfoForExternalApiEvent(event, true);
 610         verifyDistributionDataForExternalApiEvent(event);
 611         assertThat(event.getCurrArtifactUuid()).isNull();
 612         assertThat(event.getCurrState()).isEqualTo(LifecycleStateEnum.NOT_CERTIFIED_CHECKOUT.name());
 613         assertThat(event.getCurrVersion()).isEqualTo(ImportUtils.Constants.FIRST_NON_CERTIFIED_VERSION);
 614         assertThat(event.getModifier()).isEqualTo("(" + USER_ID + ")");
 615         assertThat(event.getInvariantUuid()).isEqualTo(INVARIANT_UUID);
 616         assertThat(event.getResourceName()).isEqualTo(RESOURCE_NAME);
 617         assertThat(event.getResourceType()).isEqualTo(ComponentTypeEnum.RESOURCE.getValue());
 618     }
 619
 620     @Test
 621     public void checkIfAuditEventIsExternal() {
 622         assertThat(utils.isExternalApiEvent(AuditingActionEnum.ARTIFACT_UPLOAD_BY_API)).isTrue();
 623         assertThat(utils.isExternalApiEvent(AuditingActionEnum.ARTIFACT_UPLOAD)).isFalse();
 624     }
 625
 626 }