articles-backend-app

1
package by.andd3dfx.persistence.dao;
2

3
import static org.hamcrest.CoreMatchers.is;
4
import static org.hamcrest.MatcherAssert.assertThat;
5
import static org.junit.jupiter.api.Assertions.*;
6

7
import by.andd3dfx.dto.ArticleSearchCriteria;
8
import by.andd3dfx.dto.DeleteArticleSearchCriteria;
9
import by.andd3dfx.persistence.entities.Article;
10
import by.andd3dfx.persistence.entities.Author;
11
import java.time.LocalDateTime;
12
import java.util.Arrays;
13
import java.util.List;
14
import org.junit.jupiter.api.AfterEach;
15
import org.junit.jupiter.api.BeforeEach;
16
import org.junit.jupiter.api.Test;
17
import org.junit.jupiter.api.extension.ExtendWith;
18
import org.mockito.junit.jupiter.MockitoExtension;
19
import org.springframework.beans.factory.annotation.Autowired;
20
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
21
import org.springframework.data.domain.Pageable;
22

23
@ExtendWith(MockitoExtension.class)
24
@DataJpaTest
25
class ArticleRepositoryCustomImplTest {
26

27
    @Autowired
28
    private ArticleRepository repository;
29

30
    private Article entity;
31
    private Article entity2;
32
    private Article entity3;
33

34
    @BeforeEach
35
    public void setup() {
36
        repository.deleteAll();
37
        entity = buildArticle("Ivan", "HD", LocalDateTime.parse("2010-12-03T10:15:30"));
38
        entity2 = buildArticle("Vasily", "HD", LocalDateTime.parse("2011-12-03T10:15:30"));
39
        entity3 = buildArticle("Ivan", "4K", LocalDateTime.parse("2012-12-03T10:15:30"));
40
        repository.saveAll(Arrays.asList(entity, entity2, entity3));
41
    }
42

43
    @AfterEach
44
    public void tearDown() {
45
        repository.deleteAll();
46
    }
47

48
    @Test
49
    public void existsByCriteriaWithoutParams() {
50
        assertThat(repository.existsByCriteria(new ArticleSearchCriteria()), is(true));
51
    }
52

53
    @Test
54
    public void existsByCriteriaWithUserId() {
55
        assertThat("Wrong result for Ivan", repository.existsByCriteria(
56
            new ArticleSearchCriteria("Ivan", null, null)), is(true));
57
        assertThat("Wrong result for Vasily", repository.existsByCriteria(
58
            new ArticleSearchCriteria("Vasily", null, null)), is(true));
59
        assertThat("Wrong result for unknown", repository.existsByCriteria(
60
            new ArticleSearchCriteria("unknown", null, null)), is(false));
61
    }
62

63
    @Test
64
    public void existsByCriteriaWithResolution() {
65
        assertThat("Wrong result for HD", repository.existsByCriteria(
66
            new ArticleSearchCriteria(null, null, "HD")), is(true));
67
        assertThat("Wrong result for 4K", repository.existsByCriteria(
68
            new ArticleSearchCriteria(null, null, "4K")), is(true));
69
        assertThat("Wrong result for unknown", repository.existsByCriteria(
70
            new ArticleSearchCriteria(null, null, "unknown")), is(false));
71
    }
72

73
    @Test
74
    public void existsByCriteriaWithTimestamp() {
75
        assertThat("Wrong result for e1-e2 date", repository.existsByCriteria(
76
            new ArticleSearchCriteria(null, "2011-11-03T10:15:30", null)), is(true));
77
        assertThat("Wrong result for e2-e3 date", repository.existsByCriteria(
78
            new ArticleSearchCriteria(null, "2012-11-03T10:15:30", null)), is(true));
79
        assertThat("Wrong result for future date", repository.existsByCriteria(
80
            new ArticleSearchCriteria(null, "2013-11-03T10:15:30", null)), is(false));
81
    }
82

83
    @Test
84
    public void existsByCriteriaWithAllParams() {
85
        assertThat("Wrong result for valid Ivan subscription", repository.existsByCriteria(
86
            new ArticleSearchCriteria("Ivan", "2012-11-03T10:15:30", "4K")), is(true));
87
        assertThat("Wrong result for expired Ivan subscription", repository.existsByCriteria(
88
            new ArticleSearchCriteria("Ivan", "2012-11-03T10:15:30", "HD")), is(false));
89
    }
90

91
    @Test
92
    public void findByCriteriaWithoutParams() {
93
        List<Article> result = repository.findByCriteria(new ArticleSearchCriteria());
94

95
        assertThat("Wrong records amount", result.size(), is(3));
96
        assertThat("Not found some entity", result.containsAll(Arrays.asList(entity, entity2, entity3)), is(true));
97
    }
98

99
    @Test
100
    public void findByCriteriaWithUserId() {
101
        List<Article> result = repository.findByCriteria(new ArticleSearchCriteria("Ivan", null, null));
102

103
        assertThat("Wrong records amount", result.size(), is(2));
104
        assertThat("Not found some entity", result.containsAll(Arrays.asList(entity, entity3)), is(true));
105
    }
106

107
    @Test
108
    public void findByCriteriaWithResolution() {
109
        List<Article> result = repository.findByCriteria(new ArticleSearchCriteria(null, null, "HD"));
110

111
        assertThat("Wrong records amount", result.size(), is(2));
112
        assertThat("Not found some entity", result.containsAll(Arrays.asList(entity, entity2)), is(true));
113
    }
114

115
    @Test
116
    public void findByCriteriaWithTimestamp() {
117
        List<Article> result = repository.findByCriteria(new ArticleSearchCriteria(null, "2011-11-03T10:15:30", null));
118

119
        assertThat("Wrong records amount", result.size(), is(2));
120
        assertThat("Not found some entity", result.containsAll(Arrays.asList(entity2, entity3)), is(true));
121
    }
122

123
    @Test
124
    public void findByCriteriaWithAllParams() {
125
        List<Article> result = repository.findByCriteria(
126
            new ArticleSearchCriteria("Ivan", "2012-11-03T10:15:30", "4K"));
127

128
        assertThat("Wrong records amount", result.size(), is(1));
129
        assertThat("Not found some entity", result.containsAll(Arrays.asList(entity3)), is(true));
130

131
        List<Article> result2 = repository.findByCriteria(
132
            new ArticleSearchCriteria("Ivan", "2012-11-03T10:15:30", "HD"));
133

134
        assertThat("Wrong records amount", result2.size(), is(0));
135
    }
136

137
    @Test
138
    public void deleteByCriteria() {
139
        final String userId = entity2.getTitle();
140
        final DeleteArticleSearchCriteria deleteCriteria = new DeleteArticleSearchCriteria(userId);
141
        final ArticleSearchCriteria searchCriteria = new ArticleSearchCriteria();
142
        searchCriteria.setTitle(userId);
143

144
        repository.deleteByCriteria(deleteCriteria);
145

146
        assertTrue(repository.findByCriteria(searchCriteria).isEmpty());
147
        assertEquals(repository.findByCriteria(new ArticleSearchCriteria()).size(), 2);
148
    }
149

150
    @Test
151
    public void deleteByCriteriaForEmptyCriteria() {
152
        repository.deleteByCriteria(new DeleteArticleSearchCriteria());
153

154
        assertTrue(repository.findByCriteria(new ArticleSearchCriteria()).isEmpty());
155
    }
156

157
    public static Article buildArticle(String title, String summary, LocalDateTime timestamp) {
158
        Article article = new Article();
159
        article.setTitle(title);
160
        article.setSummary(summary);
161
        article.setText("any text");
162
        article.setTimestamp(timestamp);
163
        article.setAuthor(new Author() {{
164
            setId(1L);
165
        }});
166
        return article;
167
    }
168
}