import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
public class HttpRequestTest {
@LocalServerPort
private int port;
@Autowired
private TestRestTemplate restTemplate;
@Test
public void greetingShouldReturnDefaultMessage() throws Exception {
assertThat(this.restTemplate.getForObject("http://localhost:" + port + "/",
String.class)).contains("Hello, World");
}
}@RestController
public class MovieController {
@Autowired
private MovieService movieService;
@GetMapping("/movies")
public List<Movie> retrieveAllMovies() {
return movieService.retrieveAllMovies();
}
@GetMapping("/movies/{id}")
public Movie retrieveMovies(@PathVariable Long id) {
return movieService.retrieveMovies(id);
}
@PostMapping("/movies")
public Long createMovie(@RequestBody Movie movie) {
return movieService.createMovie(movie);
}
}
@Service
public class MovieService {
@Autowired
private MovieRepository movieRepository;
public List<Movie> retrieveAllMovies() {
return movieRepository.findAll();
}
public Movie retrieveMovies(@PathVariable Long id) {
Movie movie = movieRepository.findById(id)
.get();
Movie response = new Movie();
response.setTitle(movie.getTitle()
.toLowerCase());
return response;
}
public Long createMovie(@RequestBody Movie movie) {
return movieRepository.save(movie)
.getId();
}
}
@Repository
public interface MovieRepository extends JpaRepository<Movie, Long> {
}
@Entity
public class Movie {
@Id
private Long id;
private String title;
private String year;
private String rating;
// Standard setters and getters
}
public class MovieServiceUnitTests {
@InjectMocks
private MovieService movieService;
@Mock
private MovieRepository movieRepository;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
}
@Test
public void givenMovieServiceWhenQueriedWithAnIdThenGetExpectedMovie() {
Movie movie = new Movie(100L, "Hello World!");
Mockito.when(movieRepository.findById(100L))
.thenReturn(Optional.ofNullable(movie));
Movie result = movieService.retrieveMovies(100L);
Assert.assertEquals(movie.getTitle().toLowerCase(), result.getTitle());
}
}
@RunWith(SpringRunner.class)
@SpringBootTest
public class MovieControllerIntegrationTests {
@Autowired
private MovieController movieController;
@Test
public void givenMovieControllerWhenQueriedWithAnIdThenGetExpectedMovie() {
Movie movie = new Movie(100L, "Hello World!");
movieController.createMovie(movie);
Movie result = movieController.retrieveMovies(100L);
Assert.assertEquals(movie.getTitle().toLowerCase(), result.getTitle());
}
}
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MovieApplicationE2eTests {
@Autowired
private MovieController movieController;
@LocalServerPort
private int port;
@Test
public void givenMovieApplicationWhenQueriedWithAnIdThenGetExpectedMovie() {
Movie movie = new Movie(100L, "Hello World!");
movieController.createMovie(movie);
when().get(String.format("http://localhost:%s/movies/100", port))
.then()
.statusCode(is(200))
.body(containsString("Hello World!".toLowerCase()));
}
}import com.fasterxml.jackson.databind.JsonNode;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.web.client.HttpStatusCodeException;
import org.springframework.web.client.RestTemplate;
import java.time.Duration;
import java.util.*;
@Service
public class RestService {
private final RestTemplate restTemplate;
public RestService(RestTemplateBuilder restTemplateBuilder) {
// set connection and read timeouts
this.restTemplate = restTemplateBuilder
.setConnectTimeout(Duration.ofSeconds(500))
.setReadTimeout(Duration.ofSeconds(500))
.build();
}
public String getPostsPlainJSON() {
String url = "https://jsonplaceholder.typicode.com/posts";
return this.restTemplate.getForObject(url, String.class);
}
public Post[] getPostsAsObject() {
String url = "https://jsonplaceholder.typicode.com/posts";
return this.restTemplate.getForObject(url, Post[].class);
}
public Post getPostWithUrlParameters() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
return this.restTemplate.getForObject(url, Post.class, 1);
}
public Post getPostWithResponseHandling() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
ResponseEntity<Post> response = this.restTemplate.getForEntity(url, Post.class, 1);
if (response.getStatusCode() == HttpStatus.OK) {
return response.getBody();
} else {
return null;
}
}
public Post getPostWithCustomHeaders() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
// create headers
HttpHeaders headers = new HttpHeaders();
// set `accept` header
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// set custom header
headers.set("x-request-src", "desktop");
// build the request
HttpEntity<String> entity = new HttpEntity<>("body", headers);
// use `exchange` method for HTTP call
ResponseEntity<Post> response = this.restTemplate.exchange(url, HttpMethod.GET, entity, Post.class, 1);
if (response.getStatusCode() == HttpStatus.OK) {
return response.getBody();
} else {
return null;
}
}
public Post createPost() {
String url = "https://jsonplaceholder.typicode.com/posts";
// create headers
HttpHeaders headers = new HttpHeaders();
// set `content-type` header
headers.setContentType(MediaType.APPLICATION_JSON);
// set `accept` header
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// create a map for post parameters
Map<String, Object> map = new HashMap<>();
map.put("userId", 1);
map.put("title", "Introduction to Spring Boot");
map.put("body", "Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications.");
// build the request
HttpEntity<Map<String, Object>> entity = new HttpEntity<>(map, headers);
// send POST request
ResponseEntity<Post> response = this.restTemplate.postForEntity(url, entity, Post.class);
// check response status code
if (response.getStatusCode() == HttpStatus.CREATED) {
return response.getBody();
} else {
return null;
}
}
public Post createPostWithObject() {
String url = "https://jsonplaceholder.typicode.com/posts";
// create headers
HttpHeaders headers = new HttpHeaders();
// set `content-type` header
headers.setContentType(MediaType.APPLICATION_JSON);
// set `accept` header
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// create a post object
Post post = new Post(1, "Introduction to Spring Boot",
"Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications.");
// build the request
HttpEntity<Post> entity = new HttpEntity<>(post, headers);
// send POST request
return restTemplate.postForObject(url, entity, Post.class);
}
public void updatePost() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
// create headers
HttpHeaders headers = new HttpHeaders();
// set `content-type` header
headers.setContentType(MediaType.APPLICATION_JSON);
// set `accept` header
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// create a post object
Post post = new Post(4, "New Title", "New Body");
// build the request
HttpEntity<Post> entity = new HttpEntity<>(post, headers);
// send PUT request to update post with `id` 10
this.restTemplate.put(url, entity, 10);
}
public Post updatePostWithResponse() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
// create headers
HttpHeaders headers = new HttpHeaders();
// set `content-type` header
headers.setContentType(MediaType.APPLICATION_JSON);
// set `accept` header
headers.setAccept(Collections.singletonList(MediaType.APPLICATION_JSON));
// create a post object
Post post = new Post(4, "New Title", "New Body");
// build the request
HttpEntity<Post> entity = new HttpEntity<>(post, headers);
// send PUT request to update post with `id` 10
ResponseEntity<Post> response = this.restTemplate.exchange(url, HttpMethod.PUT, entity, Post.class, 10);
// check response status code
if (response.getStatusCode() == HttpStatus.OK) {
return response.getBody();
} else {
return null;
}
}
public void deletePost() {
String url = "https://jsonplaceholder.typicode.com/posts/{id}";
// send DELETE request to delete post with `id` 10
this.restTemplate.delete(url, 10);
}
public HttpHeaders retrieveHeaders() {
String url = "https://jsonplaceholder.typicode.com/posts";
// send HEAD request
return this.restTemplate.headForHeaders(url);
}
public Set<HttpMethod> allowedOperations() {
String url = "https://jsonplaceholder.typicode.com/posts";
// send HEAD request
return this.restTemplate.optionsForAllow(url);
}
public String unknownRequest() {
try {
String url = "https://jsonplaceholder.typicode.com/404";
return this.restTemplate.getForObject(url, String.class);
} catch (HttpStatusCodeException ex) {
// raw http status code e.g `404`
System.out.println(ex.getRawStatusCode());
// http status code e.g. `404 NOT_FOUND`
System.out.println(ex.getStatusCode().toString());
// get response body
System.out.println(ex.getResponseBodyAsString());
// get http headers
HttpHeaders headers = ex.getResponseHeaders();
System.out.println(headers.get("Content-Type"));
System.out.println(headers.get("Server"));
}
return null;
}
}@Controller
public class EmployeeController {
.............
@RequestMapping("/employee3")
@ResponseBody
public String getEmployeeByDept3 (@RequestParam("dept") Optional<String> deptName) {
return "test response for dept: " + (deptName.isPresent() ? deptName.get() :
"using default dept");
}
}
@Test
public void givenOptional_whenIfPresentWorks_thenCorrect() {
Optional<String> opt = Optional.of("baeldung");
opt.ifPresent(name -> System.out.println(name.length()));
}