X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Ftest%2Fjava%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FPreferencesTest.java;h=6756185a5baf133b7dd38f118417e1a61a128a3f;hp=65d59e7651b53e9ecaae7830190042b9f1e7be3e;hb=7b55e0be6a3283e43a9bbab98f82aebdd948eb33;hpb=fdbdc26c744865a7200017cb117943d48df498ad diff --git a/src/test/java/net/pterodactylus/sone/core/PreferencesTest.java b/src/test/java/net/pterodactylus/sone/core/PreferencesTest.java index 65d59e7..6756185 100644 --- a/src/test/java/net/pterodactylus/sone/core/PreferencesTest.java +++ b/src/test/java/net/pterodactylus/sone/core/PreferencesTest.java @@ -1,17 +1,15 @@ package net.pterodactylus.sone.core; import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS; +import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.NO; +import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING; import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.is; -import static org.mockito.ArgumentCaptor.forClass; -import static org.mockito.Matchers.any; +import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.verifyNoMoreInteractions; -import static org.mockito.Mockito.when; -import net.pterodactylus.sone.core.Options.Option; import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent; import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired; import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent; @@ -19,7 +17,7 @@ import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent; import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged; import com.google.common.eventbus.EventBus; -import org.junit.Before; +import org.junit.After; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -30,238 +28,284 @@ import org.mockito.ArgumentCaptor; */ public class PreferencesTest { - private static final int INTEGER_VALUE = 1; - private static final String STRING_VALUE = "string-value"; - private final Options options = mock(Options.class); private final EventBus eventBus = mock(EventBus.class); - private final Preferences preferences = new Preferences(eventBus, options); - private final Option integerOption = when(mock(Option.class).get()).thenReturn(INTEGER_VALUE).getMock(); - private final Option booleanOption = when(mock(Option.class).get()).thenReturn(true).getMock(); - private final Option stringOption = when(mock(Option.class).get()).thenReturn(STRING_VALUE).getMock(); + private final Preferences preferences = new Preferences(eventBus); - @Before - public void setupOptions() { - when(integerOption.validate(INTEGER_VALUE)).thenReturn(true); - when(options.getIntegerOption("InsertionDelay")).thenReturn(integerOption); - when(options.getIntegerOption("PostsPerPage")).thenReturn(integerOption); - when(options.getIntegerOption("ImagesPerPage")).thenReturn(integerOption); - when(options.getIntegerOption("CharactersPerPost")).thenReturn(integerOption); - when(options.getIntegerOption("PostCutOffLength")).thenReturn(integerOption); - when(options.getBooleanOption("RequireFullAccess")).thenReturn(booleanOption); - when(options.getIntegerOption("PositiveTrust")).thenReturn(integerOption); - when(options.getIntegerOption("NegativeTrust")).thenReturn(integerOption); - when(options.getStringOption("TrustComment")).thenReturn(stringOption); - when(options.getBooleanOption("ActivateFcpInterface")).thenReturn(booleanOption); - when(options.getIntegerOption("FcpFullAccessRequired")).thenReturn(integerOption); + @After + public void tearDown() { + verifyNoMoreInteractions(eventBus); } @Test - public void testGettingInsertionDelay() { - assertThat(preferences.getInsertionDelay(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesRetainInsertionDelay() { + preferences.setInsertionDelay(15); + assertThat(preferences.getInsertionDelay(), is(15)); + verify(eventBus).post(any(InsertionDelayChangedEvent.class)); } - @Test - public void validationOfInsertionDelayIsForwardedToOptions() { - preferences.validateInsertionDelay(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + @Test(expected = IllegalArgumentException.class) + public void invalidInsertionDelayIsRejected() { + preferences.setInsertionDelay(-15); } @Test - public void settingInsertionDelayIsForwardedToOptions() { - assertThat(preferences.setInsertionDelay(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesReturnDefaultValueWhenInsertionDelayIsSetToNull() { + preferences.setInsertionDelay(null); + assertThat(preferences.getInsertionDelay(), is(60)); + verify(eventBus).post(any(InsertionDelayChangedEvent.class)); } @Test - public void settingInsertionDelayIsForwardedToEventBus() { - assertThat(preferences.setInsertionDelay(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(eventBus).post(any(InsertionDelayChangedEvent.class)); + public void preferencesStartWithInsertionDelayDefaultValue() { + assertThat(preferences.getInsertionDelay(), is(60)); } @Test - public void testGettingPostsPerPage() { - assertThat(preferences.getPostsPerPage(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesRetainPostsPerPage() { + preferences.setPostsPerPage(15); + assertThat(preferences.getPostsPerPage(), is(15)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidPostsPerPageIsRejected() { + preferences.setPostsPerPage(-15); } @Test - public void validationOfPostsPerPageIsForwardedToOptions() { - preferences.validatePostsPerPage(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesReturnDefaultValueWhenPostsPerPageIsSetToNull() { + preferences.setPostsPerPage(null); + assertThat(preferences.getPostsPerPage(), is(10)); } @Test - public void settingPostsPerPageIsForwardedToOptions() { - assertThat(preferences.setPostsPerPage(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesStartWithPostsPerPageDefaultValue() { + assertThat(preferences.getPostsPerPage(), is(10)); } @Test - public void testGettingImagesPerPage() { - assertThat(preferences.getImagesPerPage(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesRetainImagesPerPage() { + preferences.setImagesPerPage(15); + assertThat(preferences.getImagesPerPage(), is(15)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidImagesPerPageIsRejected() { + preferences.setImagesPerPage(-15); } @Test - public void validationOfImagesPerPageIsForwardedToOptions() { - preferences.validateImagesPerPage(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesReturnDefaultValueWhenImagesPerPageIsSetToNull() { + preferences.setImagesPerPage(null); + assertThat(preferences.getImagesPerPage(), is(9)); } @Test - public void settingImagesPerPageIsForwardedToOptions() { - assertThat(preferences.setImagesPerPage(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesStartWithImagesPerPageDefaultValue() { + assertThat(preferences.getImagesPerPage(), is(9)); } @Test - public void testGettingCharactersPerPost() { - assertThat(preferences.getCharactersPerPost(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesRetainCharactersPerPost() { + preferences.setCharactersPerPost(150); + assertThat(preferences.getCharactersPerPost(), is(150)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidCharactersPerPostIsRejected() { + preferences.setCharactersPerPost(-15); } @Test - public void validationOfCharactersPerPostIsForwardedToOptions() { - preferences.validateCharactersPerPost(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesReturnDefaultValueWhenCharactersPerPostIsSetToNull() { + preferences.setCharactersPerPost(null); + assertThat(preferences.getCharactersPerPost(), is(400)); } @Test - public void settingCharactersPerPostIsForwardedToOptions() { - assertThat(preferences.setCharactersPerPost(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesStartWithCharactersPerPostDefaultValue() { + assertThat(preferences.getCharactersPerPost(), is(400)); } @Test - public void testGettingPostCutOffLength() { - assertThat(preferences.getPostCutOffLength(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesRetainPostCutOffLength() { + preferences.setPostCutOffLength(150); + assertThat(preferences.getPostCutOffLength(), is(150)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidPostCutOffLengthIsRejected() { + preferences.setPostCutOffLength(-15); + } + + @Test(expected = IllegalArgumentException.class) + public void cutOffLengthOfMinusOneIsNotAllowed() { + preferences.setPostCutOffLength(-1); } @Test - public void validationOfPostCutOffLengthIsForwardedToOptions() { - preferences.validatePostCutOffLength(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesReturnDefaultValueWhenPostCutOffLengthIsSetToNull() { + preferences.setPostCutOffLength(null); + assertThat(preferences.getPostCutOffLength(), is(200)); } @Test - public void settingPostCutOffLengthIsForwardedToOptions() { - assertThat(preferences.setPostCutOffLength(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesStartWithPostCutOffLengthDefaultValue() { + assertThat(preferences.getPostCutOffLength(), is(200)); } @Test - public void testGettingRequireFullAccess() { + public void preferencesRetainRequireFullAccessOfTrue() { + preferences.setRequireFullAccess(true); assertThat(preferences.isRequireFullAccess(), is(true)); - verify(booleanOption).get(); } @Test - public void settingRequireFullAccessIsForwardedToOption() { - preferences.setRequireFullAccess(true); - verify(booleanOption).set(true); + public void preferencesRetainRequireFullAccessOfFalse() { + preferences.setRequireFullAccess(false); + assertThat(preferences.isRequireFullAccess(), is(false)); } @Test - public void testGettingPositiveTrust() { - assertThat(preferences.getPositiveTrust(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesReturnDefaultValueWhenRequireFullAccessIsSetToNull() { + preferences.setRequireFullAccess(null); + assertThat(preferences.isRequireFullAccess(), is(false)); } @Test - public void validationOfPositiveTrustIsForwardedToOptions() { - preferences.validatePositiveTrust(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesStartWithRequireFullAccessDefaultValue() { + assertThat(preferences.isRequireFullAccess(), is(false)); } @Test - public void settingPositiveTrustIsForwardedToOptions() { - assertThat(preferences.setPositiveTrust(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesRetainPositiveTrust() { + preferences.setPositiveTrust(15); + assertThat(preferences.getPositiveTrust(), is(15)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidPositiveTrustIsRejected() { + preferences.setPositiveTrust(-15); } @Test - public void testGettingNegativeTrust() { - assertThat(preferences.getNegativeTrust(), is(INTEGER_VALUE)); - verify(integerOption).get(); + public void preferencesReturnDefaultValueWhenPositiveTrustIsSetToNull() { + preferences.setPositiveTrust(null); + assertThat(preferences.getPositiveTrust(), is(75)); } @Test - public void validationOfNegativeTrustIsForwardedToOptions() { - preferences.validateNegativeTrust(INTEGER_VALUE); - verify(integerOption).validate(INTEGER_VALUE); + public void preferencesStartWithPositiveTrustDefaultValue() { + assertThat(preferences.getPositiveTrust(), is(75)); } @Test - public void settingNegativeTrustIsForwardedToOptions() { - assertThat(preferences.setNegativeTrust(INTEGER_VALUE), instanceOf(Preferences.class)); - verify(integerOption).set(INTEGER_VALUE); + public void preferencesRetainNegativeTrust() { + preferences.setNegativeTrust(-15); + assertThat(preferences.getNegativeTrust(), is(-15)); + } + + @Test(expected = IllegalArgumentException.class) + public void invalidNegativeTrustIsRejected() { + preferences.setNegativeTrust(150); } @Test - public void gettingTrustCommentIsForwardedToOption() { - assertThat(preferences.getTrustComment(), is(STRING_VALUE)); - verify(stringOption).get(); + public void preferencesReturnDefaultValueWhenNegativeTrustIsSetToNull() { + preferences.setNegativeTrust(null); + assertThat(preferences.getNegativeTrust(), is(-25)); } @Test - public void settingTrustCommentIsForwardedToOption() { - preferences.setTrustComment(STRING_VALUE); - verify(stringOption).set(STRING_VALUE); + public void preferencesStartWithNegativeTrustDefaultValue() { + assertThat(preferences.getNegativeTrust(), is(-25)); } @Test - public void gettingFcpInterfaceActiveIsForwardedToOption() { - assertThat(preferences.isFcpInterfaceActive(), is(true)); - verify(booleanOption).get(); + public void preferencesRetainTrustComment() { + preferences.setTrustComment("Trust"); + assertThat(preferences.getTrustComment(), is("Trust")); } @Test - public void settingFcpInterfaceActiveIsForwardedToEventBus() { - preferences.setFcpInterfaceActive(true); + public void preferencesReturnDefaultValueWhenTrustCommentIsSetToNull() { + preferences.setTrustComment(null); + assertThat(preferences.getTrustComment(), + is("Set from Sone Web Interface")); + } + + @Test + public void preferencesStartWithTrustCommentDefaultValue() { + assertThat(preferences.getTrustComment(), + is("Set from Sone Web Interface")); + } + + @Test + public void preferencesRetainFcpInterfaceActiveOfTrue() { + preferences.setFcpInterfaceActive(true); + assertThat(preferences.isFcpInterfaceActive(), is(true)); verify(eventBus).post(any(FcpInterfaceActivatedEvent.class)); - verifyNoMoreInteractions(eventBus); } @Test - public void settingFcpInterfaceInactiveIsForwardedToEventBus() { - preferences.setFcpInterfaceActive(false); + public void preferencesRetainFcpInterfaceActiveOfFalse() { + preferences.setFcpInterfaceActive(false); + assertThat(preferences.isFcpInterfaceActive(), is(false)); verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class)); - verifyNoMoreInteractions(eventBus); } @Test - public void settingFcpInterfaceActiveIsForwardedToOption() { - preferences.setFcpInterfaceActive(true); - verify(booleanOption).set(true); + public void preferencesReturnDefaultValueWhenFcpInterfaceActiveIsSetToNull() { + preferences.setFcpInterfaceActive(null); + assertThat(preferences.isFcpInterfaceActive(), is(false)); + verify(eventBus).post(any(FcpInterfaceDeactivatedEvent.class)); + } + + @Test + public void preferencesStartWithFcpInterfaceActiveDefaultValue() { + assertThat(preferences.isFcpInterfaceActive(), is(false)); + } + + @Test + public void preferencesRetainFcpFullAccessRequiredOfNo() { + preferences.setFcpFullAccessRequired(NO); + assertThat(preferences.getFcpFullAccessRequired(), is(NO)); + verifyFullAccessRequiredChangedEvent(NO); + } + + private void verifyFullAccessRequiredChangedEvent( + FullAccessRequired fullAccessRequired) { + ArgumentCaptor fullAccessRequiredCaptor = + ArgumentCaptor.forClass(FullAccessRequiredChanged.class); + verify(eventBus).post(fullAccessRequiredCaptor.capture()); + assertThat( + fullAccessRequiredCaptor.getValue().getFullAccessRequired(), + is(fullAccessRequired)); } @Test - public void gettingFcpFullAccessRequired() { - assertThat(preferences.getFcpFullAccessRequired(), is(FullAccessRequired.values()[INTEGER_VALUE])); - verify(integerOption).get(); + public void preferencesRetainFcpFullAccessRequiredOfWriting() { + preferences.setFcpFullAccessRequired(WRITING); + assertThat(preferences.getFcpFullAccessRequired(), is(WRITING)); + verifyFullAccessRequiredChangedEvent(WRITING); } @Test - public void settingFcpFullAccessRequiredIsForwardedToOption() { + public void preferencesRetainFcpFullAccessRequiredOfAlways() { preferences.setFcpFullAccessRequired(ALWAYS); - verify(integerOption).set(ALWAYS.ordinal()); + assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS)); + verifyFullAccessRequiredChangedEvent(ALWAYS); } @Test - public void settingFcpFullAccessRequiredToNullIsForwardedToOption() { + public void preferencesReturnDefaultValueWhenFcpFullAccessRequiredIsSetToNull() { preferences.setFcpFullAccessRequired(null); - verify(integerOption).set(null); + assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS)); + verifyFullAccessRequiredChangedEvent(ALWAYS); } @Test - public void settingFcpFullAccessRequiredIsForwardedToEventBus() { - preferences.setFcpFullAccessRequired(ALWAYS); - verify(integerOption).set(2); - ArgumentCaptor fullAccessRequiredChangedCaptor = forClass(FullAccessRequiredChanged.class); - verify(eventBus).post(fullAccessRequiredChangedCaptor.capture()); - assertThat(fullAccessRequiredChangedCaptor.getValue().getFullAccessRequired(), is(ALWAYS)); + public void preferencesStartWithFcpFullAccessRequiredDefaultValue() { + assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS)); } }