composite-build-usage-example

1
package by.andd3dfx.templateapp.services.impl;
2

3
import by.andd3dfx.templateapp.dto.ArticleDto;
4
import by.andd3dfx.templateapp.dto.ArticleUpdateDto;
5
import by.andd3dfx.templateapp.error.exception.ArticleNotFoundException;
6
import by.andd3dfx.templateapp.mappers.ArticleMapper;
7
import by.andd3dfx.templateapp.persistence.dao.ArticleRepository;
8
import by.andd3dfx.templateapp.persistence.entities.Article;
9
import org.junit.jupiter.api.BeforeEach;
10
import org.junit.jupiter.api.Test;
11
import org.junit.jupiter.api.extension.ExtendWith;
12
import org.mockito.InjectMocks;
13
import org.mockito.Mock;
14
import org.mockito.Mockito;
15
import org.mockito.junit.jupiter.MockitoExtension;
16
import org.springframework.dao.EmptyResultDataAccessException;
17
import org.springframework.data.domain.PageImpl;
18
import org.springframework.data.domain.PageRequest;
19
import org.springframework.data.domain.Pageable;
20
import org.springframework.data.domain.Slice;
21
import org.springframework.data.domain.Sort;
22

23
import java.time.Clock;
24
import java.time.Instant;
25
import java.time.ZoneId;
26
import java.util.Arrays;
27
import java.util.List;
28
import java.util.Optional;
29

30
import static org.hamcrest.CoreMatchers.is;
31
import static org.hamcrest.MatcherAssert.assertThat;
32
import static org.junit.jupiter.api.Assertions.fail;
33
import static org.mockito.Mockito.doReturn;
34
import static org.mockito.Mockito.doThrow;
35
import static org.mockito.Mockito.lenient;
36
import static org.mockito.Mockito.verify;
37
import static org.mockito.Mockito.when;
38

39
@ExtendWith(MockitoExtension.class)
40
class ArticleServiceTest {
41

42
    @Mock
43
    private ArticleRepository articleRepositoryMock;
44

45
    @Mock
46
    private ArticleMapper articleMapperMock;
47

48
    @Mock
49
    private Clock clockMock;
50
    private Clock fixedClock;
51

52
    @InjectMocks
53
    private ArticleService articleService;
54

55
    @BeforeEach
56
    public void before() {
57
        fixedClock = Clock.fixed(Instant.parse("2014-12-22T10:15:30.00Z"), ZoneId.systemDefault());
58
        // Allow unnecessary stubbing:
59
        lenient().doReturn(fixedClock.instant()).when(clockMock).instant();
60
        lenient().doReturn(fixedClock.getZone()).when(clockMock).getZone();
61
    }
62

63
    @Test
64
    void create() {
65
        ArticleDto articleDto = new ArticleDto();
66
        Article article = new Article();
67
        Article updatedArticle = new Article();
68
        ArticleDto updatedArticleDto = new ArticleDto();
69

70
        when(articleMapperMock.toArticle(articleDto)).thenReturn(article);
71
        when(articleRepositoryMock.save(article)).thenReturn(updatedArticle);
72
        when(articleMapperMock.toArticleDto(updatedArticle)).thenReturn(updatedArticleDto);
73

74
        ArticleDto result = articleService.create(articleDto);
75

76
        verify(articleMapperMock).toArticle(articleDto);
77
        verify(articleRepositoryMock).save(article);
78
        verify(articleMapperMock).toArticleDto(updatedArticle);
79
        assertThat(result, is(updatedArticleDto));
80
    }
81

82
    @Test
83
    public void get() {
84
        final Long ARTICLE_ID = 123L;
85
        Article article = new Article();
86
        Optional<Article> optionalArticle = Optional.of(article);
87
        ArticleDto articleDto = new ArticleDto();
88
        when(articleRepositoryMock.findById(ARTICLE_ID)).thenReturn(optionalArticle);
89
        when(articleMapperMock.toArticleDto(article)).thenReturn(articleDto);
90

91
        ArticleDto result = articleService.get(ARTICLE_ID);
92

93
        verify(articleRepositoryMock).findById(ARTICLE_ID);
94
        verify(articleMapperMock).toArticleDto(article);
95
        assertThat(result, is(articleDto));
96
    }
97

98
    @Test
99
    public void getAbsentArticle() {
100
        final Long ARTICLE_ID = 123L;
101
        Optional<Article> optionalArticle = Optional.empty();
102
        when(articleRepositoryMock.findById(ARTICLE_ID)).thenReturn(optionalArticle);
103

104
        try {
105
            articleService.get(ARTICLE_ID);
106

107
            fail("Exception should be thrown");
108
        } catch (ArticleNotFoundException ex) {
109
            verify(articleRepositoryMock).findById(ARTICLE_ID);
110
        }
111
    }
112

113
    @Test
114
    void update() {
115
        final Long ARTICLE_ID = 123L;
116
        Article article = new Article();
117
        Article savedArticle = new Article();
118
        Optional<Article> optionalArticle = Optional.of(article);
119
        ArticleUpdateDto articleUpdateDto = new ArticleUpdateDto();
120
        ArticleDto updatedArticleDto = new ArticleDto();
121
        updatedArticleDto.setTitle("New title");
122

123
        when(articleRepositoryMock.findById(ARTICLE_ID)).thenReturn(optionalArticle);
124
        when(articleRepositoryMock.save(article)).thenReturn(savedArticle);
125
        when(articleMapperMock.toArticleDto(savedArticle)).thenReturn(updatedArticleDto);
126

127
        articleService.update(ARTICLE_ID, articleUpdateDto);
128

129
        verify(articleRepositoryMock).findById(ARTICLE_ID);
130
        verify(articleMapperMock).toArticle(articleUpdateDto, article);
131
        verify(articleRepositoryMock).save(article);
132
        verify(articleMapperMock).toArticleDto(savedArticle);
133
    }
134

135
    @Test
136
    void updateAbsentArticle() {
137
        final Long ARTICLE_ID = 123L;
138
        Optional<Article> optionalArticle = Optional.empty();
139
        when(articleRepositoryMock.findById(ARTICLE_ID)).thenReturn(optionalArticle);
140
        ArticleUpdateDto articleUpdateDto = new ArticleUpdateDto();
141

142
        try {
143
            articleService.update(ARTICLE_ID, articleUpdateDto);
144

145
            fail("Exception should be thrown");
146
        } catch (ArticleNotFoundException ex) {
147
            verify(articleRepositoryMock).findById(ARTICLE_ID);
148
        }
149
    }
150

151
    @Test
152
    void delete() {
153
        final Long ARTICLE_ID = 123L;
154

155
        articleService.delete(ARTICLE_ID);
156

157
        verify(articleRepositoryMock).deleteById(ARTICLE_ID);
158
    }
159

160
    @Test
161
    void deleteAbsentArticle() {
162
        final Long ARTICLE_ID = 123L;
163
        doThrow(new EmptyResultDataAccessException(1)).when(articleRepositoryMock).deleteById(ARTICLE_ID);
164

165
        try {
166
            articleService.delete(ARTICLE_ID);
167

168
            fail("Exception should be thrown");
169
        } catch (ArticleNotFoundException ex) {
170
            verify(articleRepositoryMock).deleteById(ARTICLE_ID);
171
            assertThat("Wrong message", ex.getMessage(), is("Could not find an article by id=" + ARTICLE_ID));
172
        }
173
    }
174

175
    @Test
176
    void getAll() {
177
        final Integer pageNo = 2;
178
        final Integer pageSize = 20;
179
        final String sortBy = "title";
180
        final Pageable pageRequest = PageRequest.of(pageNo, pageSize, Sort.by(sortBy));
181

182
        final List<Article> articles = Arrays.asList(new Article());
183
        final Slice<Article> pagedResult = new PageImpl<>(articles, pageRequest, articles.size());
184
        final List<ArticleDto> articleDtoList = Arrays.asList(new ArticleDto());
185

186
        doReturn(pagedResult).when(articleRepositoryMock).findAll(pageRequest);
187
        doReturn(articleDtoList.get(0)).when(articleMapperMock).toArticleDto(articles.get(0));
188

189
        Slice<ArticleDto> result = articleService.getAll(pageRequest);
190

191
        verify(articleRepositoryMock).findAll(pageRequest);
192
        verify(articleMapperMock).toArticleDto(articles.get(0));
193
        assertThat(result.getContent().size(), is(1));
194
        assertThat(result.getContent().get(0), is(articleDtoList.get(0)));
195
    }
196
}
197