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