chore(unit-tests): library services and TransactionAuditService,TransactionService

src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java

@@ -1,5 +1,7 @@
 package org.folio.dcb.service;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.BORROWER;
 import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.AWAITING_PICKUP;
 import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CANCELLED;
@@ -12,8 +14,6 @@
 import static org.folio.dcb.utils.EntityUtils.createDcbTransactionByRole;
 import static org.folio.dcb.utils.EntityUtils.createServicePointRequest;
 import static org.folio.dcb.utils.EntityUtils.createTransactionEntity;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doNothing;
@@ -55,7 +55,7 @@ void testTransactionStatusUpdateFromOpenToAwaitingPickup() {
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkInByBarcode(any());
-    assertEquals(AWAITING_PICKUP, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(AWAITING_PICKUP);
     verify(transactionRepository).save(any());
   }
 
@@ -69,28 +69,29 @@ void testTransactionStatusUpdateFromCreatedToOpen() {
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkInByBarcode(any(), any());
-    assertEquals(OPEN, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(OPEN);
   }
 
   @Test
   void testTransactionStatusUpdateWithIncorrectStatus() {
     var transactionEntity = createTransactionEntity();
     transactionEntity.setStatus(CREATED);
     var transactionStatus = TransactionStatus.builder().status(AWAITING_PICKUP).build();
-    assertThrows(IllegalArgumentException.class, () ->
-      borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus));
+    assertThatThrownBy(() -> borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus))
+      .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void createTransactionTest() {
     var servicePointRequest = createServicePointRequest();
     var dcbTransaction = createDcbTransactionByRole(BORROWER);
+    assertThat(dcbTransaction.getPickup()).isNotNull();
     servicePointRequest.setId(UUID.randomUUID().toString());
     when(servicePointService.createServicePointIfNotExists(dcbTransaction)).thenReturn(servicePointRequest);
 
     borrowingLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction);
 
-    assertEquals(servicePointRequest.getId(), dcbTransaction.getPickup().getServicePointId());
+    assertThat(dcbTransaction.getPickup().getServicePointId()).isEqualTo(servicePointRequest.getId());
     verify(baseLibraryService).createBorrowingLibraryTransaction(
       DCB_TRANSACTION_ID, dcbTransaction, servicePointRequest.getId());
   }
@@ -103,7 +104,7 @@ void testTransactionStatusUpdateFromItemCheckedInToClosed() {
 
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
-    assertEquals(CLOSED, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(CLOSED);
   }
 
   @Test
@@ -116,7 +117,7 @@ void testTransactionStatusUpdateFromAwaitingPickupToItemCheckedOut() {
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkOutByBarcode(any());
-    assertEquals(ITEM_CHECKED_OUT, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(ITEM_CHECKED_OUT);
   }
 
   @Test
@@ -129,7 +130,7 @@ void testTransactionStatusUpdateFromItemCheckedOutToItemCheckedIn() {
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkInByBarcode(any(), any());
-    assertEquals(ITEM_CHECKED_IN, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(ITEM_CHECKED_IN);
   }
 
   @Test
@@ -148,7 +149,7 @@ void testTransactionStatusUpdateFromItemCheckedOutToItemCheckedInWithFoundByLibr
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkInByBarcode(any(), any(), eq(ClaimedReturnedResolution.FOUND_BY_LIBRARY));
-    assertEquals(ITEM_CHECKED_IN, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(ITEM_CHECKED_IN);
   }
 
   @Test
@@ -167,7 +168,7 @@ void testTransactionStatusUpdateFromItemCheckedOutToItemCheckedInWithReturnedByP
     borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus);
 
     verify(circulationService).checkInByBarcode(any(), any(), eq(ClaimedReturnedResolution.RETURNED_BY_PATRON));
-    assertEquals(ITEM_CHECKED_IN, transactionEntity.getStatus());
+    assertThat(transactionEntity.getStatus()).isEqualTo(ITEM_CHECKED_IN);
   }
 
   @Test

src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java

@@ -1,6 +1,10 @@
 package org.folio.dcb.service;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.LENDER;
+import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CREATED;
+import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.OPEN;
 import static org.folio.dcb.utils.EntityUtils.CIRCULATION_REQUEST_ID;
 import static org.folio.dcb.utils.EntityUtils.DCB_TRANSACTION_ID;
 import static org.folio.dcb.utils.EntityUtils.createCirculationRequest;
@@ -9,25 +13,21 @@
 import static org.folio.dcb.utils.EntityUtils.createTransactionEntity;
 import static org.folio.dcb.utils.EntityUtils.createTransactionStatus;
 import static org.folio.dcb.utils.EntityUtils.createUser;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import java.util.UUID;
 import org.folio.dcb.domain.dto.TransactionStatus;
+import org.folio.dcb.domain.dto.TransactionStatus.StatusEnum;
 import org.folio.dcb.domain.dto.TransactionStatusResponse;
-import org.folio.dcb.domain.entity.TransactionEntity;
 import org.folio.dcb.repository.TransactionRepository;
 import org.folio.dcb.service.impl.BaseLibraryService;
 import org.folio.dcb.service.impl.CirculationServiceImpl;
 import org.folio.dcb.service.impl.LendingLibraryServiceImpl;
 import org.folio.dcb.service.impl.RequestServiceImpl;
 import org.folio.dcb.service.impl.UserServiceImpl;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
@@ -48,78 +48,91 @@ class LendingLibraryServiceTest {
 
   @Test
   void createTransactionTest() {
-    var user = createUser();
     var dcbTransaction = createDcbTransactionByRole(LENDER);
-    var servicePoint = createServicePointRequest();
-    servicePoint.setId(UUID.randomUUID().toString());
-
-    when(userService.fetchOrCreateUser(any()))
-      .thenReturn(user);
-    when(servicePointService.createServicePointIfNotExists(dcbTransaction))
-        .thenReturn(servicePoint);
-    when(requestService.createRequestBasedOnItemStatus(any(), any(), anyString()))
-        .thenReturn(createCirculationRequest());
+    assertThat(dcbTransaction.getPatron()).isNotNull();
+    assertThat(dcbTransaction.getItem()).isNotNull();
+    assertThat(dcbTransaction.getPickup()).isNotNull();
+
+    var user = createUser();
+    var servicePoint = createServicePointRequest().id(UUID.randomUUID().toString());
+
+    when(userService.fetchOrCreateUser(any())).thenReturn(user);
+    when(servicePointService.createServicePointIfNotExists(dcbTransaction)).thenReturn(servicePoint);
+    when(requestService.createRequestBasedOnItemStatus(any(), any(), any())).thenReturn(createCirculationRequest());
     doNothing().when(baseLibraryService).saveDcbTransaction(any(), any(), any());
 
     var response = lendingLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction);
-    Assertions.assertEquals(TransactionStatusResponse.StatusEnum.CREATED, response.getStatus());
+
+    assertThat(response.getStatus()).isEqualTo(TransactionStatusResponse.StatusEnum.CREATED);
     verify(userService).fetchOrCreateUser(dcbTransaction.getPatron());
     verify(requestService).createRequestBasedOnItemStatus(
       user, dcbTransaction.getItem(), dcbTransaction.getPickup().getServicePointId());
     verify(baseLibraryService).saveDcbTransaction(DCB_TRANSACTION_ID, dcbTransaction, CIRCULATION_REQUEST_ID);
-    assertEquals(servicePoint.getId(), dcbTransaction.getPickup().getServicePointId());
+    assertThat(dcbTransaction.getPickup().getServicePointId()).isEqualTo(servicePoint.getId());
   }
 
   @Test
   void transactionStatusFromOpenToAwaitingTest() {
-    TransactionEntity dcbTransaction = createTransactionEntity();
+    var dcbTransaction = createTransactionEntity();
     dcbTransaction.setStatus(TransactionStatus.StatusEnum.OPEN);
     doNothing().when(circulationService).checkInByBarcode(dcbTransaction);
-    lendingLibraryService.updateTransactionStatus(dcbTransaction,
-      TransactionStatus.builder().status(TransactionStatus.StatusEnum.AWAITING_PICKUP).build());
+    var awaitingPickupStatus = TransactionStatus.builder().status(StatusEnum.AWAITING_PICKUP).build();
 
-    verify(circulationService).checkInByBarcode(dcbTransaction);
+    lendingLibraryService.updateTransactionStatus(dcbTransaction, awaitingPickupStatus);
 
-    Assertions.assertEquals(TransactionStatus.StatusEnum.AWAITING_PICKUP, dcbTransaction.getStatus());
+    assertThat(dcbTransaction.getStatus()).isEqualTo(TransactionStatus.StatusEnum.AWAITING_PICKUP);
+    verify(circulationService).checkInByBarcode(dcbTransaction);
   }
 
   @Test
   void transactionStatusFromAwaitingToCheckoutTest() {
-    TransactionEntity dcbTransaction = createTransactionEntity();
+    var dcbTransaction = createTransactionEntity();
     dcbTransaction.setStatus(TransactionStatus.StatusEnum.AWAITING_PICKUP);
     doNothing().when(circulationService).checkOutByBarcode(dcbTransaction);
-    lendingLibraryService.updateTransactionStatus(dcbTransaction,
-      TransactionStatus.builder().status(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT).build());
+    var checkedOutStatus = TransactionStatus.builder().status(StatusEnum.ITEM_CHECKED_OUT).build();
 
-    verify(circulationService).checkOutByBarcode(dcbTransaction);
+    lendingLibraryService.updateTransactionStatus(dcbTransaction, checkedOutStatus);
 
-    Assertions.assertEquals(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT, dcbTransaction.getStatus());
+    verify(circulationService).checkOutByBarcode(dcbTransaction);
+    assertThat(dcbTransaction.getStatus()).isEqualTo(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT);
   }
 
   @Test
   void transactionStatusFromCheckoutToCheckInTest() {
-    TransactionEntity dcbTransaction = createTransactionEntity();
+    var dcbTransaction = createTransactionEntity();
     dcbTransaction.setStatus(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT);
-    lendingLibraryService.updateTransactionStatus(dcbTransaction,
-      TransactionStatus.builder().status(TransactionStatus.StatusEnum.ITEM_CHECKED_IN).build());
-
-    Assertions.assertEquals(TransactionStatus.StatusEnum.ITEM_CHECKED_IN, dcbTransaction.getStatus());
+    var checkedInStatus = TransactionStatus.builder().status(StatusEnum.ITEM_CHECKED_IN).build();
+    lendingLibraryService.updateTransactionStatus(dcbTransaction, checkedInStatus);
+    assertThat(dcbTransaction.getStatus()).isEqualTo(TransactionStatus.StatusEnum.ITEM_CHECKED_IN);
   }
 
   @Test
   void transactionStatusFromCreatedToCancelledTest() {
-    TransactionEntity dcbTransaction = createTransactionEntity();
+    var dcbTransaction = createTransactionEntity();
     dcbTransaction.setStatus(TransactionStatus.StatusEnum.CREATED);
-    lendingLibraryService.updateTransactionStatus(dcbTransaction,
-      TransactionStatus.builder().status(TransactionStatus.StatusEnum.CANCELLED).build());
+    var cancelledStatus = TransactionStatus.builder().status(StatusEnum.CANCELLED).build();
+    lendingLibraryService.updateTransactionStatus(dcbTransaction, cancelledStatus);
     verify(baseLibraryService).cancelTransactionRequest(dcbTransaction);
   }
 
   @Test
   void updateTransactionWithWrongStatusTest() {
-    TransactionEntity transactionEntity = createTransactionEntity();
-    TransactionStatus transactionStatus = createTransactionStatus(TransactionStatus.StatusEnum.AWAITING_PICKUP);
-    assertThrows(IllegalArgumentException.class,
-      () -> lendingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus));
+    var transactionEntity = createTransactionEntity();
+    var transactionStatus = createTransactionStatus(TransactionStatus.StatusEnum.AWAITING_PICKUP);
+    assertThatThrownBy(() -> lendingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus))
+      .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @Test
+  void testUpdateTransactionStatusFromCreatedToOpenShouldUpdateEntity() {
+    // TestMate-1bbc6de8d11f860bac864b25fad8e5ad
+    var dcbTransaction = createTransactionEntity();
+    dcbTransaction.setStatus(CREATED);
+    var transactionStatus = createTransactionStatus(OPEN);
+
+    lendingLibraryService.updateTransactionStatus(dcbTransaction, transactionStatus);
+
+    assertThat(dcbTransaction.getStatus()).isEqualTo(OPEN);
+    verify(transactionRepository).save(dcbTransaction);
   }
 }

src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java

@@ -1,13 +1,14 @@
 package org.folio.dcb.service;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.BORROWER;
 import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.LENDER;
 import static org.folio.dcb.utils.EntityUtils.DCB_TRANSACTION_ID;
 import static org.folio.dcb.utils.EntityUtils.borrowerDcbTransaction;
 import static org.folio.dcb.utils.EntityUtils.createDcbTransactionByRole;
 import static org.folio.dcb.utils.EntityUtils.createTransactionAuditEntity;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -34,18 +35,18 @@ class TransactionAuditServiceTest {
 
   @Test
   void logTheErrorForExistedTransactionAuditTest() {
-    when(repository.findLatestTransactionAuditEntityByDcbTransactionId(any()))
-      .thenReturn(Optional.of(createTransactionAuditEntity()));
+    var searchResult = Optional.of(createTransactionAuditEntity());
+    when(repository.findLatestTransactionAuditEntityByDcbTransactionId(any())).thenReturn(searchResult);
     transactionAuditService.logErrorIfTransactionAuditExists(DCB_TRANSACTION_ID, "error_message");
-    verify(transactionMapper, times(0)).mapToEntity(any(), any());
+    verify(transactionMapper, never()).mapToEntity(any(), any());
     verify(repository).save(any());
   }
 
   @Test
   void logTheErrorForNotExistedTransactionAuditTest() {
+    var transaction = createDcbTransactionByRole(LENDER);
     when(repository.findLatestTransactionAuditEntityByDcbTransactionId(any())).thenReturn(Optional.empty());
-    transactionAuditService.logErrorIfTransactionAuditNotExists(
-      DCB_TRANSACTION_ID, createDcbTransactionByRole(LENDER), "error_message");
+    transactionAuditService.logErrorIfTransactionAuditNotExists(DCB_TRANSACTION_ID, transaction, "error_message");
     verify(repository).save(any());
   }
 
@@ -92,4 +93,46 @@ void logErrorIfTransactionAuditNotExists_positive_transactionObjectIsNull() {
       .contains("role = null")
       .contains("error message = null object error");
   }
+
+  @Test
+  void testLogErrorIfTransactionAuditNotExistsWhenAuditExistsShouldLogDuplicateError() {
+    // TestMate-fa5231f9fd8fb40f55082244d97512b7
+    var errorMsg = "Duplicate ID";
+    var dcbTransaction = createDcbTransactionByRole(BORROWER);
+    var existingAudit = createTransactionAuditEntity();
+    var searchResult = Optional.of(existingAudit);
+    var auditCaptor = ArgumentCaptor.forClass(TransactionAuditEntity.class);
+    when(repository.findLatestTransactionAuditEntityByDcbTransactionId(DCB_TRANSACTION_ID)).thenReturn(searchResult);
+    when(repository.save(auditCaptor.capture())).then(inv -> inv.getArgument(0));
+
+    transactionAuditService.logErrorIfTransactionAuditNotExists(DCB_TRANSACTION_ID, dcbTransaction, errorMsg);
+
+    var savedAudit = auditCaptor.getValue();
+    assertThat(savedAudit.getAction()).isEqualTo("DUPLICATE_ERROR");
+    assertThat(savedAudit.getTransactionId()).isEqualTo("-1");
+    assertThat(savedAudit.getBefore()).isNull();
+    assertThat(savedAudit.getAfter()).isNull();
+    assertThat(savedAudit.getErrorMessage()).isEqualTo(String.format(
+      "dcbTransactionId = %s; role = %s; error message = %s.", DCB_TRANSACTION_ID, BORROWER, errorMsg));
+  }
+
+  @Test
+  void testLogErrorIfTransactionAuditNotExistsWhenDcbTransactionIsNull() {
+    // TestMate-dbb7ede2a4d44cf4e63907539abcc619
+    var dcbTransactionId = "trn-456";
+    var errorMsg = "Null payload";
+    var auditCaptor = ArgumentCaptor.forClass(TransactionAuditEntity.class);
+    when(repository.findLatestTransactionAuditEntityByDcbTransactionId(dcbTransactionId)).thenReturn(Optional.empty());
+    when(repository.save(auditCaptor.capture())).then(inv -> inv.getArgument(0));
+
+    transactionAuditService.logErrorIfTransactionAuditNotExists(dcbTransactionId, null, errorMsg);
+
+    var savedAudit = auditCaptor.getValue();
+    assertThat(savedAudit.getAction()).isEqualTo("ERROR");
+    assertThat(savedAudit.getTransactionId()).isEqualTo(dcbTransactionId);
+    assertThat(savedAudit.getBefore()).isNull();
+    assertThat(savedAudit.getAfter()).isNull();
+    assertThat(savedAudit.getErrorMessage()).isEqualTo(
+      "dcbTransactionId = trn-456; role = null; error message = Null payload.");
+  }
 }