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

Create an initial web service

Browse Source 
Create a maven project structure.

One mock webservice should be included. Both Json and XML payload accepted.
Configuration of this webservice (response body, response headers, http status code) should be fully configured in a configuration file.

Invoication details (headers, payload) should be logged.

Closes #T124
This commit is contained in:
Szakalakamaka
2020-08-25 14:05:39 +02:00
commit dcc996c006
157 changed files with 3572 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/main/java/com/release11/klaus/KlausApplication.java Normal file
View File

@@ -0,0 +1,19 @@
package com.release11.klaus;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KlausApplication {
public static void main(String[] args) {
SpringApplication.run(KlausApplication.class, args);
}
}
//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

25
src/main/java/com/release11/klaus/config/RedisConfig.java Normal file
View File

@@ -0,0 +1,25 @@
package com.release11.klaus.config;
import org.springframework.beans.factory.annotation.Autowired;
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;
@Configuration
@PropertySource("classpath:data-access.properties")
public class RedisConfig {
@Autowired
private Environment environment;
@Bean
JedisPool jedisPool(){
final JedisPool pool = new JedisPool(environment.getProperty("redis.host"),
Integer.parseInt(environment.getProperty("redis.port")));
return pool;
}
}

39
src/main/java/com/release11/klaus/controller/KlausController.java Normal file
View File

@@ -0,0 +1,39 @@
package com.release11.klaus.controller;
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;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.UUID;
@Controller("/")
@Slf4j
@AllArgsConstructor
public class KlausController {
private final KlausService klausService;
@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);
}
@RequestMapping(value = "klaus/v1/get/{clientUUID}/{mockedResponseId}")
public ResponseEntity getMockedResponse(@PathVariable UUID clientUUID,
@PathVariable int mockedResponseId){
return klausService.getMockedResponse(clientUUID, mockedResponseId);
}
}

76
src/main/java/com/release11/klaus/controller/KlausMvcController.java Normal file
View File

@@ -0,0 +1,76 @@
package com.release11.klaus.controller;
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.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import java.net.URI;
import java.util.Arrays;
import java.util.UUID;
@Slf4j
@Controller
@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);
return "login";
}
@GetMapping("/home")
public String showHome(Model model, @RequestParam UUID clientUUID) {
model.addAttribute("mockedResponseDto", new MockedResponseDto(clientUUID, 1,
"body", new HttpHeaders(), "application/xml"));
return "index";
}
//TODO refactor
//TODO form validation and proper error messages
@PostMapping("/home")
public String showHomePost(Model model, MockedResponseDto mockedResponseDto,
@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());
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.setContentType(MediaType.valueOf(mockedResponseDto.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);
model.addAttribute("mockedResponseDto", new MockedResponseDto(mockedResponseDto.getClientUUID(), 1,
"body", new HttpHeaders(), "application/xml"));
model.addAttribute("mockSaved", "true");
return "index";
}
@GetMapping("/home/getMockedResponse")
@ResponseBody
public String showGetMockedResponse(MockedResponseDto mockedResponseDto) {
return klausService.getMockedResponse(mockedResponseDto.getClientUUID(),
mockedResponseDto.getMockedResponseId()).toString();
}
}

22
src/main/java/com/release11/klaus/model/MockedResponseDto.java Normal file
View File

@@ -0,0 +1,22 @@
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 java.util.UUID;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class MockedResponseDto {
private UUID clientUUID;
private int mockedResponseId;
private String messageBody;
private HttpHeaders httpHeaders;
private String mediaType;
}

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

@@ -0,0 +1,66 @@
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));
}
}
}

7
src/main/java/com/release11/klaus/repository/MockedResponseRepository.java Normal file
View File

@@ -0,0 +1,7 @@
package com.release11.klaus.repository;
import org.springframework.stereotype.Repository;
@Repository
public interface MockedResponseRepository {
}

13
src/main/java/com/release11/klaus/service/KlausService.java Normal file
View File

@@ -0,0 +1,13 @@
package com.release11.klaus.service;
import org.springframework.http.HttpStatus;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
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);
}

35
src/main/java/com/release11/klaus/service/KlausServiceImpl.java Normal file
View File

@@ -0,0 +1,35 @@
package com.release11.klaus.service;
import com.release11.klaus.repository.MockedResponseRedisRepository;
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.Service;
import java.util.UUID;
@Slf4j
@Service
@AllArgsConstructor
public class KlausServiceImpl implements KlausService {
private final MockedResponseRedisRepository mockedResponseRedisRepository;
@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;
}
@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);
}
}