diff --git a/src/main/java/org/folio/dcb/service/impl/TransactionsServiceImpl.java b/src/main/java/org/folio/dcb/service/impl/TransactionsServiceImpl.java
index 7dbd4aee..7ae58ceb 100644
--- a/src/main/java/org/folio/dcb/service/impl/TransactionsServiceImpl.java
+++ b/src/main/java/org/folio/dcb/service/impl/TransactionsServiceImpl.java
@@ -198,17 +198,16 @@ public TransactionStatusResponse renewLoanByTransactionId(String dcbTransactionI
     var loanPolicy = circulationLoanPolicyStorageClient.fetchLoanPolicyById(
       renewalResponse.getLoanPolicyId());
     log.info("renewLoanByTransactionId:: Loan policy response {}", loanPolicy);
-    validateLoanPolicy(renewalResponse, loanPolicy);
+    validateLoanPolicy(renewalResponse.getLoanPolicyId(), loanPolicy);
     var loanRenewalDetails = Optional.of(new LoanRenewalDetails(renewalResponse.getRenewalCount(),
       loanPolicy.getRenewalsPolicy().getNumberAllowed(), loanPolicy.getRenewable()));
     return generateTransactionStatusResponseFromTransactionEntity(transaction, loanRenewalDetails);
   }
 
-  private void validateLoanPolicy(RenewByIdResponse renewalResponse, LoanPolicy loanPolicy) {
+  private void validateLoanPolicy(String loanPolicyId, LoanPolicy loanPolicy) {
     if (Objects.isNull(loanPolicy)) {
       log.debug("validateLoanPolicy:: Loan policy is null");
-      throw new NotFoundException(String.format("Loan policy not found for loan id: %s",
-        renewalResponse.getLoanPolicyId()));
+      throw new NotFoundException(String.format("Loan policy not found for loan id: %s", loanPolicyId));
     }
   }
 
diff --git a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java
index b462bdb0..216c5803 100644
--- a/src/test/java/org/folio/dcb/service/TransactionServiceTest.java
+++ b/src/test/java/org/folio/dcb/service/TransactionServiceTest.java
@@ -1,6 +1,13 @@
 package org.folio.dcb.service;
 
+import org.folio.dcb.client.feign.CirculationClient;
+import org.folio.dcb.client.feign.CirculationLoanPolicyStorageClient;
+import org.folio.dcb.domain.dto.DcbTransaction.RoleEnum;
+import org.folio.dcb.domain.dto.LoanPolicy;
+import org.folio.dcb.domain.dto.RenewByIdResponse;
+import org.folio.dcb.domain.dto.RenewalsPolicy;
 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.dto.TransactionStatusResponseList;
 import org.folio.dcb.domain.entity.TransactionAuditEntity;
@@ -16,6 +23,9 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
@@ -25,8 +35,16 @@
 import java.util.List;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Stream;
 
+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.TransactionStatus.StatusEnum.AWAITING_PICKUP;
+import static org.folio.dcb.domain.dto.TransactionStatus.StatusEnum.CLOSED;
+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;
 import static org.folio.dcb.utils.EntityUtils.DCB_TRANSACTION_ID;
 import static org.folio.dcb.utils.EntityUtils.createDcbTransactionByRole;
 import static org.folio.dcb.utils.EntityUtils.createTransactionEntity;
@@ -35,8 +53,10 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 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.when;
 
@@ -55,7 +75,65 @@ class TransactionServiceTest {
   private TransactionAuditRepository transactionAuditRepository;
   @Mock
   private TransactionMapper transactionMapper;
+  @Mock
+  private CirculationClient circulationClient;
+  @Mock
+  private CirculationLoanPolicyStorageClient circulationLoanPolicyStorageClient;
+
+  @Test
+  void renewLoanByTransactionIdTest() {
+    when(transactionRepository.findById(anyString())).thenReturn(Optional.of(buildTransactionToRenew(
+      ITEM_CHECKED_OUT, LENDER)));
+    when(circulationClient.renewById(any())).thenReturn(buildTestRenewBleResponse());
+    when(circulationLoanPolicyStorageClient.fetchLoanPolicyById(anyString())).thenReturn(buildTestLoanPolicy());
+    when(circulationClient.renewById(any())).thenReturn(buildTestRenewBleResponse());
+    when(circulationLoanPolicyStorageClient.fetchLoanPolicyById(anyString())).thenReturn(buildTestLoanPolicy());
+
+    transactionsService.renewLoanByTransactionId(DCB_TRANSACTION_ID);
+    verify(circulationClient, times(1)).renewById(any());
+    verify(circulationLoanPolicyStorageClient, times(1)).fetchLoanPolicyById(any());
+  }
+
+  @ParameterizedTest
+  @MethodSource("renewLoanByTransactionIdTest1")
+  void renewLoanByTransactionIdShouldThrowExceptionTest(TransactionEntity transaction, Class<Throwable> exception) {
+    when(transactionRepository.findById(anyString())).thenReturn(Optional.of(transaction));
+    assertThrows(exception, () -> transactionsService.renewLoanByTransactionId(DCB_TRANSACTION_ID));
+  }
 
+  private static Stream<Arguments> renewLoanByTransactionIdTest1() {
+    return Stream.of(
+      Arguments.of(buildTransactionToRenew(ITEM_CHECKED_IN, LENDER), StatusException.class),
+      Arguments.of(buildTransactionToRenew(OPEN, LENDER), StatusException.class),
+      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)
+    );
+  }
+
+  private static TransactionEntity buildTransactionToRenew(StatusEnum status, RoleEnum role) {
+    return TransactionEntity.builder()
+      .id(DCB_TRANSACTION_ID)
+      .status(status)
+      .role(role)
+      .build();
+  }
+
+  private static LoanPolicy buildTestLoanPolicy() {
+    return new LoanPolicy()
+      .renewalsPolicy(
+        new RenewalsPolicy()
+          .numberAllowed(10)
+      );
+  }
+
+  private static RenewByIdResponse buildTestRenewBleResponse() {
+    return new RenewByIdResponse()
+      .loanPolicyId("123")
+      .renewalCount(2);
+  }
   @Test
   void createLendingCirculationRequestTest() {
     when(lendingLibraryService.createCirculation(any(), any()))
@@ -69,7 +147,7 @@ void shouldReturnAnyTransactionStatusById(){
     var transactionIdUnique = UUID.randomUUID().toString();
     when(transactionRepository.findById(transactionIdUnique))
       .thenReturn(Optional.ofNullable(TransactionEntity.builder()
-        .status(TransactionStatus.StatusEnum.CREATED)
+        .status(StatusEnum.CREATED)
         .role(LENDER)
         .build()));
 
@@ -105,34 +183,37 @@ void createTransactionWithExistingTransactionIdTest() {
   @Test
   void updateTransactionEntityLenderTest() {
     var dcbTransactionEntity = createTransactionEntity();
-    dcbTransactionEntity.setStatus(TransactionStatus.StatusEnum.OPEN);
+    dcbTransactionEntity.setStatus(StatusEnum.OPEN);
     dcbTransactionEntity.setRole(LENDER);
 
     when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity));
-    when(statusProcessorService.lendingChainProcessor(TransactionStatus.StatusEnum.OPEN, TransactionStatus.StatusEnum.ITEM_CHECKED_OUT))
-      .thenReturn(List.of(TransactionStatus.StatusEnum.AWAITING_PICKUP, TransactionStatus.StatusEnum.ITEM_CHECKED_OUT));
-    doNothing().when(lendingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(TransactionStatus.StatusEnum.AWAITING_PICKUP).build());
-    doNothing().when(lendingLibraryService).updateTransactionStatus(dcbTransactionEntity, TransactionStatus.builder().status(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT).build());
+    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());
 
-    transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, TransactionStatus.builder().status(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT).build());
+    transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, TransactionStatus.builder().status(
+      ITEM_CHECKED_OUT).build());
 
-    verify(statusProcessorService).lendingChainProcessor(TransactionStatus.StatusEnum.OPEN, TransactionStatus.StatusEnum.ITEM_CHECKED_OUT);
+    verify(statusProcessorService).lendingChainProcessor(StatusEnum.OPEN, ITEM_CHECKED_OUT);
   }
 
   @Test
   void updateTransactionEntityErrorTest() {
     var dcbTransactionEntity = createTransactionEntity();
-    dcbTransactionEntity.setStatus(TransactionStatus.StatusEnum.OPEN);
+    dcbTransactionEntity.setStatus(StatusEnum.OPEN);
     when(transactionRepository.findById(DCB_TRANSACTION_ID)).thenReturn(Optional.of(dcbTransactionEntity));
-    var openTransactionStatus = TransactionStatus.builder().status(TransactionStatus.StatusEnum.OPEN).build();
+    var openTransactionStatus = TransactionStatus.builder().status(StatusEnum.OPEN).build();
 
     Assertions.assertThrows(StatusException.class, () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, openTransactionStatus));
 
-    dcbTransactionEntity.setStatus(TransactionStatus.StatusEnum.ITEM_CHECKED_IN);
-    var cancelledTransactionStatus = TransactionStatus.builder().status(TransactionStatus.StatusEnum.CANCELLED).build();
+    dcbTransactionEntity.setStatus(StatusEnum.ITEM_CHECKED_IN);
+    var cancelledTransactionStatus = TransactionStatus.builder().status(StatusEnum.CANCELLED).build();
     Assertions.assertThrows(StatusException.class, () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, cancelledTransactionStatus));
 
-    dcbTransactionEntity.setStatus(TransactionStatus.StatusEnum.ITEM_CHECKED_OUT);
+    dcbTransactionEntity.setStatus(ITEM_CHECKED_OUT);
     Assertions.assertThrows(StatusException.class, () -> transactionsService.updateTransactionStatus(DCB_TRANSACTION_ID, cancelledTransactionStatus));
   }