X-Git-Url: https://git.pterodactylus.net/?p=Sone.git;a=blobdiff_plain;f=src%2Ftest%2Fkotlin%2Fnet%2Fpterodactylus%2Fsone%2Fcore%2FPreferencesTest.kt;h=dafe7827dbc7286f3c8a5d3855bfd8b8c16dbe54;hp=199604b26d7c8e15c6e0c305fc25118105ae394d;hb=aa82f7eaab5b33951ca7aa0d240f0537c31e3247;hpb=7e43bed09912f401dc53be9b998ebd1072656ffe diff --git a/src/test/kotlin/net/pterodactylus/sone/core/PreferencesTest.kt b/src/test/kotlin/net/pterodactylus/sone/core/PreferencesTest.kt index 199604b..dafe782 100644 --- a/src/test/kotlin/net/pterodactylus/sone/core/PreferencesTest.kt +++ b/src/test/kotlin/net/pterodactylus/sone/core/PreferencesTest.kt @@ -1,27 +1,35 @@ package net.pterodactylus.sone.core -import com.google.common.eventbus.* -import net.pterodactylus.sone.core.event.* -import net.pterodactylus.sone.fcp.FcpInterface.* -import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.* -import net.pterodactylus.sone.fcp.event.* -import net.pterodactylus.sone.test.* -import org.hamcrest.MatcherAssert.* -import org.hamcrest.Matchers.* -import org.junit.* -import org.mockito.ArgumentMatchers.any -import org.mockito.Mockito.atLeastOnce -import org.mockito.Mockito.never -import org.mockito.Mockito.verify +import com.google.common.eventbus.EventBus +import com.google.common.eventbus.Subscribe +import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent +import net.pterodactylus.sone.core.event.StrictFilteringActivatedEvent +import net.pterodactylus.sone.core.event.StrictFilteringDeactivatedEvent +import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired +import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS +import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.NO +import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING +import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent +import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent +import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged +import net.pterodactylus.util.config.Configuration +import net.pterodactylus.util.config.MapConfigurationBackend +import org.hamcrest.Matcher +import org.hamcrest.MatcherAssert.assertThat +import org.hamcrest.Matchers.emptyIterable +import org.hamcrest.Matchers.equalTo +import org.hamcrest.Matchers.hasItem +import org.hamcrest.Matchers.instanceOf +import org.hamcrest.Matchers.nullValue +import org.junit.Test /** * Unit test for [Preferences]. */ class PreferencesTest { - private val eventBus = mock() + private val eventBus = EventBus() private val preferences = Preferences(eventBus) - private val eventsCaptor = capture() @Test fun `preferences retain insertion delay`() { @@ -31,9 +39,14 @@ class PreferencesTest { @Test fun `preferences sends event on setting insertion delay`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun insertionDelayChangedEvent(event: InsertionDelayChangedEvent) = + events.add(event) + }) preferences.newInsertionDelay = 15 - verify(eventBus, atLeastOnce()).post(eventsCaptor.capture()) - assertThat(eventsCaptor.allValues, hasItem(InsertionDelayChangedEvent(15))) + assertThat(events, hasItem(InsertionDelayChangedEvent(15))) } @Test(expected = IllegalArgumentException::class) @@ -43,13 +56,19 @@ class PreferencesTest { @Test fun `no event is sent when invalid insertion delay is set`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun insertionDelayChanged(event: InsertionDelayChangedEvent) = + events.add(event) + }) try { preferences.newInsertionDelay = -15 } catch (iae: IllegalArgumentException) { /* ignore. */ } - verify(eventBus, never()).post(any()) + assertThat(events, emptyIterable()) } @Test @@ -64,6 +83,11 @@ class PreferencesTest { } @Test + fun `preferences saves null for default insertion delay setting`() { + verifySavedOption(nullValue()) { it.getIntValue("Option/InsertionDelay").getValue(null) } + } + + @Test fun `preferences retain posts per page`() { preferences.newPostsPerPage = 15 assertThat(preferences.postsPerPage, equalTo(15)) @@ -180,149 +204,168 @@ class PreferencesTest { } @Test - fun `preferences retain positive trust`() { - preferences.newPositiveTrust = 15 - assertThat(preferences.positiveTrust, equalTo(15)) - } - - @Test(expected = IllegalArgumentException::class) - fun `invalid positive trust is rejected`() { - preferences.newPositiveTrust = -15 + fun `preferences retain fcp interface active of true`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun fcpInterfaceActivatedEvent(event: FcpInterfaceActivatedEvent) = + events.add(event) + }) + preferences.newFcpInterfaceActive = true + assertThat(preferences.fcpInterfaceActive, equalTo(true)) + assertThat(events, hasItem(instanceOf(FcpInterfaceActivatedEvent::class.java))) } @Test - fun `preferences return default value when positive trust is set to null`() { - preferences.newPositiveTrust = null - assertThat(preferences.positiveTrust, equalTo(75)) + fun `preferences retain fcp interface active of false`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun fcpInterfaceDeactivatedEvent(event: FcpInterfaceDeactivatedEvent) = + events.add(event) + }) + preferences.newFcpInterfaceActive = false + assertThat(preferences.fcpInterfaceActive, equalTo(false)) + assertThat(events, hasItem(instanceOf(FcpInterfaceDeactivatedEvent::class.java))) } @Test - fun `preferences start with positive trust default value`() { - assertThat(preferences.positiveTrust, equalTo(75)) + fun `preferences return default value when fcp interface active is set to null`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun fcpInterfaceDeactivatedEvent(event: FcpInterfaceDeactivatedEvent) = + events.add(event) + }) + preferences.newFcpInterfaceActive = null + assertThat(preferences.fcpInterfaceActive, equalTo(false)) + assertThat(events, hasItem(instanceOf(FcpInterfaceDeactivatedEvent::class.java))) } @Test - fun `preferences retain negative trust`() { - preferences.newNegativeTrust = -15 - assertThat(preferences.negativeTrust, equalTo(-15)) - } - - @Test(expected = IllegalArgumentException::class) - fun `invalid negative trust is rejected`() { - preferences.newNegativeTrust = 150 + fun `preferences start with fcp interface active default value`() { + assertThat(preferences.fcpInterfaceActive, equalTo(false)) } @Test - fun `preferences return default value when negative trust is set to null`() { - preferences.newNegativeTrust = null - assertThat(preferences.negativeTrust, equalTo(-25)) + fun `preferences retain fcp full access required of no`() { + verifyFullAccessRequiredChangedEvent(NO) } - @Test - fun `preferences start with negative trust default value`() { - assertThat(preferences.negativeTrust, equalTo(-25)) + private fun verifyFullAccessRequiredChangedEvent(set: FullAccessRequired?, expected: FullAccessRequired = set!!) { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun fullAccessRequiredChanged(event: FullAccessRequiredChanged) = + events.add(event) + }) + preferences.newFcpFullAccessRequired = set + assertThat(preferences.fcpFullAccessRequired, equalTo(expected)) + assertThat(events.single().fullAccessRequired, equalTo(expected)) } @Test - fun `preferences retain trust comment`() { - preferences.newTrustComment = "Trust" - assertThat(preferences.trustComment, equalTo("Trust")) + fun `preferences retain fcp full access required of writing`() { + verifyFullAccessRequiredChangedEvent(WRITING) } @Test - fun `preferences return default value when trust comment is set to null`() { - preferences.newTrustComment = null - assertThat(preferences.trustComment, - equalTo("Set from Sone Web Interface")) + fun `preferences retain fcp full access required of always`() { + verifyFullAccessRequiredChangedEvent(ALWAYS) } @Test - fun `preferences start with trust comment default value`() { - assertThat(preferences.trustComment, - equalTo("Set from Sone Web Interface")) + fun `preferences return default value when fcp full access required is set to null`() { + verifyFullAccessRequiredChangedEvent(null, ALWAYS) } @Test - fun `preferences retain fcp interface active of true`() { - preferences.newFcpInterfaceActive = true - assertThat(preferences.fcpInterfaceActive, equalTo(true)) - verify(eventBus).post(any(FcpInterfaceActivatedEvent::class.java)) + fun `preferences start with fcp full access required default value`() { + assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS)) } @Test - fun `preferences retain fcp interface active of false`() { - preferences.newFcpInterfaceActive = false - assertThat(preferences.fcpInterfaceActive, equalTo(false)) - verify(eventBus).post(any(FcpInterfaceDeactivatedEvent::class.java)) + fun `setting insertion delay to valid value sends change event`() { + testPreferencesChangedEvent("InsertionDelay", { preferences.newInsertionDelay = it }, 30) } @Test - fun `preferences return default value when fcp interface active is set to null`() { - preferences.newFcpInterfaceActive = null - assertThat(preferences.fcpInterfaceActive, equalTo(false)) - verify(eventBus).post(any(FcpInterfaceDeactivatedEvent::class.java)) + fun `setting posts per page to valid value sends change event`() { + testPreferencesChangedEvent("PostsPerPage", { preferences.newPostsPerPage = it }, 31) } @Test - fun `preferences start with fcp interface active default value`() { - assertThat(preferences.fcpInterfaceActive, equalTo(false)) + fun `default strict filtering is false`() { + assertThat(preferences.strictFiltering, equalTo(false)) } @Test - fun `preferences retain fcp full access required of no`() { - preferences.newFcpFullAccessRequired = NO - assertThat(preferences.fcpFullAccessRequired, equalTo(NO)) - verifyFullAccessRequiredChangedEvent(NO) + fun `strict filtering can be set`() { + preferences.newStrictFiltering = true + assertThat(preferences.strictFiltering, equalTo(true)) } - private fun verifyFullAccessRequiredChangedEvent( - fullAccessRequired: FullAccessRequired) { - verify(eventBus).post(eventsCaptor.capture()) - assertThat(eventsCaptor.value, instanceOf(FullAccessRequiredChanged::class.java)) - assertThat((eventsCaptor.value as FullAccessRequiredChanged).fullAccessRequired, - equalTo(fullAccessRequired)) + @Test + fun `strict filtering returns to default on null`() { + preferences.newStrictFiltering = true + preferences.newStrictFiltering = null + assertThat(preferences.strictFiltering, equalTo(false)) } @Test - fun `preferences retain fcp full access required of writing`() { - preferences.newFcpFullAccessRequired = WRITING - assertThat(preferences.fcpFullAccessRequired, equalTo(WRITING)) - verifyFullAccessRequiredChangedEvent(WRITING) + fun `event is generated when strict filtering is activated`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe fun strictFilteringActivatedEvent(event: StrictFilteringActivatedEvent) = + events.add(event) + }) + preferences.newStrictFiltering = true + assertThat(events, hasItem(instanceOf(StrictFilteringActivatedEvent::class.java))) } @Test - fun `preferences retain fcp full access required of always`() { - preferences.newFcpFullAccessRequired = ALWAYS - assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS)) - verifyFullAccessRequiredChangedEvent(ALWAYS) + fun `event is generated when strict filtering is deactivated`() { + val events = mutableListOf() + eventBus.register(object { + @Subscribe fun strictFilteringDeactivatedEvent(event: StrictFilteringDeactivatedEvent) = + events.add(event) + }) + preferences.newStrictFiltering = false + assertThat(events, hasItem(instanceOf(StrictFilteringDeactivatedEvent::class.java))) } @Test - fun `preferences return default value when fcp full access required is set to null`() { - preferences.newFcpFullAccessRequired = null - assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS)) - verifyFullAccessRequiredChangedEvent(ALWAYS) + fun `default strict filtering is saved as null`() { + verifySavedOption(nullValue()) { it.getBooleanValue("Option/StrictFiltering").value } } @Test - fun `preferences start with fcp full access required default value`() { - assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS)) + fun `activated strict filtering is saved as true`() { + preferences.newStrictFiltering = true + verifySavedOption(equalTo(true)) { it.getBooleanValue("Option/StrictFiltering").value } } @Test - fun `setting insertion delay to valid value sends change event`() { - testPreferencesChangedEvent("InsertionDelay", { preferences.newInsertionDelay = it }, 30) + fun `deactivated strict filtering is saved as false`() { + preferences.newStrictFiltering = false + verifySavedOption(equalTo(false)) { it.getBooleanValue("Option/StrictFiltering").value } } - @Test - fun `setting posts per page to valid value sends change event`() { - testPreferencesChangedEvent("PostsPerPage", { preferences.newPostsPerPage = it }, 31) + private fun verifySavedOption(matcher: Matcher, getter: (Configuration) -> T) { + val configuration = Configuration(MapConfigurationBackend()) + preferences.saveTo(configuration) + assertThat(getter(configuration), matcher) } private fun testPreferencesChangedEvent(name: String, setter: (T) -> Unit, value: T) { + val events = mutableListOf() + eventBus.register(object { + @Subscribe + fun preferenceChanged(event: PreferenceChangedEvent) = + events.add(event) + }) setter(value) - verify(eventBus, atLeastOnce()).post(eventsCaptor.capture()) - assertThat(eventsCaptor.allValues, hasItem(PreferenceChangedEvent(name, value))) + assertThat(events, hasItem(PreferenceChangedEvent(name, value))) } }