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.Matchers.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
 141         public void preferencesReturnDefaultValueWhenPostCutOffLengthIsSetToNull() {
 142                 preferences.setPostCutOffLength(null);
 143                 assertThat(preferences.getPostCutOffLength(), is(200));
 144         }
 145
 146         @Test
 147         public void preferencesStartWithPostCutOffLengthDefaultValue() {
 148                 assertThat(preferences.getPostCutOffLength(), is(200));
 149         }
 150
 151         @Test
 152         public void preferencesRetainRequireFullAccessOfTrue() {
 153                 preferences.setRequireFullAccess(true);
 154                 assertThat(preferences.isRequireFullAccess(), is(true));
 155         }
 156
 157         @Test
 158         public void preferencesRetainRequireFullAccessOfFalse() {
 159                 preferences.setRequireFullAccess(false);
 160                 assertThat(preferences.isRequireFullAccess(), is(false));
 161         }
 162
 163         @Test
 164         public void preferencesReturnDefaultValueWhenRequireFullAccessIsSetToNull() {
 165                 preferences.setRequireFullAccess(null);
 166                 assertThat(preferences.isRequireFullAccess(), is(false));
 167         }
 168
 169         @Test
 170         public void preferencesStartWithRequireFullAccessDefaultValue() {
 171                 assertThat(preferences.isRequireFullAccess(), is(false));
 172         }
 173
 174         @Test
 175         public void preferencesRetainPositiveTrust() {
 176                 preferences.setPositiveTrust(15);
 177                 assertThat(preferences.getPositiveTrust(), is(15));
 178         }
 179
 180         @Test(expected = IllegalArgumentException.class)
 181         public void invalidPositiveTrustIsRejected() {
 182                 preferences.setPositiveTrust(-15);
 183         }
 184
 185         @Test
 186         public void preferencesReturnDefaultValueWhenPositiveTrustIsSetToNull() {
 187                 preferences.setPositiveTrust(null);
 188                 assertThat(preferences.getPositiveTrust(), is(75));
 189         }
 190
 191         @Test
 192         public void preferencesStartWithPositiveTrustDefaultValue() {
 193                 assertThat(preferences.getPositiveTrust(), is(75));
 194         }
 195
 196         @Test
 197         public void preferencesRetainNegativeTrust() {
 198                 preferences.setNegativeTrust(-15);
 199                 assertThat(preferences.getNegativeTrust(), is(-15));
 200         }
 201
 202         @Test(expected = IllegalArgumentException.class)
 203         public void invalidNegativeTrustIsRejected() {
 204                 preferences.setNegativeTrust(150);
 205         }
 206
 207         @Test
 208         public void preferencesReturnDefaultValueWhenNegativeTrustIsSetToNull() {
 209                 preferences.setNegativeTrust(null);
 210                 assertThat(preferences.getNegativeTrust(), is(-25));
 211         }
 212
 213         @Test
 214         public void preferencesStartWithNegativeTrustDefaultValue() {
 215                 assertThat(preferences.getNegativeTrust(), is(-25));
 216         }
 217
 218         @Test
 219         public void preferencesRetainTrustComment() {
 220                 preferences.setTrustComment("Trust");
 221                 assertThat(preferences.getTrustComment(), is("Trust"));
 222         }
 223
 224         @Test
 225         public void preferencesReturnDefaultValueWhenTrustCommentIsSetToNull() {
 226                 preferences.setTrustComment(null);
 227                 assertThat(preferences.getTrustComment(),
 228                                 is("Set from Sone Web Interface"));
 229         }
 230
 231         @Test
 232         public void preferencesStartWithTrustCommentDefaultValue() {
 233                 assertThat(preferences.getTrustComment(),
 234                                 is("Set from Sone Web Interface"));
 235         }
 236
 237         @Test
 238         public void preferencesRetainFcpInterfaceActiveOfTrue() {
 239                 preferences.setFcpInterfaceActive(true);
 240                 assertThat(preferences.isFcpInterfaceActive(), is(true));
 241                 verify(eventBus).post(any(FcpInterfaceActivatedEvent.class));
 242         }
 243
 244         @Test
 245         public void preferencesRetainFcpInterfaceActiveOfFalse() {
 246                 preferences.setFcpInterfaceActive(false);
 247                 assertThat(preferences.isFcpInterfaceActive(), is(false));
 248                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class));
 249         }
 250
 251         @Test
 252         public void preferencesReturnDefaultValueWhenFcpInterfaceActiveIsSetToNull() {
 253                 preferences.setFcpInterfaceActive(null);
 254                 assertThat(preferences.isFcpInterfaceActive(), is(false));
 255                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class));
 256         }
 257
 258         @Test
 259         public void preferencesStartWithFcpInterfaceActiveDefaultValue() {
 260                 assertThat(preferences.isFcpInterfaceActive(), is(false));
 261         }
 262
 263         @Test
 264         public void preferencesRetainFcpFullAccessRequiredOfNo() {
 265                 preferences.setFcpFullAccessRequired(NO);
 266                 assertThat(preferences.getFcpFullAccessRequired(), is(NO));
 267                 verifyFullAccessRequiredChangedEvent(NO);
 268         }
 269
 270         private void verifyFullAccessRequiredChangedEvent(
 271                         FullAccessRequired fullAccessRequired) {
 272                 ArgumentCaptor<FullAccessRequiredChanged> fullAccessRequiredCaptor =
 273                                 ArgumentCaptor.forClass(FullAccessRequiredChanged.class);
 274                 verify(eventBus).post(fullAccessRequiredCaptor.capture());
 275                 assertThat(
 276                                 fullAccessRequiredCaptor.getValue().getFullAccessRequired(),
 277                                 is(fullAccessRequired));
 278         }
 279
 280         @Test
 281         public void preferencesRetainFcpFullAccessRequiredOfWriting() {
 282                 preferences.setFcpFullAccessRequired(WRITING);
 283                 assertThat(preferences.getFcpFullAccessRequired(), is(WRITING));
 284                 verifyFullAccessRequiredChangedEvent(WRITING);
 285         }
 286
 287         @Test
 288         public void preferencesRetainFcpFullAccessRequiredOfAlways() {
 289                 preferences.setFcpFullAccessRequired(ALWAYS);
 290                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
 291                 verifyFullAccessRequiredChangedEvent(ALWAYS);
 292         }
 293
 294         @Test
 295         public void preferencesReturnDefaultValueWhenFcpFullAccessRequiredIsSetToNull() {
 296                 preferences.setFcpFullAccessRequired(null);
 297                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
 298                 verifyFullAccessRequiredChangedEvent(ALWAYS);
 299         }
 300
 301         @Test
 302         public void preferencesStartWithFcpFullAccessRequiredDefaultValue() {
 303                 assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
 304         }
 305
 306 }