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

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