import net.pterodactylus.sone.freenet.wot.event.OwnIdentityAddedEvent;
import net.pterodactylus.sone.freenet.wot.event.OwnIdentityRemovedEvent;
import net.pterodactylus.sone.main.SonePlugin;
-import net.pterodactylus.sone.utils.DefaultOption;
-import net.pterodactylus.sone.utils.IntegerRangePredicate;
import net.pterodactylus.util.config.Configuration;
import net.pterodactylus.util.config.ConfigurationException;
import net.pterodactylus.util.logging.Logging;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
-import com.google.common.base.Predicates;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
/** The start time. */
private final long startupTime = System.currentTimeMillis();
- /** The options. */
- private final Options options = new Options();
-
/** The preferences. */
private final Preferences preferences;
this.webOfTrustUpdater = webOfTrustUpdater;
this.eventBus = eventBus;
this.database = database;
- preferences = new Preferences(this.eventBus, options);
+ preferences = new Preferences(eventBus);
}
@VisibleForTesting
this.webOfTrustUpdater = webOfTrustUpdater;
this.eventBus = eventBus;
this.database = database;
- preferences = new Preferences(this.eventBus, options);
+ preferences = new Preferences(eventBus);
}
//
/* store the options first. */
try {
- configuration.getIntValue("Option/ConfigurationVersion").setValue(0);
- configuration.getIntValue("Option/InsertionDelay").setValue(options.getIntegerOption("InsertionDelay").getReal());
- configuration.getIntValue("Option/PostsPerPage").setValue(options.getIntegerOption("PostsPerPage").getReal());
- configuration.getIntValue("Option/ImagesPerPage").setValue(options.getIntegerOption("ImagesPerPage").getReal());
- configuration.getIntValue("Option/CharactersPerPost").setValue(options.getIntegerOption("CharactersPerPost").getReal());
- configuration.getIntValue("Option/PostCutOffLength").setValue(options.getIntegerOption("PostCutOffLength").getReal());
- configuration.getBooleanValue("Option/RequireFullAccess").setValue(options.getBooleanOption("RequireFullAccess").getReal());
- configuration.getIntValue("Option/PositiveTrust").setValue(options.getIntegerOption("PositiveTrust").getReal());
- configuration.getIntValue("Option/NegativeTrust").setValue(options.getIntegerOption("NegativeTrust").getReal());
- configuration.getStringValue("Option/TrustComment").setValue(options.getStringOption("TrustComment").getReal());
- configuration.getBooleanValue("Option/ActivateFcpInterface").setValue(options.getBooleanOption("ActivateFcpInterface").getReal());
- configuration.getIntValue("Option/FcpFullAccessRequired").setValue(options.getIntegerOption("FcpFullAccessRequired").getReal());
+ preferences.saveTo(configuration);
/* save known Sones. */
int soneCounter = 0;
* Loads the configuration.
*/
private void loadConfiguration() {
- /* create options. */
- options.addIntegerOption("InsertionDelay", new DefaultOption<Integer>(60, new IntegerRangePredicate(0, Integer.MAX_VALUE)));
- options.addIntegerOption("PostsPerPage", new DefaultOption<Integer>(10, new IntegerRangePredicate(1, Integer.MAX_VALUE)));
- options.addIntegerOption("ImagesPerPage", new DefaultOption<Integer>(9, new IntegerRangePredicate(1, Integer.MAX_VALUE)));
- options.addIntegerOption("CharactersPerPost", new DefaultOption<Integer>(400, Predicates.<Integer> or(new IntegerRangePredicate(50, Integer.MAX_VALUE), Predicates.equalTo(-1))));
- options.addIntegerOption("PostCutOffLength", new DefaultOption<Integer>(200, Predicates.<Integer> or(new IntegerRangePredicate(50, Integer.MAX_VALUE), Predicates.equalTo(-1))));
- options.addBooleanOption("RequireFullAccess", new DefaultOption<Boolean>(false));
- options.addIntegerOption("PositiveTrust", new DefaultOption<Integer>(75, new IntegerRangePredicate(0, 100)));
- options.addIntegerOption("NegativeTrust", new DefaultOption<Integer>(-25, new IntegerRangePredicate(-100, 100)));
- options.addStringOption("TrustComment", new DefaultOption<String>("Set from Sone Web Interface"));
- options.addBooleanOption("ActivateFcpInterface", new DefaultOption<Boolean>(false));
- options.addIntegerOption("FcpFullAccessRequired", new DefaultOption<Integer>(2));
-
- loadConfigurationValue("InsertionDelay");
- loadConfigurationValue("PostsPerPage");
- loadConfigurationValue("ImagesPerPage");
- loadConfigurationValue("CharactersPerPost");
- loadConfigurationValue("PostCutOffLength");
- options.getBooleanOption("RequireFullAccess").set(configuration.getBooleanValue("Option/RequireFullAccess").getValue(null));
- loadConfigurationValue("PositiveTrust");
- loadConfigurationValue("NegativeTrust");
- options.getStringOption("TrustComment").set(configuration.getStringValue("Option/TrustComment").getValue(null));
- options.getBooleanOption("ActivateFcpInterface").set(configuration.getBooleanValue("Option/ActivateFcpInterface").getValue(null));
- options.getIntegerOption("FcpFullAccessRequired").set(configuration.getIntValue("Option/FcpFullAccessRequired").getValue(null));
+ new PreferencesLoader(preferences).loadFrom(configuration);
/* load known Sones. */
int soneCounter = 0;
}
/**
- * Loads an {@link Integer} configuration value for the option with the
- * given name, logging validation failures.
- *
- * @param optionName
- * The name of the option to load
- */
- private void loadConfigurationValue(String optionName) {
- try {
- options.getIntegerOption(optionName).set(configuration.getIntValue("Option/" + optionName).getValue(null));
- } catch (IllegalArgumentException iae1) {
- logger.log(Level.WARNING, String.format("Invalid value for %s in configuration, using default.", optionName));
- }
- }
-
- /**
* Notifies the core that a new {@link OwnIdentity} was added.
*
* @param ownIdentityAddedEvent
package net.pterodactylus.sone.core;
+import static com.google.common.base.Predicates.equalTo;
+import static java.lang.Integer.MAX_VALUE;
+import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS;
+import static net.pterodactylus.sone.utils.IntegerRangePredicate.range;
+
import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent;
import net.pterodactylus.sone.fcp.FcpInterface;
import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired;
import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent;
import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent;
import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged;
+import net.pterodactylus.sone.utils.DefaultOption;
+import net.pterodactylus.sone.utils.Option;
+import net.pterodactylus.util.config.Configuration;
+import net.pterodactylus.util.config.ConfigurationException;
+import com.google.common.base.Predicates;
import com.google.common.eventbus.EventBus;
/**
public class Preferences {
private final EventBus eventBus;
- private final Options options;
-
- public Preferences(EventBus eventBus, Options options) {
+ private final Option<Integer> insertionDelay =
+ new DefaultOption<Integer>(60, range(0, MAX_VALUE));
+ private final Option<Integer> postsPerPage =
+ new DefaultOption<Integer>(10, range(1, MAX_VALUE));
+ private final Option<Integer> imagesPerPage =
+ new DefaultOption<Integer>(9, range(1, MAX_VALUE));
+ private final Option<Integer> charactersPerPost =
+ new DefaultOption<Integer>(400, Predicates.<Integer>or(
+ range(50, MAX_VALUE), equalTo(-1)));
+ private final Option<Integer> postCutOffLength =
+ new DefaultOption<Integer>(200, Predicates.<Integer>or(
+ range(50, MAX_VALUE), equalTo(-1)));
+ private final Option<Boolean> requireFullAccess =
+ new DefaultOption<Boolean>(false);
+ private final Option<Integer> positiveTrust =
+ new DefaultOption<Integer>(75, range(0, 100));
+ private final Option<Integer> negativeTrust =
+ new DefaultOption<Integer>(-25, range(-100, 100));
+ private final Option<String> trustComment =
+ new DefaultOption<String>("Set from Sone Web Interface");
+ private final Option<Boolean> activateFcpInterface =
+ new DefaultOption<Boolean>(false);
+ private final Option<FullAccessRequired> fcpFullAccessRequired =
+ new DefaultOption<FullAccessRequired>(ALWAYS);
+
+ public Preferences(EventBus eventBus) {
this.eventBus = eventBus;
- this.options = options;
}
/**
* @return The insertion delay
*/
public int getInsertionDelay() {
- return options.getIntegerOption("InsertionDelay").get();
+ return insertionDelay.get();
}
/**
* {@code false} otherwise
*/
public boolean validateInsertionDelay(Integer insertionDelay) {
- return options.getIntegerOption("InsertionDelay").validate(insertionDelay);
+ return this.insertionDelay.validate(insertionDelay);
}
/**
* @return This preferences
*/
public Preferences setInsertionDelay(Integer insertionDelay) {
- options.getIntegerOption("InsertionDelay").set(insertionDelay);
+ this.insertionDelay.set(insertionDelay);
eventBus.post(new InsertionDelayChangedEvent(getInsertionDelay()));
return this;
}
* @return The number of posts to show per page
*/
public int getPostsPerPage() {
- return options.getIntegerOption("PostsPerPage").get();
+ return postsPerPage.get();
}
/**
* {@code false} otherwise
*/
public boolean validatePostsPerPage(Integer postsPerPage) {
- return options.getIntegerOption("PostsPerPage").validate(postsPerPage);
+ return this.postsPerPage.validate(postsPerPage);
}
/**
* @return This preferences object
*/
public Preferences setPostsPerPage(Integer postsPerPage) {
- options.getIntegerOption("PostsPerPage").set(postsPerPage);
+ this.postsPerPage.set(postsPerPage);
return this;
}
* @return The number of images to show per page
*/
public int getImagesPerPage() {
- return options.getIntegerOption("ImagesPerPage").get();
+ return imagesPerPage.get();
}
/**
* {@code false} otherwise
*/
public boolean validateImagesPerPage(Integer imagesPerPage) {
- return options.getIntegerOption("ImagesPerPage").validate(imagesPerPage);
+ return this.imagesPerPage.validate(imagesPerPage);
}
/**
* @return This preferences object
*/
public Preferences setImagesPerPage(Integer imagesPerPage) {
- options.getIntegerOption("ImagesPerPage").set(imagesPerPage);
+ this.imagesPerPage.set(imagesPerPage);
return this;
}
* @return The numbers of characters per post
*/
public int getCharactersPerPost() {
- return options.getIntegerOption("CharactersPerPost").get();
+ return charactersPerPost.get();
}
/**
* {@code false} otherwise
*/
public boolean validateCharactersPerPost(Integer charactersPerPost) {
- return options.getIntegerOption("CharactersPerPost").validate(charactersPerPost);
+ return this.charactersPerPost.validate(charactersPerPost);
}
/**
* @return This preferences objects
*/
public Preferences setCharactersPerPost(Integer charactersPerPost) {
- options.getIntegerOption("CharactersPerPost").set(charactersPerPost);
+ this.charactersPerPost.set(charactersPerPost);
return this;
}
* @return The number of characters of the snippet
*/
public int getPostCutOffLength() {
- return options.getIntegerOption("PostCutOffLength").get();
+ return postCutOffLength.get();
}
/**
* valid, {@code false} otherwise
*/
public boolean validatePostCutOffLength(Integer postCutOffLength) {
- return options.getIntegerOption("PostCutOffLength").validate(postCutOffLength);
+ return this.postCutOffLength.validate(postCutOffLength);
}
/**
* @return This preferences
*/
public Preferences setPostCutOffLength(Integer postCutOffLength) {
- options.getIntegerOption("PostCutOffLength").set(postCutOffLength);
+ this.postCutOffLength.set(postCutOffLength);
return this;
}
* otherwise
*/
public boolean isRequireFullAccess() {
- return options.getBooleanOption("RequireFullAccess").get();
+ return requireFullAccess.get();
}
/**
* otherwise
*/
public void setRequireFullAccess(Boolean requireFullAccess) {
- options.getBooleanOption("RequireFullAccess").set(requireFullAccess);
+ this.requireFullAccess.set(requireFullAccess);
}
/**
* @return The positive trust
*/
public int getPositiveTrust() {
- return options.getIntegerOption("PositiveTrust").get();
+ return positiveTrust.get();
}
/**
* otherwise
*/
public boolean validatePositiveTrust(Integer positiveTrust) {
- return options.getIntegerOption("PositiveTrust").validate(positiveTrust);
+ return this.positiveTrust.validate(positiveTrust);
}
/**
* @return This preferences
*/
public Preferences setPositiveTrust(Integer positiveTrust) {
- options.getIntegerOption("PositiveTrust").set(positiveTrust);
+ this.positiveTrust.set(positiveTrust);
return this;
}
* @return The negative trust
*/
public int getNegativeTrust() {
- return options.getIntegerOption("NegativeTrust").get();
+ return negativeTrust.get();
}
/**
* otherwise
*/
public boolean validateNegativeTrust(Integer negativeTrust) {
- return options.getIntegerOption("NegativeTrust").validate(negativeTrust);
+ return this.negativeTrust.validate(negativeTrust);
}
/**
* @return The preferences
*/
public Preferences setNegativeTrust(Integer negativeTrust) {
- options.getIntegerOption("NegativeTrust").set(negativeTrust);
+ this.negativeTrust.set(negativeTrust);
return this;
}
* @return The trust comment
*/
public String getTrustComment() {
- return options.getStringOption("TrustComment").get();
+ return trustComment.get();
}
/**
* @return This preferences
*/
public Preferences setTrustComment(String trustComment) {
- options.getStringOption("TrustComment").set(trustComment);
+ this.trustComment.set(trustComment);
return this;
}
* {@code false} otherwise
*/
public boolean isFcpInterfaceActive() {
- return options.getBooleanOption("ActivateFcpInterface").get();
+ return activateFcpInterface.get();
}
/**
* to deactivate the FCP interface
* @return This preferences object
*/
- public Preferences setFcpInterfaceActive(boolean fcpInterfaceActive) {
- options.getBooleanOption("ActivateFcpInterface").set(fcpInterfaceActive);
- if (fcpInterfaceActive) {
+ public Preferences setFcpInterfaceActive(Boolean fcpInterfaceActive) {
+ this.activateFcpInterface.set(fcpInterfaceActive);
+ if (isFcpInterfaceActive()) {
eventBus.post(new FcpInterfaceActivatedEvent());
} else {
eventBus.post(new FcpInterfaceDeactivatedEvent());
* is required
*/
public FullAccessRequired getFcpFullAccessRequired() {
- return FullAccessRequired.values()[options.getIntegerOption("FcpFullAccessRequired").get()];
+ return fcpFullAccessRequired.get();
}
/**
* The action level
* @return This preferences
*/
- public Preferences setFcpFullAccessRequired(FullAccessRequired fcpFullAccessRequired) {
- options.getIntegerOption("FcpFullAccessRequired").set((fcpFullAccessRequired != null) ? fcpFullAccessRequired.ordinal() : null);
- eventBus.post(new FullAccessRequiredChanged(fcpFullAccessRequired));
+ public Preferences setFcpFullAccessRequired(
+ FullAccessRequired fcpFullAccessRequired) {
+ this.fcpFullAccessRequired.set(fcpFullAccessRequired);
+ eventBus.post(new FullAccessRequiredChanged(getFcpFullAccessRequired()));
return this;
}
+ public void saveTo(Configuration configuration) throws ConfigurationException {
+ configuration.getIntValue("Option/ConfigurationVersion").setValue(0);
+ configuration.getIntValue("Option/InsertionDelay").setValue(insertionDelay.getReal());
+ configuration.getIntValue("Option/PostsPerPage").setValue(postsPerPage.getReal());
+ configuration.getIntValue("Option/ImagesPerPage").setValue(imagesPerPage.getReal());
+ configuration.getIntValue("Option/CharactersPerPost").setValue(charactersPerPost.getReal());
+ configuration.getIntValue("Option/PostCutOffLength").setValue(postCutOffLength.getReal());
+ configuration.getBooleanValue("Option/RequireFullAccess").setValue(requireFullAccess.getReal());
+ configuration.getIntValue("Option/PositiveTrust").setValue(positiveTrust.getReal());
+ configuration.getIntValue("Option/NegativeTrust").setValue(negativeTrust.getReal());
+ configuration.getStringValue("Option/TrustComment").setValue(trustComment.getReal());
+ configuration.getBooleanValue("Option/ActivateFcpInterface").setValue(activateFcpInterface.getReal());
+ configuration.getIntValue("Option/FcpFullAccessRequired").setValue(toInt(fcpFullAccessRequired.getReal()));
+ }
+
+ private Integer toInt(FullAccessRequired fullAccessRequired) {
+ return (fullAccessRequired == null) ? null : fullAccessRequired.ordinal();
+ }
+
}
--- /dev/null
+package net.pterodactylus.sone.core;
+
+import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired;
+import net.pterodactylus.util.config.Configuration;
+import net.pterodactylus.util.config.ConfigurationException;
+
+/**
+ * Loads preferences stored in a {@link Configuration} into a {@link
+ * Preferences} object.
+ *
+ * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+ */
+public class PreferencesLoader {
+
+ private final Preferences preferences;
+
+ public PreferencesLoader(Preferences preferences) {
+ this.preferences = preferences;
+ }
+
+ public void loadFrom(Configuration configuration) {
+ loadInsertionDelay(configuration);
+ loadPostsPerPage(configuration);
+ loadImagesPerPage(configuration);
+ loadCharactersPerPost(configuration);
+ loadPostCutOffLength(configuration);
+ loadRequireFullAccess(configuration);
+ loadPositiveTrust(configuration);
+ loadNegativeTrust(configuration);
+ loadTrustComment(configuration);
+ loadFcpInterfaceActive(configuration);
+ loadFcpFullAccessRequired(configuration);
+ }
+
+ private void loadInsertionDelay(Configuration configuration) {
+ preferences.setInsertionDelay(configuration.getIntValue(
+ "Option/InsertionDelay").getValue(null));
+ }
+
+ private void loadPostsPerPage(Configuration configuration) {
+ preferences.setPostsPerPage(
+ configuration.getIntValue("Option/PostsPerPage")
+ .getValue(null));
+ }
+
+ private void loadImagesPerPage(Configuration configuration) {
+ preferences.setImagesPerPage(
+ configuration.getIntValue("Option/ImagesPerPage")
+ .getValue(null));
+ }
+
+ private void loadCharactersPerPost(Configuration configuration) {
+ preferences.setCharactersPerPost(
+ configuration.getIntValue("Option/CharactersPerPost")
+ .getValue(null));
+ }
+
+ private void loadPostCutOffLength(Configuration configuration) {
+ preferences.setPostCutOffLength(
+ configuration.getIntValue("Option/PostCutOffLength")
+ .getValue(null));
+ }
+
+ private void loadRequireFullAccess(Configuration configuration) {
+ preferences.setRequireFullAccess(
+ configuration.getBooleanValue("Option/RequireFullAccess")
+ .getValue(null));
+ }
+
+ private void loadPositiveTrust(Configuration configuration) {
+ preferences.setPositiveTrust(
+ configuration.getIntValue("Option/PositiveTrust")
+ .getValue(null));
+ }
+
+ private void loadNegativeTrust(Configuration configuration) {
+ preferences.setNegativeTrust(
+ configuration.getIntValue("Option/NegativeTrust")
+ .getValue(null));
+ }
+
+ private void loadTrustComment(Configuration configuration) {
+ preferences.setTrustComment(
+ configuration.getStringValue("Option/TrustComment")
+ .getValue(null));
+ }
+
+ private void loadFcpInterfaceActive(Configuration configuration) {
+ preferences.setFcpInterfaceActive(configuration.getBooleanValue(
+ "Option/ActivateFcpInterface").getValue(null));
+ }
+
+ private void loadFcpFullAccessRequired(Configuration configuration) {
+ Integer fullAccessRequiredInteger = configuration
+ .getIntValue("Option/FcpFullAccessRequired").getValue(null);
+ preferences.setFcpFullAccessRequired(
+ (fullAccessRequiredInteger == null) ? null :
+ FullAccessRequired.values()[fullAccessRequiredInteger]);
+ }
+
+}
--- /dev/null
+package net.pterodactylus.sone.core;
+
+import static net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import net.pterodactylus.sone.TestValue;
+import net.pterodactylus.util.config.Configuration;
+
+import com.google.common.eventbus.EventBus;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Unit test for {@link PreferencesLoader}.
+ *
+ * @author <a href="mailto:bombe@pterodactylus.net">David ‘Bombe’ Roden</a>
+ */
+public class PreferencesLoaderTest {
+
+ private final EventBus eventBus = mock(EventBus.class);
+ private final Preferences preferences = new Preferences(eventBus);
+ private final Configuration configuration = mock(Configuration.class);
+ private final PreferencesLoader preferencesLoader =
+ new PreferencesLoader(preferences);
+
+ @Before
+ public void setupConfiguration() {
+ setupIntValue("InsertionDelay", 15);
+ setupIntValue("PostsPerPage", 25);
+ setupIntValue("ImagesPerPage", 12);
+ setupIntValue("CharactersPerPost", 150);
+ setupIntValue("PostCutOffLength", 300);
+ setupBooleanValue("RequireFullAccess", true);
+ setupIntValue("PositiveTrust", 50);
+ setupIntValue("NegativeTrust", -50);
+ when(configuration.getStringValue("Option/TrustComment")).thenReturn(
+ new TestValue<String>("Trusted"));
+ setupBooleanValue("ActivateFcpInterface", true);
+ setupIntValue("FcpFullAccessRequired", 1);
+ }
+
+ private void setupIntValue(String optionName, int value) {
+ when(configuration.getIntValue("Option/" + optionName)).thenReturn(
+ new TestValue<Integer>(value));
+ }
+
+ private void setupBooleanValue(String optionName, boolean value) {
+ when(configuration.getBooleanValue(
+ "Option/" + optionName)).thenReturn(
+ new TestValue<Boolean>(value));
+ }
+
+ @Test
+ public void configurationIsLoadedCorrectly() {
+ setupConfiguration();
+ preferencesLoader.loadFrom(configuration);
+ assertThat(preferences.getInsertionDelay(), is(15));
+ assertThat(preferences.getPostsPerPage(), is(25));
+ assertThat(preferences.getImagesPerPage(), is(12));
+ assertThat(preferences.getCharactersPerPost(), is(150));
+ assertThat(preferences.getPostCutOffLength(), is(300));
+ assertThat(preferences.isRequireFullAccess(), is(true));
+ assertThat(preferences.getPositiveTrust(), is(50));
+ assertThat(preferences.getNegativeTrust(), is(-50));
+ assertThat(preferences.getTrustComment(), is("Trusted"));
+ assertThat(preferences.isFcpInterfaceActive(), is(true));
+ assertThat(preferences.getFcpFullAccessRequired(), is(WRITING));
+ }
+
+}
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.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.event.InsertionDelayChangedEvent;
import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired;
import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent;
import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent;
import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged;
-import net.pterodactylus.sone.utils.Option;
import com.google.common.eventbus.EventBus;
-import org.junit.Before;
+import org.junit.After;
import org.junit.Test;
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<Integer> integerOption = when(mock(Option.class).get()).thenReturn(INTEGER_VALUE).getMock();
- private final Option<Boolean> booleanOption = when(mock(Option.class).get()).thenReturn(true).getMock();
- private final Option<String> 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
- 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<FullAccessRequiredChanged> 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<FullAccessRequiredChanged> fullAccessRequiredChangedCaptor = forClass(FullAccessRequiredChanged.class);
- verify(eventBus).post(fullAccessRequiredChangedCaptor.capture());
- assertThat(fullAccessRequiredChangedCaptor.getValue().getFullAccessRequired(), is(ALWAYS));
+ public void preferencesStartWithFcpFullAccessRequiredDefaultValue() {
+ assertThat(preferences.getFcpFullAccessRequired(), is(ALWAYS));
}
}
projects / Sone.git / commitdiff