src/test/kotlin/net/pterodactylus/sone/core/PreferencesTest.kt

   1 package net.pterodactylus.sone.core
   2
   3 import com.google.common.eventbus.EventBus
   4 import com.google.common.eventbus.Subscribe
   5 import net.pterodactylus.sone.core.event.InsertionDelayChangedEvent
   6 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired
   7 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.ALWAYS
   8 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.NO
   9 import net.pterodactylus.sone.fcp.FcpInterface.FullAccessRequired.WRITING
  10 import net.pterodactylus.sone.fcp.event.FcpInterfaceActivatedEvent
  11 import net.pterodactylus.sone.fcp.event.FcpInterfaceDeactivatedEvent
  12 import net.pterodactylus.sone.fcp.event.FullAccessRequiredChanged
  13 import net.pterodactylus.util.config.Configuration
  14 import net.pterodactylus.util.config.MapConfigurationBackend
  15 import org.hamcrest.MatcherAssert.assertThat
  16 import org.hamcrest.Matchers.emptyIterable
  17 import org.hamcrest.Matchers.equalTo
  18 import org.hamcrest.Matchers.hasItem
  19 import org.hamcrest.Matchers.instanceOf
  20 import org.hamcrest.Matchers.nullValue
  21 import org.junit.Test
  22
  23 /**
  24  * Unit test for [Preferences].
  25  */
  26 class PreferencesTest {
  27
  28         private val eventBus = EventBus()
  29         private val preferences = Preferences(eventBus)
  30
  31         @Test
  32         fun `preferences retain insertion delay`() {
  33                 preferences.newInsertionDelay = 15
  34                 assertThat(preferences.insertionDelay, equalTo(15))
  35         }
  36
  37         @Test
  38         fun `preferences sends event on setting insertion delay`() {
  39                 val events = mutableListOf<InsertionDelayChangedEvent>()
  40                 eventBus.register(object {
  41                         @Subscribe
  42                         fun insertionDelayChangedEvent(event: InsertionDelayChangedEvent) =
  43                                         events.add(event)
  44                 })
  45                 preferences.newInsertionDelay = 15
  46                 assertThat(events, hasItem(InsertionDelayChangedEvent(15)))
  47         }
  48
  49         @Test(expected = IllegalArgumentException::class)
  50         fun `invalid insertion delay is rejected`() {
  51                 preferences.newInsertionDelay = -15
  52         }
  53
  54         @Test
  55         fun `no event is sent when invalid insertion delay is set`() {
  56                 val events = mutableListOf<InsertionDelayChangedEvent>()
  57                 eventBus.register(object {
  58                         @Subscribe
  59                         fun insertionDelayChanged(event: InsertionDelayChangedEvent) =
  60                                         events.add(event)
  61                 })
  62                 try {
  63                         preferences.newInsertionDelay = -15
  64                 } catch (iae: IllegalArgumentException) {
  65                         /* ignore. */
  66                 }
  67
  68                 assertThat(events, emptyIterable())
  69         }
  70
  71         @Test
  72         fun `preferences return default value when insertion delay is set to null`() {
  73                 preferences.newInsertionDelay = null
  74                 assertThat(preferences.insertionDelay, equalTo(60))
  75         }
  76
  77         @Test
  78         fun `preferences start with insertion delay default value`() {
  79                 assertThat(preferences.insertionDelay, equalTo(60))
  80         }
  81
  82         @Test
  83         fun `preferences saves null for default insertion delay setting`() {
  84                 val configuration = Configuration(MapConfigurationBackend())
  85                 preferences.saveTo(configuration)
  86                 assertThat(configuration.getIntValue("Option/InsertionDelay").getValue(null), nullValue())
  87         }
  88
  89         @Test
  90         fun `preferences retain posts per page`() {
  91                 preferences.newPostsPerPage = 15
  92                 assertThat(preferences.postsPerPage, equalTo(15))
  93         }
  94
  95         @Test(expected = IllegalArgumentException::class)
  96         fun `invalid posts per page is rejected`() {
  97                 preferences.newPostsPerPage = -15
  98         }
  99
 100         @Test
 101         fun `preferences return default value when posts per page is set to null`() {
 102                 preferences.newPostsPerPage = null
 103                 assertThat(preferences.postsPerPage, equalTo(10))
 104         }
 105
 106         @Test
 107         fun `preferences start with posts per page default value`() {
 108                 assertThat(preferences.postsPerPage, equalTo(10))
 109         }
 110
 111         @Test
 112         fun `preferences retain images per page`() {
 113                 preferences.newImagesPerPage = 15
 114                 assertThat(preferences.imagesPerPage, equalTo(15))
 115         }
 116
 117         @Test(expected = IllegalArgumentException::class)
 118         fun `invalid images per page is rejected`() {
 119                 preferences.newImagesPerPage = -15
 120         }
 121
 122         @Test
 123         fun `preferences return default value when images per page is set to null`() {
 124                 preferences.newImagesPerPage = null
 125                 assertThat(preferences.imagesPerPage, equalTo(9))
 126         }
 127
 128         @Test
 129         fun `preferences start with images per page default value`() {
 130                 assertThat(preferences.imagesPerPage, equalTo(9))
 131         }
 132
 133         @Test
 134         fun `preferences retain characters per post`() {
 135                 preferences.newCharactersPerPost = 150
 136                 assertThat(preferences.charactersPerPost, equalTo(150))
 137         }
 138
 139         @Test(expected = IllegalArgumentException::class)
 140         fun `invalid characters per post is rejected`() {
 141                 preferences.newCharactersPerPost = -15
 142         }
 143
 144         @Test
 145         fun `preferences return default value when characters per post is set to null`() {
 146                 preferences.newCharactersPerPost = null
 147                 assertThat(preferences.charactersPerPost, equalTo(400))
 148         }
 149
 150         @Test
 151         fun `preferences start with characters per post default value`() {
 152                 assertThat(preferences.charactersPerPost, equalTo(400))
 153         }
 154
 155         @Test
 156         fun `preferences retain post cut off length`() {
 157                 preferences.newPostCutOffLength = 150
 158                 assertThat(preferences.postCutOffLength, equalTo(150))
 159         }
 160
 161         @Test(expected = IllegalArgumentException::class)
 162         fun `invalid post cut off length is rejected`() {
 163                 preferences.newPostCutOffLength = -15
 164         }
 165
 166         @Test(expected = IllegalArgumentException::class)
 167         fun `cut off length of minus one is not allowed`() {
 168                 preferences.newPostCutOffLength = -1
 169         }
 170
 171         @Test
 172         fun `preferences return default value when post cut off length is set to null`() {
 173                 preferences.newPostCutOffLength = null
 174                 assertThat(preferences.postCutOffLength, equalTo(200))
 175         }
 176
 177         @Test
 178         fun `preferences start with post cut off length default value`() {
 179                 assertThat(preferences.postCutOffLength, equalTo(200))
 180         }
 181
 182         @Test
 183         fun `preferences retain require full access of true`() {
 184                 preferences.newRequireFullAccess = true
 185                 assertThat(preferences.requireFullAccess, equalTo(true))
 186         }
 187
 188         @Test
 189         fun `preferences retain require full access of false`() {
 190                 preferences.newRequireFullAccess = false
 191                 assertThat(preferences.requireFullAccess, equalTo(false))
 192         }
 193
 194         @Test
 195         fun `preferences return default value when require full access is set to null`() {
 196                 preferences.newRequireFullAccess = null
 197                 assertThat(preferences.requireFullAccess, equalTo(false))
 198         }
 199
 200         @Test
 201         fun `preferences start with require full access default value`() {
 202                 assertThat(preferences.requireFullAccess, equalTo(false))
 203         }
 204
 205         @Test
 206         fun `preferences retain fcp interface active of true`() {
 207                 val events = mutableListOf<FcpInterfaceActivatedEvent>()
 208                 eventBus.register(object {
 209                         @Subscribe
 210                         fun fcpInterfaceActivatedEvent(event: FcpInterfaceActivatedEvent) =
 211                                         events.add(event)
 212                 })
 213                 preferences.newFcpInterfaceActive = true
 214                 assertThat(preferences.fcpInterfaceActive, equalTo(true))
 215                 assertThat(events, hasItem<FcpInterfaceActivatedEvent>(instanceOf(FcpInterfaceActivatedEvent::class.java)))
 216         }
 217
 218         @Test
 219         fun `preferences retain fcp interface active of false`() {
 220                 val events = mutableListOf<FcpInterfaceDeactivatedEvent>()
 221                 eventBus.register(object {
 222                         @Subscribe
 223                         fun fcpInterfaceDeactivatedEvent(event: FcpInterfaceDeactivatedEvent) =
 224                                         events.add(event)
 225                 })
 226                 preferences.newFcpInterfaceActive = false
 227                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 228                 assertThat(events, hasItem<FcpInterfaceDeactivatedEvent>(instanceOf(FcpInterfaceDeactivatedEvent::class.java)))
 229         }
 230
 231         @Test
 232         fun `preferences return default value when fcp interface active is set to null`() {
 233                 val events = mutableListOf<FcpInterfaceDeactivatedEvent>()
 234                 eventBus.register(object {
 235                         @Subscribe
 236                         fun fcpInterfaceDeactivatedEvent(event: FcpInterfaceDeactivatedEvent) =
 237                                         events.add(event)
 238                 })
 239                 preferences.newFcpInterfaceActive = null
 240                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 241                 assertThat(events, hasItem<FcpInterfaceDeactivatedEvent>(instanceOf(FcpInterfaceDeactivatedEvent::class.java)))
 242         }
 243
 244         @Test
 245         fun `preferences start with fcp interface active default value`() {
 246                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 247         }
 248
 249         @Test
 250         fun `preferences retain fcp full access required of no`() {
 251                 verifyFullAccessRequiredChangedEvent(NO)
 252         }
 253
 254         private fun verifyFullAccessRequiredChangedEvent(set: FullAccessRequired?, expected: FullAccessRequired = set!!) {
 255                 val events = mutableListOf<FullAccessRequiredChanged>()
 256                 eventBus.register(object {
 257                         @Subscribe
 258                         fun fullAccessRequiredChanged(event: FullAccessRequiredChanged) =
 259                                         events.add(event)
 260                 })
 261                 preferences.newFcpFullAccessRequired = set
 262                 assertThat(preferences.fcpFullAccessRequired, equalTo(expected))
 263                 assertThat(events.single().fullAccessRequired, equalTo(expected))
 264         }
 265
 266         @Test
 267         fun `preferences retain fcp full access required of writing`() {
 268                 verifyFullAccessRequiredChangedEvent(WRITING)
 269         }
 270
 271         @Test
 272         fun `preferences retain fcp full access required of always`() {
 273                 verifyFullAccessRequiredChangedEvent(ALWAYS)
 274         }
 275
 276         @Test
 277         fun `preferences return default value when fcp full access required is set to null`() {
 278                 verifyFullAccessRequiredChangedEvent(null, ALWAYS)
 279         }
 280
 281         @Test
 282         fun `preferences start with fcp full access required default value`() {
 283                 assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS))
 284         }
 285
 286         @Test
 287         fun `setting insertion delay to valid value sends change event`() {
 288                 testPreferencesChangedEvent("InsertionDelay", { preferences.newInsertionDelay = it }, 30)
 289         }
 290
 291         @Test
 292         fun `setting posts per page to valid value sends change event`() {
 293                 testPreferencesChangedEvent("PostsPerPage", { preferences.newPostsPerPage = it }, 31)
 294         }
 295
 296         private fun <T : Any> testPreferencesChangedEvent(name: String, setter: (T) -> Unit, value: T) {
 297                 val events = mutableListOf<PreferenceChangedEvent>()
 298                 eventBus.register(object {
 299                         @Subscribe
 300                         fun preferenceChanged(event: PreferenceChangedEvent) =
 301                                         events.add(event)
 302                 })
 303                 setter(value)
 304                 assertThat(events, hasItem(PreferenceChangedEvent(name, value)))
 305         }
 306
 307 }