Add test for page that shows bookmarked posts
[Sone.git] / src / test / java / net / pterodactylus / sone / core / PreferencesTest.java
1 package net.pterodactylus.sone.core;
2
3 import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS;
4 import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.NO;
5 import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING;
6 import static org.hamcrest.MatcherAssert.assertThat;
7 import static org.hamcrest.Matchers.is;
8 import static org.mockito.ArgumentMatchers.any;
9 import static org.mockito.Mockito.mock;
10 import static org.mockito.Mockito.verify;
11 import static org.mockito.Mockito.verifyNoMoreInteractions;
12
13 import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent;
14 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired;
15 import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent;
16 import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent;
17 import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged;
18
19 import com.google.common.eventbus.EventBus;
20 import org.junit.After;
21 import org.junit.Test;
22 import org.mockito.ArgumentCaptor;
23
24 /**
25  * Unit test for {@link Preferences}.
26  *
27  * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
28  */
29 public class PreferencesTest {
30
31         private final EventBus eventBus = mock(EventBus.class);
32         private final Preferences preferences = new Preferences(eventBus);
33
34         @After
35         public void tearDown() {
36                 verifyNoMoreInteractions(eventBus);
37         }
38
39         @Test
40         public void preferencesRetainInsertionDelay() {
41                 preferences.setInsertionDelay(15);
42                 assertThat(preferences.getInsertionDelay(), is(15));
43                 verify(eventBus).post(any(InsertionDelayChangedEvent.class));
44         }
45
46         @Test(expected = IllegalArgumentException.class)
47         public void invalidInsertionDelayIsRejected() {
48                 preferences.setInsertionDelay(-15);
49         }
50
51         @Test
52         public void preferencesReturnDefaultValueWhenInsertionDelayIsSetToNull() {
53                 preferences.setInsertionDelay(null);
54                 assertThat(preferences.getInsertionDelay(), is(60));
55                 verify(eventBus).post(any(InsertionDelayChangedEvent.class));
56         }
57
58         @Test
59         public void preferencesStartWithInsertionDelayDefaultValue() {
60                 assertThat(preferences.getInsertionDelay(), is(60));
61         }
62
63         @Test
64         public void preferencesRetainPostsPerPage() {
65                 preferences.setPostsPerPage(15);
66                 assertThat(preferences.getPostsPerPage(), is(15));
67         }
68
69         @Test(expected = IllegalArgumentException.class)
70         public void invalidPostsPerPageIsRejected() {
71                 preferences.setPostsPerPage(-15);
72         }
73
74         @Test
75         public void preferencesReturnDefaultValueWhenPostsPerPageIsSetToNull() {
76                 preferences.setPostsPerPage(null);
77                 assertThat(preferences.getPostsPerPage(), is(10));
78         }
79
80         @Test
81         public void preferencesStartWithPostsPerPageDefaultValue() {
82                 assertThat(preferences.getPostsPerPage(), is(10));
83         }
84
85         @Test
86         public void preferencesRetainImagesPerPage() {
87                 preferences.setImagesPerPage(15);
88                 assertThat(preferences.getImagesPerPage(), is(15));
89         }
90
91         @Test(expected = IllegalArgumentException.class)
92         public void invalidImagesPerPageIsRejected() {
93                 preferences.setImagesPerPage(-15);
94         }
95
96         @Test
97         public void preferencesReturnDefaultValueWhenImagesPerPageIsSetToNull() {
98                 preferences.setImagesPerPage(null);
99                 assertThat(preferences.getImagesPerPage(), is(9));
100         }
101
102         @Test
103         public void preferencesStartWithImagesPerPageDefaultValue() {
104                 assertThat(preferences.getImagesPerPage(), is(9));
105         }
106
107         @Test
108         public void preferencesRetainCharactersPerPost() {
109                 preferences.setCharactersPerPost(150);
110                 assertThat(preferences.getCharactersPerPost(), is(150));
111         }
112
113         @Test(expected = IllegalArgumentException.class)
114         public void invalidCharactersPerPostIsRejected() {
115                 preferences.setCharactersPerPost(-15);
116         }
117
118         @Test
119         public void preferencesReturnDefaultValueWhenCharactersPerPostIsSetToNull() {
120                 preferences.setCharactersPerPost(null);
121                 assertThat(preferences.getCharactersPerPost(), is(400));
122         }
123
124         @Test
125         public void preferencesStartWithCharactersPerPostDefaultValue() {
126                 assertThat(preferences.getCharactersPerPost(), is(400));
127         }
128
129         @Test
130         public void preferencesRetainPostCutOffLength() {
131                 preferences.setPostCutOffLength(150);
132                 assertThat(preferences.getPostCutOffLength(), is(150));
133         }
134
135         @Test(expected = IllegalArgumentException.class)
136         public void invalidPostCutOffLengthIsRejected() {
137                 preferences.setPostCutOffLength(-15);
138         }
139
140         @Test(expected = IllegalArgumentException.class)
141         public void cutOffLengthOfMinusOneIsNotAllowed() {
142                 preferences.setPostCutOffLength(-1);
143         }
144
145         @Test
146         public void preferencesReturnDefaultValueWhenPostCutOffLengthIsSetToNull() {
147                 preferences.setPostCutOffLength(null);
148                 assertThat(preferences.getPostCutOffLength(), is(200));
149         }
150
151         @Test
152         public void preferencesStartWithPostCutOffLengthDefaultValue() {
153                 assertThat(preferences.getPostCutOffLength(), is(200));
154         }
155
156         @Test
157         public void preferencesRetainRequireFullAccessOfTrue() {
158                 preferences.setRequireFullAccess(true);
159                 assertThat(preferences.isRequireFullAccess(), is(true));
160         }
161
162         @Test
163         public void preferencesRetainRequireFullAccessOfFalse() {
164                 preferences.setRequireFullAccess(false);
165                 assertThat(preferences.isRequireFullAccess(), is(false));
166         }
167
168         @Test
169         public void preferencesReturnDefaultValueWhenRequireFullAccessIsSetToNull() {
170                 preferences.setRequireFullAccess(null);
171                 assertThat(preferences.isRequireFullAccess(), is(false));
172         }
173
174         @Test
175         public void preferencesStartWithRequireFullAccessDefaultValue() {
176                 assertThat(preferences.isRequireFullAccess(), is(false));
177         }
178
179         @Test
180         public void preferencesRetainPositiveTrust() {
181                 preferences.setPositiveTrust(15);
182                 assertThat(preferences.getPositiveTrust(), is(15));
183         }
184
185         @Test(expected = IllegalArgumentException.class)
186         public void invalidPositiveTrustIsRejected() {
187                 preferences.setPositiveTrust(-15);
188         }
189
190         @Test
191         public void preferencesReturnDefaultValueWhenPositiveTrustIsSetToNull() {
192                 preferences.setPositiveTrust(null);
193                 assertThat(preferences.getPositiveTrust(), is(75));
194         }
195
196         @Test
197         public void preferencesStartWithPositiveTrustDefaultValue() {
198                 assertThat(preferences.getPositiveTrust(), is(75));
199         }
200
201         @Test
202         public void preferencesRetainNegativeTrust() {
203                 preferences.setNegativeTrust(-15);
204                 assertThat(preferences.getNegativeTrust(), is(-15));
205         }
206
207         @Test(expected = IllegalArgumentException.class)
208         public void invalidNegativeTrustIsRejected() {
209                 preferences.setNegativeTrust(150);
210         }
211
212         @Test
213         public void preferencesReturnDefaultValueWhenNegativeTrustIsSetToNull() {
214                 preferences.setNegativeTrust(null);
215                 assertThat(preferences.getNegativeTrust(), is(-25));
216         }
217
218         @Test
219         public void preferencesStartWithNegativeTrustDefaultValue() {
220                 assertThat(preferences.getNegativeTrust(), is(-25));
221         }
222
223         @Test
224         public void preferencesRetainTrustComment() {
225                 preferences.setTrustComment("Trust");
226                 assertThat(preferences.getTrustComment(), is("Trust"));
227         }
228
229         @Test
230         public void preferencesReturnDefaultValueWhenTrustCommentIsSetToNull() {
231                 preferences.setTrustComment(null);
232                 assertThat(preferences.getTrustComment(),
233                                 is("Set from Sone Web Interface"));
234         }
235
236         @Test
237         public void preferencesStartWithTrustCommentDefaultValue() {
238                 assertThat(preferences.getTrustComment(),
239                                 is("Set from Sone Web Interface"));
240         }
241
242         @Test
243         public void preferencesRetainFcpInterfaceActiveOfTrue() {
244                 preferences.setFcpInterfaceActive(true);
245                 assertThat(preferences.isFcpInterfaceActive(), is(true));
246                 verify(eventBus).post(any(FcpInterfaceActivatedEvent.class));
247         }
248
249         @Test
250         public void preferencesRetainFcpInterfaceActiveOfFalse() {
251                 preferences.setFcpInterfaceActive(false);
252                 assertThat(preferences.isFcpInterfaceActive(), is(false));
253                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class));
254         }
255
256         @Test
257         public void preferencesReturnDefaultValueWhenFcpInterfaceActiveIsSetToNull() {
258                 preferences.setFcpInterfaceActive(null);
259                 assertThat(preferences.isFcpInterfaceActive(), is(false));
260                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class));
261         }
262
263         @Test
264         public void preferencesStartWithFcpInterfaceActiveDefaultValue() {
265                 assertThat(preferences.isFcpInterfaceActive(), is(false));
266         }
267
268         @Test
269         public void preferencesRetainFcpFullAccessRequiredOfNo() {
270                 preferences.setFcpFullAccessRequired(NO);
271                 assertThat(preferences.getFcpFullAccessRequired(), is(NO));
272                 verifyFullAccessRequiredChangedEvent(NO);
273         }
274
275         private void verifyFullAccessRequiredChangedEvent(
276                         FullAccessRequired fullAccessRequired) {
277                 ArgumentCaptor<FullAccessRequiredChanged> fullAccessRequiredCaptor =
278                                 ArgumentCaptor.forClass(FullAccessRequiredChanged.class);
279                 verify(eventBus).post(fullAccessRequiredCaptor.capture());
280                 assertThat(
281                                 fullAccessRequiredCaptor.getValue().getFullAccessRequired(),
282                                 is(fullAccessRequired));
283         }
284
285         @Test
286         public void preferencesRetainFcpFullAccessRequiredOfWriting() {
287                 preferences.setFcpFullAccessRequired(WRITING);
288                 assertThat(preferences.getFcpFullAccessRequired(), is(WRITING));
289                 verifyFullAccessRequiredChangedEvent(WRITING);
290         }
291
292         @Test
293         public void preferencesRetainFcpFullAccessRequiredOfAlways() {
294                 preferences.setFcpFullAccessRequired(ALWAYS);
295                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
296                 verifyFullAccessRequiredChangedEvent(ALWAYS);
297         }
298
299         @Test
300         public void preferencesReturnDefaultValueWhenFcpFullAccessRequiredIsSetToNull() {
301                 preferences.setFcpFullAccessRequired(null);
302                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
303                 verifyFullAccessRequiredChangedEvent(ALWAYS);
304         }
305
306         @Test
307         public void preferencesStartWithFcpFullAccessRequiredDefaultValue() {
308                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
309         }
310
311 }