diff options
Diffstat (limited to 'catalog-be/src/test/java/org/openecomp/sdc/be/auditing')
10 files changed, 2624 insertions, 0 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditBaseEventFactoryTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditBaseEventFactoryTest.java new file mode 100644 index 0000000000..9bdf784f1c --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditBaseEventFactoryTest.java @@ -0,0 +1,132 @@ +package org.openecomp.sdc.be.auditing.impl; + +import org.junit.Test; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.common.api.Constants; + +import static org.junit.Assert.assertEquals; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESIGNER_USER_ROLE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_EMAIL; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_EXTENDED_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_FIRST_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_LAST_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_UID; + +public class AuditBaseEventFactoryTest { + + private User user = new User(); + + @Test + public void buildUserNameWhenFullNameAndUserIdNotSet() { + assertEquals(Constants.EMPTY_STRING, AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFullNameIsNotSetAndUserIdIsSet() { + user.setUserId(USER_ID); + assertEquals("(" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFullNameIsNullNullAndUserIdSet() { + user.setUserId(USER_ID); + user.setFirstName(Constants.NULL_STRING); + user.setLastName(Constants.NULL_STRING); + assertEquals("(" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFirtsNameIsNotSetAndLastNameIsNull() { + user.setUserId(USER_ID); + user.setLastName(Constants.NULL_STRING); + assertEquals("(" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenLastNameIsNull() { + user.setUserId(USER_ID); + user.setFirstName(USER_FIRST_NAME); + user.setLastName(Constants.NULL_STRING); + assertEquals(USER_FIRST_NAME + " (" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFirstNameIsNullAndLastNameIsSet() { + user.setUserId(USER_ID); + user.setFirstName(Constants.NULL_STRING); + user.setLastName(USER_LAST_NAME); + assertEquals(USER_LAST_NAME + "(" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFullNameIsSetAndUserIdSet() { + user.setUserId(USER_ID); + user.setFirstName(USER_FIRST_NAME); + user.setLastName(USER_LAST_NAME); + assertEquals(USER_UID, AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildUserNameWhenFirstNameIsSetAndUserIdSet() { + user.setUserId(USER_ID); + user.setFirstName(USER_FIRST_NAME); + assertEquals(USER_FIRST_NAME + " (" + USER_ID + ")", AuditBaseEventFactory.buildUserName(user)); + } + + @Test + public void buildExtendedUserNameWhenNothingIsSet() { + assertEquals(Constants.EMPTY_STRING, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenOnlyUserIdIsSet() { + user.setUserId(USER_ID); + assertEquals(USER_ID, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameAllSet() { + user.setUserId(USER_ID); + user.setFirstName(USER_FIRST_NAME); + user.setLastName(USER_LAST_NAME); + user.setEmail(USER_EMAIL); + user.setRole(DESIGNER_USER_ROLE); + assertEquals(USER_EXTENDED_NAME, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenFirstNameAndUserIdAreSet() { + user.setUserId(USER_ID); + user.setFirstName(USER_FIRST_NAME); + assertEquals(USER_ID + ", " + USER_FIRST_NAME, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenLastNameAndUserIdAreSet() { + user.setUserId(USER_ID); + user.setLastName(USER_LAST_NAME); + assertEquals(USER_ID + ", " + USER_LAST_NAME, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenOnlyEmailAndRoleAreSet() { + user.setEmail(USER_EMAIL); + user.setRole(DESIGNER_USER_ROLE); + assertEquals(USER_EMAIL + ", " + DESIGNER_USER_ROLE, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenOnlyNameIsSet() { + user.setFirstName(USER_FIRST_NAME); + user.setLastName(USER_LAST_NAME); + assertEquals(USER_FIRST_NAME + " " + USER_LAST_NAME, AuditBaseEventFactory.buildUserNameExtended(user)); + } + + @Test + public void buildExtendedUserNameWhenOnlyRoleIsSet() { + user.setRole(DESIGNER_USER_ROLE); + assertEquals(DESIGNER_USER_ROLE, AuditBaseEventFactory.buildUserNameExtended(user)); + } + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditConsumerEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditConsumerEventFuncTest.java new file mode 100644 index 0000000000..0a90ffd915 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditConsumerEventFuncTest.java @@ -0,0 +1,200 @@ +package org.openecomp.sdc.be.auditing.impl; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.model.ConsumerDefinition; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.ConsumerEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.util.ThreadLocalsHolder; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CONSUMER_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CONSUMER_PASSWORD; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CONSUMER_SALT; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ADD_ECOMP_USER_CRED_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_ECOMP_USER_CRED_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier; + +@RunWith(MockitoJUnitRunner.class) +public class AuditConsumerEventFuncTest { + private AuditingManager auditingManager; + + private ConsumerDefinition consumer; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + consumer = new ConsumerDefinition(); + consumer.setConsumerName(USER_ID); + ThreadLocalsHolder.setUuid(REQUEST_ID); + } + + @Test + public void testNewAddEcompUserCredEvent() { + AuditEventFactory factory = new AuditConsumerEventFactory( + AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + modifier, consumer); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ADD_ECOMP_USER_CRED_LOG_STR); + verifyConsumerEvent(AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS.getName()); + } + + @Test + public void testOldAddEcompUserCredEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS))).isEqualTo(EXPECTED_ADD_ECOMP_USER_CRED_LOG_STR); + verifyConsumerEvent(AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS.getName()); + + } + + @Test + public void testNewGetEcompUserCredEvent() { + AuditEventFactory factory = new AuditConsumerEventFactory( + AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + modifier, consumer); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_ECOMP_USER_CRED_LOG_STR); + verifyConsumerEvent(AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS.getName()); + } + + @Test + public void testOldGetEcompUserCredEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS))).isEqualTo(EXPECTED_GET_ECOMP_USER_CRED_LOG_STR); + verifyConsumerEvent(AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS.getName()); + + } + + @Test + public void buildConsumerNameWhenAllFieldsAreProvided() { + consumer.setConsumerName(CONSUMER_NAME); + consumer.setConsumerSalt(CONSUMER_SALT); + consumer.setConsumerPassword(CONSUMER_PASSWORD); + assertEquals(CONSUMER_NAME + "," + CONSUMER_SALT + "," + CONSUMER_PASSWORD, AuditConsumerEventFactory.buildConsumerName(consumer)); + } + + @Test + public void buildConsumerNameWhenSaltIsNull() { + consumer.setConsumerName(CONSUMER_NAME); + consumer.setConsumerPassword(CONSUMER_PASSWORD); + assertEquals(CONSUMER_NAME + "," + CONSUMER_PASSWORD, AuditConsumerEventFactory.buildConsumerName(consumer)); + } + + @Test + public void buildConsumerNameWhenNameIsNull() { + consumer.setConsumerName(null); + consumer.setConsumerSalt(CONSUMER_SALT); + consumer.setConsumerPassword(CONSUMER_PASSWORD); + assertEquals(CONSUMER_SALT + "," + CONSUMER_PASSWORD, AuditConsumerEventFactory.buildConsumerName(consumer)); + } + + @Test + public void buildConsumerNameWhenNameAndPwAreNull() { + consumer.setConsumerName(null); + consumer.setConsumerSalt(CONSUMER_SALT); + assertEquals(CONSUMER_SALT, AuditConsumerEventFactory.buildConsumerName(consumer)); + } + + @Test + public void buildConsumerNameWhenNameAndSaltAreNull() { + consumer.setConsumerName(null); + consumer.setConsumerPassword(CONSUMER_PASSWORD); + assertEquals(CONSUMER_PASSWORD, AuditConsumerEventFactory.buildConsumerName(consumer)); + } + + @Test + public void buildConsumerNameWhenConsumerObjectIsNull() { + assertEquals("", AuditConsumerEventFactory.buildConsumerName(null)); + } + + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ECOMP_USER, USER_ID); + + return auditingFields; + } + + private void verifyConsumerEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + ConsumerEvent storedEvent = (ConsumerEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isNull(); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getEcompUser()).isEqualTo(USER_ID); + } +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditTestUtils.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditTestUtils.java new file mode 100644 index 0000000000..04bd34f289 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/AuditTestUtils.java @@ -0,0 +1,236 @@ +package org.openecomp.sdc.be.auditing.impl; + +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.config.ConfigurationManager; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.impl.ExternalConfiguration; +import org.openecomp.sdc.common.impl.FSConfigurationSource; + + +public class AuditTestUtils { + public final static String USER_FIRST_NAME = "Carlos"; + public final static String USER_LAST_NAME = "Santana"; + public final static String USER_ID = "cs0008"; + public final static String DESCRIPTION = "OK"; + public final static String STATUS_OK = "200"; + public final static String STATUS_CREATED = "201"; + public final static String REQUEST_ID = "123456"; + public final static String USER_UID = "Carlos Santana(cs0008)"; + public final static String SERVICE_INSTANCE_ID = "d07fdc15-122d-4476-a349-8c9a2d80b485"; + public final static String CURRENT_STATE = "CERTIFIED"; + public final static String CURRENT_VERSION = "1.1"; + public final static String RESOURCE_TYPE = ResourceTypeEnum.VF.name(); + public final static String RESOURCE_TYPE_VFC = ResourceTypeEnum.VFC.name(); + public final static String RESOURCE_NAME = "ciServicea184822c06e6"; + public final static String DIST_ID = "e5765a82-e7cd-4c5c-91a0-eae58d6ae08f"; + public final static String TOPIC_NAME = "ASDC-DISTR-NOTIF-TOPIC-PROD_TEST"; + public final static String DESIGNER_USER_ROLE = "DESIGNER"; + public final static String TESTER_USER_ROLE = "TESTER"; + public final static String USER_EMAIL = "carlos@email.com"; + public final static String MODIFIER_FIRST_NAME = "Jimmy"; + public final static String MODIFIER_LAST_NAME = "Hendrix"; + public final static String MODIFIER_ID = "jh0003"; + public final static String MODIFIER_UID = "Jimmy Hendrix(jh0003)"; + public final static String USER_EXTENDED_NAME = "cs0008, Carlos Santana, carlos@email.com, DESIGNER"; + public final static String UPDATED_USER_EXTENDED_NAME = "cs0008, Carlos Santana, carlos@email.com, TESTER"; + public final static String VNF_WORKLOAD_CONTEXT = "WORKLOAD"; + public final static String DPREV_STATUS = "DPREV_STATUS"; + public final static String DCURR_STATUS = "DCURR_STATUS"; + + public final static String CONSUMER_NAME = "consumer"; + public final static String CONSUMER_SALT = "2a1f887d607d4515d4066fe0f5452a50"; + public final static String CONSUMER_PASSWORD = "0a0dc557c3bf594b1a48030e3e99227580168b21f44e285c69740b8d5b13e33b"; + + public final static String PREV_RESOURCE_VERSION = "1.0"; + public final static String PREV_RESOURCE_STATE = "READY_FOR_CERTIFICATION"; + public final static String COMMENT = "Attempt to perform"; + public final static String ARTIFACT_DATA = "123456qwertasdfgljkPIPIPIOPI"; + public final static String TOSCA_NODE_TYPE = "tosca.node.Root"; + public final static String ARTIFACT_UUID = "1234-ASDFG_7894443"; + public final static String INVARIANT_UUID = "INV-123456"; + public final static String USER_DETAILS = "All"; + + public final static String STATUS_500 = "500"; + public final static String DESC_ERROR = "Error"; + public final static String MSG_ERROR = "Error: "; + public final static String MSG_OK = "OK: "; + + public final static String DIST_CONSUMER_ID = "ABC-123445678"; + public final static String DIST_RESOURCE_URL = "http://abc.com/res"; + public final static String DIST_STATUS_TOPIC = "STopic"; + public final static String DIST_NOTIFY_TOPIC = "NTopic"; + public final static String DIST_API_KEY = "Key111"; + public final static String DIST_ENV_NAME = "Env111"; + public final static String DIST_ROLE = "Governer"; + public final static String DIST_STATUS_TIME = "154567890123"; + + public final static String AUTH_URL = "http://abc.com/auth"; + public final static String REALM = "12345ABSDF"; + public final static String AUTH_STATUS = "AUTHENTICATED"; + + public final static String CATEGORY = "VFs"; + public final static String SUB_CATEGORY = "Network"; + public final static String GROUPING_NAME = "Group1"; + + public final static String OP_ENV_ID = "12345678"; + public final static String OP_ENV_NAME = "Op1"; + public final static String OP_ENV_TYPE = "ECOMP"; + public final static String OP_ENV_ACTION = "Create"; + public final static String TENANT_CONTEXT = "TENANT"; + + public final static String EXPECTED_USER_ACCESS_LOG_STR = "ACTION = \"" + AuditingActionEnum.USER_ACCESS.getName() + "\" USER = \"" + USER_UID + + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DISTRIB_NOTIFICATION_LOG_STR = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_NOTIFY.getName() + + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE + "\" SERVICE_INSTANCE_ID = \"" + + SERVICE_INSTANCE_ID + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + USER_UID + "\" CURR_STATE = \"" + CURRENT_STATE + + "\" DID = \"" + DIST_ID + "\" TOPIC_NAME = \"" + TOPIC_NAME + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + + "\" TENANT = \"" + TENANT_CONTEXT + "\" VNF_WORKLOAD_CONTEXT = \"" + VNF_WORKLOAD_CONTEXT + "\" ENV_ID = \"" + OP_ENV_ID + "\""; + + public final static String EXPECTED_ADD_USER_LOG_STR = "ACTION = \"" + AuditingActionEnum.ADD_USER.getName() + "\" MODIFIER = \"" + MODIFIER_UID + + "\" USER_BEFORE = \"\" USER_AFTER = \"" + USER_EXTENDED_NAME + "\" STATUS = \"" + STATUS_CREATED + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_UPDATE_USER_LOG_STR = "ACTION = \"" + AuditingActionEnum.UPDATE_USER.getName() + "\" MODIFIER = \"" + MODIFIER_UID + + "\" USER_BEFORE = \"" + USER_EXTENDED_NAME + "\" USER_AFTER = \"" + UPDATED_USER_EXTENDED_NAME + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DELETE_USER_LOG_STR = "ACTION = \"" + AuditingActionEnum.DELETE_USER.getName() + "\" MODIFIER = \"" + MODIFIER_UID + + "\" USER_BEFORE = \"" + USER_EXTENDED_NAME + "\" USER_AFTER = \"\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_CHECK_IN_RESOURCE_LOG_STR = "ACTION = \"" + AuditingActionEnum.CHECKIN_RESOURCE.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\"" + " INVARIANT_UUID = \"" + INVARIANT_UUID + "\"" + + " PREV_VERSION = \"" + PREV_RESOURCE_VERSION + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_STATE = \"" + + PREV_RESOURCE_STATE + "\" CURR_STATE = \"" + CURRENT_STATE + "\" COMMENT = \"" + COMMENT + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_CREATE_RESOURCE_LOG_STR = "ACTION = \"" + AuditingActionEnum.CREATE_RESOURCE.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\"" + " INVARIANT_UUID = \"" + INVARIANT_UUID + "\"" + + " PREV_VERSION = \"" + PREV_RESOURCE_VERSION + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_STATE = \"" + + PREV_RESOURCE_STATE + "\" CURR_STATE = \"" + CURRENT_STATE + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_IMPORT_RESOURCE_LOG_STR = "ACTION = \"" + AuditingActionEnum.IMPORT_RESOURCE.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\"" + " INVARIANT_UUID = \"" + INVARIANT_UUID + "\"" + + " PREV_VERSION = \"" + PREV_RESOURCE_VERSION + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_STATE = \"" + + PREV_RESOURCE_STATE + "\" CURR_STATE = \"" + CURRENT_STATE + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\" TOSCA_NODE_TYPE = \"" + + TOSCA_NODE_TYPE + "\""; + + public final static String EXPECTED_ARTIFACT_UPLOAD_LOG_STR = "ACTION = \"" + AuditingActionEnum.ARTIFACT_UPLOAD.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\"" + " INVARIANT_UUID = \"" + INVARIANT_UUID + "\"" + + " PREV_VERSION = \"" + PREV_RESOURCE_VERSION + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_STATE = \"" + + PREV_RESOURCE_STATE + "\" CURR_STATE = \"" + CURRENT_STATE + "\" PREV_ARTIFACT_UUID = \"" + ARTIFACT_UUID + "\" CURR_ARTIFACT_UUID = \"" + + ARTIFACT_UUID + "\" ARTIFACT_DATA = \"" + ARTIFACT_DATA + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DIST_STATE_CHANGE_REQUEST = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + + MODIFIER_UID + "\" CURR_STATE = \"" + CURRENT_STATE + "\" DPREV_STATUS = \"" + DPREV_STATUS + "\" DCURR_STATUS = \"" + + DCURR_STATUS + "\" DID = \"" + DIST_ID + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DIST_STATE_CHANGE_APPROV = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE_VFC + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + + MODIFIER_UID + "\" CURR_STATE = \"" + CURRENT_STATE + "\" DPREV_STATUS = \"" + DPREV_STATUS + "\" DCURR_STATUS = \"" + + DCURR_STATUS + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\" COMMENT = \"" + COMMENT + "\""; + + public final static String EXPECTED_GET_USER_LIST_LOG_STR = "ACTION = \"" + AuditingActionEnum.GET_USERS_LIST.getName() + "\" MODIFIER = \"" + USER_UID + + "\" DETAILS = \"" + USER_DETAILS + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_ACTIVATE_SERVICE_API_LOG_STR = "ACTION = \"" + AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getName() + "\" RESOURCE_TYPE = \"" + + RESOURCE_TYPE + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + "\" MODIFIER = \"" + + MODIFIER_UID + "\" STATUS = \"" + STATUS_OK + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\" INVARIANT_UUID = \"" + INVARIANT_UUID + + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR = "CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + + DIST_RESOURCE_URL + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR = "ACTION = \"" + AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_VERSION = \"" + PREV_RESOURCE_VERSION + "\" CURR_VERSION = \"" + CURRENT_VERSION + + "\" PREV_STATE = \"" + PREV_RESOURCE_STATE + "\" CURR_STATE = \"" + CURRENT_STATE + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + + "\" INVARIANT_UUID = \"" + INVARIANT_UUID + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR = "ACTION = \"" + AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName() + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + + "\" MODIFIER = \"" + MODIFIER_UID + "\" PREV_ARTIFACT_UUID = \"" + ARTIFACT_UUID + "\" CURR_ARTIFACT_UUID = \"" + ARTIFACT_UUID + + "\" ARTIFACT_DATA = \"" + ARTIFACT_DATA + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_GET_ASSET_LIST_LOG_STR = "ACTION = \"" + AuditingActionEnum.GET_ASSET_LIST.getName() + "\" CONSUMER_ID = \"" + + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_GET_TOSCA_MODEL_LOG_STR = "ACTION = \"" + AuditingActionEnum.GET_TOSCA_MODEL.getName() + "\" CONSUMER_ID = \"" + + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + "\" RESOURCE_TYPE = \"" + + RESOURCE_TYPE + "\" SERVICE_INSTANCE_ID = \"" + SERVICE_INSTANCE_ID + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_AUTH_REQUEST_LOG_STR = "ACTION = \"" + AuditingActionEnum.AUTH_REQUEST.getName() + "\" URL = \"" + + AUTH_URL + "\" USER = \"" + USER_ID + "\" AUTH_STATUS = \"" + AUTH_STATUS + "\" REALM = \"" + REALM + "\""; + + public final static String EXPECTED_ADD_ECOMP_USER_CRED_LOG_STR = "ACTION = \"" + AuditingActionEnum.ADD_ECOMP_USER_CREDENTIALS.getName() + + "\" MODIFIER = \"" + MODIFIER_UID + "\" ECOMP_USER = \"" + USER_ID + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_GET_ECOMP_USER_CRED_LOG_STR = "ACTION = \"" + AuditingActionEnum.GET_ECOMP_USER_CREDENTIALS.getName() + + "\" MODIFIER = \"" + MODIFIER_UID + "\" ECOMP_USER = \"" + USER_ID + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_ADD_CATEGORY_LOG_STR = "ACTION = \"" + AuditingActionEnum.ADD_CATEGORY.getName() + + "\" MODIFIER = \"" + MODIFIER_UID + "\" CATEGORY_NAME = \"" + CATEGORY + "\" SUB_CATEGORY_NAME = \"" + SUB_CATEGORY + + "\" GROUPING_NAME = \"" + GROUPING_NAME + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + private final static String OP_ENV_LOG = "\" OPERATIONAL_ENVIRONMENT_ACTION = \"" + OP_ENV_ACTION + "\" OPERATIONAL_ENVIRONMENT_ID = \"" + OP_ENV_ID + + "\" OPERATIONAL_ENVIRONMENT_NAME = \"" + OP_ENV_NAME + "\" OPERATIONAL_ENVIRONMENT_TYPE = \"" + OP_ENV_TYPE + + "\" TENANT_CONTEXT = \"" + TENANT_CONTEXT + "\""; + + public final static String EXPECTED_CREATE_OP_ENV_LOG_STR = "ACTION = \"" + AuditingActionEnum.CREATE_ENVIRONMENT.getName() + OP_ENV_LOG; + + public final static String EXPECTED_UNSUPPORTED_TYPE_OP_ENV_LOG_STR = "ACTION = \"" + AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getName() + OP_ENV_LOG; + + public final static String EXPECTED_UNKNOWN_NOTIFICATION_OP_ENV_LOG_STR = "ACTION = \"" + AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION.getName() + OP_ENV_LOG; + + public final static String EXPECTED_DIST_ADD_KEY_ENGINE_LOG_STR = "ACTION = \"" + AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL.getName() + + "\" D_ENV = \"" + DIST_ENV_NAME + "\" TOPIC_NAME = \"" + DIST_NOTIFY_TOPIC + "\" ROLE = \"" + DIST_ROLE + "\" API_KEY = \"" + + DIST_API_KEY + "\" STATUS = \"" + STATUS_OK + "\""; + + public final static String EXPECTED_DIST_CREATE_TOPIC_ENGINE_LOG_STR = "ACTION = \"" + AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC.getName() + + "\" D_ENV = \"" + DIST_ENV_NAME + "\" TOPIC_NAME = \"" + DIST_NOTIFY_TOPIC + "\" STATUS = \"" + STATUS_OK + "\""; + + public final static String EXPECTED_DIST_REG_ENGINE_LOG_STR = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_REGISTER.getName() + + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" API_KEY = \"" + DIST_API_KEY + "\" D_ENV = \"" + DIST_ENV_NAME + "\" STATUS = \"" + + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\" DNOTIF_TOPIC = \"" + DIST_NOTIFY_TOPIC + "\" DSTATUS_TOPIC = \"" + DIST_STATUS_TOPIC + "\""; + + public final static String EXPECTED_DIST_STATUS_LOG_STR = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_STATUS.getName() + + "\" DID = \"" + DIST_ID + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" TOPIC_NAME = \"" + TOPIC_NAME + + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + "\" STATUS_TIME = \"" + DIST_STATUS_TIME + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DIST_DOWNLOAD_LOG_STR = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_ARTIFACT_DOWNLOAD.getName() + + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" RESOURCE_URL = \"" + DIST_RESOURCE_URL + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_DISTRIB_DEPLOY_LOG_STR = "ACTION = \"" + AuditingActionEnum.DISTRIBUTION_DEPLOY.getName() + + "\" RESOURCE_NAME = \"" + RESOURCE_NAME + "\" RESOURCE_TYPE = \"" + RESOURCE_TYPE + "\" SERVICE_INSTANCE_ID = \"" + + SERVICE_INSTANCE_ID + "\" CURR_VERSION = \"" + CURRENT_VERSION + "\" MODIFIER = \"" + USER_UID + "\" DID = \"" + DIST_ID + + "\" STATUS = \"" + STATUS_OK + "\" DESC = \"" + DESCRIPTION + "\""; + + public final static String EXPECTED_GET_UEB_CLUSTER_LOG_STR = "ACTION = \"" + AuditingActionEnum.GET_UEB_CLUSTER.getName() + + "\" CONSUMER_ID = \"" + DIST_CONSUMER_ID + "\" STATUS = \"" + STATUS_OK + "\" STATUS_DESC = \"" + DESCRIPTION + "\""; + + + public static User user; + public static User modifier; + + public static void init(Configuration.ElasticSearchConfig esConfig) { + String appConfigDir = "src/test/resources/config/catalog-be"; + ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir); + ConfigurationManager configurationManager = new ConfigurationManager(configurationSource); + configurationManager.getConfiguration().setDisableAudit(false); + configurationManager.getConfiguration().setElasticSearch(esConfig); + + user = new User(); + modifier = new User(); + user.setFirstName(USER_FIRST_NAME); + user.setLastName(USER_LAST_NAME); + user.setUserId(USER_ID); + + modifier.setFirstName(MODIFIER_FIRST_NAME); + modifier.setLastName(MODIFIER_LAST_NAME); + modifier.setUserId(MODIFIER_ID); + } + + + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/category/AuditCategoryEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/category/AuditCategoryEventFuncTest.java new file mode 100644 index 0000000000..a774dea352 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/category/AuditCategoryEventFuncTest.java @@ -0,0 +1,127 @@ +package org.openecomp.sdc.be.auditing.impl.category; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.CategoryEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.util.ThreadLocalsHolder; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CATEGORY; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ADD_CATEGORY_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.GROUPING_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SUB_CATEGORY; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier; + +@RunWith(MockitoJUnitRunner.class) +public class AuditCategoryEventFuncTest { + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + ThreadLocalsHolder.setUuid(REQUEST_ID); + } + + @Test + public void testNewAddCategoryEvent() { + AuditEventFactory builder = new AuditAddCategoryEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + modifier, CATEGORY, SUB_CATEGORY, GROUPING_NAME, RESOURCE_TYPE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ADD_CATEGORY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_ADD_CATEGORY_LOG_STR); + verifyCategoryEvent(AuditingActionEnum.ADD_CATEGORY.getName()); + } + + @Test + public void testOldAddEcompUserCredEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ADD_CATEGORY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ADD_CATEGORY))).isEqualTo(EXPECTED_ADD_CATEGORY_LOG_STR); + verifyCategoryEvent(AuditingActionEnum.ADD_CATEGORY.getName()); + + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CATEGORY_NAME, CATEGORY); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SUB_CATEGORY_NAME, SUB_CATEGORY); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_GROUPING_NAME, GROUPING_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + + return auditingFields; + } + + private void verifyCategoryEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + CategoryEvent storedEvent = (CategoryEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); +// assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getCategoryName()).isEqualTo(CATEGORY); + assertThat(storedEvent.getSubCategoryName()).isEqualTo(SUB_CATEGORY); + assertThat(storedEvent.getGroupingName()).isEqualTo(GROUPING_NAME); + assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE); + + } +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEngineFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEngineFuncTest.java new file mode 100644 index 0000000000..199597b82c --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEngineFuncTest.java @@ -0,0 +1,191 @@ +package org.openecomp.sdc.be.auditing.impl.distribution; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.DistributionEngineEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.util.ThreadLocalsHolder; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_API_KEY; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_CONSUMER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_ENV_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_NOTIFY_TOPIC; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_ROLE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_STATUS_TOPIC; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_ADD_KEY_ENGINE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_CREATE_TOPIC_ENGINE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_REG_ENGINE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; + +@RunWith(MockitoJUnitRunner.class) +public class AuditDistrEngineFuncTest { + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + ThreadLocalsHolder.setUuid(REQUEST_ID); + } + + @Test + public void testNewAddKeyEvent() { + AuditEventFactory factory = new AuditAddKeyDistribEngineEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + DIST_CONSUMER_ID, DIST_STATUS_TOPIC, DIST_NOTIFY_TOPIC, DIST_API_KEY, DIST_ENV_NAME, DIST_ROLE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_ADD_KEY_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL.getName()); + } + + @Test + public void testOldAddKeyEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL))).isEqualTo(EXPECTED_DIST_ADD_KEY_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.ADD_KEY_TO_TOPIC_ACL.getName()); + + } + + @Test + public void testNewCreateTopicEvent() { + AuditEventFactory factory = new AuditCreateTopicDistribEngineEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + DIST_CONSUMER_ID, DIST_STATUS_TOPIC, DIST_NOTIFY_TOPIC, DIST_API_KEY, DIST_ENV_NAME, DIST_ROLE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_CREATE_TOPIC_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC.getName()); + } + + @Test + public void testOldCreateTopicEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC))).isEqualTo(EXPECTED_DIST_CREATE_TOPIC_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.CREATE_DISTRIBUTION_TOPIC.getName()); + } + + @Test + public void testNewRegisterEvent() { + AuditEventFactory factory = new AuditRegisterDistribEngineEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + DIST_CONSUMER_ID, DIST_STATUS_TOPIC, DIST_NOTIFY_TOPIC, DIST_API_KEY, DIST_ENV_NAME, DIST_ROLE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_REGISTER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_REG_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.DISTRIBUTION_REGISTER.getName()); + } + + @Test + public void testOldRegisterEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_REGISTER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DISTRIBUTION_REGISTER))).isEqualTo(EXPECTED_DIST_REG_ENGINE_LOG_STR); + verifyEvent(AuditingActionEnum.DISTRIBUTION_REGISTER.getName()); + } + + private void verifyEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + DistributionEngineEvent storedEvent = (DistributionEngineEvent) eventCaptor.getValue(); + assertThat(storedEvent.getDnotifTopic()).isEqualTo(DIST_NOTIFY_TOPIC); + assertThat(storedEvent.getDstatusTopic()).isEqualTo(DIST_STATUS_TOPIC); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getEnvironmentName()).isEqualTo(DIST_ENV_NAME); + assertThat(storedEvent.getApiKey()).isEqualTo(DIST_API_KEY); + assertThat(storedEvent.getConsumerId()).isEqualTo(DIST_CONSUMER_ID); + assertThat(storedEvent.getRole()).isEqualTo(DIST_ROLE); + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVRIONMENT_NAME, DIST_ENV_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TOPIC_NAME, DIST_STATUS_TOPIC); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_NOTIFICATION_TOPIC_NAME, DIST_NOTIFY_TOPIC); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, DIST_NOTIFY_TOPIC); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_API_KEY, DIST_API_KEY); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ROLE, DIST_ROLE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + + return auditingFields; + } + + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEventFuncTest.java new file mode 100644 index 0000000000..09a168a132 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/distribution/AuditDistrEventFuncTest.java @@ -0,0 +1,387 @@ +package org.openecomp.sdc.be.auditing.impl.distribution; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGetUebClusterEvent; +import org.openecomp.sdc.be.resources.data.auditing.DistributionDeployEvent; +import org.openecomp.sdc.be.resources.data.auditing.DistributionDownloadEvent; +import org.openecomp.sdc.be.resources.data.auditing.DistributionNotificationEvent; +import org.openecomp.sdc.be.resources.data.auditing.DistributionStatusEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.be.resources.data.auditing.model.DistributionData; +import org.openecomp.sdc.be.resources.data.auditing.model.OperationalEnvAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.util.ThreadLocalsHolder; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_STATE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_VERSION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_CONSUMER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_RESOURCE_URL; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_STATUS_TIME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DISTRIB_DEPLOY_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DISTRIB_NOTIFICATION_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_DOWNLOAD_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_STATUS_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_UEB_CLUSTER_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.OP_ENV_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TENANT_CONTEXT; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TOPIC_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_FIRST_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_LAST_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.VNF_WORKLOAD_CONTEXT; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.user; + +@RunWith(MockitoJUnitRunner.class) +public class AuditDistrEventFuncTest { + + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + ThreadLocalsHolder.setUuid(REQUEST_ID); + } + + @Test + public void testNewNotifyEvent() { + AuditEventFactory factory = new AuditDistribNotificationEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + CURRENT_STATE, CURRENT_VERSION, DIST_ID, user, + RESOURCE_NAME, RESOURCE_TYPE, TOPIC_NAME, + new OperationalEnvAuditData(OP_ENV_ID, VNF_WORKLOAD_CONTEXT, TENANT_CONTEXT)); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_NOTIFY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DISTRIB_NOTIFICATION_LOG_STR); + verifyNotifyEvent(); + } + + @Test + public void testOldNotifyEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_NOTIFY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillNotifyMap())).isEqualTo(EXPECTED_DISTRIB_NOTIFICATION_LOG_STR); + verifyNotifyEvent(); + + } + + @Test + public void testNewStatusEvent() { + AuditEventFactory factory = new AuditDistribStatusEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + DIST_ID, DIST_CONSUMER_ID, TOPIC_NAME, DIST_RESOURCE_URL, DIST_STATUS_TIME); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATUS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATUS_LOG_STR); + verifyStatusEvent(); + } + + @Test + public void testOldStatusEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_STATUS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillStatusMap())).isEqualTo(EXPECTED_DIST_STATUS_LOG_STR); + verifyStatusEvent(); + } + + @Test + public void testNewDownloadEvent() { + AuditEventFactory factory = new AuditDistribDownloadEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + new DistributionData(DIST_CONSUMER_ID, DIST_RESOURCE_URL)); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_ARTIFACT_DOWNLOAD.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_DOWNLOAD_LOG_STR); + verifyDownloadsEvent(); + } + + @Test + public void testOldDownloadEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_ARTIFACT_DOWNLOAD.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillDownloadMap())).isEqualTo(EXPECTED_DIST_DOWNLOAD_LOG_STR); + verifyDownloadsEvent(); + } + + @Test + public void testNewDeployEvent() { + AuditEventFactory factory = new AuditDistribDeployEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + CURRENT_VERSION, + DIST_ID, user, RESOURCE_NAME, RESOURCE_TYPE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_DEPLOY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DISTRIB_DEPLOY_LOG_STR); + verifyDeployEvent(); + } + + @Test + public void testOldDeployEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_DEPLOY.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillDeployMap())).isEqualTo(EXPECTED_DISTRIB_DEPLOY_LOG_STR); + verifyDeployEvent(); + } + + @Test + public void testNewGetUebClusterEvent() { + AuditEventFactory factory = new AuditGetUebClusterEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + DIST_CONSUMER_ID); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_UEB_CLUSTER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_UEB_CLUSTER_LOG_STR); + verifyGetUebClusterEvent(); + } + + @Test + public void testOldGetUebClusterEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_UEB_CLUSTER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillGetUebClusterMap())).isEqualTo(EXPECTED_GET_UEB_CLUSTER_LOG_STR); + verifyGetUebClusterEvent(); + } + + private void verifyNotifyEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + DistributionNotificationEvent storedEvent = (DistributionNotificationEvent) eventCaptor.getValue(); + assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE); + assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.DISTRIBUTION_NOTIFY.getName()); + assertThat(storedEvent.getDid()).isEqualTo(DIST_ID); + assertThat(storedEvent.getModifier()).isEqualTo(USER_UID); + assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME); + assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE); + assertThat(storedEvent.getTopicName()).isEqualTo(TOPIC_NAME); + assertThat(storedEvent.getVnfWorkloadContext()).isEqualTo(VNF_WORKLOAD_CONTEXT); + assertThat(storedEvent.getEnvId()).isEqualTo(OP_ENV_ID); + assertThat(storedEvent.getTenant()).isEqualTo(TENANT_CONTEXT); + } + + private void verifyStatusEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + DistributionStatusEvent storedEvent = (DistributionStatusEvent) eventCaptor.getValue(); + assertThat(storedEvent.getConsumerId()).isEqualTo(DIST_CONSUMER_ID); + assertThat(storedEvent.getDid()).isEqualTo(DIST_ID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.DISTRIBUTION_STATUS.getName()); + assertThat(storedEvent.getStatusTime()).isEqualTo(DIST_STATUS_TIME); + assertThat(storedEvent.getResoureURL()).isEqualTo(DIST_RESOURCE_URL); + assertThat(storedEvent.getTopicName()).isEqualTo(TOPIC_NAME); + } + + private void verifyDownloadsEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + DistributionDownloadEvent storedEvent = (DistributionDownloadEvent) eventCaptor.getValue(); + assertThat(storedEvent.getConsumerId()).isEqualTo(DIST_CONSUMER_ID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getResourceUrl()).isEqualTo(DIST_RESOURCE_URL); + } + + private void verifyDeployEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + DistributionDeployEvent storedEvent = (DistributionDeployEvent) eventCaptor.getValue(); + assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getDid()).isEqualTo(DIST_ID); + assertThat(storedEvent.getModifier()).isEqualTo(USER_UID); + assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME); + assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE); + } + + private void verifyGetUebClusterEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + AuditingGetUebClusterEvent storedEvent = (AuditingGetUebClusterEvent) eventCaptor.getValue(); + assertThat(storedEvent.getConsumerId()).isEqualTo(DIST_CONSUMER_ID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillNotifyMap() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.DISTRIBUTION_NOTIFY.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, DIST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, CURRENT_STATE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, USER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, USER_FIRST_NAME + " " + USER_LAST_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, TOPIC_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_VNF_WORKLOAD_CONTEXT, VNF_WORKLOAD_CONTEXT); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TENANT, TENANT_CONTEXT); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ENVIRONMENT_ID, OP_ENV_ID); + + return auditingFields; + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillStatusMap() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.DISTRIBUTION_STATUS.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_TOPIC_NAME, TOPIC_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, DIST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, DIST_RESOURCE_URL); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_TIME, DIST_STATUS_TIME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID); + + return auditingFields; + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillDownloadMap() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.DISTRIBUTION_ARTIFACT_DOWNLOAD.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, DIST_RESOURCE_URL); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + + return auditingFields; + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillDeployMap() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.DISTRIBUTION_DEPLOY.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, DIST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, USER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, USER_FIRST_NAME + " " + USER_LAST_NAME); + + return auditingFields; + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillGetUebClusterMap() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.GET_UEB_CLUSTER.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_STATUS_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + + return auditingFields; + } + + + + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/ecompopenv/AuditEcompOpEnvEventTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/ecompopenv/AuditEcompOpEnvEventTest.java new file mode 100644 index 0000000000..f859b75607 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/ecompopenv/AuditEcompOpEnvEventTest.java @@ -0,0 +1,156 @@ +package org.openecomp.sdc.be.auditing.impl.ecompopenv; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditEcompOpEnvEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.EcompOperationalEnvironmentEvent; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CREATE_OP_ENV_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_UNKNOWN_NOTIFICATION_OP_ENV_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_UNSUPPORTED_TYPE_OP_ENV_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.OP_ENV_ACTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.OP_ENV_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.OP_ENV_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.OP_ENV_TYPE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TENANT_CONTEXT; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; + +@RunWith(MockitoJUnitRunner.class) +public class AuditEcompOpEnvEventTest { + + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + } + + @Test + public void testNewCreateOpEnvEvent() { + AuditEventFactory factory = new AuditEcompOpEnvEventFactory(AuditingActionEnum.CREATE_ENVIRONMENT, + OP_ENV_ID, OP_ENV_NAME, OP_ENV_TYPE, OP_ENV_ACTION, TENANT_CONTEXT); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CREATE_ENVIRONMENT.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CREATE_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.CREATE_ENVIRONMENT.getName()); + } + + @Test + public void testOldCreateOpEnvEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CREATE_ENVIRONMENT.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CREATE_ENVIRONMENT))).isEqualTo(EXPECTED_CREATE_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.CREATE_ENVIRONMENT.getName()); + + } + + @Test + public void testNewUnsupportedTypeOpEnvEvent() { + AuditEventFactory factory = new AuditEcompOpEnvEventFactory(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE, + OP_ENV_ID, OP_ENV_NAME, OP_ENV_TYPE, OP_ENV_ACTION, TENANT_CONTEXT); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_UNSUPPORTED_TYPE_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getName()); + } + + @Test + public void testOldUnsupportedTypeOpEnvEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE))).isEqualTo(EXPECTED_UNSUPPORTED_TYPE_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getName()); + } + + @Test + public void testNewUnknownNotificationOpEnvEvent() { + AuditEventFactory factory = new AuditEcompOpEnvEventFactory(AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION, + OP_ENV_ID, OP_ENV_NAME, OP_ENV_TYPE, OP_ENV_ACTION, TENANT_CONTEXT); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_UNKNOWN_NOTIFICATION_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION.getName()); + } + + @Test + public void testOldUnknownNotificationOpEnvEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.UNSUPPORTED_ENVIRONMENT_TYPE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION))).isEqualTo(EXPECTED_UNKNOWN_NOTIFICATION_OP_ENV_LOG_STR); + verifyEvent(AuditingActionEnum.UNKNOWN_ENVIRONMENT_NOTIFICATION.getName()); + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_OPERATIONAL_ENVIRONMENT_ID, OP_ENV_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_OPERATIONAL_ENVIRONMENT_TYPE, OP_ENV_TYPE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_OPERATIONAL_ENVIRONMENT_NAME, OP_ENV_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_OPERATIONAL_ENVIRONMENT_ACTION, OP_ENV_ACTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_TENANT_CONTEXT, TENANT_CONTEXT); + + return auditingFields; + } + + private void verifyEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + EcompOperationalEnvironmentEvent storedEvent = (EcompOperationalEnvironmentEvent) eventCaptor.getValue(); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getOperationalEnvironmentId()).isEqualTo(OP_ENV_ID); + assertThat(storedEvent.getOperationalEnvironmentName()).isEqualTo(OP_ENV_NAME); + assertThat(storedEvent.getOperationalEnvironmentType()).isEqualTo(OP_ENV_TYPE); + assertThat(storedEvent.getTenantContext()).isEqualTo(TENANT_CONTEXT); + + + } + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/externalapi/AuditExternalApiEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/externalapi/AuditExternalApiEventFuncTest.java new file mode 100644 index 0000000000..7ddc9a0606 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/externalapi/AuditExternalApiEventFuncTest.java @@ -0,0 +1,368 @@ +package org.openecomp.sdc.be.auditing.impl.externalapi; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.ExternalApiEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.be.resources.data.auditing.model.ResourceAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_DATA; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_UUID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_STATE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_VERSION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_CONSUMER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_RESOURCE_URL; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ACTIVATE_SERVICE_API_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_ASSET_LIST_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_TOSCA_MODEL_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.INVARIANT_UUID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_STATE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_VERSION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier; + +@RunWith(MockitoJUnitRunner.class) +public class AuditExternalApiEventFuncTest { + + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + } + + @Test + public void testNewActivateServiceEvent() { + AuditEventFactory builder = new AuditActivateServiceExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_ACTIVATE_SERVICE_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getName()); + } + + @Test + public void testOldActivateServiceEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ACTIVATE_SERVICE_BY_API))).isEqualTo(EXPECTED_ACTIVATE_SERVICE_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.ACTIVATE_SERVICE_BY_API.getName()); + + } + + @Test + public void testNewDownloadArtifactEvent() { + AuditEventFactory builder = new AuditDownloadArtifactExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DOWNLOAD_ARTIFACT.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.DOWNLOAD_ARTIFACT.getName()); + } + + @Test + public void testOldDownloadArtifactEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DOWNLOAD_ARTIFACT.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DOWNLOAD_ARTIFACT))).isEqualTo(EXPECTED_DOWNLOAD_ARTIFACT_EXTERNAL_API_LOG_STR + " "); + verifyExternalApiEvent(AuditingActionEnum.DOWNLOAD_ARTIFACT.getName()); + } + + @Test + public void testNewChangeLifecycleEvent() { + AuditEventFactory factory = new AuditChangeLifecycleExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName()); + } + + @Test + public void testOldChangeLifecycleEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API))).isEqualTo(EXPECTED_CHANGE_LIFECYCLE_EXTERNAL_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.CHANGE_LIFECYCLE_BY_API.getName()); + + } + + @Test + public void testNewDeleteArtifactEvent() { + AuditEventFactory factory = new AuditDeleteArtByApiCrudExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName()); + } + + @Test + public void testOldDeleteArtifactEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ARTIFACT_DELETE_BY_API))).isEqualTo(EXPECTED_DELETE_ARTIFACT_EXTERNAL_API_LOG_STR + " "); + verifyExternalApiEvent(AuditingActionEnum.ARTIFACT_DELETE_BY_API.getName()); + + } + + @Test + public void testNewGetAssetsListEvent() { + AuditEventFactory factory = new AuditGetAssetListExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_ASSET_LIST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_ASSET_LIST_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.GET_ASSET_LIST.getName()); + } + + @Test + public void testOldGetAssetsListEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_ASSET_LIST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.GET_ASSET_LIST))).isEqualTo(EXPECTED_GET_ASSET_LIST_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.GET_ASSET_LIST.getName()); + } + + @Test + public void testNewGetToscaModelEvent() { + AuditEventFactory factory = new AuditGetToscaModelExternalApiEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + RESOURCE_TYPE, RESOURCE_NAME, DIST_CONSUMER_ID, DIST_RESOURCE_URL, + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .build(), + INVARIANT_UUID, modifier, ARTIFACT_DATA); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_TOSCA_MODEL.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_TOSCA_MODEL_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.GET_TOSCA_MODEL.getName()); + } + + @Test + public void testOldGetToscaModelEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_TOSCA_MODEL.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.GET_TOSCA_MODEL))).isEqualTo(EXPECTED_GET_TOSCA_MODEL_LOG_STR); + verifyExternalApiEvent(AuditingActionEnum.GET_TOSCA_MODEL.getName()); + } + + private void verifyExternalApiEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + ExternalApiEvent storedEvent = (ExternalApiEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getArtifactData()).isEqualTo(ARTIFACT_DATA); + assertThat(storedEvent.getCurrArtifactUuid()).isEqualTo(ARTIFACT_UUID); + assertThat(storedEvent.getPrevArtifactUuid()).isEqualTo(ARTIFACT_UUID); + assertThat(storedEvent.getPrevState()).isEqualTo(PREV_RESOURCE_STATE); + assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE); + assertThat(storedEvent.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION); + assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION); + assertThat(storedEvent.getInvariantUuid()).isEqualTo(INVARIANT_UUID); + assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME); + assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE); + + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, PREV_RESOURCE_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, PREV_RESOURCE_STATE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, CURRENT_STATE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, INVARIANT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, ARTIFACT_DATA); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, ARTIFACT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, ARTIFACT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_CONSUMER_ID, DIST_CONSUMER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_RESOURCE_URL, DIST_RESOURCE_URL); + return auditingFields; + } + + + +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/resourceadmin/AuditResourceAdminEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/resourceadmin/AuditResourceAdminEventFuncTest.java new file mode 100644 index 0000000000..18bd41c765 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/resourceadmin/AuditResourceAdminEventFuncTest.java @@ -0,0 +1,432 @@ +package org.openecomp.sdc.be.auditing.impl.resourceadmin; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.model.LifecycleStateEnum; +import org.openecomp.sdc.be.model.Resource; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.ResourceAdminEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.be.resources.data.auditing.model.ResourceAuditData; +import org.openecomp.sdc.common.api.ConfigurationSource; +import org.openecomp.sdc.common.api.Constants; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; +import org.openecomp.sdc.common.util.ThreadLocalsHolder; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_DATA; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.ARTIFACT_UUID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.COMMENT; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_STATE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.CURRENT_VERSION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DCURR_STATUS; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DIST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DPREV_STATUS; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ARTIFACT_UPLOAD_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CHECK_IN_RESOURCE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_CREATE_RESOURCE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_STATE_CHANGE_APPROV; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DIST_STATE_CHANGE_REQUEST; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_IMPORT_RESOURCE_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.INVARIANT_UUID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_STATE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.PREV_RESOURCE_VERSION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.RESOURCE_TYPE_VFC; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.SERVICE_INSTANCE_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TOSCA_NODE_TYPE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier; + +@RunWith(MockitoJUnitRunner.class) +public class AuditResourceAdminEventFuncTest { + private AuditingManager auditingManager; + + @Mock + private static AuditCassandraDao cassandraDao; + @Mock + private static ConfigurationSource configurationSource; + @Mock + private static AuditingDao auditingDao; + @Mock + private static Configuration.ElasticSearchConfig esConfig; + + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + ThreadLocalsHolder.setUuid(REQUEST_ID); + } + + @Test + public void testNewCheckInResourceAdminEvent() { + Resource resource = new Resource(); + resource.setName(RESOURCE_NAME); + resource.setUUID(SERVICE_INSTANCE_ID); + resource.setInvariantUUID(INVARIANT_UUID); + resource.setLifecycleState(LifecycleStateEnum.CERTIFIED); + resource.setVersion(CURRENT_VERSION); + + AuditEventFactory factory = new AuditCertificationResourceAdminEventFactory( + AuditingActionEnum.CHECKIN_RESOURCE, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CHECKIN_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CHECK_IN_RESOURCE_LOG_STR); + verifyResourceAdminEvent(AuditingActionEnum.CHECKIN_RESOURCE.getName()); + } + + @Test + public void testOldCheckInResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CHECKIN_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CHECKIN_RESOURCE))).isEqualTo(EXPECTED_CHECK_IN_RESOURCE_LOG_STR + " "); + verifyResourceAdminEvent(AuditingActionEnum.CHECKIN_RESOURCE.getName()); + + } + + private EnumMap<AuditingFieldsKeysEnum, Object> fillMap(AuditingActionEnum action) { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, action.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TYPE, RESOURCE_TYPE_VFC); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_VERSION, PREV_RESOURCE_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_PREV_STATE, PREV_RESOURCE_STATE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_NAME, RESOURCE_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_VERSION, CURRENT_VERSION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_CURR_STATE, CURRENT_STATE); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_SERVICE_INSTANCE_ID, SERVICE_INSTANCE_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_INVARIANT_UUID, INVARIANT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ARTIFACT_DATA, ARTIFACT_DATA); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_CURR_ARTIFACT_UUID, ARTIFACT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_PREV_ARTIFACT_UUID, ARTIFACT_UUID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DISTRIBUTION_ID, DIST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_COMMENT, COMMENT); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DCURR_STATUS, DCURR_STATUS); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_DPREV_STATUS, DPREV_STATUS); + + if (action == AuditingActionEnum.IMPORT_RESOURCE) { + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, TOSCA_NODE_TYPE); + } + else { + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_RESOURCE_TOSCA_NODE_TYPE, Constants.EMPTY_STRING); + } + + return auditingFields; + } + + @Test + public void testNewCreateResourceAdminEvent() { + + AuditEventFactory factory = new AuditCreateUpdateResourceAdminEventFactory( + AuditingActionEnum.CREATE_RESOURCE, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID, Constants.EMPTY_STRING); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.CREATE_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_CREATE_RESOURCE_LOG_STR); + verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName()); + } + + @Test + public void testOldCreateResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.CREATE_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.CREATE_RESOURCE))).isEqualTo(EXPECTED_CREATE_RESOURCE_LOG_STR + " "); + verifyResourceAdminEvent(AuditingActionEnum.CREATE_RESOURCE.getName()); + + } + + @Test + public void testNewImportResourceAdminEvent() { + + Resource resource = new Resource(); + resource.setName(RESOURCE_NAME); + resource.setVersion(CURRENT_VERSION); + resource.setInvariantUUID(INVARIANT_UUID); + resource.setUUID(SERVICE_INSTANCE_ID); + resource.setState(LifecycleStateEnum.CERTIFIED); + resource.setToscaType(TOSCA_NODE_TYPE); + + AuditEventFactory factory = new AuditImportResourceAdminEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID, TOSCA_NODE_TYPE); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_IMPORT_RESOURCE_LOG_STR); + verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName()); + } + + @Test + public void testOldImportResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.IMPORT_RESOURCE))).isEqualTo(EXPECTED_IMPORT_RESOURCE_LOG_STR + " "); + verifyResourceAdminEvent(AuditingActionEnum.IMPORT_RESOURCE.getName()); + + } + + @Test + public void testNewArtifactUploadResourceAdminEvent() { + + AuditEventFactory factory = new AuditArtifactResourceAdminEventFactory( + AuditingActionEnum.ARTIFACT_UPLOAD, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ARTIFACT_UPLOAD.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ARTIFACT_UPLOAD_LOG_STR); + verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_UPLOAD.getName()); + } + + @Test + public void testOldArtifactUploadResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.IMPORT_RESOURCE.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.ARTIFACT_UPLOAD))).isEqualTo(EXPECTED_ARTIFACT_UPLOAD_LOG_STR + " "); + verifyResourceAdminEvent(AuditingActionEnum.ARTIFACT_UPLOAD.getName()); + + } + + @Test + public void testNewDistStateChangeRequestResourceAdminEvent() { + + AuditEventFactory factory = new AuditDistStateChangeRequestResourceAdminEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_REQUEST); + verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName()); + } + + @Test + public void testOldDistStateChangeRequestResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST))).isEqualTo(EXPECTED_DIST_STATE_CHANGE_REQUEST); + verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getName()); + } + + @Test + public void testNewDistStateChangeApprovResourceAdminEvent() { + + AuditEventFactory factory = new AuditDistStateChangeResourceAdminEventFactory( + AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .serviceInstanceId(SERVICE_INSTANCE_ID) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(PREV_RESOURCE_STATE) + .version(PREV_RESOURCE_VERSION) + .distributionStatus(DPREV_STATUS) + .build(), + ResourceAuditData.newBuilder() + .artifactUuid(ARTIFACT_UUID) + .state(CURRENT_STATE) + .version(CURRENT_VERSION) + .distributionStatus(DCURR_STATUS) + .build(), + RESOURCE_TYPE_VFC, RESOURCE_NAME, INVARIANT_UUID, modifier, + ARTIFACT_DATA, COMMENT, DIST_ID); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_REQUEST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DIST_STATE_CHANGE_APPROV); + verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName()); + } + + @Test + public void testOldDistStateChangeApprovResourceAdminEvent() { + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(fillMap(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV))).isEqualTo(EXPECTED_DIST_STATE_CHANGE_APPROV); + verifyResourceAdminEvent(AuditingActionEnum.DISTRIBUTION_STATE_CHANGE_APPROV.getName()); + } + + + private void verifyResourceAdminEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + ResourceAdminEvent storedEvent = (ResourceAdminEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); + assertThat(storedEvent.getServiceInstanceId()).isEqualTo(SERVICE_INSTANCE_ID); + assertThat(storedEvent.getAction()).isEqualTo(action); + assertThat(storedEvent.getArtifactData()).isEqualTo(ARTIFACT_DATA); + assertThat(storedEvent.getComment()).isEqualTo(COMMENT); + assertThat(storedEvent.getCurrArtifactUUID()).isEqualTo(ARTIFACT_UUID); + assertThat(storedEvent.getPrevArtifactUUID()).isEqualTo(ARTIFACT_UUID); + assertThat(storedEvent.getPrevState()).isEqualTo(PREV_RESOURCE_STATE); + assertThat(storedEvent.getCurrState()).isEqualTo(CURRENT_STATE); + assertThat(storedEvent.getPrevVersion()).isEqualTo(PREV_RESOURCE_VERSION); + assertThat(storedEvent.getCurrVersion()).isEqualTo(CURRENT_VERSION); + assertThat(storedEvent.getDcurrStatus()).isEqualTo(DCURR_STATUS); + assertThat(storedEvent.getDprevStatus()).isEqualTo(DPREV_STATUS); + assertThat(storedEvent.getDid()).isEqualTo(DIST_ID); + assertThat(storedEvent.getInvariantUUID()).isEqualTo(INVARIANT_UUID); + assertThat(storedEvent.getResourceName()).isEqualTo(RESOURCE_NAME); + assertThat(storedEvent.getResourceType()).isEqualTo(RESOURCE_TYPE_VFC); + + if (action.equals(AuditingActionEnum.IMPORT_RESOURCE.getName())) { + assertThat(storedEvent.getToscaNodeType()).isEqualTo(TOSCA_NODE_TYPE); + } else { + assertThat(storedEvent.getToscaNodeType()).isEmpty(); + } + } +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/usersadmin/AuditUserEventFuncTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/usersadmin/AuditUserEventFuncTest.java new file mode 100644 index 0000000000..4a5b1bbd59 --- /dev/null +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/usersadmin/AuditUserEventFuncTest.java @@ -0,0 +1,395 @@ +package org.openecomp.sdc.be.auditing.impl.usersadmin; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnitRunner; +import org.openecomp.sdc.be.auditing.api.AuditEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditAuthRequestEventFactory; +import org.openecomp.sdc.be.auditing.impl.AuditingManager; +import org.openecomp.sdc.be.config.Configuration; +import org.openecomp.sdc.be.dao.api.ActionStatus; +import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao; +import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus; +import org.openecomp.sdc.be.dao.impl.AuditingDao; +import org.openecomp.sdc.be.model.User; +import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum; +import org.openecomp.sdc.be.resources.data.auditing.AuditingGenericEvent; +import org.openecomp.sdc.be.resources.data.auditing.AuthEvent; +import org.openecomp.sdc.be.resources.data.auditing.GetUsersListEvent; +import org.openecomp.sdc.be.resources.data.auditing.UserAccessEvent; +import org.openecomp.sdc.be.resources.data.auditing.UserAdminEvent; +import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData; +import org.openecomp.sdc.common.datastructure.AuditingFieldsKeysEnum; + +import java.util.EnumMap; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.AUTH_STATUS; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.AUTH_URL; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESCRIPTION; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.DESIGNER_USER_ROLE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_ADD_USER_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_AUTH_REQUEST_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_DELETE_USER_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_GET_USER_LIST_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_UPDATE_USER_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.EXPECTED_USER_ACCESS_LOG_STR; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.MODIFIER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REALM; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.REQUEST_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_CREATED; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.STATUS_OK; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.TESTER_USER_ROLE; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.UPDATED_USER_EXTENDED_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_DETAILS; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_EMAIL; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_EXTENDED_NAME; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_ID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.USER_UID; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.init; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.modifier; +import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.user; + +@RunWith(MockitoJUnitRunner.class) +public class AuditUserEventFuncTest { + @Mock + private static AuditCassandraDao cassandraDao; + @Captor + private ArgumentCaptor<AuditingGenericEvent> eventCaptor; + @Mock + private static AuditingDao auditingDao; + @Mock + private Configuration.ElasticSearchConfig esConfig; + + private AuditingManager auditingManager; + + @Before + public void setUp() { + init(esConfig); + auditingManager = new AuditingManager(auditingDao, cassandraDao); + } + + @Test + public void testNewUserAccessEvent() { + AuditEventFactory factory = new AuditUserAccessEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .build(), + user); + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.USER_ACCESS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_USER_ACCESS_LOG_STR); + verifyUserAccessEvent(); + } + + @Test + public void testOldUserAccessEvent() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.USER_ACCESS.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_UID, user.getFirstName() + " " + user.getLastName() + '(' + user.getUserId() + ')'); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.USER_ACCESS.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_USER_ACCESS_LOG_STR); + verifyUserAccessEvent(); + } + + @Test + public void testNewUserAdminEventForAddUser() { + + user.setRole(DESIGNER_USER_ROLE); + user.setEmail(USER_EMAIL); + + AuditEventFactory factory = new AuditUserAdminEventFactory(AuditingActionEnum.ADD_USER, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_CREATED) + .requestId(REQUEST_ID) + .build(), + modifier, null, user); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ADD_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ADD_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.ADD_USER.getName()); + } + + @Test + public void testOldUserAdminEventForAddUser() { + user.setRole(TESTER_USER_ROLE); + user.setEmail(USER_EMAIL); + + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.ADD_USER.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_CREATED); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, null); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, USER_EXTENDED_NAME); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.ADD_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_ADD_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.ADD_USER.getName()); + } + + @Test + public void testNewUserAdminEventForUpdateUser() { + + user.setRole(DESIGNER_USER_ROLE); + user.setEmail(USER_EMAIL); + + User updated = new User(user); + updated.setRole(TESTER_USER_ROLE); + + AuditEventFactory builder = new AuditUserAdminEventFactory(AuditingActionEnum.UPDATE_USER, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .build(), + modifier, user, updated); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.UPDATE_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_UPDATE_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.UPDATE_USER.getName()); + } + + @Test + public void testOldUserAdminEventForUpdateUser() { + user.setRole(DESIGNER_USER_ROLE); + user.setEmail(USER_EMAIL); + + User updated = new User(user); + updated.setRole(TESTER_USER_ROLE); + + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.UPDATE_USER.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, USER_EXTENDED_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, UPDATED_USER_EXTENDED_NAME); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.UPDATE_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_UPDATE_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.UPDATE_USER.getName()); + } + + @Test + public void testNewUserAdminEventForDeleteUser() { + + user.setRole(DESIGNER_USER_ROLE); + user.setEmail(USER_EMAIL); + + AuditEventFactory factory = new AuditUserAdminEventFactory(AuditingActionEnum.DELETE_USER, + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .build(), + modifier, user, null); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DELETE_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DELETE_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.DELETE_USER.getName()); + } + + @Test + public void testOldUserAdminEventForDeleteUser() { + user.setRole(TESTER_USER_ROLE); + user.setEmail(USER_EMAIL); + + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.DELETE_USER.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, modifier.getFirstName() + " " + modifier.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, modifier.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_BEFORE, USER_EXTENDED_NAME); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_AFTER, null); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.DELETE_USER.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_DELETE_USER_LOG_STR); + verifyUserEvent(AuditingActionEnum.DELETE_USER.getName()); + } + + @Test + public void testNewGetUserListEvent() { + + AuditEventFactory factory = new AuditGetUsersListEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .build(), + user, USER_DETAILS); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_USERS_LIST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_USER_LIST_LOG_STR); + verifyGetUserListEvent(); + } + + @Test + public void testOldGetUserListEvent() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.GET_USERS_LIST.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_NAME, user.getFirstName() + " " + user.getLastName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_MODIFIER_UID, user.getUserId()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_USER_DETAILS, USER_DETAILS); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.GET_USERS_LIST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_GET_USER_LIST_LOG_STR); + verifyGetUserListEvent(); + } + + @Test + public void testNewAuthRequestEvent() { + + AuditEventFactory factory = new AuditAuthRequestEventFactory( + CommonAuditData.newBuilder() + .description(DESCRIPTION) + .status(STATUS_OK) + .requestId(REQUEST_ID) + .build(), + USER_ID, AUTH_URL, REALM, AUTH_STATUS); + + when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.AUTH_REQUEST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_AUTH_REQUEST_LOG_STR); + verifyAuthRequestEvent(); + } + + @Test + public void testOldAuthRequestEvent() { + EnumMap<AuditingFieldsKeysEnum, Object> auditingFields = new EnumMap<>(AuditingFieldsKeysEnum.class); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_ACTION, AuditingActionEnum.AUTH_REQUEST.getName()); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_USER, USER_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_STATUS, STATUS_OK); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_DESC, DESCRIPTION); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_REQUEST_ID, REQUEST_ID); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_REALM, REALM); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_URL, AUTH_URL); + auditingFields.put(AuditingFieldsKeysEnum.AUDIT_AUTH_STATUS, AUTH_STATUS); + + when(auditingDao.addRecord(anyMap(), eq(AuditingActionEnum.AUTH_REQUEST.getAuditingEsType()))) + .thenReturn(ActionStatus.OK); + when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK); + + assertThat(auditingManager.auditEvent(auditingFields)).isEqualTo(EXPECTED_AUTH_REQUEST_LOG_STR); + verifyAuthRequestEvent(); + } + + + private void verifyUserEvent(String action) { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + UserAdminEvent storedEvent = (UserAdminEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); +// assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); - it is not filled out by the old code!!! + assertThat(storedEvent.getServiceInstanceId()).isNull(); + assertThat(storedEvent.getAction()).isEqualTo(action); + if (action.equals(AuditingActionEnum.ADD_USER.getName())) { + //TODO enable this test after deleting the old auditEvent method +// assertThat(storedEvent.getUserBefore()).isNull(); + assertThat(storedEvent.getUserAfter()).isEqualTo(USER_EXTENDED_NAME); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_CREATED); + } + else if (action.equals(AuditingActionEnum.UPDATE_USER.getName())){ + assertThat(storedEvent.getUserBefore()).isEqualTo(USER_EXTENDED_NAME); + assertThat(storedEvent.getUserAfter()).isEqualTo(UPDATED_USER_EXTENDED_NAME); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + } + else { + assertThat(storedEvent.getUserBefore()).isEqualTo(USER_EXTENDED_NAME); + //TODO enable this test after deleting the old auditEvent method +// assertThat(storedEvent.getUserAfter()).isNull(); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + } + } + + private void verifyGetUserListEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + GetUsersListEvent storedEvent = (GetUsersListEvent) eventCaptor.getValue(); + assertThat(storedEvent.getModifier()).isEqualTo(USER_UID); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getServiceInstanceId()).isNull(); + assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.GET_USERS_LIST.getName()); + } + + private void verifyUserAccessEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + UserAccessEvent storedEvent = (UserAccessEvent) eventCaptor.getValue(); + assertThat(storedEvent.getUserUid()).isEqualTo(USER_UID); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getRequestId()).isNotBlank(); + assertThat(storedEvent.getServiceInstanceId()).isNull(); + assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.USER_ACCESS.getName()); + } + + private void verifyAuthRequestEvent() { + verify(cassandraDao).saveRecord(eventCaptor.capture()); + AuthEvent storedEvent = (AuthEvent) eventCaptor.getValue(); + assertThat(storedEvent.getUser()).isEqualTo(USER_ID); + assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK); + assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION); + assertThat(storedEvent.getRequestId()).isNotBlank(); + assertThat(storedEvent.getServiceInstanceId()).isNull(); + assertThat(storedEvent.getAuthStatus()).isEqualTo(AUTH_STATUS); + assertThat(storedEvent.getUrl()).isEqualTo(AUTH_URL); + assertThat(storedEvent.getRealm()).isEqualTo(REALM); + assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.AUTH_REQUEST.getName()); + } + +} |