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

update to current version

Browse Source 
all initial features implemented
tbd:
   etrack
   front
This commit is contained in:
Szakalakamaka
2020-09-01 09:50:30 +02:00
parent 16dec0fc4d
commit 0223adb1cf
41 changed files with 373 additions and 377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/main/java/com/release11/klaus/KlausApplication.java
View File

@@ -3,6 +3,7 @@ package com.release11.klaus;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KlausApplication {
@@ -14,6 +15,8 @@ public class KlausApplication {
//TODO Jenkins
//TODO history logs
//TODO form validation
//TODO JedisPool jedisPool = new JedisPool(jedisPoolConfig, redisHost, redisPort, timeout, redisPassword)
//TODO JedisPool optimalization https://partners-intl.aliyun.com/help/doc-detail/98726.htm
// loging and security
// tracking clients activity
// use a centralized logging collection tool like logstash

28
src/main/java/com/release11/klaus/config/RedisConfig.java
View File

@@ -5,9 +5,16 @@ import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import redis.clients.jedis.JedisPool;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import java.util.Objects;
@Configuration
@EnableRedisRepositories
@PropertySource("classpath:data-access.properties")
public class RedisConfig {
@@ -15,11 +22,20 @@ public class RedisConfig {
private Environment environment;
@Bean
JedisPool jedisPool(){
final JedisPool pool = new JedisPool(environment.getProperty("redis.host"),
Integer.parseInt(environment.getProperty("redis.port")));
return pool;
JedisConnectionFactory jedisConnectionFactory() {
RedisStandaloneConfiguration redisStandaloneConfiguration =
new RedisStandaloneConfiguration(Objects.requireNonNull(environment.getProperty("redis.host")),
Integer.parseInt(Objects.requireNonNull(environment.getProperty("redis.port"))));
return new JedisConnectionFactory(redisStandaloneConfiguration);
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(jedisConnectionFactory());
redisTemplate.setExposeConnection(true);
redisTemplate.setDefaultSerializer(new GenericJackson2JsonRedisSerializer());
return redisTemplate;
}
}

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

@@ -1,10 +1,12 @@
package com.release11.klaus.controller;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.service.KlausService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
@@ -13,6 +15,7 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.Map;
import java.util.UUID;
@Controller("/")
@@ -22,18 +25,29 @@ public class KlausController {
private final KlausService klausService;
@RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
public ResponseEntity getMockedResponse(@PathVariable UUID clientUUID,
@PathVariable int mockedResponseId){
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
return klausService.getMockedResponse(clientUUID, mockedResponseId);
}
@PostMapping(value = "klaus/v1/set/{clientUUID}/{mockedResponseId}")
public ResponseEntity<String> setMockedResponse(@PathVariable UUID clientUUID,
@PathVariable int mockedResponseId,
@RequestParam(required = false) int httpStatus,
RequestEntity<String> requestEntity){
return klausService.setMockedResponse(clientUUID, mockedResponseId, HttpStatus.valueOf(httpStatus), requestEntity);
}
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "setMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(clientUUID),
BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseId)));
@RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
public ResponseEntity getMockedResponse(@PathVariable UUID clientUUID,
@PathVariable int mockedResponseId){
return klausService.getMockedResponse(clientUUID, mockedResponseId);
MockedResponseDto mockedResponseDto = new MockedResponseDto(clientUUID, mockedResponseId,
requestEntity.getHeaders().getContentType().toString(), requestEntity.getBody(),
requestEntity.getHeaders().toSingleValueMap(), httpStatus);
return klausService.setMockedResponse(mockedResponseDto);
}
}

58
src/main/java/com/release11/klaus/controller/KlausMvcController.java
View File

@@ -1,20 +1,20 @@
package com.release11.klaus.controller;
import com.release11.klaus.utilis.BusinessKey;
import com.release11.klaus.utilis.TrackingClient;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.service.KlausService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.*;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import java.net.URI;
import java.util.Arrays;
import javax.validation.Valid;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
@Slf4j
@@ -22,47 +22,44 @@ import java.util.UUID;
@RequestMapping
@AllArgsConstructor
public class KlausMvcController {
private final String SET_MOCKED_RESPONSE_PATH_V1 = "/klaus/v1/set/";
private final String apiHost = "http://localhost:8097";
private final KlausService klausService;
@GetMapping("/login")
public String login(Model model) {
UUID uuid = UUID.randomUUID();
model.addAttribute("clientUUID", uuid);
model.addAttribute("clientUUID", UUID.randomUUID());
return "login";
}
@GetMapping("/home")
public String showHome(Model model, @RequestParam UUID clientUUID) {
model.addAttribute("mockedResponseDto", new MockedResponseDto(clientUUID, 1,
"body", new HttpHeaders(), "application/xml"));
"application/xml", "body", new HashMap<>(), 200));
return "index";
}
//TODO refactor
//TODO form validation and proper error messages
@PostMapping("/home")
public String showHomePost(Model model, MockedResponseDto mockedResponseDto,
public String showHomePost(@Valid MockedResponseDto mockRsp, BindingResult bindingResult, Model model,
@RequestParam(required = false) String[] header,
@RequestParam(required = false) String[] value,
@RequestParam(required = false) int httpStatus) {
log.info(mockedResponseDto.toString());
URI uri = URI.create(apiHost + SET_MOCKED_RESPONSE_PATH_V1 + mockedResponseDto.getClientUUID() + "/"
+ mockedResponseDto.getMockedResponseId());
@RequestParam(required = false) String[] value) throws Exception {
if (bindingResult.hasErrors()) {
return "index";
}
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "setMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockRsp.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockRsp.getMockedResponseId())));
log.info(mockRsp.toString());
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.valueOf(mockedResponseDto.getMediaType()));
httpHeaders.setContentType(MediaType.valueOf(mockRsp.getMediaType()));
if (header!=null){
for (int i = 0; i < header.length; i++) {
httpHeaders.set(header[i], value[i]);
}}
RequestEntity<String> requestEntity = new RequestEntity<String>(mockedResponseDto.getMessageBody(),
httpHeaders, HttpMethod.POST, uri);
klausService.setMockedResponse(mockedResponseDto.getClientUUID(), mockedResponseDto.getMockedResponseId(),
HttpStatus.valueOf(httpStatus), requestEntity);
MockedResponseDto mockedResponseDto = new MockedResponseDto(mockRsp.getClientUUID(), mockRsp.getMockedResponseId(),
mockRsp.getMediaType(), mockRsp.getMessageBody(), httpHeaders.toSingleValueMap(), mockRsp.getHttpStatus());
model.addAttribute("mockedResponseDto", new MockedResponseDto(mockedResponseDto.getClientUUID(), 1,
"body", new HttpHeaders(), "application/xml"));
klausService.setMockedResponse(mockedResponseDto);
model.addAttribute("mockSaved", "true");
return "index";
}
@@ -70,7 +67,16 @@ public class KlausMvcController {
@GetMapping("/home/getMockedResponse")
@ResponseBody
public String showGetMockedResponse(MockedResponseDto mockedResponseDto) {
return klausService.getMockedResponse(mockedResponseDto.getClientUUID(),
TrackingClient.setBusinessKeys(Map.of(BusinessKey.INTERFACE_NAME, "getMockedResponse",
BusinessKey.CLIENT_UUID, String.valueOf(mockedResponseDto.getClientUUID()),
BusinessKey.MESSAGE_ID, String.valueOf(mockedResponseDto.getMockedResponseId())));
return klausService.getMockedResponse(mockedResponseDto.getClientUUID(),
mockedResponseDto.getMockedResponseId()).toString();
}
private void setHeaders(MockedResponseDto mockedResponseDto, String[] header, String[] value){
}
}

42
src/main/java/com/release11/klaus/model/MockedResponseDto.java
View File

@@ -1,22 +1,44 @@
package com.release11.klaus.model;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.http.HttpHeaders;
import org.springframework.http.RequestEntity;
import com.release11.klaus.model.constraints.HttpCode;
import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;
import org.springframework.data.redis.core.index.Indexed;
import javax.validation.constraints.Positive;
import java.io.Serializable;
import java.util.Map;
import java.util.UUID;
@Data
@ToString
@RedisHash("MockedResponseDto")
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class MockedResponseDto {
public final class MockedResponseDto implements Serializable {
@Id
private String compositePrimaryKey;
@Indexed
private UUID clientUUID;
@Positive
private int mockedResponseId;
private String messageBody;
private HttpHeaders httpHeaders;
private String mediaType;
private String messageBody;
private Map<String, String> httpHeaders;
@HttpCode
private Integer httpStatus;
public MockedResponseDto(UUID clientUUID, int mockedResponseId, String mediaType,
String messageBody, Map<String, String> httpHeaders, Integer httpStatus) {
this.compositePrimaryKey = clientUUID.toString() + "_" + mockedResponseId;
this.clientUUID = clientUUID;
this.mockedResponseId = mockedResponseId;
this.mediaType = mediaType;
this.messageBody = messageBody;
this.httpHeaders = httpHeaders;
this.httpStatus = httpStatus;
}
}

66
src/main/java/com/release11/klaus/repository/MockedResponseRedisRepository.java
View File

@@ -1,66 +0,0 @@
package com.release11.klaus.repository;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.util.Map;
import java.util.Objects;
import java.util.UUID;
@Slf4j
@Repository
@Transactional
@AllArgsConstructor
public class MockedResponseRedisRepository implements MockedResponseRepository {
private final JedisPool jedisPool;
//TODO redis persistence
public ResponseEntity<String> getMockedResponse(UUID clientUUID, int mockedResponseId){
String body, httpCodeStatus;
String key = String.format("%s_%s", clientUUID.toString(), mockedResponseId);
HttpHeaders responseHeaders = new HttpHeaders();
try(Jedis jedis = jedisPool.getResource()){
body = jedis.get(key + "_body");
Map<String, String> headerMap = jedis.hgetAll(key + "_headers");
headerMap.forEach(responseHeaders::set);
httpCodeStatus = jedis.get(key + "_httpCodeStatus");
}
return new ResponseEntity<String>(body, responseHeaders,
Objects.requireNonNull(HttpStatus.valueOf(Integer.parseInt(httpCodeStatus))));
}
public ResponseEntity<String> setMockedResponse(UUID clientUUID, int mockedResponseId, HttpStatus httpStatus,
RequestEntity<String> requestEntity){
log.info("mockedResponseRepository, setMockedResponse, clientUUID {}, mockedResponseId {}, httpStatus{} requestEntity{} ",
clientUUID, mockedResponseId, httpStatus, requestEntity);
if (httpStatus == null){httpStatus = HttpStatus.OK;}
String key = String.format("%s_%s", clientUUID.toString(), mockedResponseId);
setMockedResponseBody(key + "_body", requestEntity.getBody());
setMockedResponseHeader(key + "_headers", requestEntity.getHeaders().toSingleValueMap());
setMockedResponseBody(key + "_httpCodeStatus", String.valueOf(httpStatus.value()));
return new ResponseEntity<String>("MockedResponse has been setup successfully! :D", new HttpHeaders(), HttpStatus.ACCEPTED);
}
private synchronized void setMockedResponseBody(String key, String body){
try(Jedis jedis = jedisPool.getResource()){
jedis.set(key, body);
}
}
private synchronized void setMockedResponseHeader(String key, Map<String, String> headers){
try(Jedis jedis = jedisPool.getResource()){
jedis.del(key);
headers.forEach((field, value)->jedis.hset(key, field, value));
}
}
}

6
src/main/java/com/release11/klaus/repository/MockedResponseRepository.java
View File

@@ -1,7 +1,11 @@
package com.release11.klaus.repository;
import com.release11.klaus.model.MockedResponseDto;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import java.util.UUID;
@Repository
public interface MockedResponseRepository {
public interface MockedResponseRepository extends CrudRepository<MockedResponseDto, String>{
}

4
src/main/java/com/release11/klaus/service/KlausService.java
View File

@@ -1,5 +1,6 @@
package com.release11.klaus.service;
import com.release11.klaus.model.MockedResponseDto;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
@@ -8,6 +9,5 @@ import java.util.UUID;
public interface KlausService {
ResponseEntity<String> getMockedResponse(UUID clientUUID, int mockedResponseId);
ResponseEntity<String> setMockedResponse(UUID clientUUID, int mockedResponseId, HttpStatus httpStatus,
RequestEntity<String> requestEntity);
ResponseEntity<String> setMockedResponse(MockedResponseDto mockedResponseDto);
}

29
src/main/java/com/release11/klaus/service/KlausServiceImpl.java
View File

@@ -1,13 +1,16 @@
package com.release11.klaus.service;
import com.release11.klaus.repository.MockedResponseRedisRepository;
import com.release11.klaus.model.MockedResponseDto;
import com.release11.klaus.repository.MockedResponseRepository;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import java.util.Objects;
import java.util.Optional;
import java.util.UUID;
@Slf4j
@@ -15,21 +18,27 @@ import java.util.UUID;
@AllArgsConstructor
public class KlausServiceImpl implements KlausService {
private final MockedResponseRedisRepository mockedResponseRedisRepository;
private final MockedResponseRepository mockedResponseRepository;
@Override
public ResponseEntity<String> getMockedResponse(UUID clientUUID, int mockedResponseId) {
log.info("KlausServiceImpl, operation getMockedResponse, clientId {}, mockedResponseId {} ",
clientUUID, mockedResponseId);
ResponseEntity<String> responseEntity = mockedResponseRedisRepository.getMockedResponse(clientUUID, mockedResponseId);
return responseEntity;
String key = clientUUID.toString() + "_" + mockedResponseId;
Optional<MockedResponseDto> optMockedResponseDto = mockedResponseRepository.findById(key);
MockedResponseDto mockedResponseDto = optMockedResponseDto.get();
HttpHeaders httpHeaders = new HttpHeaders();
mockedResponseDto.getHttpHeaders().forEach(httpHeaders::set);
return new ResponseEntity<>(mockedResponseDto.getMessageBody(), httpHeaders,
Objects.requireNonNull(HttpStatus.valueOf(mockedResponseDto.getHttpStatus())));
}
@Override
public ResponseEntity<String> setMockedResponse(UUID clientUUID, int mockedResponseId, HttpStatus httpStatus,
RequestEntity<String> requestEntity) {
log.info("KlausServiceImpl, operation setMockedResponse, messageBody {}, mockedResponseId {} ",
requestEntity, mockedResponseId);
return mockedResponseRedisRepository.setMockedResponse(clientUUID, mockedResponseId, httpStatus,requestEntity);
public ResponseEntity<String> setMockedResponse(MockedResponseDto mockedResponseDto) {
mockedResponseRepository.save(mockedResponseDto);
log.info("KlausServiceImpl, operation setMockedResponse, mockedResponseDto {} ", mockedResponseDto.toString());
return new ResponseEntity<>("MockedResponse has been setup successfully!", new HttpHeaders(),
HttpStatus.ACCEPTED);
}
}

10
src/main/resources/application.properties
View File

@@ -1,9 +1,11 @@
server.port = 8099
server.port = 8097
spring.output.ansi.enabled = always
logging.file.name=/var/log/klaus/
#logging.file.name=/var/log/klaus/
logging.level.root=INFO
logging.level.org.springframework.web=DEBUG
logging.level.com.release11=DEBUG
logging.level.org.springframework.web=INFO
logging.level.com.release11=INFO
logging.file.max-size = 10MB
spring.mvc.log-request-details=true
appender.rolling.layout.type = ESJsonLayout
appender.rolling.layout.type_name = server

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

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

123
src/main/resources/templates/index.html
View File

@@ -3,94 +3,63 @@
<head>
<meta charset="UTF-8">
<title>Title</title>
<script type='text/javascript'>
function httpGetAsync()
{
var clientUUID = document.getElementById("clientUUID").value;
var mockedResponseId = document.getElementById("mockedResponseId").value;
var url = "http://localhost:8097/klaus/v1/get/" + clientUUID + "/" + mockedResponseId;
var xmlHttp = new XMLHttpRequest();
xmlHttp.onreadystatechange = function() {
if (xmlHttp.readyState == 4 && xmlHttp.status == 200)
alert(xmlHttp.responseText);
}
xmlHttp.open("GET", url, true);
xmlHttp.send(null);
var container = document.getElementById("getMockedResponse");
container.appendChild(document.createElement("br"));
container.appendChild(document.createTextNode(xmlHttp.responseText));
}
function httpGet()
{
var clientUUID = document.getElementById("getClientUUID").value;
var mockedResponseId = document.getElementById("getMockedResponseId").value;
var url = "http://localhost:8097/klaus/v1/get/" + clientUUID + "/" + mockedResponseId;
var xmlHttp = new XMLHttpRequest();
xmlHttp.open( "GET", url, false ); // false for synchronous request
xmlHttp.send( null );
var container = document.getElementById("getMockedResponse");
var headers = xmlHttp.getAllResponseHeaders();
container.appendChild(document.createTextNode(headers));
container.appendChild(document.createTextNode("Your message: "));
container.appendChild(document.createElement("br"));
container.appendChild(document.createTextNode((xmlHttp.responseText)));
return xmlHttp.responseText;
}
var numberOfHeaders = 0;
function addFields(){
var container = document.getElementById("headers");
numberOfHeaders++;
container.appendChild(document.createElement("br"));
container.appendChild(document.createTextNode("Header " + (numberOfHeaders)));
var headerInput = document.createElement("input");
headerInput.type = "text";
headerInput.name = "header";
container.appendChild(headerInput);
container.appendChild(document.createTextNode("Value " + (numberOfHeaders)));
var valueInput = document.createElement("input");
valueInput.type = "text";
valueInput.name = "value";
container.appendChild(valueInput);
}
</script>
<script src="/js/main.js"></script>
</head>
<body>
<br>----------------------------------------------------------------------------------------------------------------
<hr>
<div><br>In order to set mockup response. Please send the response, that you want to receive, on:
<br>http://localhost:8097/klaus/v1/set/ <a th:text="${mockedResponseDto.clientUUID}">clientUUID should be here</a>/{mockedResponseId}?httpStatus=200
<br>or simply fill and submit the below form:</div>
<div class="col-lg-4 form-max">
sayHi('John');
<form action="#" th:action="@{/home}" th:object="${mockedResponseDto}" method="post">
<input type="text" th:field="*{clientUUID}" th:placeholder="*{clientUUID}" hidden/>
<br><label >Mocked response id:</label><br/>
<input type="text" th:field="*{mockedResponseId}" th:value=1/>
<br><label >Mocked response body:</label><br/>
<textarea rows="4" cols="50" th:field="*{messageBody}" th:placeholder='messageBody'></textarea>
<br><label >Mocked response http code status:</label><br/>
<input type="text" th:name="httpStatus" th:value='200' />
<br>Provide mocked response headers: <a href="#" id="addHeader" onclick="addFields()">Add a new header</a>
<div id="headers"></div>
<br><label >Media type:</label>
<select th:field="*{mediaType}">
<option value="application/xml">application/xml</option>
<option value="application/json">application/json</option>
<option value="text/xml">text/xml</option>
</select>
<input type="submit" value="Save mocked response" onclick="submit()"/>
<table>
<input type="text" th:field="*{clientUUID}" th:placeholder="*{clientUUID}" hidden/>
<tr>
<td>Mocked response id:</td>
<td><input type="text" th:field="*{mockedResponseId}" th:value=1/></td>
<td th:if="${#fields.hasErrors('mockedResponseId')}" th:errors="*{mockedResponseId}">Id Error</td>
</tr>
<tr>
<td>Mocked response body:</td>
<td><textarea rows="4" cols="50" th:field="*{messageBody}" th:placeholder='messageBody'></textarea></td>
<td th:if="${#fields.hasErrors('messageBody')}" th:errors="*{messageBody}">Body Error</td>
</tr>
<tr>
<td>Mocked response http code status:</td>
<td><input type="text" th:field="*{httpStatus}" th:value='200'></td>
<td th:if="${#fields.hasErrors('httpStatus')}" th:errors="*{httpStatus}">HttpStatus Error</td>
</tr>
<tr>
<td>Provide mocked response headers:</td>
<td><a href="#" id="addHeader" onclick="addFields()">Add a new header</a>
<table>
<tr>
<td><div id="headers"></div></td>
</tr>
</table>
</td>
</tr>
<tr>
<td>Media type:</td>
<td><select th:field="*{mediaType}">
<option value="application/xml">application/xml</option>
<option value="application/json">application/json</option>
<option value="text/xml">text/xml</option>
</select></td>
</tr>
<tr>
<td><input type="submit" value="Save mocked response"/></td>
</tr>
</table>
</form>
<p th:if="${mockSaved}">Mock has been saved</p>
<br>----------------------------------------------------------------------------------------------------------------
<hr>
<div><br>In order to use the mocked response in your integration tests or simply
get your mocked response please send a request to
<br>http://localhost:8097/klaus/v1/get/<a th:text="${mockedResponseDto.clientUUID}">clientUUID should be here</a>/{mockedResponseId}
@@ -104,7 +73,7 @@ function httpGet()
<input type="text" th:field="*{mockedResponseId}" th:placeholder="12345"/>
<input type="submit" value="Get mocked response"/>
</form>
<br>----------------------------------------------------------------------------------------------------------------
<hr>
</div>
</div>

2
src/main/resources/templates/login.html
View File

@@ -3,6 +3,7 @@
<head>
<meta charset="UTF-8">
<title>Login</title>
<script src="/js/main.js"></script>
</head>
<body>
<div><br>Please move to the next step with your own client UUID: </div>
@@ -16,5 +17,6 @@
<br><a th:text="${clientUUID}">clientUUID should be here</a>
</div>
</body>
</html>

4
src/test/java/com/release11/klaus/config/RedisConfigTest.java
View File

@@ -3,12 +3,8 @@ package com.release11.klaus.config;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.core.env.Environment;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class RedisConfigTest {

2
src/test/java/com/release11/klaus/controller/KlausControllerTest.java
View File

@@ -2,8 +2,6 @@ package com.release11.klaus.controller;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
class KlausControllerTest {
@Test

9
src/test/java/com/release11/klaus/controller/KlausMvcControllerTest.java
View File

@@ -1,6 +1,12 @@
package com.release11.klaus.controller;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpStatus;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.*;
@@ -8,5 +14,6 @@ class KlausMvcControllerTest {
@Test
void showHome() {
}
}
}

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

@@ -12,5 +12,11 @@ class MockedResponseRedisRepositoryTest {
@Test
void setMockedResponse() {
// System.out.println("Before Test, clearing Redis");
// JedisPool pool = new JedisPool("localhost");
// redis = pool.getResource();
// redis.ltrim(key, 1, 0);
}
}

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

@@ -1,6 +1,7 @@
package com.release11.klaus.service;
import com.release11.klaus.repository.MockedResponseRedisRepository;
import com.release11.klaus.model.MockedResponseDto;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
@@ -19,43 +20,44 @@ import static org.mockito.Mockito.*;
@SpringBootTest
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;
@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(), anyInt(), any(), any()))
.thenReturn(mockedResponseEntity);
ResponseEntity<String> responseEntity = klausServiceImpl.setMockedResponse(uuid, 1,
HttpStatus.ACCEPTED, mockedRequestEntity);
assertThat(responseEntity).isNotNull();
verify(mockedResponseRedisRepository).setMockedResponse(any(), anyInt(), any(), any());
}
// @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 MockedResponseDto mockedResponseDto = new MockedResponseDto(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(mockedResponseDto);
// assertThat(responseEntity).isNotNull();
// verify(mockedResponseRedisRepository).setMockedResponse(any());
// }
}