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.ResourceAuditData;
  24 import org.openecomp.sdc.common.api.ConfigurationSource;
  25 import org.openecomp.sdc.common.api.Constants;
  26 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  27 import org.openecomp.sdc.common.util.ThreadLocalsHolder;
  28
  29 import java.util.EnumMap;
  30
  31 import static org.assertj.core.api.Assertions.assertThat;
  32 import static org.mockito.ArgumentMatchers.any;
  33 import static org.mockito.ArgumentMatchers.anyMap;
  34 import static org.mockito.ArgumentMatchers.eq;
  35 import static org.mockito.Mockito.verify;
  36 import static org.mockito.Mockito.when;
  37 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_DATA;
  38 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_UUID;
  39 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.COMMENT;
  40 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_STATE;
  41 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_VERSION;
  42 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DCURR_STATUS;
  43 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION;
  44 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_ID;
  45 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DPREV_STATUS;
  46 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ARTIFACT_UPLOAD_LOG_STR;
  47 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CHECK_IN_RESOURCE_LOG_STR;
  48 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CREATE_RESOURCE_LOG_STR;
  49 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_STATE_CHANGE_APPROV;
  50 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_STATE_CHANGE_REQUEST;
  51 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_IMPORT_RESOURCE_LOG_STR;
  52 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.INVARIANT_UUID;
  53 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID;
  54 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_STATE;
  55 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_VERSION;
  56 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID;
  57 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_NAME;
  58 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE_VFC;
  59 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID;
  60 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK;
  61 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TOSCA_NODE_TYPE;
  62 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init;
  63 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier;
  64
  65 @RunWith(MockitoJUnitRunner.class)
  66 public class AuditResourceAdminEventFuncTest {
  67     private AuditingManager auditingManager;
  68
  69     @Mock
  70     private static AuditCassandraDao cassandraDao;
  71     @Mock
  72     private static ConfigurationSource configurationSource;
  73     @Mock
  74     private static AuditingDao auditingDao;
  75     @Mock
  76     private static Configuration.ElasticSearchConfig esConfig;
  77
  78     @Captor
  79     private ArgumentCaptor<AuditingGenericEvent> eventCaptor;
  80
  81     @Before
  82     public void setUp() {
  83         init(esConfig);
  84         auditingManager = new AuditingManager(auditingDao, cassandraDao);
  85         ThreadLocalsHolder.setUuid(REQUEST_ID);
  86     }
  87
  88     @Test
  89     public void testNewCheckInResourceAdminEvent() {
  90        Resource resource = new Resource();
  91         resource.setName(RESOURCE_NAME);
  92         resource.setUUID(SERVICE_INSTANCE_ID);
  93         resource.setInvariantUUID(INVARIANT_UUID);
  94         resource.setLifecycleState(LifecycleStateEnum.CERTIFIED);
  95         resource.setVersion(CURRENT_VERSION);
  96
  97         AuditEventFactory factory = new AuditCertificationResourceAdminEventFactory(
  98                 AuditingActionEnum.CHECKIN_RESOURCE,
  99                 CommonAuditData.newBuilder()
 100                         .description(DESCRIPTION)
 101                         .status(STATUS_OK)
 102                         .requestId(REQUEST_ID)
 103                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 104                         .build(),
 105                 ResourceAuditData.newBuilder()
 106                         .artifactUuid(ARTIFACT_UUID)
 107                         .state(PREV_RESOURCE_STATE)
 108                         .version(PREV_RESOURCE_VERSION)
 109                         .distributionStatus(DPREV_STATUS)
 110                         .build(),
 111                 ResourceAuditData.newBuilder()
 112                         .artifactUuid(ARTIFACT_UUID)
 113                         .state(CURRENT_STATE)
 114                         .version(CURRENT_VERSION)
 115                         .distributionStatus(DCURR_STATUS)
 116                         .build(),
 117                 RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 118                 ARTIFACT_DATA, COMMENT, DIST_ID);
 119
 120         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CHECKIN_RESOURCE.getAuditingEsType())))
 121                 .thenReturn(ActionStatus.OK);
 122         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 123
 124         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CHECK_IN_RESOURCE_LOG_STR);
 125         verifyResourceAdminEvent(AuditingActionEnum.CHECKIN_RESOURCE.getName());
 126     }
 127
 128     @Test
 129     public void testOldCheckInResourceAdminEvent() {
 130         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CHECKIN_RESOURCE.getAuditingEsType())))
 131                 .thenReturn(ActionStatus.OK);
 132         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 133
 134         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CHECKIN_RESOURCE))).isEqualTo(EXPECTED_CHECK_IN_RESOURCE_LOG_STR + " ");
 135         verifyResourceAdminEvent(AuditingActionEnum.CHECKIN_RESOURCE.getName());
 136
 137     }
 138
 139     private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) {
 140         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class);
 141         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName());
 142         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
 143         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
 144         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK);
 145         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION);
 146
 147         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE_VFC);
 148         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, PREV_RESOURCE_VERSION);
 149         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, PREV_RESOURCE_STATE);
 150         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME);
 151         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION);
 152         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, CURRENT_STATE);
 153         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID);
 154         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, INVARIANT_UUID);
 155         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, ARTIFACT_DATA);
 156         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, ARTIFACT_UUID);
 157         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, ARTIFACT_UUID);
 158         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, DIST_ID);
 159         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, COMMENT);
 160         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, DCURR_STATUS);
 161         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, DPREV_STATUS);
 162
 163         if (action == AuditingActionEnum.IMPORT_RESOURCE) {
 164             auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, TOSCA_NODE_TYPE);
 165         }
 166         else {
 167             auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, Constants.EMPTY_STRING);
 168         }
 169
 170         return auditingFields;
 171     }
 172
 173     @Test
 174     public void testNewCreateResourceAdminEvent() {
 175
 176       AuditEventFactory factory = new AuditCreateUpdateResourceAdminEventFactory(
 177              AuditingActionEnum.CREATE_RESOURCE,
 178              CommonAuditData.newBuilder()
 179                      .description(DESCRIPTION)
 180                      .status(STATUS_OK)
 181                      .requestId(REQUEST_ID)
 182                      .serviceInstanceId(SERVICE_INSTANCE_ID)
 183                      .build(),
 184               ResourceAuditData.newBuilder()
 185                       .artifactUuid(ARTIFACT_UUID)
 186                       .state(PREV_RESOURCE_STATE)
 187                       .version(PREV_RESOURCE_VERSION)
 188                       .distributionStatus(DPREV_STATUS)
 189                       .build(),
 190               ResourceAuditData.newBuilder()
 191                       .artifactUuid(ARTIFACT_UUID)
 192                       .state(CURRENT_STATE)
 193                       .version(CURRENT_VERSION)
 194                       .distributionStatus(DCURR_STATUS)
 195                       .build(),
 196              RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 197              ARTIFACT_DATA, COMMENT, DIST_ID, Constants.EMPTY_STRING);
 198
 199         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CREATE_RESOURCE.getAuditingEsType())))
 200                 .thenReturn(ActionStatus.OK);
 201         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 202
 203         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CREATE_RESOURCE_LOG_STR);
 204         verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName());
 205     }
 206
 207     @Test
 208     public void testOldCreateResourceAdminEvent() {
 209         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CREATE_RESOURCE.getAuditingEsType())))
 210                 .thenReturn(ActionStatus.OK);
 211         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 212
 213         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CREATE_RESOURCE))).isEqualTo(EXPECTED_CREATE_RESOURCE_LOG_STR + " ");
 214         verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName());
 215
 216     }
 217
 218     @Test
 219     public void testNewImportResourceAdminEvent() {
 220
 221         Resource resource = new Resource();
 222         resource.setName(RESOURCE_NAME);
 223         resource.setVersion(CURRENT_VERSION);
 224         resource.setInvariantUUID(INVARIANT_UUID);
 225         resource.setUUID(SERVICE_INSTANCE_ID);
 226         resource.setState(LifecycleStateEnum.CERTIFIED);
 227         resource.setToscaType(TOSCA_NODE_TYPE);
 228
 229         AuditEventFactory factory = new AuditImportResourceAdminEventFactory(
 230                 CommonAuditData.newBuilder()
 231                         .description(DESCRIPTION)
 232                         .status(STATUS_OK)
 233                         .requestId(REQUEST_ID)
 234                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 235                         .build(),
 236                 ResourceAuditData.newBuilder()
 237                         .artifactUuid(ARTIFACT_UUID)
 238                         .state(PREV_RESOURCE_STATE)
 239                         .version(PREV_RESOURCE_VERSION)
 240                         .distributionStatus(DPREV_STATUS)
 241                         .build(),
 242                 ResourceAuditData.newBuilder()
 243                         .artifactUuid(ARTIFACT_UUID)
 244                         .state(CURRENT_STATE)
 245                         .version(CURRENT_VERSION)
 246                         .distributionStatus(DCURR_STATUS)
 247                         .build(),
 248                 RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 249                 ARTIFACT_DATA, COMMENT, DIST_ID, TOSCA_NODE_TYPE);
 250
 251         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType())))
 252                 .thenReturn(ActionStatus.OK);
 253         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 254
 255         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_IMPORT_RESOURCE_LOG_STR);
 256         verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName());
 257     }
 258
 259     @Test
 260     public void testOldImportResourceAdminEvent() {
 261         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType())))
 262                 .thenReturn(ActionStatus.OK);
 263         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 264
 265         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.IMPORT_RESOURCE))).isEqualTo(EXPECTED_IMPORT_RESOURCE_LOG_STR + " ");
 266         verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName());
 267
 268     }
 269
 270     @Test
 271     public void testNewArtifactUploadResourceAdminEvent() {
 272
 273         AuditEventFactory factory = new AuditArtifactResourceAdminEventFactory(
 274                 AuditingActionEnum.ARTIFACT_UPLOAD,
 275                 CommonAuditData.newBuilder()
 276                         .description(DESCRIPTION)
 277                         .status(STATUS_OK)
 278                         .requestId(REQUEST_ID)
 279                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 280                         .build(),
 281                 ResourceAuditData.newBuilder()
 282                         .artifactUuid(ARTIFACT_UUID)
 283                         .state(PREV_RESOURCE_STATE)
 284                         .version(PREV_RESOURCE_VERSION)
 285                         .distributionStatus(DPREV_STATUS)
 286                         .build(),
 287                 ResourceAuditData.newBuilder()
 288                         .artifactUuid(ARTIFACT_UUID)
 289                         .state(CURRENT_STATE)
 290                         .version(CURRENT_VERSION)
 291                         .distributionStatus(DCURR_STATUS)
 292                         .build(),
 293                 RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 294                 ARTIFACT_DATA, COMMENT, DIST_ID);
 295
 296         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ARTIFACT_UPLOAD.getAuditingEsType())))
 297                 .thenReturn(ActionStatus.OK);
 298         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 299
 300         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ARTIFACT_UPLOAD_LOG_STR);
 301         verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_UPLOAD.getName());
 302     }
 303
 304     @Test
 305     public void testOldArtifactUploadResourceAdminEvent() {
 306         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType())))
 307                 .thenReturn(ActionStatus.OK);
 308         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 309
 310         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ARTIFACT_UPLOAD))).isEqualTo(EXPECTED_ARTIFACT_UPLOAD_LOG_STR + " ");
 311         verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_UPLOAD.getName());
 312
 313     }
 314
 315     @Test
 316     public void testNewDistStateChangeRequestResourceAdminEvent() {
 317
 318         AuditEventFactory factory = new AuditDistStateChangeRequestResourceAdminEventFactory(
 319                 CommonAuditData.newBuilder()
 320                         .description(DESCRIPTION)
 321                         .status(STATUS_OK)
 322                         .requestId(REQUEST_ID)
 323                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 324                         .build(),
 325                 ResourceAuditData.newBuilder()
 326                         .artifactUuid(ARTIFACT_UUID)
 327                         .state(PREV_RESOURCE_STATE)
 328                         .version(PREV_RESOURCE_VERSION)
 329                         .distributionStatus(DPREV_STATUS)
 330                         .build(),
 331                 ResourceAuditData.newBuilder()
 332                         .artifactUuid(ARTIFACT_UUID)
 333                         .state(CURRENT_STATE)
 334                         .version(CURRENT_VERSION)
 335                         .distributionStatus(DCURR_STATUS)
 336                         .build(),
 337                 RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 338                 ARTIFACT_DATA, COMMENT, DIST_ID);
 339
 340         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType())))
 341                 .thenReturn(ActionStatus.OK);
 342         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 343
 344         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_REQUEST);
 345         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
 346     }
 347
 348     @Test
 349     public void testOldDistStateChangeRequestResourceAdminEvent() {
 350         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType())))
 351                 .thenReturn(ActionStatus.OK);
 352         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 353
 354         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST))).isEqualTo(EXPECTED_DIST_STATE_CHANGE_REQUEST);
 355         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName());
 356     }
 357
 358     @Test
 359     public void testNewDistStateChangeApprovResourceAdminEvent() {
 360
 361         AuditEventFactory factory = new AuditDistStateChangeResourceAdminEventFactory(
 362                 AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV,
 363                 CommonAuditData.newBuilder()
 364                         .description(DESCRIPTION)
 365                         .status(STATUS_OK)
 366                         .requestId(REQUEST_ID)
 367                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 368                         .build(),
 369                  ResourceAuditData.newBuilder()
 370                         .artifactUuid(ARTIFACT_UUID)
 371                         .state(PREV_RESOURCE_STATE)
 372                         .version(PREV_RESOURCE_VERSION)
 373                         .distributionStatus(DPREV_STATUS)
 374                         .build(),
 375                 ResourceAuditData.newBuilder()
 376                         .artifactUuid(ARTIFACT_UUID)
 377                         .state(CURRENT_STATE)
 378                         .version(CURRENT_VERSION)
 379                         .distributionStatus(DCURR_STATUS)
 380                         .build(),
 381                 RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier,
 382                 ARTIFACT_DATA, COMMENT, DIST_ID);
 383
 384         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType())))
 385                 .thenReturn(ActionStatus.OK);
 386         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 387
 388         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_APPROV);
 389         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName());
 390     }
 391
 392     @Test
 393     public void testOldDistStateChangeApprovResourceAdminEvent() {
 394         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getAuditingEsType())))
 395                 .thenReturn(ActionStatus.OK);
 396         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 397
 398         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV))).isEqualTo(EXPECTED_DIST_STATE_CHANGE_APPROV);
 399         verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName());
 400     }
 401
 402
 403     private void verifyResourceAdminEvent(String action) {
 404         verify(cassandraDao).saveRecord(eventCaptor.capture());
 405         ResourceAdminEvent storedEvent = (ResourceAdminEvent) eventCaptor.getValue();
 406         assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID);
 407         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 408         assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID);
 409         assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID);
 410         assertThat(storedEvent.getAction()).isEqualTo(action);
 411         assertThat(storedEvent.getArtifactData()).isEqualTo(ARTIFACT_DATA);
 412         assertThat(storedEvent.getComment()).isEqualTo(COMMENT);
 413         assertThat(storedEvent.getCurrArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 414         assertThat(storedEvent.getPrevArtifactUUID()).isEqualTo(ARTIFACT_UUID);
 415         assertThat(storedEvent.getPrevState()).isEqualTo(PREV_RESOURCE_STATE);
 416         assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE);
 417         assertThat(storedEvent.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION);
 418         assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION);
 419         assertThat(storedEvent.getDcurrStatus()).isEqualTo(DCURR_STATUS);
 420         assertThat(storedEvent.getDprevStatus()).isEqualTo(DPREV_STATUS);
 421         assertThat(storedEvent.getDid()).isEqualTo(DIST_ID);
 422         assertThat(storedEvent.getInvariantUUID()).isEqualTo(INVARIANT_UUID);
 423         assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME);
 424         assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE_VFC);
 425
 426         if (action.equals(AuditingActionEnum.IMPORT_RESOURCE.getName())) {
 427             assertThat(storedEvent.getToscaNodeType()).isEqualTo(TOSCA_NODE_TYPE);
 428         } else {
 429             assertThat(storedEvent.getToscaNodeType()).isEmpty();
 430         }
 431     }
 432 }