package com.dveamer.contract.comment;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.cloud.openfeign.SpringQueryMap;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

import java.util.List;

@FeignClient(name = "${api.contract.commentClient.name}"
        , url = "${api.contract.commentClient.url}"
        , contextId = "${api.contract.commentClient.contextId}")
public interface CommentContract {

    String PV_articleId = "articleId";

    String PATH_loadCommentsByArticleId = "/articles/{articleId}/comments";
    @GetMapping(path= PATH_loadCommentsByArticleId)
    List<CommentDto> loadCommentsByArticleId(@PathVariable(PV_articleId) String articleId);

    String PATH_loadArticleIdHavingNumerousComments = "/articles";
    @GetMapping(path= PATH_loadArticleIdHavingNumerousComments)
    List<ArticleCommentCountDto> loadArticleIdHavingNumerousComments(@SpringQueryMap ConditionDto conditionDto);

}

package com.dveamer.contract.comment.stub;

import com.dveamer.contract.comment.ArticleCommentCountDto;
import com.dveamer.contract.comment.CommentContract;
import com.dveamer.contract.comment.CommentDto;
import com.dveamer.contract.comment.ConditionDto;
import org.springframework.stereotype.Component;

import java.util.List;

@RestController
public class CommentContractStub implements CommentContract {

    @Override
    @GetMapping(path=PATH_loadCommentsByArticleId)
    public List<CommentDto> loadCommentsByArticleId(@PathVariable(PV_articleId) String articleId) {
        if(articleId.equals(ArticleFixture.articleId1())) {
            return CommentFixture.commentList1();
        }

        return CommentFixture.commentList2();
    }

    @Override
    @GetMapping(path=PATH_loadArticleIdHavingNumerousComments)
    public List<ArticleCommentCountDto> loadArticleIdHavingNumerousComments(ConditionDto conditionDto) {
        return ArticleCommentCountFixture.articleCommentCountList(conditionDto.getBiggerThan(), conditionDto.getBeforeDays());
    }

}

package com.dveamer.contract.comment;

import com.dveamer.contract.comment.stub.ArticleFixture;
import com.dveamer.contract.comment.stub.CommentContractStub;
import com.dveamer.contract.comment.stub.ConditionFixture;
import feign.Feign;
import feign.jackson.JacksonDecoder;
import feign.jackson.JacksonEncoder;

...(생략)

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class CommentContractTests {

    Logger logger = LoggerFactory.getLogger(this.getClass());

    private CommentContract commentContract;

    @BeforeAll
    void setup() {
        ...(생략)

        commentContract = Feign.builder()
                              .contract(new SpringMvcContract())
                              .encoder(new JacksonEncoder())
                              .decoder(new JacksonDecoder())
                              .target(CommentContract.class, url);
    }

    @Test
    void loadCommentsByArticleIdTest() {
        List<CommentDto> expectedList = new CommentContractStub().loadCommentsByArticleId(ArticleFixture.articleId1());
        List<CommentDto> actualList = commentContract.loadCommentsByArticleId(ArticleFixture.articleId1());
        assertThat(actualList, is(samePropertyValuesAs(expectedList)));
    }

    @Test
    void loadArticleIdHavingNumerousCommentsTest() {
        ConditionDto condition = ConditionFixture.conditionDto();
        List<ArticleCommentCountDto> expectedList = new CommentContractStub().loadArticleIdHavingNumerousComments(condition);
        List<ArticleCommentCountDto> actualList = commentContract.loadArticleIdHavingNumerousComments(condition);
        assertThat(actualList, is(samePropertyValuesAs(expectedList)));
    }

}

package com.dveamer.article.component;

import com.dveamer.contract.comment.CommentContract;
import com.dveamer.contract.comment.ConditionDto;
import org.springframework.stereotype.Service;

@Service
public class ArticleServiceImpl implements ArticleService {

    private final CommentContract commentContract;

    ArticleServiceImpl(CommentContract commentContract) {
        this.commentContract = commentContract;
    }

    @Override
    public int loadCountOfComments(String articleId) {
        return commentContract.loadCommentsByArticleId(articleId).size();
    }

    @Override
    public int loadCountOfFamousArticle() {
        ConditionDto conditionDto = new ConditionDto();
        conditionDto.setBiggerThan(2);
        conditionDto.setBeforeDays(3);
        return commentContract.loadArticleIdHavingNumerousComments(conditionDto).size();
    }
}

package com.dveamer.article.component;

import com.dveamer.contract.comment.stub.ArticleFixture;
import com.dveamer.contract.comment.stub.CommentContractStub;
import com.dveamer.contract.comment.stub.ConditionFixture;
...(생략)

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class ArticleServiceTests {

    private CommentContractStubWrapper commentContract;
    private ArticleService articleService;

    @BeforeAll
    public void setup() {
        commentContract= new CommentContractStubWrapper();
        articleService = new ArticleServiceImpl(commentContract);
    }

    @Test
    public void loadCountOfComments_success() throws Exception {
        int expectedValue = new CommentContractStub().loadCommentsByArticleId(ArticleFixture.articleId1()).size();
        int actualValue = articleService.loadCountOfComments(ArticleFixture.articleId1());
        assertThat(actualValue, equalTo(expectedValue));

        assertThat(commentContract.loadCommentsByArticleId_wasCalled(), equalTo(true));
    }

    @Test
    public void loadArticleIdHavingNumerousComments_success() throws Exception {
        int expectedValue = new CommentContractStub().loadArticleIdHavingNumerousComments(ConditionFixture.conditionDto()).size();
        int actualValue = articleService.loadCountOfFamousArticle();
        assertThat(actualValue, equalTo(expectedValue));

        assertThat(commentContract.loadArticleIdHavingNumerousComments_wasCalled(), equalTo(true));
    }

}

package com.dveamer.article.component;

import com.dveamer.contract.comment.ArticleCommentCountDto;
import com.dveamer.contract.comment.CommentContract;
import com.dveamer.contract.comment.CommentDto;
import com.dveamer.contract.comment.ConditionDto;
import com.dveamer.contract.comment.stub.CommentContractStub;
import com.dveamer.contract.comment.stub.ConditionFixture;

import java.util.List;

public class CommentContractStubWrapper implements CommentContract  {

    private final CommentContract commentContract;

    private boolean loadCommentsByArticleId_wasCalled = false;
    private boolean loadArticleIdHavingNumerousComments_wasCalled = false;

    CommentContractStubWrapper() {
        commentContract = new CommentContractStub();
    }

    public boolean loadCommentsByArticleId_wasCalled() {
        return loadCommentsByArticleId_wasCalled;
    }

    public boolean loadArticleIdHavingNumerousComments_wasCalled() {
        return loadArticleIdHavingNumerousComments_wasCalled;
    }

    @Override
    public List<CommentDto> loadCommentsByArticleId(String articleId) {
        loadCommentsByArticleId_wasCalled = true;
        return commentContract.loadCommentsByArticleId(articleId);
    }

    @Override
    public List<ArticleCommentCountDto> loadArticleIdHavingNumerousComments(ConditionDto conditionDto) {
        loadArticleIdHavingNumerousComments_wasCalled = true;
        return commentContract.loadArticleIdHavingNumerousComments(ConditionFixture.conditionDto());
    }
}

package com.dveamer.comment.web;

import com.dveamer.comment.component.Article;
import com.dveamer.comment.component.Comment;
import com.dveamer.comment.component.CommentService;
import com.dveamer.comment.component.ConditionVo;

...(생략)

@RestController
public class CommentController implements CommentContract {

    ...(생략)

    private final CommentService commentService;

    CommentController(CommentService commentService) {
        this.commentService = commentService;
    }

    @Override
    @GetMapping(PATH_loadCommentsByArticleId)
    public List<CommentDto> loadCommentsByArticleId(@PathVariable(PV_articleId) String articleId) {
        ...(생략)
    }

    @Override
    @GetMapping(PATH_loadArticleIdHavingNumerousComments)
    public List<ArticleCommentCountDto> loadArticleIdHavingNumerousComments(ConditionDto conditionDto) {
        ...(생략)
    }

    ...(생략)

}

package com.dveamer.comment.web;


import com.dveamer.contract.comment.CommentContract;
import com.dveamer.contract.comment.ArticleCommentCountDto;
import com.dveamer.contract.comment.CommentDto;
import com.dveamer.contract.comment.ConditionDto;
import com.dveamer.contract.comment.stub.ArticleFixture;
import com.dveamer.contract.comment.stub.CommentContractStub;
import com.dveamer.contract.comment.stub.ConditionFixture;

...(생략)

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class CommentControllerTests {

    private MockMvc mockMvc;
    private CommentServiceStub commentService;

    @BeforeAll
    public void setup() {
        commentService= new CommentServiceStub();
        mockMvc = MockMvcBuilders.standaloneSetup(new CommentController(commentService)).build();
    }


    @Test
    public void loadCommentsByArticleId_success() throws Exception {
        List<CommentDto> expectedCommentDtoList = new CommentContractStub().loadCommentsByArticleId(ArticleFixture.articleId1());
        mockMvc.perform(get(CommentContract.PATH_loadCommentsByArticleId, ArticleFixture.articleId1()))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(content().string(JsonConverterUtil.toJson(expectedCommentDtoList)));

        assertThat(commentService.loadCommentsByArticleId_wasCalled(), equalTo(true));
    }

    @Test
    public void loadArticleIdHavingNumerousComments_success() throws Exception {
        ConditionDto condition = ConditionFixture.conditionDto();
        List<ArticleCommentCountDto> expectedArticleCommentCountDtoList = new CommentContractStub().loadArticleIdHavingNumerousComments(condition);
        mockMvc.perform(get(CommentContract.PATH_loadArticleIdHavingNumerousComments)
                            .queryParam("beforeDays", Integer.toString(condition.getBeforeDays()))
                            .queryParam("biggerThan", Integer.toString(condition.getBiggerThan())))
                .andExpect(status().isOk())
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                .andExpect(content().string(JsonConverterUtil.toJson(expectedArticleCommentCountDtoList)));

        assertThat(commentService.loadArticleIdHavingNumerousComments_wasCalled(), equalTo(true));
    }


}

public interface GitHub {

  @RequestLine("GET /repos/{owner}/{repo}/contributors")
  List<Contributor> contributors(@Param("owner") String owner, @Param("repo") String repo);

  @RequestLine("POST /repos/{owner}/{repo}/issues")
  void createIssue(Issue issue, @Param("owner") String owner, @Param("repo") String repo);
}

@FeignClient(name = "${feign.name}", url = "${feign.url}")
public interface GitHub {

  @GetMapping("/repos/{owner}/{repo}/contributors")
  List<Contributor> contributors(@PathVariable("owner") String owner, @PathVariable("repo") String repo);

  @PostMapping("/repos/{owner}/{repo}/issues")
  void createIssue(Issue issue, @PathVariable("owner") String owner, @PathVariable("repo") String repo);
}

@RestController
public class GitHubController {

  @GetMapping("/repos/{owner}/{repo}/contributors")
  List<Contributor> contributors(@PathVariable("owner") String owner, @PathVariable("repo") String repo) {

      // do something...

      return contributors;
  }

  @PostMapping("/repos/{owner}/{repo}/issues")
  void createIssue(Issue issue, @PathVariable("owner") String owner, @PathVariable("repo") String repo) {

      // do something...

  }
}