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