catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/externalapi/AuditExternalApiEventFuncTest.java

   1 package org.openecomp.sdc.be.auditing.impl.externalapi;
   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.resources.data.auditing.AuditingActionEnum;
  18 import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent;
  19 import org.openecomp.sdc.be.resources.data.auditing.ExternalApiEvent;
  20 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
  21 import org.openecomp.sdc.be.resources.data.auditing.model.ResourceAuditData;
  22 import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum;
  23
  24 import java.util.EnumMap;
  25
  26 import static org.assertj.core.api.Assertions.assertThat;
  27 import static org.mockito.ArgumentMatchers.any;
  28 import static org.mockito.ArgumentMatchers.anyMap;
  29 import static org.mockito.ArgumentMatchers.eq;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_DATA;
  33 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_UUID;
  34 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_STATE;
  35 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_VERSION;
  36 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION;
  37 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_CONSUMER_ID;
  38 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_RESOURCE_URL;
  39 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ACTIVATE_SERVICE_API_LOG_STR;
  40 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR;
  41 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR;
  42 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR;
  43 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_ASSET_LIST_LOG_STR;
  44 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_TOSCA_MODEL_LOG_STR;
  45 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.INVARIANT_UUID;
  46 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID;
  47 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_STATE;
  48 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_VERSION;
  49 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID;
  50 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_NAME;
  51 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE;
  52 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID;
  53 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK;
  54 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init;
  55 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier;
  56
  57 @RunWith(MockitoJUnitRunner.class)
  58 public class AuditExternalApiEventFuncTest {
  59
  60     private AuditingManager auditingManager;
  61
  62     @Mock
  63     private static AuditCassandraDao cassandraDao;
  64     @Mock
  65     private static AuditingDao auditingDao;
  66     @Mock
  67     private static Configuration.ElasticSearchConfig esConfig;
  68
  69     @Captor
  70     private ArgumentCaptor<AuditingGenericEvent> eventCaptor;
  71
  72     @Before
  73     public void setUp() {
  74         init(esConfig);
  75         auditingManager = new AuditingManager(auditingDao, cassandraDao);
  76     }
  77
  78     @Test
  79     public void testNewActivateServiceEvent() {
  80         AuditEventFactory builder = new AuditActivateServiceExternalApiEventFactory(
  81                 CommonAuditData.newBuilder()
  82                         .description(DESCRIPTION)
  83                         .status(STATUS_OK)
  84                         .requestId(REQUEST_ID)
  85                         .serviceInstanceId(SERVICE_INSTANCE_ID)
  86                         .build(),
  87                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
  88                 ResourceAuditData.newBuilder()
  89                         .artifactUuid(ARTIFACT_UUID)
  90                         .state(PREV_RESOURCE_STATE)
  91                         .version(PREV_RESOURCE_VERSION)
  92                         .build(),
  93                 ResourceAuditData.newBuilder()
  94                         .artifactUuid(ARTIFACT_UUID)
  95                         .state(CURRENT_STATE)
  96                         .version(CURRENT_VERSION)
  97                         .build(),
  98                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
  99
 100         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getAuditingEsType())))
 101                 .thenReturn(ActionStatus.OK);
 102         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 103
 104         assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_ACTIVATE_SERVICE_API_LOG_STR);
 105         verifyExternalApiEvent(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getName());
 106     }
 107
 108     @Test
 109     public void testOldActivateServiceEvent() {
 110         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getAuditingEsType())))
 111                 .thenReturn(ActionStatus.OK);
 112         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 113
 114         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ACTIVATE_SERVICE_BY_API))).isEqualTo(EXPECTED_ACTIVATE_SERVICE_API_LOG_STR);
 115         verifyExternalApiEvent(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getName());
 116
 117     }
 118
 119     @Test
 120     public void testNewDownloadArtifactEvent() {
 121         AuditEventFactory builder = new AuditDownloadArtifactExternalApiEventFactory(
 122                 CommonAuditData.newBuilder()
 123                         .description(DESCRIPTION)
 124                         .status(STATUS_OK)
 125                         .requestId(REQUEST_ID)
 126                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 127                         .build(),
 128                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
 129                 ResourceAuditData.newBuilder()
 130                         .artifactUuid(ARTIFACT_UUID)
 131                         .state(PREV_RESOURCE_STATE)
 132                         .version(PREV_RESOURCE_VERSION)
 133                         .build(),
 134                 ResourceAuditData.newBuilder()
 135                         .artifactUuid(ARTIFACT_UUID)
 136                         .state(CURRENT_STATE)
 137                         .version(CURRENT_VERSION)
 138                         .build(),
 139                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
 140
 141         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DOWNLOAD_ARTIFACT.getAuditingEsType())))
 142                 .thenReturn(ActionStatus.OK);
 143         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 144
 145         assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR);
 146         verifyExternalApiEvent(AuditingActionEnum.DOWNLOAD_ARTIFACT.getName());
 147     }
 148
 149     @Test
 150     public void testOldDownloadArtifactEvent() {
 151         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DOWNLOAD_ARTIFACT.getAuditingEsType())))
 152                 .thenReturn(ActionStatus.OK);
 153         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 154
 155         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DOWNLOAD_ARTIFACT))).isEqualTo(EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR + " ");
 156         verifyExternalApiEvent(AuditingActionEnum.DOWNLOAD_ARTIFACT.getName());
 157     }
 158
 159     @Test
 160     public void testNewChangeLifecycleEvent() {
 161         AuditEventFactory factory = new AuditChangeLifecycleExternalApiEventFactory(
 162                 CommonAuditData.newBuilder()
 163                         .description(DESCRIPTION)
 164                         .status(STATUS_OK)
 165                         .requestId(REQUEST_ID)
 166                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 167                         .build(),
 168                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
 169                 ResourceAuditData.newBuilder()
 170                         .artifactUuid(ARTIFACT_UUID)
 171                         .state(PREV_RESOURCE_STATE)
 172                         .version(PREV_RESOURCE_VERSION)
 173                         .build(),
 174                 ResourceAuditData.newBuilder()
 175                         .artifactUuid(ARTIFACT_UUID)
 176                         .state(CURRENT_STATE)
 177                         .version(CURRENT_VERSION)
 178                         .build(),
 179                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
 180
 181         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getAuditingEsType())))
 182                 .thenReturn(ActionStatus.OK);
 183         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 184
 185         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR);
 186         verifyExternalApiEvent(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 187     }
 188
 189     @Test
 190     public void testOldChangeLifecycleEvent() {
 191         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getAuditingEsType())))
 192                 .thenReturn(ActionStatus.OK);
 193         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 194
 195         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API))).isEqualTo(EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR);
 196         verifyExternalApiEvent(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName());
 197
 198     }
 199
 200     @Test
 201     public void testNewDeleteArtifactEvent() {
 202         AuditEventFactory factory = new AuditDeleteArtByApiCrudExternalApiEventFactory(
 203                 CommonAuditData.newBuilder()
 204                         .description(DESCRIPTION)
 205                         .status(STATUS_OK)
 206                         .requestId(REQUEST_ID)
 207                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 208                         .build(),
 209                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
 210                 ResourceAuditData.newBuilder()
 211                         .artifactUuid(ARTIFACT_UUID)
 212                         .state(PREV_RESOURCE_STATE)
 213                         .version(PREV_RESOURCE_VERSION)
 214                         .build(),
 215                 ResourceAuditData.newBuilder()
 216                         .artifactUuid(ARTIFACT_UUID)
 217                         .state(CURRENT_STATE)
 218                         .version(CURRENT_VERSION)
 219                         .build(),
 220                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
 221
 222         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getAuditingEsType())))
 223                 .thenReturn(ActionStatus.OK);
 224         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 225
 226         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR);
 227         verifyExternalApiEvent(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName());
 228     }
 229
 230     @Test
 231     public void testOldDeleteArtifactEvent() {
 232         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getAuditingEsType())))
 233                 .thenReturn(ActionStatus.OK);
 234         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 235
 236         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ARTIFACT_DELETE_BY_API))).isEqualTo(EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR + " ");
 237         verifyExternalApiEvent(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName());
 238
 239     }
 240
 241     @Test
 242     public void testNewGetAssetsListEvent() {
 243         AuditEventFactory factory = new AuditGetAssetListExternalApiEventFactory(
 244                 CommonAuditData.newBuilder()
 245                         .description(DESCRIPTION)
 246                         .status(STATUS_OK)
 247                         .requestId(REQUEST_ID)
 248                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 249                         .build(),
 250                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
 251                 ResourceAuditData.newBuilder()
 252                         .artifactUuid(ARTIFACT_UUID)
 253                         .state(PREV_RESOURCE_STATE)
 254                         .version(PREV_RESOURCE_VERSION)
 255                         .build(),
 256                 ResourceAuditData.newBuilder()
 257                         .artifactUuid(ARTIFACT_UUID)
 258                         .state(CURRENT_STATE)
 259                         .version(CURRENT_VERSION)
 260                         .build(),
 261                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
 262
 263         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_ASSET_LIST.getAuditingEsType())))
 264                 .thenReturn(ActionStatus.OK);
 265         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 266
 267         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_ASSET_LIST_LOG_STR);
 268         verifyExternalApiEvent(AuditingActionEnum.GET_ASSET_LIST.getName());
 269     }
 270
 271     @Test
 272     public void testOldGetAssetsListEvent() {
 273         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_ASSET_LIST.getAuditingEsType())))
 274                 .thenReturn(ActionStatus.OK);
 275         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 276
 277         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.GET_ASSET_LIST))).isEqualTo(EXPECTED_GET_ASSET_LIST_LOG_STR);
 278         verifyExternalApiEvent(AuditingActionEnum.GET_ASSET_LIST.getName());
 279     }
 280
 281     @Test
 282     public void testNewGetToscaModelEvent() {
 283         AuditEventFactory factory = new AuditGetToscaModelExternalApiEventFactory(
 284                 CommonAuditData.newBuilder()
 285                         .description(DESCRIPTION)
 286                         .status(STATUS_OK)
 287                         .requestId(REQUEST_ID)
 288                         .serviceInstanceId(SERVICE_INSTANCE_ID)
 289                         .build(),
 290                 RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL,
 291                 ResourceAuditData.newBuilder()
 292                         .artifactUuid(ARTIFACT_UUID)
 293                         .state(PREV_RESOURCE_STATE)
 294                         .version(PREV_RESOURCE_VERSION)
 295                         .build(),
 296                 ResourceAuditData.newBuilder()
 297                         .artifactUuid(ARTIFACT_UUID)
 298                         .state(CURRENT_STATE)
 299                         .version(CURRENT_VERSION)
 300                         .build(),
 301                 INVARIANT_UUID, modifier, ARTIFACT_DATA);
 302
 303         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_TOSCA_MODEL.getAuditingEsType())))
 304                 .thenReturn(ActionStatus.OK);
 305         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 306
 307         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_TOSCA_MODEL_LOG_STR);
 308         verifyExternalApiEvent(AuditingActionEnum.GET_TOSCA_MODEL.getName());
 309     }
 310
 311     @Test
 312     public void testOldGetToscaModelEvent() {
 313         when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_TOSCA_MODEL.getAuditingEsType())))
 314                 .thenReturn(ActionStatus.OK);
 315         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 316
 317         assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.GET_TOSCA_MODEL))).isEqualTo(EXPECTED_GET_TOSCA_MODEL_LOG_STR);
 318         verifyExternalApiEvent(AuditingActionEnum.GET_TOSCA_MODEL.getName());
 319     }
 320
 321     private void verifyExternalApiEvent(String action) {
 322         verify(cassandraDao).saveRecord(eventCaptor.capture());
 323         ExternalApiEvent storedEvent = (ExternalApiEvent) eventCaptor.getValue();
 324         assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID);
 325         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 326         assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK);
 327         assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID);
 328         assertThat(storedEvent.getAction()).isEqualTo(action);
 329         assertThat(storedEvent.getArtifactData()).isEqualTo(ARTIFACT_DATA);
 330         assertThat(storedEvent.getCurrArtifactUuid()).isEqualTo(ARTIFACT_UUID);
 331         assertThat(storedEvent.getPrevArtifactUuid()).isEqualTo(ARTIFACT_UUID);
 332         assertThat(storedEvent.getPrevState()).isEqualTo(PREV_RESOURCE_STATE);
 333         assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE);
 334         assertThat(storedEvent.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION);
 335         assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION);
 336         assertThat(storedEvent.getInvariantUuid()).isEqualTo(INVARIANT_UUID);
 337         assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME);
 338         assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE);
 339
 340     }
 341
 342     private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) {
 343         EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class);
 344         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName());
 345         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName());
 346         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId());
 347         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK);
 348         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION);
 349
 350         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE);
 351         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, PREV_RESOURCE_VERSION);
 352         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, PREV_RESOURCE_STATE);
 353         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME);
 354         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION);
 355         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, CURRENT_STATE);
 356         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID);
 357         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, INVARIANT_UUID);
 358         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, ARTIFACT_DATA);
 359         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, ARTIFACT_UUID);
 360         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, ARTIFACT_UUID);
 361         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID);
 362         auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, DIST_RESOURCE_URL);
 363         return auditingFields;
 364     }
 365
 366
 367
 368 }