catalog-be/src/test/java/org/openecomp/sdc/be/auditing/impl/usersadmin/AuditUserEventFuncTest.java

   1 package org.openecomp.sdc.be.auditing.impl.usersadmin;
   2
   3 import org.junit.Before;
   4 import org.junit.Test;
   5 import org.junit.runner.RunWith;
   6 import org.mockito.ArgumentCaptor;
   7 import org.mockito.Captor;
   8 import org.mockito.Mock;
   9 import org.mockito.junit.MockitoJUnitRunner;
  10 import org.openecomp.sdc.be.auditing.api.AuditEventFactory;
  11 import org.openecomp.sdc.be.auditing.impl.AuditAuthRequestEventFactory;
  12 import org.openecomp.sdc.be.auditing.impl.AuditingManager;
  13 import org.openecomp.sdc.be.config.Configuration;
  14 import org.openecomp.sdc.be.dao.api.ActionStatus;
  15 import org.openecomp.sdc.be.dao.cassandra.AuditCassandraDao;
  16 import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
  17 import org.openecomp.sdc.be.dao.impl.AuditingDao;
  18 import org.openecomp.sdc.be.model.User;
  19 import org.openecomp.sdc.be.resources.data.auditing.*;
  20 import org.openecomp.sdc.be.resources.data.auditing.model.CommonAuditData;
  21
  22 import static org.assertj.core.api.Assertions.assertThat;
  23 import static org.mockito.ArgumentMatchers.any;
  24 import static org.mockito.ArgumentMatchers.eq;
  25 import static org.mockito.Mockito.verify;
  26 import static org.mockito.Mockito.when;
  27 import static org.openecomp.sdc.be.auditing.impl.AuditTestUtils.*;
  28
  29
  30 @RunWith(MockitoJUnitRunner.class)
  31 public class AuditUserEventFuncTest {
  32     @Mock
  33     private static AuditCassandraDao cassandraDao;
  34     @Captor
  35     private ArgumentCaptor<AuditingGenericEvent> eventCaptor;
  36     @Mock
  37     private static AuditingDao auditingDao;
  38     @Mock
  39     private Configuration.ElasticSearchConfig esConfig;
  40
  41     private AuditingManager auditingManager;
  42
  43     @Before
  44     public void setUp() {
  45         init(esConfig);
  46         auditingManager = new AuditingManager(auditingDao, cassandraDao);
  47     }
  48
  49     @Test
  50     public void testUserAccessEvent() {
  51         AuditEventFactory factory = new AuditUserAccessEventFactory(
  52                 CommonAuditData.newBuilder()
  53                         .description(DESCRIPTION)
  54                         .status(STATUS_OK)
  55                         .requestId(REQUEST_ID)
  56                         .build(),
  57                 user);
  58         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.USER_ACCESS.getAuditingEsType())))
  59                 .thenReturn(ActionStatus.OK);
  60         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
  61
  62         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_USER_ACCESS_LOG_STR);
  63         verifyUserAccessEvent();
  64     }
  65
  66     @Test
  67     public void testUserAdminEventForAddUser() {
  68
  69         user.setRole(DESIGNER_USER_ROLE);
  70         user.setEmail(USER_EMAIL);
  71
  72         AuditEventFactory factory = new AuditUserAdminEventFactory(AuditingActionEnum.ADD_USER,
  73                 CommonAuditData.newBuilder()
  74                         .description(DESCRIPTION)
  75                         .status(STATUS_CREATED)
  76                         .requestId(REQUEST_ID)
  77                         .build(),
  78                 modifier, null, user);
  79
  80         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.ADD_USER.getAuditingEsType())))
  81                 .thenReturn(ActionStatus.OK);
  82         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
  83
  84         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_ADD_USER_LOG_STR);
  85         verifyUserEvent(AuditingActionEnum.ADD_USER.getName());
  86     }
  87
  88     @Test
  89     public void testUserAdminEventForUpdateUser() {
  90
  91         user.setRole(DESIGNER_USER_ROLE);
  92         user.setEmail(USER_EMAIL);
  93
  94         User updated = new User(user);
  95         updated.setRole(TESTER_USER_ROLE);
  96
  97         AuditEventFactory builder = new AuditUserAdminEventFactory(AuditingActionEnum.UPDATE_USER,
  98                 CommonAuditData.newBuilder()
  99                         .description(DESCRIPTION)
 100                         .status(STATUS_OK)
 101                         .requestId(REQUEST_ID)
 102                         .build(),
 103                 modifier, user, updated);
 104
 105         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.UPDATE_USER.getAuditingEsType())))
 106                 .thenReturn(ActionStatus.OK);
 107         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 108
 109         assertThat(auditingManager.auditEvent(builder)).isEqualTo(EXPECTED_UPDATE_USER_LOG_STR);
 110         verifyUserEvent(AuditingActionEnum.UPDATE_USER.getName());
 111     }
 112
 113     @Test
 114     public void testUserAdminEventForDeleteUser() {
 115
 116         user.setRole(DESIGNER_USER_ROLE);
 117         user.setEmail(USER_EMAIL);
 118
 119         AuditEventFactory factory = new AuditUserAdminEventFactory(AuditingActionEnum.DELETE_USER,
 120                 CommonAuditData.newBuilder()
 121                         .description(DESCRIPTION)
 122                         .status(STATUS_OK)
 123                         .requestId(REQUEST_ID)
 124                         .build(),
 125                 modifier, user, null);
 126
 127         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.DELETE_USER.getAuditingEsType())))
 128                 .thenReturn(ActionStatus.OK);
 129         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 130
 131         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_DELETE_USER_LOG_STR);
 132         verifyUserEvent(AuditingActionEnum.DELETE_USER.getName());
 133     }
 134
 135     @Test
 136     public void testGetUserListEvent() {
 137
 138         AuditEventFactory factory = new AuditGetUsersListEventFactory(
 139                 CommonAuditData.newBuilder()
 140                         .description(DESCRIPTION)
 141                         .status(STATUS_OK)
 142                         .requestId(REQUEST_ID)
 143                         .build(),
 144                 user, USER_DETAILS);
 145
 146         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.GET_USERS_LIST.getAuditingEsType())))
 147                 .thenReturn(ActionStatus.OK);
 148         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 149
 150         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_GET_USER_LIST_LOG_STR);
 151         verifyGetUserListEvent();
 152     }
 153
 154     @Test
 155     public void testAuthRequestEvent() {
 156
 157         AuditEventFactory factory = new AuditAuthRequestEventFactory(
 158                 CommonAuditData.newBuilder()
 159                         .description(DESCRIPTION)
 160                         .status(STATUS_OK)
 161                         .requestId(REQUEST_ID)
 162                         .build(),
 163                 USER_ID, AUTH_URL, REALM, AUTH_STATUS);
 164
 165         when(auditingDao.addRecord(any(AuditingGenericEvent.class), eq(AuditingActionEnum.AUTH_REQUEST.getAuditingEsType())))
 166                 .thenReturn(ActionStatus.OK);
 167         when(cassandraDao.saveRecord(any(AuditingGenericEvent.class))).thenReturn(CassandraOperationStatus.OK);
 168
 169         assertThat(auditingManager.auditEvent(factory)).isEqualTo(EXPECTED_AUTH_REQUEST_LOG_STR);
 170         verifyAuthRequestEvent();
 171     }
 172
 173     private void verifyUserEvent(String action) {
 174         verify(cassandraDao).saveRecord(eventCaptor.capture());
 175         UserAdminEvent storedEvent = (UserAdminEvent) eventCaptor.getValue();
 176         assertThat(storedEvent.getModifier()).isEqualTo(MODIFIER_UID);
 177         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 178 //        assertThat(storedEvent.getRequestId()).isEqualTo(REQUEST_ID); - it is not filled out by the old code!!!
 179         assertThat(storedEvent.getServiceInstanceId()).isNull();
 180         assertThat(storedEvent.getAction()).isEqualTo(action);
 181         if (action.equals(AuditingActionEnum.ADD_USER.getName())) {
 182             //TODO enable this test after deleting the old auditEvent method
 183 //            assertThat(storedEvent.getUserBefore()).isNull();
 184             assertThat(storedEvent.getUserAfter()).isEqualTo(USER_EXTENDED_NAME);
 185             assertThat(storedEvent.getStatus()).isEqualTo(STATUS_CREATED);
 186         }
 187         else if (action.equals(AuditingActionEnum.UPDATE_USER.getName())){
 188             assertThat(storedEvent.getUserBefore()).isEqualTo(USER_EXTENDED_NAME);
 189             assertThat(storedEvent.getUserAfter()).isEqualTo(UPDATED_USER_EXTENDED_NAME);
 190             assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK);
 191         }
 192         else {
 193             assertThat(storedEvent.getUserBefore()).isEqualTo(USER_EXTENDED_NAME);
 194             //TODO enable this test after deleting the old auditEvent method
 195 //            assertThat(storedEvent.getUserAfter()).isNull();
 196             assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK);
 197         }
 198     }
 199
 200     private void verifyGetUserListEvent() {
 201         verify(cassandraDao).saveRecord(eventCaptor.capture());
 202         GetUsersListEvent storedEvent = (GetUsersListEvent) eventCaptor.getValue();
 203         assertThat(storedEvent.getModifier()).isEqualTo(USER_UID);
 204         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 205         assertThat(storedEvent.getServiceInstanceId()).isNull();
 206         assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.GET_USERS_LIST.getName());
 207     }
 208
 209     private void verifyUserAccessEvent() {
 210         verify(cassandraDao).saveRecord(eventCaptor.capture());
 211         UserAccessEvent storedEvent = (UserAccessEvent) eventCaptor.getValue();
 212         assertThat(storedEvent.getUserUid()).isEqualTo(USER_UID);
 213         assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK);
 214         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 215         assertThat(storedEvent.getRequestId()).isNotBlank();
 216         assertThat(storedEvent.getServiceInstanceId()).isNull();
 217         assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.USER_ACCESS.getName());
 218     }
 219
 220     private void verifyAuthRequestEvent() {
 221         verify(cassandraDao).saveRecord(eventCaptor.capture());
 222         AuthEvent storedEvent = (AuthEvent) eventCaptor.getValue();
 223         assertThat(storedEvent.getUser()).isEqualTo(USER_ID);
 224         assertThat(storedEvent.getStatus()).isEqualTo(STATUS_OK);
 225         assertThat(storedEvent.getDesc()).isEqualTo(DESCRIPTION);
 226         assertThat(storedEvent.getRequestId()).isNotBlank();
 227         assertThat(storedEvent.getServiceInstanceId()).isNull();
 228         assertThat(storedEvent.getAuthStatus()).isEqualTo(AUTH_STATUS);
 229         assertThat(storedEvent.getUrl()).isEqualTo(AUTH_URL);
 230         assertThat(storedEvent.getRealm()).isEqualTo(REALM);
 231         assertThat(storedEvent.getAction()).isEqualTo(AuditingActionEnum.AUTH_REQUEST.getName());
 232     }
 233
 234 }