From c1cb9912aecc06ba5a9ca1002d54e1c8efcf18a2 Mon Sep 17 00:00:00 2001 From: aitestmate Date: Sat, 23 May 2026 18:09:44 +0000 Subject: [PATCH 1/2] [chore] [mod-dcb] unit tests --- .../service/BorrowingLibraryServiceTest.java | 15 ++ .../service/LendingLibraryServiceTest.java | 16 ++ .../service/TransactionAuditServiceTest.java | 51 ++++++ .../dcb/service/TransactionServiceTest.java | 167 ++++++++++++++++++ 4 files changed, 249 insertions(+) diff --git a/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java b/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java index 75ec031b..1400389d 100644 --- a/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java +++ b/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java @@ -30,6 +30,8 @@ import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import org.folio.dcb.domain.entity.TransactionEntity; +import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CANCELLED; @ExtendWith(MockitoExtension.class) @@ -117,4 +119,17 @@ void testTransactionStatusUpdateFromItemCheckedOutToItemCheckedIn() { Assertions.assertEquals(ITEM_CHECKED_IN, transactionEntity.getStatus()); } + @Test + void testTransactionStatusUpdateToCancelled() { + // TestMate-9100f3c36cb9c9dc6ddfe4531639c7de + // Given + TransactionEntity transactionEntity = createTransactionEntity(); + transactionEntity.setStatus(OPEN); + TransactionStatus transactionStatus = TransactionStatus.builder().status(CANCELLED).build(); + // When + borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus); + // Then + verify(baseLibraryService).cancelTransactionRequest(transactionEntity); + } + } diff --git a/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java b/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java index 4dc28b90..31f620aa 100644 --- a/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java +++ b/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java @@ -36,6 +36,8 @@ import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CREATED; +import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.OPEN; @ExtendWith(MockitoExtension.class) class LendingLibraryServiceTest { @@ -119,4 +121,18 @@ void updateTransactionWithWrongStatusTest() { TransactionStatus transactionStatus = createTransactionStatus(TransactionStatus.StatusEnum.AWAITING_PICKUP); assertThrows(IllegalArgumentException.class, () -> lendingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus)); } + + @Test + void testUpdateTransactionStatusFromCreatedToOpenShouldUpdateEntity() { + // TestMate-1bbc6de8d11f860bac864b25fad8e5ad + // Given + TransactionEntity dcbTransaction = createTransactionEntity(); + dcbTransaction.setStatus(CREATED); + TransactionStatus transactionStatus = createTransactionStatus(OPEN); + // When + lendingLibraryService.updateTransactionStatus(dcbTransaction, transactionStatus); + // Then + Assertions.assertEquals(OPEN, dcbTransaction.getStatus()); + verify(transactionRepository).save(dcbTransaction); + } } diff --git a/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java b/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java index 48606e31..7d7c00cb 100644 --- a/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java +++ b/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java @@ -19,6 +19,12 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.times; import static org.mockito.Mockito.when; +import org.folio.dcb.domain.entity.TransactionAuditEntity; +import org.mockito.ArgumentCaptor; +import static org.assertj.core.api.Assertions.assertThat; +import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.BORROWER; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.verify; @ExtendWith(MockitoExtension.class) class TransactionAuditServiceTest { @@ -46,4 +52,49 @@ void logTheErrorForNotExistedTransactionAuditTest() { Mockito.verify(transactionAuditRepository, times(1)).save(any()); } + @Test + void testLogErrorIfTransactionAuditNotExistsWhenAuditExistsShouldLogDuplicateError() { + // TestMate-fa5231f9fd8fb40f55082244d97512b7 + // Given + String errorMsg = "Duplicate ID"; + var dcbTransaction = createDcbTransactionByRole(BORROWER); + TransactionAuditEntity existingAudit = createTransactionAuditEntity(); + when(transactionAuditRepository.findLatestTransactionAuditEntityByDcbTransactionId(DCB_TRANSACTION_ID)) + .thenReturn(Optional.of(existingAudit)); + // When + transactionAuditService.logErrorIfTransactionAuditNotExists(DCB_TRANSACTION_ID, dcbTransaction, errorMsg); + // Then + ArgumentCaptor captor = ArgumentCaptor.forClass(TransactionAuditEntity.class); + verify(transactionAuditRepository).save(captor.capture()); + TransactionAuditEntity savedAudit = captor.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 + // Given + String dcbTransactionId = "trn-456"; + String errorMsg = "Null payload"; + when(transactionAuditRepository.findLatestTransactionAuditEntityByDcbTransactionId(dcbTransactionId)) + .thenReturn(Optional.empty()); + // When + transactionAuditService.logErrorIfTransactionAuditNotExists(dcbTransactionId, null, errorMsg); + // Then + ArgumentCaptor captor = ArgumentCaptor.forClass(TransactionAuditEntity.class); + verify(transactionAuditRepository).save(captor.capture()); + TransactionAuditEntity savedAudit = captor.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."); + } + } diff --git a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java index 221cb259..058a5b3c 100644 --- a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java +++ b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java @@ -62,6 +62,12 @@ import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.data.domain.Page; +import org.folio.dcb.service.impl.BaseLibraryService; +import org.junit.jupiter.api.BeforeEach; +import org.folio.dcb.service.LibraryService; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.PICKUP; +import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CREATED; @ExtendWith(MockitoExtension.class) class TransactionServiceTest { @@ -83,6 +89,35 @@ class TransactionServiceTest { @Mock private CirculationLoanPolicyStorageClient circulationLoanPolicyStorageClient; + @Mock(name = "pickupLibraryService") + private LibraryService pickupLibraryService; + + @Mock(name = "borrowingPickupLibraryService") + private LibraryService borrowingPickupLibraryService; + + @Mock(name = "borrowingLibraryService") + private LibraryService borrowingLibraryService; + + @Mock + private BaseLibraryService baseLibraryService; + + @BeforeEach + void setUp() { + transactionsService = new TransactionsServiceImpl( + lendingLibraryService, + borrowingPickupLibraryService, + pickupLibraryService, + borrowingLibraryService, + transactionRepository, + statusProcessorService, + transactionMapper, + transactionAuditRepository, + baseLibraryService, + circulationClient, + circulationLoanPolicyStorageClient + ); + } + @Test void renewLoanByTransactionIdTest() { when(transactionRepository.findById(anyString())).thenReturn(Optional.ofNullable( @@ -162,6 +197,13 @@ private static RenewByIdResponse buildTestRenewBleResponse() { .renewalCount(2); } + private static Stream pickupRolesProvider() { + return Stream.of( + Arguments.of(PICKUP), + Arguments.of(BORROWING_PICKUP) + ); + } + @Test void createLendingCirculationRequestTest() { when(lendingLibraryService.createCirculation(any(), any())) @@ -319,4 +361,129 @@ void shouldVerifyLocationCodeWhenCreatingCirculationRequest() { assertEquals("TEST_LOCATION_CODE", dcbTransactionActual.getItem().getLocationCode()); } + @Test + void createCirculationRequestShouldDelegateToBorrowingPickupService() { + // TestMate-0a2a9520399d5c7abefe2604abee8bb1 + // Given + DcbTransaction dcbTransaction = createDcbTransactionByRole(BORROWING_PICKUP); + TransactionStatusResponse expectedResponse = createTransactionResponse(); + when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); + when(borrowingPickupLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) + .thenReturn(expectedResponse); + // When + TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); + // Then + verify(transactionRepository).existsById(DCB_TRANSACTION_ID); + verify(borrowingPickupLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); + verifyNoInteractions(lendingLibraryService, pickupLibraryService, borrowingLibraryService); + assertEquals(expectedResponse, actualResponse); + } + + @Test + void createCirculationRequestShouldDelegateToPickupService() { + // TestMate-597be30571329e3ce0267cdfff9dfb08 + // Given + DcbTransaction dcbTransaction = createDcbTransactionByRole(PICKUP); + TransactionStatusResponse expectedResponse = createTransactionResponse(); + when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); + when(pickupLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) + .thenReturn(expectedResponse); + // When + TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); + // Then + verify(transactionRepository).existsById(DCB_TRANSACTION_ID); + verify(pickupLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); + verifyNoInteractions(lendingLibraryService, borrowingPickupLibraryService, borrowingLibraryService); + assertEquals(expectedResponse, actualResponse); + } + + @Test + void createCirculationRequestShouldDelegateToBorrowerService() { + // TestMate-7d4eb902b0fe10bf7674b7be235df7bd + // Given + DcbTransaction dcbTransaction = createDcbTransactionByRole(BORROWER); + TransactionStatusResponse expectedResponse = createTransactionResponse(); + when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); + when(borrowingLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) + .thenReturn(expectedResponse); + // When + TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); + // Then + verify(transactionRepository).existsById(DCB_TRANSACTION_ID); + verify(borrowingLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); + verifyNoInteractions(lendingLibraryService, borrowingPickupLibraryService, pickupLibraryService); + assertEquals(expectedResponse, actualResponse); + } + + @Test + void updateTransactionStatusWhenTransactionNotFoundShouldThrowException() { + // TestMate-dcfec3a2e25a9cd96051a6cf26412215 + // Given + String nonExistentId = "non-existent-id"; + TransactionStatus transactionStatus = TransactionStatus.builder() + .status(TransactionStatus.StatusEnum.OPEN) + .build(); + when(transactionRepository.findById(nonExistentId)).thenReturn(Optional.empty()); + // When + IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, + () -> transactionsService.updateTransactionStatus(nonExistentId, transactionStatus)); + // Then + assertEquals(String.format("Transaction with id %s not found", nonExistentId), exception.getMessage()); + verify(transactionRepository).findById(nonExistentId); + } + + @Test + void updateTransactionStatusForBorrowerRoleShouldUseBorrowingChainProcessor() { + // TestMate-e08c55185fe8d0dcaa3a2fd733caef67 + // Given + TransactionStatus targetStatus = TransactionStatus.builder() + .status(ITEM_CHECKED_OUT) + .build(); + TransactionEntity dcbTransactionEntity = createTransactionEntity(); + dcbTransactionEntity.setStatus(OPEN); + dcbTransactionEntity.setRole(BORROWER); + List statusChain = List.of(AWAITING_PICKUP, ITEM_CHECKED_OUT); + when(transactionRepository.findById(DCB_TRANSACTION_ID)) + .thenReturn(Optional.of(dcbTransactionEntity)); + when(statusProcessorService.borrowingChainProcessor(OPEN, ITEM_CHECKED_OUT)) + .thenReturn(statusChain); + doNothing().when(borrowingLibraryService).updateTransactionStatus(any(TransactionEntity.class), any(TransactionStatus.class)); + // When + TransactionStatusResponse response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); + // Then + verify(statusProcessorService).borrowingChainProcessor(OPEN, ITEM_CHECKED_OUT); + verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(AWAITING_PICKUP).build()); + verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(ITEM_CHECKED_OUT).build()); + assertEquals(TransactionStatusResponse.StatusEnum.ITEM_CHECKED_OUT, response.getStatus()); + verifyNoInteractions(lendingLibraryService, pickupLibraryService, borrowingPickupLibraryService); + } + + @ParameterizedTest + @MethodSource("pickupRolesProvider") + void updateTransactionStatusForPickupRolesShouldUpdateDirectly(DcbTransaction.RoleEnum role) { + // TestMate-beca7b72cfab01b9d15502559ed19169 + // Given + TransactionStatus targetStatus = TransactionStatus.builder() + .status(OPEN) + .build(); + TransactionEntity dcbTransactionEntity = createTransactionEntity(); + dcbTransactionEntity.setId(DCB_TRANSACTION_ID); + dcbTransactionEntity.setStatus(CREATED); + dcbTransactionEntity.setRole(role); + when(transactionRepository.findById(DCB_TRANSACTION_ID)) + .thenReturn(Optional.of(dcbTransactionEntity)); + // When + TransactionStatusResponse response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); + // Then + if (role == PICKUP) { + verify(pickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); + verifyNoInteractions(borrowingPickupLibraryService); + } else { + verify(borrowingPickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); + verifyNoInteractions(pickupLibraryService); + } + verifyNoInteractions(statusProcessorService, lendingLibraryService, borrowingLibraryService); + assertEquals(TransactionStatusResponse.StatusEnum.OPEN, response.getStatus()); + } + } From cd77b4e737649a7311e8854d7ee2bc770710a2b1 Mon Sep 17 00:00:00 2001 From: Pavel Filippov Date: Wed, 17 Jun 2026 13:33:21 +0300 Subject: [PATCH 2/2] chore(unit-tests): Update tests to follow codestyle --- .../service/BorrowingLibraryServiceTest.java | 26 +- .../service/LendingLibraryServiceTest.java | 89 +++-- .../service/TransactionAuditServiceTest.java | 58 ++-- .../dcb/service/TransactionServiceTest.java | 310 ++++++++---------- 4 files changed, 217 insertions(+), 266 deletions(-) diff --git a/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java b/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java index a8c43419..24fe0159 100644 --- a/src/test/java/org/folio/dcb/service/BorrowingLibraryServiceTest.java +++ b/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; @@ -25,7 +25,6 @@ import org.folio.dcb.domain.dto.ClaimedReturnedResolution; import org.folio.dcb.domain.dto.TransactionStatus; import org.folio.dcb.domain.dto.TransactionStatusContext; -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.BorrowingLibraryServiceImpl; @@ -56,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()); } @@ -70,7 +69,7 @@ void testTransactionStatusUpdateFromCreatedToOpen() { borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus); verify(circulationService).checkInByBarcode(any(), any()); - assertEquals(OPEN, transactionEntity.getStatus()); + assertThat(transactionEntity.getStatus()).isEqualTo(OPEN); } @Test @@ -78,20 +77,21 @@ 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()); } @@ -104,7 +104,7 @@ void testTransactionStatusUpdateFromItemCheckedInToClosed() { borrowingLibraryService.updateTransactionStatus(transactionEntity, transactionStatus); - assertEquals(CLOSED, transactionEntity.getStatus()); + assertThat(transactionEntity.getStatus()).isEqualTo(CLOSED); } @Test @@ -117,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 @@ -130,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 @@ -149,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 @@ -168,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 diff --git a/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java b/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java index 00de3c9b..f8443119 100644 --- a/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.java +++ b/src/test/java/org/folio/dcb/service/LendingLibraryServiceTest.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.LENDER; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CREATED; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.OPEN; @@ -11,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; @@ -50,92 +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 + @Test void testUpdateTransactionStatusFromCreatedToOpenShouldUpdateEntity() { // TestMate-1bbc6de8d11f860bac864b25fad8e5ad - // Given - TransactionEntity dcbTransaction = createTransactionEntity(); + var dcbTransaction = createTransactionEntity(); dcbTransaction.setStatus(CREATED); - TransactionStatus transactionStatus = createTransactionStatus(OPEN); - // When + var transactionStatus = createTransactionStatus(OPEN); + lendingLibraryService.updateTransactionStatus(dcbTransaction, transactionStatus); - // Then - Assertions.assertEquals(OPEN, dcbTransaction.getStatus()); + + assertThat(dcbTransaction.getStatus()).isEqualTo(OPEN); verify(transactionRepository).save(dcbTransaction); } } diff --git a/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java b/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java index 7fdd02d2..46224ddc 100644 --- a/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java +++ b/src/test/java/org/folio/dcb/service/TransactionAuditServiceTest.java @@ -8,7 +8,7 @@ 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; @@ -35,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()); } @@ -94,49 +94,45 @@ void logErrorIfTransactionAuditNotExists_positive_transactionObjectIsNull() { .contains("error message = null object error"); } - @Test void testLogErrorIfTransactionAuditNotExistsWhenAuditExistsShouldLogDuplicateError() { // TestMate-fa5231f9fd8fb40f55082244d97512b7 - // Given - String errorMsg = "Duplicate ID"; + var errorMsg = "Duplicate ID"; var dcbTransaction = createDcbTransactionByRole(BORROWER); - TransactionAuditEntity existingAudit = createTransactionAuditEntity(); - when(transactionAuditRepository.findLatestTransactionAuditEntityByDcbTransactionId(DCB_TRANSACTION_ID)) - .thenReturn(Optional.of(existingAudit)); - // When + 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); - // Then - ArgumentCaptor captor = ArgumentCaptor.forClass(TransactionAuditEntity.class); - verify(transactionAuditRepository).save(captor.capture()); - TransactionAuditEntity savedAudit = captor.getValue(); + + 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)); + assertThat(savedAudit.getErrorMessage()).isEqualTo(String.format( + "dcbTransactionId = %s; role = %s; error message = %s.", DCB_TRANSACTION_ID, BORROWER, errorMsg)); } @Test void testLogErrorIfTransactionAuditNotExistsWhenDcbTransactionIsNull() { // TestMate-dbb7ede2a4d44cf4e63907539abcc619 - // Given - String dcbTransactionId = "trn-456"; - String errorMsg = "Null payload"; - when(transactionAuditRepository.findLatestTransactionAuditEntityByDcbTransactionId(dcbTransactionId)) - .thenReturn(Optional.empty()); - // When + 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); - // Then - ArgumentCaptor captor = ArgumentCaptor.forClass(TransactionAuditEntity.class); - verify(transactionAuditRepository).save(captor.capture()); - TransactionAuditEntity savedAudit = captor.getValue(); + + 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."); + assertThat(savedAudit.getErrorMessage()).isEqualTo( + "dcbTransactionId = trn-456; role = null; error message = Null payload."); } } diff --git a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java index 7ff351dd..81755fe9 100644 --- a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java +++ b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java @@ -1,10 +1,15 @@ package org.folio.dcb.service; +import static java.util.Objects.requireNonNull; +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.DcbTransaction.RoleEnum.BORROWING_PICKUP; import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.LENDER; +import static org.folio.dcb.domain.dto.DcbTransaction.RoleEnum.PICKUP; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.AWAITING_PICKUP; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CLOSED; +import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CREATED; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.ITEM_CHECKED_IN; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.ITEM_CHECKED_OUT; import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.OPEN; @@ -18,9 +23,8 @@ import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; import static org.mockito.Mockito.when; import java.time.OffsetDateTime; @@ -51,7 +55,6 @@ import org.folio.dcb.service.impl.LendingLibraryServiceImpl; import org.folio.dcb.service.impl.TransactionsServiceImpl; import org.folio.spring.exception.NotFoundException; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -59,15 +62,15 @@ import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; import org.mockito.ArgumentCaptor; -import org.mockito.InjectMocks; import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.junit.jupiter.MockitoExtension; import org.springframework.data.domain.Page; @ExtendWith(MockitoExtension.class) class TransactionServiceTest { - @InjectMocks private TransactionsServiceImpl transactionsService; + private TransactionsServiceImpl transactionsService; @Mock private LendingLibraryServiceImpl lendingLibraryService; @Mock private TransactionRepository transactionRepository; @Mock private StatusProcessorService statusProcessorService; @@ -82,42 +85,31 @@ class TransactionServiceTest { @BeforeEach void setUp() { - transactionsService = new TransactionsServiceImpl( - lendingLibraryService, - borrowingPickupLibraryService, - pickupLibraryService, - borrowingLibraryService, - transactionRepository, - statusProcessorService, - transactionMapper, - transactionAuditRepository, - baseLibraryService, - circulationClient, - circulationLoanPolicyStorageClient - ); + transactionsService = new TransactionsServiceImpl(lendingLibraryService, borrowingPickupLibraryService, + pickupLibraryService, borrowingLibraryService, transactionRepository, statusProcessorService, transactionMapper, + transactionAuditRepository, baseLibraryService, circulationClient, circulationLoanPolicyStorageClient); } @Test void renewLoanByTransactionIdTest() { - when(transactionRepository.findById(anyString())) - .thenReturn(Optional.ofNullable(buildTransactionToRenew(ITEM_CHECKED_OUT, LENDER))); + var entityByIdResult = Optional.ofNullable(buildTransactionToRenew(ITEM_CHECKED_OUT, LENDER)); + when(transactionRepository.findById(anyString())).thenReturn(entityByIdResult); when(circulationClient.renewById(any())).thenReturn(buildTestRenewBleResponse()); when(circulationLoanPolicyStorageClient.getById(anyString())).thenReturn(buildTestLoanPolicy()); when(circulationClient.renewById(any())).thenReturn(buildTestRenewBleResponse()); when(circulationLoanPolicyStorageClient.getById(anyString())).thenReturn(buildTestLoanPolicy()); transactionsService.renewLoanByTransactionId(DCB_TRANSACTION_ID); - verify(circulationClient, times(1)).renewById(any()); - verify(circulationLoanPolicyStorageClient, times(1)).getById(any()); + verify(circulationClient).renewById(any()); + verify(circulationLoanPolicyStorageClient).getById(any()); } @Test void renewLoanByTransactionIdShouldThrowNotFoundExceptionWhenRenewResponseNull() { + var entityByIdResult = Optional.of(buildTransactionToRenew(ITEM_CHECKED_OUT, LENDER)); when(circulationClient.renewById(any(RenewByIdRequest.class))).thenReturn(null); - when(transactionRepository.findById(anyString())).thenReturn(Optional.of( - buildTransactionToRenew(ITEM_CHECKED_OUT, LENDER))); - assertThrows(NotFoundException.class, () -> transactionsService.renewLoanByTransactionId( - DCB_TRANSACTION_ID)); + when(transactionRepository.findById(anyString())).thenReturn(entityByIdResult); + assertThrows(NotFoundException.class, () -> transactionsService.renewLoanByTransactionId(DCB_TRANSACTION_ID)); } @Test @@ -126,8 +118,7 @@ void renewLoanByTransactionIdShouldThrowNotFoundExceptionWhenLoanPolicyResponseN buildTransactionToRenew(ITEM_CHECKED_OUT, LENDER))); when(circulationClient.renewById(any())).thenReturn(buildTestRenewBleResponse()); when(circulationLoanPolicyStorageClient.getById(anyString())).thenReturn(null); - assertThrows(NotFoundException.class, () -> transactionsService.renewLoanByTransactionId( - DCB_TRANSACTION_ID)); + assertThrows(NotFoundException.class, () -> transactionsService.renewLoanByTransactionId(DCB_TRANSACTION_ID)); } @ParameterizedTest @@ -144,10 +135,8 @@ private static Stream renewLoanByTransactionIdShouldThrowExceptionTes Arguments.of(buildTransactionToRenew(CLOSED, LENDER), StatusException.class), Arguments.of(buildTransactionToRenew(AWAITING_PICKUP, LENDER), StatusException.class), Arguments.of(buildTransactionToRenew(AWAITING_PICKUP, LENDER), StatusException.class), - Arguments.of(buildTransactionToRenew(ITEM_CHECKED_OUT, BORROWER), - IllegalArgumentException.class), - Arguments.of(buildTransactionToRenew(ITEM_CHECKED_OUT, BORROWING_PICKUP), - IllegalArgumentException.class) + Arguments.of(buildTransactionToRenew(ITEM_CHECKED_OUT, BORROWER), IllegalArgumentException.class), + Arguments.of(buildTransactionToRenew(ITEM_CHECKED_OUT, BORROWING_PICKUP), IllegalArgumentException.class) ); } @@ -173,49 +162,36 @@ private static RenewByIdResponse buildTestRenewBleResponse() { .renewalCount(2); } - private static Stream pickupRolesProvider() { - return Stream.of( - Arguments.of(PICKUP), - Arguments.of(BORROWING_PICKUP) - ); - } - @Test void createLendingCirculationRequestTest() { - when(lendingLibraryService.createCirculation(any(), any())) - .thenReturn(createTransactionResponse()); - transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, - createDcbTransactionByRole(LENDER)); - verify(lendingLibraryService).createCirculation(DCB_TRANSACTION_ID, - createDcbTransactionByRole(LENDER)); + when(lendingLibraryService.createCirculation(any(), any())).thenReturn(createTransactionResponse()); + transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, createDcbTransactionByRole(LENDER)); + verify(lendingLibraryService).createCirculation(DCB_TRANSACTION_ID, createDcbTransactionByRole(LENDER)); } @Test void shouldReturnAnyTransactionStatusById() { var transactionIdUnique = UUID.randomUUID().toString(); - when(transactionRepository.findById(transactionIdUnique)) - .thenReturn(Optional.ofNullable(TransactionEntity.builder() - .status(StatusEnum.CREATED) - .role(LENDER) - .build())); + var transactionEntity = TransactionEntity.builder() + .status(CREATED) + .role(LENDER) + .build(); + when(transactionRepository.findById(transactionIdUnique)).thenReturn(Optional.ofNullable(transactionEntity)); var trnInstance = transactionsService.getTransactionStatusById(transactionIdUnique); - assertNotNull(trnInstance); - assertEquals(TransactionStatusResponse.StatusEnum.CREATED, trnInstance.getStatus()); + + assertThat(trnInstance).isNotNull(); + assertThat(trnInstance.getStatus()).isEqualTo(TransactionStatusResponse.StatusEnum.CREATED); } @Test void getTransactionStatusByIdNotFoundExceptionTest() { var transactionIdUnique = UUID.randomUUID().toString(); - when(transactionRepository.findById(transactionIdUnique)) - .thenReturn(Optional.empty()); - - var error = assertThrows( - NotFoundException.class, - () -> transactionsService.getTransactionStatusById(transactionIdUnique) - ); + when(transactionRepository.findById(transactionIdUnique)).thenReturn(Optional.empty()); - assertEquals(String.format("DCB Transaction was not found by id= %s ", transactionIdUnique), error.getMessage()); + assertThatThrownBy(() -> transactionsService.getTransactionStatusById(transactionIdUnique)) + .isInstanceOf(NotFoundException.class) + .hasMessage("DCB Transaction was not found by id= %s ", transactionIdUnique); } /** @@ -225,8 +201,8 @@ void getTransactionStatusByIdNotFoundExceptionTest() { void createTransactionWithExistingTransactionIdTest() { var dcbTransaction = createDcbTransactionByRole(LENDER); when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(true); - assertThrows(ResourceAlreadyExistException.class, () -> - transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction)); + assertThatThrownBy(() -> transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction)) + .isInstanceOf(ResourceAlreadyExistException.class); } @Test @@ -235,20 +211,15 @@ void updateTransactionEntityLenderTest() { dcbTransactionEntity.setStatus(StatusEnum.OPEN); dcbTransactionEntity.setRole(LENDER); - when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn( - Optional.of(dcbTransactionEntity)); + when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity)); when(statusProcessorService.lendingChainProcessor(StatusEnum.OPEN, ITEM_CHECKED_OUT)) .thenReturn(List.of(StatusEnum.AWAITING_PICKUP, ITEM_CHECKED_OUT)); - doNothing().when(lendingLibraryService) - .updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status( - StatusEnum.AWAITING_PICKUP).build()); - doNothing().when(lendingLibraryService) - .updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status( - ITEM_CHECKED_OUT).build()); + doNothing().when(lendingLibraryService).updateTransactionStatus(dcbTransactionEntity, + TransactionStatus.builder().status(StatusEnum.AWAITING_PICKUP).build()); + var itemCheckedOutStatus = TransactionStatus.builder().status(ITEM_CHECKED_OUT).build(); + doNothing().when(lendingLibraryService).updateTransactionStatus(dcbTransactionEntity, itemCheckedOutStatus); - transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, - TransactionStatus.builder().status( - ITEM_CHECKED_OUT).build()); + transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, itemCheckedOutStatus); verify(statusProcessorService).lendingChainProcessor(StatusEnum.OPEN, ITEM_CHECKED_OUT); } @@ -257,34 +228,28 @@ void updateTransactionEntityLenderTest() { void updateTransactionEntityErrorTest() { var dcbTransactionEntity = createTransactionEntity(); dcbTransactionEntity.setStatus(StatusEnum.OPEN); - when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn( - Optional.of(dcbTransactionEntity)); + when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity)); var openTransactionStatus = TransactionStatus.builder().status(StatusEnum.OPEN).build(); - assertThrows(StatusException.class, - () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, openTransactionStatus)); + assertThatThrownBy(() -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, openTransactionStatus)) + .isInstanceOf(StatusException.class); dcbTransactionEntity.setStatus(StatusEnum.ITEM_CHECKED_IN); - var cancelledTransactionStatus = TransactionStatus.builder() - .status(StatusEnum.CANCELLED) - .build(); - assertThrows(StatusException.class, - () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, - cancelledTransactionStatus)); + var cancelledTxStatus = TransactionStatus.builder().status(StatusEnum.CANCELLED).build(); + assertThatThrownBy(() -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, cancelledTxStatus)) + .isInstanceOf(StatusException.class); dcbTransactionEntity.setStatus(ITEM_CHECKED_OUT); - assertThrows(StatusException.class, - () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, - cancelledTransactionStatus)); + assertThatThrownBy(() -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, cancelledTxStatus)) + .isInstanceOf(StatusException.class); } @Test void getTransactionStatusListTest() { var startDate = OffsetDateTime.now().minusDays(1L); var endDate = OffsetDateTime.now(); - Page pageMock = mock(Page.class); - when(transactionAuditRepository.findUpdatedTransactionsByDateRange(any(), any(), any())) - .thenReturn(pageMock); + var pageMock = Mockito.>mock(); + when(transactionAuditRepository.findUpdatedTransactionsByDateRange(any(), any(), any())).thenReturn(pageMock); when(pageMock.getTotalElements()).thenReturn(10L); when(transactionMapper.mapToDto(pageMock)) .thenReturn(List.of(TransactionStatusResponseList @@ -321,142 +286,135 @@ void getTransactionStatusListTest() { @Test void shouldVerifyLocationCodeWhenCreatingCirculationRequest() { when(lendingLibraryService.createCirculation(any(), any())).thenReturn(createTransactionResponse()); - DcbTransaction dcbTransaction = createDcbTransactionByRole(LENDER); - Optional.ofNullable(dcbTransaction.getItem()).ifPresent(dcbItem -> dcbItem.setLocationCode("TEST_LOCATION_CODE")); + var dcbTransaction = createDcbTransactionByRole(LENDER); + requireNonNull(dcbTransaction.getItem()).setLocationCode("TEST_LOCATION_CODE"); transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); verify(lendingLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); var dcbTransactionArgumentCaptor = ArgumentCaptor.forClass(DcbTransaction.class); - verify(lendingLibraryService, times(1)).createCirculation(any(), dcbTransactionArgumentCaptor.capture()); + verify(lendingLibraryService).createCirculation(any(), dcbTransactionArgumentCaptor.capture()); DcbTransaction dcbTransactionActual = dcbTransactionArgumentCaptor.getValue(); assertNotNull(dcbTransactionActual.getItem()); assertNotNull(dcbTransactionActual.getItem().getLocationCode()); assertEquals("TEST_LOCATION_CODE", dcbTransactionActual.getItem().getLocationCode()); } - @Test + @Test void createCirculationRequestShouldDelegateToBorrowingPickupService() { // TestMate-0a2a9520399d5c7abefe2604abee8bb1 - // Given - DcbTransaction dcbTransaction = createDcbTransactionByRole(BORROWING_PICKUP); - TransactionStatusResponse expectedResponse = createTransactionResponse(); + var transaction = createDcbTransactionByRole(BORROWING_PICKUP); + var expectedResponse = createTransactionResponse(); when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); - when(borrowingPickupLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) - .thenReturn(expectedResponse); - // When - TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); - // Then + when(borrowingPickupLibraryService.createCirculation(DCB_TRANSACTION_ID, transaction)).thenReturn(expectedResponse); + + var actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, transaction); + + assertThat(actualResponse).isEqualTo(expectedResponse); verify(transactionRepository).existsById(DCB_TRANSACTION_ID); - verify(borrowingPickupLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); + verify(borrowingPickupLibraryService).createCirculation(DCB_TRANSACTION_ID, transaction); verifyNoInteractions(lendingLibraryService, pickupLibraryService, borrowingLibraryService); - assertEquals(expectedResponse, actualResponse); } - @Test + @Test void createCirculationRequestShouldDelegateToPickupService() { // TestMate-597be30571329e3ce0267cdfff9dfb08 - // Given - DcbTransaction dcbTransaction = createDcbTransactionByRole(PICKUP); - TransactionStatusResponse expectedResponse = createTransactionResponse(); + var transaction = createDcbTransactionByRole(PICKUP); + var expectedResponse = createTransactionResponse(); when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); - when(pickupLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) - .thenReturn(expectedResponse); - // When - TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); - // Then + when(pickupLibraryService.createCirculation(DCB_TRANSACTION_ID, transaction)).thenReturn(expectedResponse); + + var actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, transaction); + + assertThat(actualResponse).isEqualTo(expectedResponse); verify(transactionRepository).existsById(DCB_TRANSACTION_ID); - verify(pickupLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); + verify(pickupLibraryService).createCirculation(DCB_TRANSACTION_ID, transaction); verifyNoInteractions(lendingLibraryService, borrowingPickupLibraryService, borrowingLibraryService); - assertEquals(expectedResponse, actualResponse); } - @Test + @Test void createCirculationRequestShouldDelegateToBorrowerService() { // TestMate-7d4eb902b0fe10bf7674b7be235df7bd - // Given - DcbTransaction dcbTransaction = createDcbTransactionByRole(BORROWER); - TransactionStatusResponse expectedResponse = createTransactionResponse(); + var dcbTransaction = createDcbTransactionByRole(BORROWER); + var expectedResponse = createTransactionResponse(); when(transactionRepository.existsById(DCB_TRANSACTION_ID)).thenReturn(false); - when(borrowingLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)) - .thenReturn(expectedResponse); - // When - TransactionStatusResponse actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); - // Then + when(borrowingLibraryService.createCirculation(DCB_TRANSACTION_ID, dcbTransaction)).thenReturn(expectedResponse); + + var actualResponse = transactionsService.createCirculationRequest(DCB_TRANSACTION_ID, dcbTransaction); + + assertThat(actualResponse).isEqualTo(expectedResponse); verify(transactionRepository).existsById(DCB_TRANSACTION_ID); verify(borrowingLibraryService).createCirculation(DCB_TRANSACTION_ID, dcbTransaction); verifyNoInteractions(lendingLibraryService, borrowingPickupLibraryService, pickupLibraryService); - assertEquals(expectedResponse, actualResponse); } - @Test + @Test void updateTransactionStatusWhenTransactionNotFoundShouldThrowException() { // TestMate-dcfec3a2e25a9cd96051a6cf26412215 - // Given - String nonExistentId = "non-existent-id"; - TransactionStatus transactionStatus = TransactionStatus.builder() - .status(TransactionStatus.StatusEnum.OPEN) - .build(); + var nonExistentId = UUID.randomUUID().toString(); when(transactionRepository.findById(nonExistentId)).thenReturn(Optional.empty()); - // When - IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, - () -> transactionsService.updateTransactionStatus(nonExistentId, transactionStatus)); - // Then - assertEquals(String.format("Transaction with id %s not found", nonExistentId), exception.getMessage()); + + var status = new TransactionStatus().status(OPEN); + assertThatThrownBy(() -> transactionsService.updateTransactionStatus(nonExistentId, status)) + .isInstanceOf(IllegalArgumentException.class) + .hasMessage("Transaction with id %s not found", nonExistentId); + verify(transactionRepository).findById(nonExistentId); } - @Test + @Test void updateTransactionStatusForBorrowerRoleShouldUseBorrowingChainProcessor() { // TestMate-e08c55185fe8d0dcaa3a2fd733caef67 - // Given - TransactionStatus targetStatus = TransactionStatus.builder() - .status(ITEM_CHECKED_OUT) - .build(); - TransactionEntity dcbTransactionEntity = createTransactionEntity(); + var dcbTransactionEntity = createTransactionEntity(); dcbTransactionEntity.setStatus(OPEN); dcbTransactionEntity.setRole(BORROWER); - List statusChain = List.of(AWAITING_PICKUP, ITEM_CHECKED_OUT); - when(transactionRepository.findById(DCB_TRANSACTION_ID)) - .thenReturn(Optional.of(dcbTransactionEntity)); - when(statusProcessorService.borrowingChainProcessor(OPEN, ITEM_CHECKED_OUT)) - .thenReturn(statusChain); - doNothing().when(borrowingLibraryService).updateTransactionStatus(any(TransactionEntity.class), any(TransactionStatus.class)); - // When - TransactionStatusResponse response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); - // Then + var statusChain = List.of(AWAITING_PICKUP, ITEM_CHECKED_OUT); + when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity)); + when(statusProcessorService.borrowingChainProcessor(OPEN, ITEM_CHECKED_OUT)).thenReturn(statusChain); + doNothing().when(borrowingLibraryService).updateTransactionStatus(any(), any()); + + var targetStatus = new TransactionStatus().status(ITEM_CHECKED_OUT); + var response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); + + assertThat(response.getStatus()).isEqualTo(TransactionStatusResponse.StatusEnum.ITEM_CHECKED_OUT); verify(statusProcessorService).borrowingChainProcessor(OPEN, ITEM_CHECKED_OUT); - verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(AWAITING_PICKUP).build()); - verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(ITEM_CHECKED_OUT).build()); - assertEquals(TransactionStatusResponse.StatusEnum.ITEM_CHECKED_OUT, response.getStatus()); + verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, + TransactionStatus.builder().status(AWAITING_PICKUP).build()); + verify(borrowingLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); verifyNoInteractions(lendingLibraryService, pickupLibraryService, borrowingPickupLibraryService); } - @ParameterizedTest - @MethodSource("pickupRolesProvider") - void updateTransactionStatusForPickupRolesShouldUpdateDirectly(DcbTransaction.RoleEnum role) { + @Test + void updateTransactionStatus_positive_borrowingPickupRole() { // TestMate-beca7b72cfab01b9d15502559ed19169 - // Given - TransactionStatus targetStatus = TransactionStatus.builder() - .status(OPEN) - .build(); - TransactionEntity dcbTransactionEntity = createTransactionEntity(); + var dcbTransactionEntity = createTransactionEntity(); dcbTransactionEntity.setId(DCB_TRANSACTION_ID); dcbTransactionEntity.setStatus(CREATED); - dcbTransactionEntity.setRole(role); - when(transactionRepository.findById(DCB_TRANSACTION_ID)) - .thenReturn(Optional.of(dcbTransactionEntity)); - // When - TransactionStatusResponse response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); - // Then - if (role == PICKUP) { - verify(pickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); - verifyNoInteractions(borrowingPickupLibraryService); - } else { - verify(borrowingPickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); - verifyNoInteractions(pickupLibraryService); - } - verifyNoInteractions(statusProcessorService, lendingLibraryService, borrowingLibraryService); - assertEquals(TransactionStatusResponse.StatusEnum.OPEN, response.getStatus()); + dcbTransactionEntity.setRole(BORROWING_PICKUP); + when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity)); + + var targetStatus = new TransactionStatus().status(OPEN); + var response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); + + assertThat(response.getStatus()).isEqualTo(TransactionStatusResponse.StatusEnum.OPEN); + verify(borrowingPickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); + verifyNoInteractions(pickupLibraryService, statusProcessorService, lendingLibraryService, borrowingLibraryService); } + @Test + void updateTransactionStatus_positive_pickupRole() { + // TestMate-beca7b72cfab01b9d15502559ed19169 + var dcbTransactionEntity = createTransactionEntity(); + dcbTransactionEntity.setId(DCB_TRANSACTION_ID); + dcbTransactionEntity.setStatus(CREATED); + dcbTransactionEntity.setRole(PICKUP); + when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity)); + + var targetStatus = new TransactionStatus().status(OPEN); + var response = transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, targetStatus); + + assertThat(response.getStatus()).isEqualTo(TransactionStatusResponse.StatusEnum.OPEN); + verify(pickupLibraryService).updateTransactionStatus(dcbTransactionEntity, targetStatus); + verifyNoInteractions(borrowingPickupLibraryService, statusProcessorService, + lendingLibraryService, borrowingLibraryService); + } }