articles-backend-app

1
package by.andd3dfx.services;
2

3
import static org.hamcrest.CoreMatchers.is;
4
import static org.hamcrest.MatcherAssert.assertThat;
5
import static org.junit.jupiter.api.Assertions.fail;
6
import static org.mockito.Mockito.lenient;
7

8
import by.andd3dfx.dto.ArticleDto;
9
import by.andd3dfx.dto.ArticleUpdateDto;
10
import by.andd3dfx.mappers.ArticleMapper;
11
import by.andd3dfx.persistence.dao.ArticleRepository;
12
import by.andd3dfx.persistence.entities.Article;
13
import by.andd3dfx.exceptions.ArticleNotFoundException;
14
import by.andd3dfx.services.impl.ArticleService;
15
import java.time.Clock;
16
import java.time.Instant;
17
import java.time.ZoneId;
18
import java.util.Arrays;
19
import java.util.List;
20
import java.util.Optional;
21
import org.junit.jupiter.api.BeforeEach;
22
import org.junit.jupiter.api.Test;
23
import org.junit.jupiter.api.extension.ExtendWith;
24
import org.mockito.InjectMocks;
25
import org.mockito.Mock;
26
import org.mockito.Mockito;
27
import org.mockito.junit.jupiter.MockitoExtension;
28
import org.springframework.data.domain.PageImpl;
29
import org.springframework.data.domain.PageRequest;
30
import org.springframework.data.domain.Pageable;
31
import org.springframework.data.domain.Slice;
32
import org.springframework.data.domain.Sort;
33

34
@ExtendWith(MockitoExtension.class)
35
class ArticleServiceTest {
36

37
    @Mock
38
    private ArticleRepository articleRepositoryMock;
39

40
    @Mock
41
    private ArticleMapper articleMapperMock;
42

43
    @Mock
44
    private Clock clockMock;
45
    private Clock fixedClock;
46

47
    @InjectMocks
48
    private ArticleService articleService;
49

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

58
    @Test
59
    void create() {
60
        ArticleDto articleDto = new ArticleDto();
61
        Article article = new Article();
62
        Article updatedArticle = new Article();
63
        ArticleDto updatedArticleDto = new ArticleDto();
64

65
        Mockito.when(articleMapperMock.toArticle(articleDto)).thenReturn(article);
66
        Mockito.when(articleRepositoryMock.save(article)).thenReturn(updatedArticle);
67
        Mockito.when(articleMapperMock.toArticleDto(updatedArticle)).thenReturn(updatedArticleDto);
68

69
        ArticleDto result = articleService.create(articleDto);
70

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

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

86
        ArticleDto result = articleService.get(ARTICLE_ID);
87

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

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

99
        try {
100
            articleService.get(ARTICLE_ID);
101

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

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

118
        Mockito.when(articleRepositoryMock.findById(ARTICLE_ID)).thenReturn(optionalArticle);
119
        Mockito.when(articleRepositoryMock.save(article)).thenReturn(savedArticle);
120
        Mockito.when(articleMapperMock.toArticleDto(savedArticle)).thenReturn(updatedArticleDto);
121

122
        articleService.update(ARTICLE_ID, articleUpdateDto);
123

124
        Mockito.verify(articleRepositoryMock).findById(ARTICLE_ID);
125
        Mockito.verify(articleMapperMock).toArticle(articleUpdateDto, article);
126
        Mockito.verify(articleRepositoryMock).save(article);
127
        Mockito.verify(articleMapperMock).toArticleDto(savedArticle);
128
    }
129

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

137
        try {
138
            articleService.update(ARTICLE_ID, articleUpdateDto);
139

140
            fail("Exception should be thrown");
141
        } catch (ArticleNotFoundException ex) {
142
            Mockito.verify(articleRepositoryMock).findById(ARTICLE_ID);
143
        }
144
    }
145

146
    @Test
147
    void delete() {
148
        final Long ARTICLE_ID = 123L;
149
        Mockito.when(articleRepositoryMock.existsById(ARTICLE_ID)).thenReturn(true);
150

151
        articleService.delete(ARTICLE_ID);
152

153
        Mockito.verify(articleRepositoryMock).deleteById(ARTICLE_ID);
154
    }
155

156
    @Test
157
    void deleteAbsentArticle() {
158
        final Long ARTICLE_ID = 123L;
159
        Mockito.when(articleRepositoryMock.existsById(ARTICLE_ID)).thenReturn(false);
160

161
        try {
162
            articleService.delete(ARTICLE_ID);
163

164
            fail("Exception should be thrown");
165
        } catch (ArticleNotFoundException ex) {
166
            assertThat("Wrong message", ex.getMessage(), is("Could not find an article by id=" + ARTICLE_ID));
167
        }
168
    }
169

170
    @Test
171
    void getAll() {
172
        final Integer pageNo = 2;
173
        final Integer pageSize = 20;
174
        final String sortBy = "title";
175
        final Pageable pageRequest = PageRequest.of(pageNo, pageSize, Sort.by(sortBy));
176

177
        final List<Article> articles = Arrays.asList(new Article());
178
        final Slice<Article> pagedResult = new PageImpl<>(articles, pageRequest, articles.size());
179
        final List<ArticleDto> articleDtoList = Arrays.asList(new ArticleDto());
180

181
        Mockito.doReturn(pagedResult).when(articleRepositoryMock).findAll(pageRequest);
182
        Mockito.doReturn(articleDtoList).when(articleMapperMock).toArticleDtoList(articles);
183

184
        List<ArticleDto> result = articleService.getAll(pageNo, pageSize, sortBy);
185

186
        Mockito.verify(articleRepositoryMock).findAll(pageRequest);
187
        Mockito.verify(articleMapperMock).toArticleDtoList(articles);
188
        assertThat(result, is(articleDtoList));
189
    }
190

191
    @Test
192
    void getAllPaged() {
193
        final Integer pageNo = 2;
194
        final Integer pageSize = 20;
195
        final String sortBy = "title";
196
        final Pageable pageRequest = PageRequest.of(pageNo, pageSize, Sort.by(sortBy));
197

198
        final List<Article> articles = Arrays.asList(new Article());
199
        final Slice<Article> pagedResult = new PageImpl<>(articles, pageRequest, articles.size());
200
        final List<ArticleDto> articleDtoList = Arrays.asList(new ArticleDto());
201

202
        Mockito.doReturn(pagedResult).when(articleRepositoryMock).findAll(pageRequest);
203
        Mockito.doReturn(articleDtoList.get(0)).when(articleMapperMock).toArticleDto(articles.get(0));
204

205
        Slice<ArticleDto> result = articleService.getAll(pageRequest);
206

207
        Mockito.verify(articleRepositoryMock).findAll(pageRequest);
208
        Mockito.verify(articleMapperMock).toArticleDto(articles.get(0));
209
        assertThat(result.getContent().size(), is(1));
210
        assertThat(result.getContent().get(0), is(articleDtoList.get(0)));
211
    }
212
}
213