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);
}
}