catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/resourceadmin/AuditResourceAdminEventFuncTest.java

   1 package org.openecomp.sdc.be.auditing.impl.resourceadmin;
   2
   3 import org.junit.Before;
   4 import org.junit.Test;
   5 import org.junit.runner.RunWith;
   6 import org.mockito.ArgumentCaptor;
   7 import org.mockito.Captor;
   8 import org.mockito.Mock;
   9 import org.mockito.junit.MockitoJUnitRunner;
  10 import org.openecomp.sdc.be.auditing.api.AuditEventFactory;
  11 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  12 import org.openecomp.sdc.be.config.Configuration;
  13 import org.openecomp.sdc.be.dao.api.ActionStatus;
  14 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  15 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  16 import org.openecomp.sdc.be.dao.impl.AuditingDao;
  17 import org.openecomp.sdc.be.model.LifecycleStateEnum;
  18 import org.openecomp.sdc.be.model.Resource;
  19 import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
  20 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
  21 import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent;
  22 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
  23 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceCommonInfo;
  24 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceVersionInfo;
  25 import org.openecomp.sdc.common.api.Constants;
  26 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  27
  28 import static org.assertj.core.api.Assertions.assertThat;
  29 import static org.mockito.ArgumentMatchers.any;
  30 import static org.mockito.ArgumentMatchers.eq;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.when;
  33 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.*;
  34
  35 @RunWith(MockitoJUnitRunner.class)
  36 public class AuditResourceAdminEventFuncTest {
  37     private AuditingManager auditingManager;
  38
  39     @Mock
  40     private static AuditCassandraDao cassandraDao;
  41     @Mock
  42     private static AuditingDao auditingDao;
  43     @Mock
  44     private static Configuration.ElasticSearchConfig esConfig;
  45
  46     @Captor
  47     private ArgumentCaptor<ResourceAdminEvent> eventCaptor;
  48
  49     @Before
  50     public void setUp() {
  51         init(esConfig);
  52         auditingManager = new AuditingManager(auditingDao, cassandraDao);
  53         ThreadLocalsHolder.setUuid(REQUEST_ID);
  54     }
  55
  56     @Test
  57     public void testCheckInResourceAdminEvent() {
  58        Resource resource = new Resource();
  59         resource.setName(RESOURCE_NAME);
  60         resource.setUUID(SERVICE_INSTANCE_ID);
  61         resource.setInvariantUUID(INVARIANT_UUID);
  62         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
  63         resource.setVersion(CURRENT_VERSION);
  64
  65         AuditEventFactory factory = new AuditCertificationResourceAdminEventFactory(
  66                 AuditingActionEnum.CHECKIN_RESOURCE,
  67                 CommonAuditData.newBuilder()
  68                         .description(DESCRIPTION)
  69                         .status(STATUS_OK)
  70                         .requestId(REQUEST_ID)
  71                         .serviceInstanceId(SERVICE_INSTANCE_ID)
  72                         .build(),
  73                 new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
  74                 ResourceVersionInfo.newBuilder()
  75                         .artifactUuid(ARTIFACT_UUID)
  76                         .state(PREV_RESOURCE_STATE)
  77                         .version(PREV_RESOURCE_VERSION)
  78                         .distributionStatus(DPREV_STATUS)
  79                         .build(),
  80                 ResourceVersionInfo.newBuilder()
  81                         .artifactUuid(ARTIFACT_UUID)
  82                         .state(CURRENT_STATE)
  83                         .version(CURRENT_VERSION)
  84                         .distributionStatus(DCURR_STATUS)
  85                         .build(),
  86                 INVARIANT_UUID, modifier,
  87                 ARTIFACT_DATA, COMMENT, DIST_ID);
  88
  89         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CHECKIN_RESOURCE.getAuditingEsType())))
  90                 .thenReturn(ActionStatus.OK);
  91         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
  92
  93         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CHECK_IN_RESOURCE_LOG_STR);
  94         verifyResourceAdminEvent(AuditingActionEnum.CHECKIN_RESOURCE.getName());
  95     }
  96
  97     @Test
  98     public void testCreateResourceAdminEvent() {
  99
 100       AuditEventFactory factory = new AuditCreateUpdateResourceAdminEventFactory(
 101              AuditingActionEnum.CREATE_RESOURCE,
 102              CommonAuditData.newBuilder()
 103                      .description(DESCRIPTION)
 104                      .status(STATUS_OK)
 105                      .requestId(REQUEST_ID)
 106                      .serviceInstanceId(SERVICE_INSTANCE_ID)
 107                      .build(),
 108               new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
 109               ResourceVersionInfo.newBuilder()
 110                       .artifactUuid(ARTIFACT_UUID)
 111                       .state(PREV_RESOURCE_STATE)
 112                       .version(PREV_RESOURCE_VERSION)
 113                       .distributionStatus(DPREV_STATUS)
 114                       .build(),
 115               ResourceVersionInfo.newBuilder()
 116                       .artifactUuid(ARTIFACT_UUID)
 117                       .state(CURRENT_STATE)
 118                       .version(CURRENT_VERSION)
 119                       .distributionStatus(DCURR_STATUS)
 120                       .build(),
 121              INVARIANT_UUID, modifier,
 122              ARTIFACT_DATA, COMMENT, DIST_ID, Constants.EMPTY_STRING);
 123
 124         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CREATE_RESOURCE.getAuditingEsType())))
 125                 .thenReturn(ActionStatus.OK);
 126         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 127
 128         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CREATE_RESOURCE_LOG_STR);
 129         verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName());
 130     }
 131
 132     @Test
 133     public void testImportResourceAdminEvent() {
 134
 135         Resource resource = new Resource();
 136         resource.setName(RESOURCE_NAME);
 137         resource.setVersion(CURRENT_VERSION);
 138         resource.setInvariantUUID(INVARIANT_UUID);
 139         resource.setUUID(SERVICE_INSTANCE_ID);
 140         resource.setState(LifecycleStateEnum.CERTIFIED);
 141         resource.setToscaType(TOSCA_NODE_TYPE);
 142
 143         AuditEventFactory factory = new AuditImportResourceAdminEventFactory(
 144                 CommonAuditData.newBuilder()
 145                         .description(DESCRIPTION)
 146                         .status(STATUS_OK)
 147                         .requestId(REQUEST_ID)
 148                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 149                         .build(),
 150                 new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
 151                 ResourceVersionInfo.newBuilder()
 152                         .artifactUuid(ARTIFACT_UUID)
 153                         .state(PREV_RESOURCE_STATE)
 154                         .version(PREV_RESOURCE_VERSION)
 155                         .distributionStatus(DPREV_STATUS)
 156                         .build(),
 157                 ResourceVersionInfo.newBuilder()
 158                         .artifactUuid(ARTIFACT_UUID)
 159                         .state(CURRENT_STATE)
 160                         .version(CURRENT_VERSION)
 161                         .distributionStatus(DCURR_STATUS)
 162                         .build(),
 163                 INVARIANT_UUID, modifier,
 164                 ARTIFACT_DATA, COMMENT, DIST_ID, TOSCA_NODE_TYPE);
 165
 166         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType())))
 167                 .thenReturn(ActionStatus.OK);
 168         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 169
 170         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_IMPORT_RESOURCE_LOG_STR);
 171         verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName());
 172     }
 173
 174     @Test
 175     public void testArtifactUploadResourceAdminEvent() {
 176
 177         AuditEventFactory factory = new AuditArtifactResourceAdminEventFactory(
 178                 AuditingActionEnum.ARTIFACT_UPLOAD,
 179                 CommonAuditData.newBuilder()
 180                         .description(DESCRIPTION)
 181                         .status(STATUS_OK)
 182                         .requestId(REQUEST_ID)
 183                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 184                         .build(),
 185                 new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
 186                 ResourceVersionInfo.newBuilder()
 187                         .artifactUuid(ARTIFACT_UUID)
 188                         .state(PREV_RESOURCE_STATE)
 189                         .version(PREV_RESOURCE_VERSION)
 190                         .distributionStatus(DPREV_STATUS)
 191                         .build(),
 192                 ResourceVersionInfo.newBuilder()
 193                         .artifactUuid(ARTIFACT_UUID)
 194                         .state(CURRENT_STATE)
 195                         .version(CURRENT_VERSION)
 196                         .distributionStatus(DCURR_STATUS)
 197                         .build(),
 198                 INVARIANT_UUID, modifier,
 199                 ARTIFACT_DATA, COMMENT, DIST_ID);
 200
 201         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ARTIFACT_UPLOAD.getAuditingEsType())))
 202                 .thenReturn(ActionStatus.OK);
 203         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 204
 205         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ARTIFACT_UPLOAD_LOG_STR);
 206         verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_UPLOAD.getName());
 207     }
 208
 209     @Test
 210     public void testDistStateChangeRequestResourceAdminEvent() {
 211
 212         AuditEventFactory factory = new AuditDistStateChangeRequestResourceAdminEventFactory(
 213                 CommonAuditData.newBuilder()
 214                         .description(DESCRIPTION)
 215                         .status(STATUS_OK)
 216                         .requestId(REQUEST_ID)
 217                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 218                         .build(),
 219                 new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
 220                 ResourceVersionInfo.newBuilder()
 221                         .artifactUuid(ARTIFACT_UUID)
 222                         .state(PREV_RESOURCE_STATE)
 223                         .version(PREV_RESOURCE_VERSION)
 224                         .distributionStatus(DPREV_STATUS)
 225                         .build(),
 226                 ResourceVersionInfo.newBuilder()
 227                         .artifactUuid(ARTIFACT_UUID)
 228                         .state(CURRENT_STATE)
 229                         .version(CURRENT_VERSION)
 230                         .distributionStatus(DCURR_STATUS)
 231                         .build(),
 232                 INVARIANT_UUID, modifier,
 233                 ARTIFACT_DATA, COMMENT, DIST_ID);
 234
 235         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType())))
 236                 .thenReturn(ActionStatus.OK);
 237         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 238
 239         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_REQUEST);
 240         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
 241     }
 242
 243     @Test
 244     public void testDistStateChangeApprovResourceAdminEvent() {
 245
 246         AuditEventFactory factory = new AuditDistStateChangeResourceAdminEventFactory(
 247                 AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV,
 248                 CommonAuditData.newBuilder()
 249                         .description(DESCRIPTION)
 250                         .status(STATUS_OK)
 251                         .requestId(REQUEST_ID)
 252                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 253                         .build(),
 254                 new ResourceCommonInfo(RESOURCE_NAME, RESOURCE_TYPE_VFC),
 255                  ResourceVersionInfo.newBuilder()
 256                         .artifactUuid(ARTIFACT_UUID)
 257                         .state(PREV_RESOURCE_STATE)
 258                         .version(PREV_RESOURCE_VERSION)
 259                         .distributionStatus(DPREV_STATUS)
 260                         .build(),
 261                 ResourceVersionInfo.newBuilder()
 262                         .artifactUuid(ARTIFACT_UUID)
 263                         .state(CURRENT_STATE)
 264                         .version(CURRENT_VERSION)
 265                         .distributionStatus(DCURR_STATUS)
 266                         .build(),
 267                 INVARIANT_UUID, modifier,
 268                 ARTIFACT_DATA, COMMENT, DIST_ID);
 269
 270         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType())))
 271                 .thenReturn(ActionStatus.OK);
 272         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 273
 274         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_APPROV);
 275         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName());
 276     }
 277
 278     private void verifyResourceAdminEvent(String action) {
 279         verify(cassandraDao).saveRecord(eventCaptor.capture());
 280         ResourceAdminEvent storedEvent = eventCaptor.getValue();
 281         assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID);
 282         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 283         assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID);
 284         assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID);
 285         assertThat(storedEvent.getAction()).isEqualTo(action);
 286         assertThat(storedEvent.getArtifactData()).isEqualTo(ARTIFACT_DATA);
 287         assertThat(storedEvent.getComment()).isEqualTo(COMMENT);
 288         assertThat(storedEvent.getCurrArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 289         assertThat(storedEvent.getPrevArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 290         assertThat(storedEvent.getPrevState()).isEqualTo(PREV_RESOURCE_STATE);
 291         assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE);
 292         assertThat(storedEvent.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION);
 293         assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION);
 294         assertThat(storedEvent.getDcurrStatus()).isEqualTo(DCURR_STATUS);
 295         assertThat(storedEvent.getDprevStatus()).isEqualTo(DPREV_STATUS);
 296         assertThat(storedEvent.getDid()).isEqualTo(DIST_ID);
 297         assertThat(storedEvent.getInvariantUUID()).isEqualTo(INVARIANT_UUID);
 298         assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME);
 299         assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE_VFC);
 300
 301         if (action.equals(AuditingActionEnum.IMPORT_RESOURCE.getName())) {
 302             assertThat(storedEvent.getToscaNodeType()).isEqualTo(TOSCA_NODE_TYPE);
 303         } else {
 304             assertThat(storedEvent.getToscaNodeType()).isEmpty();
 305         }
 306     }
 307 }