@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
class Post extends AuditableEntity {

    @JsonView(View.Summary.class)
    @NotEmpty
    private String title;
    
    @NotEmpty
    private String postSlug;

    @JsonView(View.Public.class)
    @NotEmpty
    private String content;

    @Enumerated(EnumType.STRING)
    @Builder.Default
    @JsonView(View.Summary.class)
    private Status status = Status.DRAFT;

    static enum Status {
        DRAFT,
        PUBLISHED
    }
      
    @PrePersist
    public void slugify(){
        this.postSlug = new Slugify().slugify(this.title);
    }

}

@Data
@MappedSuperclass
@EntityListeners(value = AuditingEntityListener.class)
public abstract class AuditableEntity extends PersistableEntity {

    public AuditableEntity() {
    }

    @CreatedDate
    @JsonView(View.Summary.class)
    protected LocalDateTime createdDate;

    @Embedded
    @AttributeOverrides(value = {
        @AttributeOverride(name = "username", column = @Column(name = "author"))
    })
    @CreatedBy
    @JsonView(View.Summary.class)
    protected Username author;

}

@Configuration
@EnableJpaAuditing(auditorAwareRef = "auditorAware")
@Slf4j
public class DataJpaConfig {

    @Bean
    @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public AuditorAware<Username> auditorAware() {

        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

        log.debug("current authentication:" + authentication);

        if (authentication == null || !authentication.isAuthenticated()) {
            return () -> Optional.<Username>empty();
        }

        return () -> Optional.of(
            Username.builder()
                .username(((UserDetails) authentication.getPrincipal()).getUsername())
                .build()
        );

    }
}

@Data
@MappedSuperclass
public abstract class PersistableEntity implements Serializable {
    
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @JsonView(View.Summary.class)
    protected Long id;

    public PersistableEntity() {
    }
    
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Comment extends AuditableEntity {


    @NotEmpty
    @Size(min = 10)
    private String content;


    @Embedded
    @AttributeOverrides(
        value = {
            @AttributeOverride(name = "postSlug", column = @Column(name = "post_slug"))
        }
    )
    @JsonIgnore
    private Slug post;


}

public interface PostRepository extends JpaRepository<Post, Long>, JpaSpecificationExecutor<Post> {

    Optional<Post> findBySlug(String postSlug);
    
}

@Service
@Transactional
public class PostService {

    @Inject
    private PostRepository postRepository;
    

    public Post createPost(PostForm form) {
        Post _post = Post.builder()
            .title(form.getTitle())
            .content(form.getContent())
            .build();
        
        Post saved = this.postRepository.save(_post);
        
        return saved;
    }

    public Post updatePost(String postSlug, PostForm form) {
        Post _post = this.postRepository.findBySlug(postSlug).orElseThrow(
            ()-> {
                return new PostNotFoundException(postSlug);
            }
        );
        
        _post.setTitle(form.getTitle());
        _post.setContent(form.getContent());
        
       Post saved =  this.postRepository.save(_post);
       
       return saved;
    }

    public void deletePost(String postSlug) {
        this.postRepository.delete(this.postRepository.findBySlug(postSlug).orElseThrow(
            () -> {
                return new PostNotFoundException(postSlug);
            }
        ));
    }

}

@RestController
@RequestMapping("/posts")
@Slf4j
public class PostController {

    private PostService postService;

    private PostRepository postRepository;

    private CommentRepository commentRepository;

    public PostController(PostService postService, PostRepository postRepository, CommentRepository commentRepository) {
        this.postService = postService;
        this.postRepository = postRepository;
        this.commentRepository = commentRepository;
    }

    @GetMapping()
    @JsonView(View.Summary.class)
    public ResponseEntity<Page<Post>> getAllPosts(
        @RequestParam(value = "q", required = false) String keyword, //
        @RequestParam(value = "status", required = false) Post.Status status, //
        @PageableDefault(page = 0, size = 10, sort = "createdDate", direction = Direction.DESC) Pageable page) {

        log.debug("get all posts of q@" + keyword + ", status @" + status + ", page@" + page);

        Page<Post> posts = this.postRepository.findAll(PostSpecifications.filterByKeywordAndStatus(keyword, status), page);

        return ok(posts);
    }

    @GetMapping(value = "/{postSlug}")
    @JsonView(View.Public.class)
    public ResponseEntity<Post> getPost(@PathVariable("postSlug") String postSlug) {

        log.debug("get postsinfo by postSlug @" + postSlug);

        Post post = this.postRepository.findBySlug(postSlug).orElseThrow(
            () -> {
                return new PostNotFoundException(postSlug);
            }
        );

        log.debug("get post @" + post);

        return ok(post);
    }

    @PostMapping()
    public ResponseEntity<Void> createPost(@RequestBody @Valid PostForm post, HttpServletRequest request) {

        log.debug("create a new post@" + post);

        Post saved = this.postService.createPost(post);

        log.debug("saved post id is @" + saved.getId());
        URI createdUri = ServletUriComponentsBuilder
            .fromContextPath(request)
            .path("/posts/{postSlug}")
            .buildAndExpand(saved.getSlug())
            .toUri();

        return created(createdUri).build();
    }

    @PutMapping(value = "/{postSlug}")
    public ResponseEntity<Void> updatePost(@PathVariable("postSlug") String postSlug, @RequestBody @Valid PostForm form) {

        log.debug("update post by id @" + postSlug + ", form content@" + form);

        this.postService.updatePost(postSlug, form);

        return noContent().build();
    }

    @DeleteMapping(value = "/{postSlug}")
    public ResponseEntity<Void> deletePostById(@PathVariable("postSlug") String postSlug) {

        log.debug("delete post by id @" + postSlug);

        this.postService.deletePost(postSlug);

        return noContent().build();
    }

    @GetMapping(value = "/{postSlug}/comments")
    public ResponseEntity<Page<Comment>> getCommentsOfPost(
        @PathVariable("postSlug") String postSlug,
        @PageableDefault(page = 0, size = 10, sort = "createdDate", direction = Direction.DESC) Pageable page) {

        log.debug("get comments of post@" + postSlug + ", page@" + page);

        Page<Comment> commentsOfPost = this.commentRepository.findByPost(new Slug(postSlug), page);

        log.debug("get post comment size @" + commentsOfPost.getTotalElements());

        return ok(commentsOfPost);
    }

    @PostMapping(value = "/{postSlug}/comments")
    public ResponseEntity<Void> createComment(
        @PathVariable("postSlug") @NotNull String postSlug, @RequestBody CommentForm comment, HttpServletRequest request) {

        log.debug("new comment of post@" + postSlug + ", comment" + comment);

        Comment _comment = Comment.builder()
            .post(new Slug(postSlug))
            .content(comment.getContent())
            .build();

        Comment saved = this.commentRepository.save(_comment);

        log.debug("saved comment @" + saved.getId());

        URI location = ServletUriComponentsBuilder
            .fromContextPath(request)
            .path("/posts/{postSlug}/comments/{id}")
            .buildAndExpand(postSlug, saved.getId())
            .toUri();

         return created(location).build();
    }

}

public class PostSpecifications {

    private PostSpecifications() {
    }

    public static Specification<Post> filterByKeywordAndStatus(
        final String keyword,//
        final Post.Status status) {
        return (Root<Post> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> {
            List<Predicate> predicates = new ArrayList<>();
            if (StringUtils.hasText(keyword)) {
                predicates.add(
                    cb.or(
                        cb.like(root.get(Post_.title), "%" + keyword + "%"),
                        cb.like(root.get(Post_.content), "%" + keyword + "%")
                    )
                );
            }

            if (status != null) {
                predicates.add(cb.equal(root.get(Post_.status), status));
            }

            return cb.and(predicates.toArray(new Predicate[predicates.size()]));
        };
    }

}

public class PostNotFoundException extends RuntimeException {

    private String postSlug;

    public PostNotFoundException(String postSlug) {
        super("post:" + postSlug + " was not found");
        this.postSlug = postSlug;
    }

    public String getSlug() {
        return postSlug;
    }
    
}

@RestControllerAdvice
public class PostExceptionHandler {

    @ExceptionHandler(PostNotFoundException.class)
    public ResponseEntity notFound(PostNotFoundException ex, WebRequest req) {
        Map<String, String> errors = new HashMap<>();
        errors.put("entity", "POST");
        errors.put("id", "" + ex.getSlug());
        errors.put("code", "not_found");
        errors.put("message", ex.getMessage());

        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errors);
    }

}

public final class View {

    interface Summary {
    }

    interface Public extends Summary {
    }
}

class Post extends AuditableEntity {

    @JsonView(View.Summary.class)
    private String title;
    

    @JsonView(View.Public.class)
    private String content;

    @JsonView(View.Summary.class)
    private Status status = Status.DRAFT;

}

@JsonView(View.Summary.class)
public ResponseEntity<Page<Post>> getAllPosts()

@JsonComponent
public class PageJsonSerializer extends JsonSerializer<PageImpl> {

    @Override
    public void serialize(PageImpl value, JsonGenerator gen, SerializerProvider serializers) throws IOException, JsonProcessingException {
        gen.writeStartObject();
        gen.writeNumberField("number", value.getNumber());
        gen.writeNumberField("numberOfElements", value.getNumberOfElements());
        gen.writeNumberField("totalElements", value.getTotalElements());
        gen.writeNumberField("totalPages", value.getTotalPages());
        gen.writeNumberField("size", value.getSize());
        gen.writeFieldName("content");
        serializers.defaultSerializeValue(value.getContent(), gen);
        gen.writeEndObject();
    }

}

@Configuration
public class RedisSessionConfig {

    @Bean
    public HttpSessionIdResolver httpSessionStrategy() {
        return HeaderHttpSessionIdResolver.xAuthToken();
    }

}

@RequestMapping(value = "/auth")
@RestController
public class AuthenticationController {

	@PostMapping(value = "/signin")
    public AuthenticationResult signin(
        @RequestBody @Valid AuthenticationRequest authenticationRequest,
        HttpServletRequest request) {
        
        if (log.isDebugEnabled()) {
            log.debug("signin form  data@" + authenticationRequest);
        }
        
        return this.handleAuthentication(
            authenticationRequest.getUsername(),
            authenticationRequest.getPassword(),
            request);
    }
    
    private AuthenticationResult handleAuthentication(
        String username,
        String password,
        HttpServletRequest request) {
        
        final UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(
            username,
            password
        );
        
        final Authentication authentication = this.authenticationManager
            .authenticate(token);
        
        SecurityContextHolder.getContext().setAuthentication(authentication);
        
        final HttpSession session = request.getSession(true);
        
        session.setAttribute(
            HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY,
            SecurityContextHolder.getContext());
        
        return AuthenticationResult.builder()
            .name(authentication.getName())
            .roles(authentication.getAuthorities().stream().map(r -> r.getAuthority()).collect(Collectors.toList()))
            .token(session.getId())
            .build();
    }
	
	...

@Configuration
@Slf4j
public class SecurityConfig {
    
    @Bean
    public WebSecurityConfigurerAdapter securityConfigBean(){
        
        return new  WebSecurityConfigurerAdapter() {

            @Override
            protected void configure(HttpSecurity http) throws Exception {
                // We need this to prevent the browser from popping up a dialog on a 401
                http
                    .httpBasic()
                    .and()
                        .authorizeRequests()
                        .antMatchers(HttpMethod.GET, "/posts/**").permitAll()
                        .antMatchers(HttpMethod.DELETE, "/posts/**").hasRole("ADMIN")
                        .anyRequest().authenticated()
                    .and()
                        .csrf().disable();
            }
        };   
    }
}

public class PostTest {

    @Test
    public void testSlug() {
        System.out.println("getSlug");
        Post instance = new Post();
        instance.setTitle("test post 1");
        instance.slugify();
        assertEquals("test-post-1", instance.getSlug());
    }
}

 @RunWith(SpringRunner.class)
 @DataJpaTest()
 @Slf4j
 public class PostRepositoryTest {
 
     @Autowired
     private TestEntityManager em;
 
     @Autowired
     PostRepository posts;
 
     @Before
     public void setup() {
         assertNotNull("posts is not null", posts);
         posts.deleteAllInBatch();
         em.persist(Post.builder().title("test post 1").content("test content of test post 1").build());
     }
 
     @Test
     public void testGetAllPosts() {
         assertTrue(1 == posts.findAll().size());
         Post post = posts.findAll().get(0);
         assertTrue("test-post-1".equals(post.getSlug()));
     }
 
 }

@RunWith(SpringRunner.class)
@Slf4j
public class PostServiceTest {

    @MockBean
    private PostRepository posts;

    @Autowired
    private PostService postService;


    @Test
    public void createPost() {
        final String TITLE = "test post title";
        final String CONTENT = "test post content";

        final PostForm input = PostForm.builder().title(TITLE).content(CONTENT).build();
        Post expected = Post.builder().title(TITLE).content(CONTENT).build();
        expected.setId(1L);

        given(posts.save(Post.builder().title(input.getTitle()).content(input.getContent()).build()))
                .willReturn(expected);

        Post returned = postService.createPost(input);

        assertTrue(returned == expected);

        verify(posts, times(1)).save(any(Post.class));
        verifyNoMoreInteractions(posts);
    }

    @TestConfiguration
    @Import(PostService.class)
    static class TestConfig {

    }

}

@RunWith(SpringRunner.class)
@Slf4j
@WebMvcTest(controllers = PostController.class, secure = false)
public class PostControllerTest {

    @MockBean
    PostRepository posts;

    @MockBean
    CommentRepository comments;

    @MockBean
    PostService postService;

    @Autowired
    ObjectMapper objectMapper;

    @Autowired
    MockMvc mockMvc;

    @Test
    public void createPost() throws Exception {
        Post _data = Post.builder().slug("test-my-first-post").title("my first post").content("my content of my post").build();
        given(this.postService.createPost(any(PostForm.class)))
                .willReturn(_data);

        this.mockMvc
                .perform(
                        post("/posts")
                                .content(objectMapper.writeValueAsString(PostForm.builder().title("my first post").content("my content of my post").build()))
                                .contentType(MediaType.APPLICATION_JSON)
                )
                .andExpect(status().isCreated())
                .andExpect(header().exists("Location"));

        verify(this.postService, times(1)).createPost(any(PostForm.class));
        verifyNoMoreInteractions(this.postService);
    }

}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
@RunWith(SpringRunner.class)
@Slf4j
public class ApplicationControllerMockMvcTest {

    @Autowired
    WebApplicationContext wac;

    @MockBean
    PostRepository posts;

    @MockBean
    CommentRepository comments;

    @MockBean
    PostService postService;

    @Autowired
    ObjectMapper objectMapper;

    @Autowired
    FilterChainProxy springSecurityFilterChain;

    MockMvc mockMvc;

    @Before
    public void setup() {
        this.mockMvc = standaloneSetup(new PostController(postService, posts, comments))
                .setCustomArgumentResolvers(
                        new PageableHandlerMethodArgumentResolver()
                )
                .setMessageConverters(
                        new MappingJackson2HttpMessageConverter(objectMapper)
                )
                .alwaysDo(print())
                .apply(springSecurity(springSecurityFilterChain))
                .build();
    }

    @Test
    //@Ignore
    public void testGetAllPosts() throws Exception {
        given(this.posts
                .findAll(any(Specification.class), any(Pageable.class)))
                .willReturn(
                        new PageImpl(
                                Arrays.asList(
                                        Post.builder().title("my first post1").content("my content of my post1").build(),
                                        Post.builder().title("my first post2").content("my content of my post2").build(),
                                        Post.builder().title("my first post3").content("my content of my post3").build()
                                ),
                                PageRequest.of(0, 10),
                                3L
                        )
                );

        MvcResult result = this.mockMvc
                .perform(
                        get("/posts?q=my")
                                .accept(MediaType.APPLICATION_JSON)
                )
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.content[*].title", hasItem("my first post1")))
                .andReturn();

        log.debug("mvc result:::" + result.getResponse().getContentAsString());
        verify(this.posts, times(1)).findAll(any(Specification.class), any(Pageable.class));
        verifyNoMoreInteractions(this.posts);
    }

    @Test
    public void createPostWithoutAuthentication() throws Exception {
        Post _data = Post.builder().title("my first post").content("my content of my post").build();
        given(this.postService.createPost(any(PostForm.class)))
                .willReturn(_data);

        MvcResult result = this.mockMvc
                .perform(
                        post("/posts")
                                .content(objectMapper.writeValueAsString(PostForm.builder().title("my first post").content("my content of my post").build()))
                                .contentType(MediaType.APPLICATION_JSON)
                )
                .andExpect(status().isUnauthorized())
                .andReturn();

        log.debug("mvc result::" + result.getResponse().getContentAsString());

        verify(this.postService, times(0)).createPost(any(PostForm.class));
        verifyNoMoreInteractions(this.postService);
    }

    @Test
    @WithMockUser
    public void createPostWithMockUser() throws Exception {
        Post _data = Post.builder().title("my first post").content("my content of my post").build();
        given(this.postService.createPost(any(PostForm.class)))
                .willReturn(_data);

        MvcResult result = this.mockMvc
                .perform(
                        post("/posts")
                                .content(objectMapper.writeValueAsString(PostForm.builder().title("my first post").content("my content of my post").build()))
                                .contentType(MediaType.APPLICATION_JSON)
                )
                .andExpect(status().isCreated())
                .andExpect(header().string(HttpHeaders.LOCATION, containsString("/posts")))
                .andReturn();

        log.debug("mvc result::" + result.getResponse().getContentAsString());

        verify(this.postService, times(1)).createPost(any(PostForm.class));
    }

}

this.mockMvc = webAppContextSetup(this.wac)
    .alwaysDo(print())
    .apply(springSecurity(springSecurityFilterChain))
    .build();

@RunWith(SpringRunner.class)
@JsonTest
@Slf4j
public class JsonViewTest {

    @Autowired
    private JacksonTester<Post> json;

    @Test
    public void serializeJson() throws IOException {
        Post details = Post.builder().title("test title").content("test content").build();

        assertThat(this.json.write(details)).extractingJsonPathStringValue("@.title")
                .isEqualTo("test title");
        assertThat(this.json.write(details)).extractingJsonPathStringValue("@.content")
                .isEqualTo("test content");

    }

    @Test
    public void serializeJsonWithView() throws IOException {
        Post details = Post.builder().title("test title").content("test content").build();

        ObjectMapper mapper = new ObjectMapper();
        String result = mapper
                .writerWithView(View.Summary.class)
                .writeValueAsString(details);
        log.debug("result:::" + result);

        assertTrue(result.contains("test title"));
        assertTrue(!result.contains("test content"));

    }
}

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@RunWith(SpringRunner.class)
@Slf4j
public class IntegrationTests {

    @LocalServerPort
    int port;

    @Autowired
    PostRepository posts;

    @Autowired
    CommentRepository comments;

    String test_title = "test title";
    String test_content = "test content";
    String test_comment = "test_comment";
    String slug = "";

    @Before
    public void setup() {
        RestAssured.reset();
        RestAssured.port = this.port;
        this.comments.deleteAllInBatch();
        this.posts.deleteAllInBatch();

        Post post = posts.save(
                Post.builder()
                        .title(test_title)
                        .content(test_content)
                        .build()
        );
        log.debug("saved post:" + post);
        this.slug = post.getSlug();

        log.debug("print all posts:");
        posts.findAll().forEach(System.out::println);

        Comment comment = this.comments.save(
                Comment.builder()
                        .content(test_comment)
                        .post(new PostSlug(this.slug))
                        .build()
        );
        log.debug("saved comment:" + comment);
    }

    @Test
    public void testGetNoneExistingPost_shouldReturn404() throws Exception {
        //@formatter:off
        when()
            .get("/posts/100000")
        .then()
            .statusCode(HttpStatus.SC_NOT_FOUND);
        //@formatter:on
    }


    @Test
    public void testGetAllPosts_shouldBeOK() throws Exception {
        //@formatter:off
        when()
            .get("/posts")
        .then()
            .body("content[0].title", is(test_title))
            .statusCode(HttpStatus.SC_OK);
        //@formatter:on
    }

    @Test
    public void testGetPostBySlug_shouldBeOK() throws Exception {
        //@formatter:off
        when()
            .get("/posts/"+ this.slug)
        .then()
            .body("title", is(test_title))
            .body("content", is(test_content))
            .statusCode(HttpStatus.SC_OK);
        //@formatter:on
    }

    @Test
    public void testGetCommentsOfPostBySlug_shouldBeOK() throws Exception {
        //@formatter:off
        when()
            .get("/posts/"+ this.slug+"/comments")
        .then()
            .body("content[0].content", is(test_comment))
            .statusCode(HttpStatus.SC_OK);
        //@formatter:on
    }

    //-------------- test with auth -----------------------
    @Test
    public void testCreateAPost_withoutUserAuth_shouldReturn401() throws Exception {
        PostForm _data = PostForm.builder().title(test_title).content(test_content).build();

        //@formatter:off
        given()
            //.auth().basic("user", "password")
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .post("/posts")
        .then()
            .statusCode(HttpStatus.SC_UNAUTHORIZED);
        //@formatter:on
    }

    @Test
    public void testCreateAPost_withUserAuth_shouldBeOK() throws Exception {
        PostForm _data = PostForm.builder().title(test_title).content(test_content).build();

        //@formatter:off
        given()
            .auth().basic("user", "password")
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .post("/posts")
        .then()
            .header("Location", containsString("/posts"))
            .statusCode(HttpStatus.SC_CREATED);
        //@formatter:on
    }


    @Test
    public void testUpdateAPost_withoutUserAuth_shouldReturn401() throws Exception {
        PostForm _data = PostForm.builder().title(test_title).content(test_content).build();

        //@formatter:off
        given()
            //.auth().basic("user", "password")
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .put("/posts/"+ this.slug)
        .then()
            .statusCode(HttpStatus.SC_UNAUTHORIZED);
        //@formatter:on
    }

    @Test
    public void testUpdateAPost_withUserAuth_shouldBeOK() throws Exception {
        PostForm _data = PostForm.builder().title(test_title).content(test_content).build();

        //@formatter:off
        given()
            .auth().basic("user", "password")
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .put("/posts/"+ this.slug)
        .then()
            .statusCode(HttpStatus.SC_NO_CONTENT);
        //@formatter:on
    }


    @Test
    public void testDeleteAPost_withoutAuth_shouldReturn401() throws Exception {

        //@formatter:off
        when()
            .delete("/posts/"+ this.slug)
        .then()
            .statusCode(HttpStatus.SC_UNAUTHORIZED);
        //@formatter:on
    }

    @Test
    public void testDeleteAPost_withUserAuth_shouldReturn403() throws Exception {

        //@formatter:off
        given()
            .auth().basic("user", "password")
        .when()
            .delete("/posts/"+ this.slug)
        .then()
            .statusCode(HttpStatus.SC_FORBIDDEN);
        //@formatter:on
    }


    @Test
    public void testDeleteAPost_withAdminAuth_shouldOK() throws Exception {

        //@formatter:off
        given()
            .auth().basic("admin", "password")
        .when()
            .delete("/posts/"+ this.slug)
        .then()
            .statusCode(HttpStatus.SC_NO_CONTENT);
        //@formatter:on
    }


    @Test
    public void testCreateACommentsOfPostBySlug_withoutAuth_shouldReturn401() throws Exception {
        CommentForm _data = CommentForm.builder().content(test_comment).build();

        //@formatter:off
        given()
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .post("/posts/"+ this.slug+"/comments")
        .then()
            .statusCode(HttpStatus.SC_UNAUTHORIZED);
        //@formatter:on
    }

    @Test
    public void testCreateACommentsOfPostBySlug_withUserAuth_shouldBeOk() throws Exception {
        CommentForm _data = CommentForm.builder().content(test_comment).build();

        //@formatter:off
        given()
            .auth().basic("user", "password")
            .body(_data)
            .contentType(ContentType.JSON)
        .when()
            .post("/posts/"+ this.slug+"/comments")
        .then()
            .header("Location", containsString("/posts/"+ this.slug+"/comments"))
            .statusCode(HttpStatus.SC_CREATED);
        //@formatter:on
    }

    
    @TestComponent
    @Slf4j
    static class TestUserDetailsService implements UserDetailsService {

        private final PasswordEncoder passwordEncoder;

        TestUserDetailsService(PasswordEncoder passwordEncoder) {
            this.passwordEncoder = passwordEncoder;
        }

        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            UserDetails user = User.withUsername("user")
                    .password(passwordEncoder.encode("password"))
                    .roles("USER")
                    .accountExpired(false)
                    .accountLocked(false)
                    .credentialsExpired(false)
                    .disabled(false)
                    .build();

            UserDetails admin = User.withUsername("admin")
                    .password(passwordEncoder.encode("password"))
                    .roles("ADMIN")
                    .accountExpired(false)
                    .accountLocked(false)
                    .credentialsExpired(false)
                    .disabled(false)
                    .build();

            log.debug("dummy user:" + user);
            log.debug("dummy admin:" + admin);


            if ("user".equals(username)) {
                return user;
            } else {
                return admin;
            }
        }
    }

    @TestConfiguration
    @Slf4j
    @Import(TestUserDetailsService.class)
    @Order(-1)
    static class TestSecurityConfig extends WebSecurityConfigurerAdapter {

        @Autowired
        PasswordEncoder passwordEncoder;

        @Autowired
        UserDetailsService userDetailsService;

        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                    .httpBasic()
                    .and()
                    .authorizeRequests()
                    .antMatchers(HttpMethod.GET, "/posts/**").permitAll()
                    .antMatchers(HttpMethod.DELETE, "/posts/**").hasRole("ADMIN")
                    .anyRequest().authenticated()
                    .and()
                    .csrf().disable();
        }

        @Override
        protected void configure(AuthenticationManagerBuilder auth) throws Exception {
            auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder);
        }

        @Override
        @Bean
        public AuthenticationManager authenticationManagerBean() throws Exception {
            return super.authenticationManagerBean();
        }

    }
}

@Component
public class UserServiceClient {

    private RestTemplate restTemplate;

    private ObjectMapper objectMapper;

    @Value("${services.user-service-url}")
    private String userServiceUrl;

    public UserServiceClient(RestTemplateBuilder builder, ObjectMapper objectMapper) {
        this.restTemplate = builder.build();
        this.objectMapper = objectMapper;
    }

    public void handleSignup(SignupForm form) {
        try {
            ResponseEntity<Void> response = this.restTemplate.postForEntity(userServiceUrl + "/users", form, Void.class);
        } catch (HttpClientErrorException e) {
            if (e.getStatusCode() == CONFLICT) {
                Map map = null;
                try {
                    map = objectMapper.readValue(e.getResponseBodyAsByteArray(), Map.class);
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
                throw new SignupConflictException((String) map.get("message"));
            }
        }
    }

    public User findByUsername(String username) {
        try {
            ResponseEntity<User> response = this.restTemplate.getForEntity(userServiceUrl + "/users/{username}", User.class, username);
            return response.getBody();
        } catch (HttpClientErrorException e) {
            if (e.getStatusCode() == NOT_FOUND) {
                return null;
            }
        }
        return null;
    }
}

@RunWith(SpringRunner.class)
@RestClientTest(UserServiceClient.class)
@Slf4j
public class UserServiceClientTest {

    @Value("${services.user-service-url:http://localhost:8001}")
    private String userServiceUrl;

    @Autowired
    private UserServiceClient client;

    @Autowired
    private MockRestServiceServer server;

    @Test
    public void testFindbyUsername() {
        this.server.expect(requestTo(userServiceUrl + "/users/user"))
            .andRespond(withSuccess(new ClassPathResource("/find-user-by-username.json"), MediaType.APPLICATION_JSON_UTF8));
            //.andRespond(withSuccess("{\"username\":\"user\",\"password\":\"password\",\"email\":\"[email protected]\"}", MediaType.APPLICATION_JSON_UTF8));

        User user = this.client.findByUsername("user");
        assertNotNull(user);
        assertEquals("user", user.getUsername());

        this.server.verify();
    }

    @Test
    public void testFindbyUsername_notFound() {
        this.server.expect(requestTo(userServiceUrl + "/users/user1"))
            .andRespond(withStatus(NOT_FOUND));

        User user = this.client.findByUsername("user1");
        assertNull(user);

        this.server.verify();
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Slf4j
public class UserServiceClientWireMockTest {

    @Value("${services.user-service-url:http://localhost:8001}")
    private String userServiceUrl;

    @Autowired
    private UserServiceClient client;

    @Rule
    public WireMockRule wireMockRule = new WireMockRule(options().port(8001));

    @Before
    public void setup() {
        WireMock.reset();
    }

    @Test
    public void testFindbyUsername() {

        stubFor(
            get("/users/user")
                //.withHeader("Accept", equalTo(MediaType.APPLICATION_JSON_VALUE))
                .willReturn(
                    okJson("{\"username\":\"user\",\"password\":\"password\",\"email\":\"[email protected]\"}")
                )
        );

        User user = this.client.findByUsername("user");
        assertNotNull(user);
        assertEquals("user", user.getUsername());

        verify(1, getRequestedFor(urlMatching( "/users/user")));
    }

    @Test
    public void testFindbyUsername_notFound() {
        stubFor(
            get( "/users/user1")
                //.withHeader("Accept", equalTo(MediaType.APPLICATION_JSON_VALUE))
                .willReturn(
                    aResponse()
                        .withStatus(HttpStatus.SC_NOT_FOUND)
                )
        );

        User user = this.client.findByUsername("user1");
        assertNull(user);

        verify(1, getRequestedFor(urlMatching( "/users/user1")));
    }
}