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

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