R11/release11-tools-mocked-services
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

unit tests

Browse Source
This commit is contained in:
Szakalakamaka
2020-10-09 16:56:48 +02:00
parent 2c5cddb93e
commit 76cab9630f
11 changed files with 307 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/com/release11/klaus/controller/KlausController.java
View File

@@ -39,8 +39,7 @@ public class KlausController {
@GetMapping(value = "klaus/v1/getAll/{clientUUID}")
public ResponseEntity<String> getAllMockedResponses(@PathVariable UUID clientUUID){
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getAllMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
BusinessKey.MESSAGE_ID, "all"));
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID)));
List<MockedMessageDto> mockedMessages = klausService.getAllMockedResponses(clientUUID);
return new ResponseEntity<>(mockedMessages.toString(), HttpStatus.OK);
}

12
src/main/java/com/release11/klaus/repository/LogsRepository.java
View File

@@ -1,12 +0,0 @@
package com.release11.klaus.repository;
import com.release11.klaus.utilis.BusinessKey;
import org.springframework.stereotype.Repository;
import java.time.ZonedDateTime;
import java.util.List;
@Repository
public interface LogsRepository {
String getLogsByBusinessKeys(List<BusinessKey> businessKeys, ZonedDateTime zonedDateTime);
}

2
src/main/resources/data-access.properties
View File

@@ -1,2 +1,2 @@
redis.host = redis
redis.host = localhost
redis.port = 6379

24
src/test/java/com/release11/klaus/repository/EventRepositoryImplTest.java Normal file
View File

@@ -0,0 +1,24 @@
package com.release11.klaus.repository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class EventRepositoryImplTest {
@BeforeEach
void setUp() {
}
@Test
void findEvents() {
}
@AfterEach
void tearDown() {
}
}

25
src/test/java/com/release11/klaus/repository/MockedResponseRedisRepositoryTest.java
View File

@@ -1,25 +0,0 @@
package com.release11.klaus.repository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class MockedResponseRedisRepositoryTest {
@Autowired
ObjectMapper objectMapper;
@Test
void getMockedResponse() throws JsonProcessingException {
}
@Test
void setMockedResponse() throws JsonProcessingException {
}
}

107
src/test/java/com/release11/klaus/service/EtrackServiceImplTest.java Normal file
View File

@@ -0,0 +1,107 @@
package com.release11.klaus.service;
import com.release11.klaus.model.Event;
import com.release11.klaus.model.EventRequestDto;
import com.release11.klaus.repository.EventRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class EtrackServiceImplTest {
@Mock
EventRepository eventRepository;
@InjectMocks
EtrackServiceImpl etrackServiceImpl;
EventRequestDto eventRequestDto;
List<Event> eventList = new ArrayList<>();
@BeforeEach
void setUp() {
UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.randomUUID();
Event event1 = Event.builder()
.dateTimeStamp(LocalDateTime.of(2018, 9, 9, 0, 0))
.interfaceName("getMockedResponse")
.clientUUID(String.valueOf(uuid1))
.messageId(323)
.thread("superThread")
.level("INFO")
.message("Log message!")
.build();
Event event2 = Event.builder()
.dateTimeStamp(LocalDateTime.of(2020, 5, 2, 13, 22))
.interfaceName("getAllMockedResponse")
.clientUUID(String.valueOf(uuid2))
.thread("superThread")
.level("INFO")
.message("Log message!")
.build();
Event event3 = Event.builder()
.dateTimeStamp(LocalDateTime.of(2020, 3, 2, 16, 12))
.interfaceName("setMockedResponse")
.clientUUID(String.valueOf(uuid1))
.messageId(323)
.thread("superThread")
.level("INFO")
.message("MockedResponse has been setup successfully!")
.build();
Event event4 = Event.builder()
.dateTimeStamp(LocalDateTime.of(2020, 1, 2, 3,4,5))
.interfaceName("deleteMockedResponse")
.clientUUID(String.valueOf(uuid1))
.messageId(22)
.thread("superThread")
.level("INFO")
.message("Message 22 has been removed.")
.build();
eventList.add(event1);
eventList.add(event2);
eventList.add(event3);
eventList.add(event4);
eventRequestDto = EventRequestDto.builder()
.clientUUID(uuid1)
.localDateTimeTo(LocalDateTime.now())
.localDateTimeFrom(LocalDateTime.of(2010, 2, 3, 4, 5,6 ))
.mockedResponseId(323)
.build();
}
@Test
void getEventsByDateTimeAndBusinessKeys() {
when(eventRepository.findEvents(any(), any(), any()))
.thenReturn(eventList);
List<Event> responseList = etrackServiceImpl.getEventsByDateTimeAndBusinessKeys(eventRequestDto);
assertThat(responseList, hasSize(4));
verify(eventRepository).findEvents(any(), any(), any());
}
@AfterEach
void tearDown() { reset(eventRepository); }
}

148
src/test/java/com/release11/klaus/service/KlausServiceImplTest.java
View File

@@ -1,50 +1,118 @@
package com.release11.klaus.service;
import com.release11.klaus.mappers.MockedMessageMapper;
import com.release11.klaus.mappers.MockedMessageMapperImpl;
import com.release11.klaus.model.MockedMessage;
import com.release11.klaus.model.MockedMessageDto;
import com.release11.klaus.repository.MockedResponseRepository;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import javax.ws.rs.core.MediaType;
import java.util.*;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.hasSize;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
@SpringBootTest
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {MockedMessageMapperImpl.class})
class KlausServiceImplTest {
// @Mock
// MockedResponseRedisRepository mockedResponseRedisRepository;
//
// @InjectMocks
// KlausServiceImpl klausServiceImpl;
//
// private final static UUID uuid = UUID.fromString("e4248095-100e-4f1f-8226-e722014ae29f");
// private final static URI uri = URI.create("http//:localhost:8080");
// private static ResponseEntity<String> mockedResponseEntity;
// private static RequestEntity<String> mockedRequestEntity;
// private static mockedMessage mockedMessage = new mockedMessage(uuid, 1, "application/xml", "body",
// new HttpHeaders(), 200);
//
// @BeforeAll
// public static void initializeMockEntities(){
// HttpHeaders httpHeaders = new HttpHeaders();
// mockedResponseEntity = new ResponseEntity<String>("body", httpHeaders, HttpStatus.ACCEPTED);
// mockedRequestEntity = new RequestEntity<String>(HttpMethod.POST, uri);
// }
//
// @Test
// void getMockedResponse() {
//// when(mockedResponseRedisRepository.getMockedResponse(any(), anyInt()))
//// .thenReturn(mockedResponseEntity);
////
//// ResponseEntity<String> responseEntity = klausServiceImpl.getMockedResponse(uuid, 1);
//// assertThat(responseEntity).isNotNull();
//// verify(mockedResponseRedisRepository).getMockedResponse(any(), anyInt());
// }
//
// @Test
// void setMockedResponse() {
// when(mockedResponseRedisRepository.setMockedResponse(any()))
// .thenReturn(mockedResponseEntity);
//
// ResponseEntity<String> responseEntity = klausServiceImpl.setMockedResponse(mockedMessage);
// assertThat(responseEntity).isNotNull();
// verify(mockedResponseRedisRepository).setMockedResponse(any());
// }
@Mock
MockedResponseRepository mockedResponseRepository;
@Mock private MockedMessageMapper mockedMessageMapper;
@InjectMocks
KlausServiceImpl klausService;
UUID uuid;
MockedMessage mockedMessage1;
Map<String, String> httpHeaders;
MockedMessageDto mockedMessageDto1;
MockedMessageDto mockedMessageDto2;
MockedMessageDto mockedMessageDto3;
List<MockedMessage> mockedMessageList = new ArrayList<>();
@BeforeEach
void setUp() {
uuid = UUID.randomUUID();
httpHeaders = new HashMap<>();
mockedMessageDto1 = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(323)
.mediaType(MediaType.APPLICATION_JSON)
.messageBody("it's okey to be gey")
.httpHeaders(httpHeaders)
.httpStatus(200)
.build();
mockedMessageDto2 = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(3123)
.mediaType(MediaType.APPLICATION_JSON)
.messageBody("some random message")
.httpHeaders(httpHeaders)
.httpStatus(404)
.build();
mockedMessageDto3 = MockedMessageDto.builder()
.clientUUID(uuid)
.mockedResponseId(3233)
.mediaType(MediaType.APPLICATION_XML)
.messageBody("loooking good")
.httpHeaders(httpHeaders)
.httpStatus(205)
.build();
mockedMessage1 = new MockedMessage();
mockedMessageList.add(mockedMessage1);
mockedMessageList.add(mockedMessage1);
mockedMessageList.add(mockedMessage1);
}
@Test
void deleteMockedResponse() {
klausService.deleteMockedResponse(uuid, 323);
verify(mockedResponseRepository).deleteById(any());
}
@Test
void getAllMockedResponses() {
when(mockedResponseRepository.findAllByClientUUID(any()))
.thenReturn(mockedMessageList);
assertThat(klausService.getAllMockedResponses(uuid), hasSize(3));
verify(mockedResponseRepository).findAllByClientUUID(any());
}
@Test
void getMockedResponse() {
when(mockedResponseRepository.getByCompositePrimaryKey(any()))
.thenReturn(mockedMessage1);
assertThat(klausService.getMockedResponse(uuid, 323)).isNotNull();
verify(mockedResponseRepository).findById(any());
}
@Test
void setMockedResponse() {
klausService.setMockedResponse(mockedMessageDto1);
verify(mockedResponseRepository).save(any());
}
@AfterEach
void tearDown() { reset(mockedResponseRepository); }
}