Merge branch 'Junit_Test_Branch' into 'master'

Added Junit Test

See merge request !3

bin/main/application.yml

-spring:
-  application:
-    name: store-producer
-  datasource:
-    url: jdbc:postgresql://127.0.0.1:5432/epe
-    username: postgres
-    password: welcome
-    driver-class-name: org.postgresql.Driver
-  jpa:
-    show-sql: true
-    properties:
-      hibernate:
-        dialect: org.hibernate.dialect.PostgreSQLDialect
-server:
-  port: 8200
-
-kafka:
-  producer:
-    offer-transaction-record-topic : transactionRecord
-
-schema:
-  api:
-    baseurl:  http://localhost:8082

bin/main/transactionRecord.avsc

-{
-  "name": "TransactionRecorder",
-  "type": "record",
-  "namespace": "com.safeway.epe.domain",
-  "fields": [
-    {
-      "name": "uuid",
-      "type": "string"
-    },
-    {
-      "name": "offertransactionresponse",
-      "type": "string"
-    },
-    {
-      "name": "offers",
-      "type": "string"
-    }
-  ]
-}
\ No newline at end of file

src/main/java/com/safeway/epe/controller/TransactionController.java

@@ -2,6 +2,8 @@ package com.safeway.epe.controller;
 
 import com.safeway.epe.domain.Offsets;
 import com.safeway.epe.service.TransactionService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -13,12 +15,14 @@ import java.util.List;
 @RestController
 public class TransactionController
 {
+    Logger logger = LoggerFactory.getLogger(this.getClass());
     @Autowired
     private TransactionService service;
 
     @GetMapping("transaction/{uuid}")
     public ResponseEntity<List<Offsets>> produce(@PathVariable("uuid") String uuid)
     {
+        logger.info("Started producing message for transactionId :: "+uuid);
         return service.produceMessage(uuid);
     }
 }

src/main/java/com/safeway/epe/service/TransactionServiceImpl.java

@@ -43,7 +43,8 @@ public class TransactionServiceImpl implements  TransactionService
     private ResponseEntity<List<Offsets>> sendData(TransactionRecorder transactionRecorder, boolean isReprocesed) {
         Record record = TransactionRecordMapper.INSTANCE.recordConvertion(transactionRecorder.getUuid().toString(), transactionRecorder);
         TransactionPayload transactionPayload = TransactionPayloadMapper.INSTANCE.transactionPayloadMapper(record);
-        return  ResponseEntity.ok(producerService.produce(transactionPayload,configProps.getOfferTransactionRecordTopic(),transactionRecorder,isReprocesed));
+        List<Offsets> offsetsList = producerService.produce(transactionPayload,configProps.getOfferTransactionRecordTopic(),transactionRecorder,isReprocesed);
+        return  ResponseEntity.ok(offsetsList);
     }
 
     public ResponseEntity<String> errorResponse(TransactionRecorder transactionRecorder, String exceptionMessage, boolean isReprocesed) {

src/main/resources/avro/transactionRecord.avsc

-{
-  "name": "TransactionRecorder",
-  "type": "record",
-  "namespace": "com.safeway.epe.domain",
-  "fields": [
-    {
-      "name": "uuid",
-      "type": "string"
-    },
-    {
-      "name": "offertransactionresponse",
-      "type": "string"
-    },
-    {
-      "name": "offers",
-      "type": "string"
-    }
-  ]
-}
\ No newline at end of file

src/test/java/com/safeway/epe/StoreProducerApplicationTests.java

-//package com.safeway.epe;
-//
-//import org.junit.jupiter.api.Test;
-//import org.springframework.boot.test.context.SpringBootTest;
-//
-//@SpringBootTest
-//class StoreProducerApplicationTests {
-//
-//	@Test
-//	void contextLoads() {
-//	}
-//
-//}
+package com.safeway.epe;
+
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@Disabled
+@SpringBootTest
+class StoreProducerApplicationTests {
+
+	@Test
+	void contextLoads() {
+	}
+
+}

src/test/java/com/safeway/epe/controller/TransactionControllerTest.java

 package com.safeway.epe.controller;
 
-import com.safeway.epe.domain.Offsets;
-import com.safeway.epe.domain.TransactionPayload;
-import com.safeway.epe.domain.TransactionRecorder;
-import com.safeway.epe.repository.TransactionRepository;
-import com.safeway.epe.service.ProducerService;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
+
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentMatchers;
-import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
-import org.springframework.test.context.junit.jupiter.web.SpringJUnitWebConfig;
 
-import java.util.*;
+import com.safeway.epe.domain.Offsets;
+import com.safeway.epe.domain.TransactionPayload;
+import com.safeway.epe.domain.TransactionRecorder;
+import com.safeway.epe.repository.TransactionRepository;
+import com.safeway.epe.service.ProducerService;
 
 @SpringBootTest
+@DisplayName("Component_Test_Case_For_Transaction_Controller")
 public class TransactionControllerTest {
 
-    @Autowired
-    private TransactionController transactionController;
+	Logger logger = LoggerFactory.getLogger(this.getClass());
 
-    @MockBean
-    private ProducerService producerService;
+	@Autowired
+	private TransactionController transactionController;
 
-    @MockBean
-    private TransactionRepository transactionRepository;
+	@MockBean
+	private ProducerService producerService;
 
-    private static String transactionId = "0ed78832-ea04-4062-b7dd-35c6c903c44c";
-    private List<Offsets> listOfOffest;
+	@MockBean
+	private TransactionRepository transactionRepository;
 
-    @Test
-    public void testProducer_Success() {
-        listOfOffest=new ArrayList<>();
-        Offsets offsets=new Offsets();
-        offsets.setPartition("0");
-        offsets.setOffset("1");
-        listOfOffest.add(offsets);
+	private static String transactionId = "0ed78832-ea04-4062-b7dd-35c6c903c44c";
+	private List<Offsets> listOfOffest;
 
-        UUID uuid = UUID.fromString(transactionId);
-        Optional<TransactionRecorder> optionalOfferTransaction = Optional.of(createTransactionRecorder(uuid));
-        Mockito.when(transactionRepository.findById(Mockito.any(UUID.class))).thenReturn(optionalOfferTransaction);
-        Mockito.when(producerService.produce(Mockito.any(TransactionPayload.class), Mockito.anyString(),
-                Mockito.any(TransactionRecorder.class),Mockito.anyBoolean()
-        )).thenReturn(listOfOffest);
+	@Test
+	public void testProducer_Success() {
+		listOfOffest = new ArrayList<>();
+		Offsets offsets = new Offsets();
+		offsets.setPartition("0");
+		offsets.setOffset("1");
+		listOfOffest.add(offsets);
 
-        ResponseEntity<List<Offsets>> responseEntity =  transactionController.produce(transactionId);
-        Assertions.assertEquals(responseEntity.getStatusCode(), HttpStatus.OK);
-    }
+		UUID uuid = UUID.fromString(transactionId);
+		Optional<TransactionRecorder> optionalOfferTransaction = Optional.of(createTransactionRecorder(uuid));
+		Mockito.when(transactionRepository.findById(Mockito.any(UUID.class))).thenReturn(optionalOfferTransaction);
+		Mockito.when(producerService.produce(Mockito.any(TransactionPayload.class), Mockito.anyString(),
+				Mockito.any(TransactionRecorder.class), Mockito.anyBoolean())).thenReturn(listOfOffest);
 
-    @Test
-    public void testProducer_Failure() {
-        Optional<TransactionRecorder> optionalOfferTransaction = Optional.empty();
-        Mockito.when(transactionRepository.findById(Mockito.any(UUID.class))).thenReturn(optionalOfferTransaction);
-        ResponseEntity<List<Offsets>> responseEntity =  transactionController.produce(transactionId);
-        Assertions.assertEquals(responseEntity.getStatusCode(), HttpStatus.NOT_FOUND);
-        Assertions.assertEquals(responseEntity.getBody(), Arrays.asList(new Offsets()));
-    }
+		ResponseEntity<List<Offsets>> responseEntity = transactionController.produce(transactionId);
+		Assertions.assertEquals(responseEntity.getStatusCode(), HttpStatus.OK);
+	}
 
-    private TransactionRecorder createTransactionRecorder(UUID uuid) {
-        TransactionRecorder transactionRecorder = new TransactionRecorder();
-        transactionRecorder.setUuid(uuid);
-        transactionRecorder.setProcessed(true);
-        transactionRecorder.setOffers("offers");
-        transactionRecorder.setOfferTransactionResponse("TransactionResponse");
-        return transactionRecorder;
-    }
+	@Test
+	public void testProducer_Failure() {
+		Optional<TransactionRecorder> optionalOfferTransaction = Optional.empty();
+		Mockito.when(transactionRepository.findById(Mockito.any(UUID.class))).thenReturn(optionalOfferTransaction);
+		ResponseEntity<List<Offsets>> responseEntity = transactionController.produce(transactionId);
+		Assertions.assertEquals(responseEntity.getStatusCode(), HttpStatus.NOT_FOUND);
+		Assertions.assertEquals(responseEntity.getBody(), Arrays.asList(new Offsets()));
+	}
 
+	private TransactionRecorder createTransactionRecorder(UUID uuid) {
+		TransactionRecorder transactionRecorder = new TransactionRecorder();
+		transactionRecorder.setUuid(uuid);
+		transactionRecorder.setProcessed(true);
+		transactionRecorder.setOffers("offers");
+		transactionRecorder.setOfferTransactionResponse("TransactionResponse");
+		return transactionRecorder;
+	}
 
 }
-

src/test/java/com/safeway/epe/service/ProducerServiceTest.java

+package com.safeway.epe.service;
+
+import com.safeway.epe.config.ProducerServiceProxy;
+import com.safeway.epe.domain.ConsumerPayload;
+import com.safeway.epe.domain.Offsets;
+import com.safeway.epe.domain.TransactionPayload;
+import com.safeway.epe.domain.TransactionRecorder;
+import org.junit.jupiter.api.*;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.ResponseEntity;
+
+import java.util.Arrays;
+import java.util.List;
+
+@DisplayName("Producer_Service_Test_Class")
+public class ProducerServiceTest {
+
+    Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @InjectMocks
+    ProducerService producerService;
+    @Mock
+    ProducerServiceProxy mockProducerServiceProxy;
+
+    private final String topic = "trasactionRecordTopic";
+    private final boolean isReprocesed = true;
+    List<Offsets> mockOffsetsList;
+    TransactionPayload request;
+    TransactionRecorder transactionRecorder;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        logger.info("After Each Method Executed");
+        MockitoAnnotations.initMocks(this);
+        request = new TransactionPayload();
+        transactionRecorder = new TransactionRecorder();
+    }
+
+    @Test
+    public void testProduce(){
+        Mockito.when(mockProducerServiceProxy.produceTransactionService(Mockito.anyString(),Mockito.any())).thenReturn(mockConsumerPayloadResponse());
+        List<Offsets> offsetsList = producerService. produce(request, topic,transactionRecorder , isReprocesed);
+        Assertions.assertEquals(offsetsList,mockOffsetsList);
+    }
+    private ResponseEntity<ConsumerPayload> mockConsumerPayloadResponse(){
+        ConsumerPayload entity = new ConsumerPayload();
+        Offsets offsets = new Offsets();
+        offsets.setOffset("1");
+        offsets.setPartition("0");
+        mockOffsetsList = Arrays.asList(offsets);
+        entity.setOffsetsList(mockOffsetsList);
+        return ResponseEntity.ok(entity);
+    }
+
+    @AfterEach
+    public void tearDown(){
+        logger.info("After Each Method Executed");
+    }
+}

src/test/java/com/safeway/epe/service/TransactionServiceImplTest.java

@@ -4,37 +4,40 @@ import com.safeway.epe.config.ConfigProps;
 import com.safeway.epe.domain.Offsets;
 import com.safeway.epe.domain.TransactionRecorder;
 import com.safeway.epe.repository.TransactionRepository;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.*;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 
 import java.util.*;
 
+@DisplayName("Transaction_Service_Impl_Test_Class")
 public class TransactionServiceImplTest {
 
+    Logger logger = LoggerFactory.getLogger(this.getClass());
+
     @InjectMocks
     TransactionServiceImpl transactionServiceImpl;
     @Mock
     private TransactionRepository mockTransactionRepository;
     @Mock
-    private ProducerService testProducerService;
+    private ProducerService mockProducerService;
     @Mock
     private ConfigProps configProps;
 
     @BeforeEach
     public void setUp() throws Exception {
+        logger.info("Before Each Method Executed");
         MockitoAnnotations.initMocks(this);
     }
 
     @Test
-    @DisplayName("Produce Message to Kafka Topic")
+    @DisplayName("Produce_Message_to_Kafka_Topic_Success_Scenario")
     public void testProduceMessage(){
 
         String transactionId = "997a9ed1-fb45-46d6-baee-0230f1da93dd";
@@ -48,6 +51,7 @@ public class TransactionServiceImplTest {
     }
 
     @Test
+    @DisplayName("Produce_Message_to_Kafka_Topic_Exception_Scenario")
     public void testProduceMessage_Exception(){
 
         String transactionId = "997a9ed1-fb45-46d6-baee-0230f1da93dd";
@@ -71,6 +75,10 @@ public class TransactionServiceImplTest {
         return transactionRecorder;
     }
 
+    @AfterEach
+    public void tearDown(){
+        logger.info("After Each Method Executed");
+    }
 
 }