spring-boot-2-template

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.junit.jupiter.MockitoExtension;
15
import org.springframework.data.domain.PageImpl;
16
import org.springframework.data.domain.PageRequest;
17
import org.springframework.data.domain.Pageable;
18
import org.springframework.data.domain.Slice;
19
import org.springframework.data.domain.Sort;
20

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

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

36
@ExtendWith(MockitoExtension.class)
37
class ArticleServiceTest {
38

39
    @Mock
40
    private ArticleRepository articleRepositoryMock;
41

42
    @Mock
43
    private ArticleMapper articleMapperMock;
44

45
    @Mock
46
    private Clock clockMock;
47
    private Clock fixedClock;
48

49
    @InjectMocks
50
    private ArticleService articleService;
51

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

60
    @Test
61
    void create() {
62
        ArticleDto articleDto = ArticleDto.builder().build();
63
        Article article = Article.builder().build();
64
        Article updatedArticle = Article.builder().build();
65
        ArticleDto updatedArticleDto = ArticleDto.builder().build();
66

67
        when(articleMapperMock.toArticle(articleDto)).thenReturn(article);
68
        when(articleRepositoryMock.save(article)).thenReturn(updatedArticle);
69
        when(articleMapperMock.toArticleDto(updatedArticle)).thenReturn(updatedArticleDto);
70

71
        ArticleDto result = articleService.create(articleDto);
72

73
        verify(articleMapperMock).toArticle(articleDto);
74
        verify(articleRepositoryMock).save(article);
75
        verify(articleMapperMock).toArticleDto(updatedArticle);
76
        assertThat(result, is(updatedArticleDto));
77
    }
78

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

88
        ArticleDto result = articleService.get(ARTICLE_ID);
89

90
        verify(articleRepositoryMock).findById(ARTICLE_ID);
91
        verify(articleMapperMock).toArticleDto(article);
92
        assertThat(result, is(articleDto));
93
    }
94

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

101
        try {
102
            articleService.get(ARTICLE_ID);
103

104
            fail("Exception should be thrown");
105
        } catch (ArticleNotFoundException ex) {
106
            verify(articleRepositoryMock).findById(ARTICLE_ID);
107
        }
108
    }
109

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

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

125
        articleService.update(ARTICLE_ID, articleUpdateDto);
126

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

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

140
        try {
141
            articleService.update(ARTICLE_ID, articleUpdateDto);
142

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

149
    @Test
150
    void delete() {
151
        final Long ARTICLE_ID = 123L;
152
        when(articleRepositoryMock.existsById(ARTICLE_ID)).thenReturn(true);
153

154
        articleService.delete(ARTICLE_ID);
155

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

160
    @Test
161
    void deleteAbsentArticle() {
162
        final Long ARTICLE_ID = 123L;
163
        when(articleRepositoryMock.existsById(ARTICLE_ID)).thenReturn(false);
164

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

168
            fail("Exception should be thrown");
169
        } catch (ArticleNotFoundException ex) {
170
            verify(articleRepositoryMock).existsById(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 getAllPaged() {
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