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 fcp interface active of true`() {
 184                 preferences.newFcpInterfaceActive = true
 185                 assertThat(preferences.fcpInterfaceActive, equalTo(true))
 186                 verify(eventBus).post(any(FcpInterfaceActivatedEvent::class.java))
 187         }
 188
 189         @Test
 190         fun `preferences retain fcp interface active of false`() {
 191                 preferences.newFcpInterfaceActive = false
 192                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 193                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent::class.java))
 194         }
 195
 196         @Test
 197         fun `preferences return default value when fcp interface active is set to null`() {
 198                 preferences.newFcpInterfaceActive = null
 199                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 200                 verify(eventBus).post(any(FcpInterfaceDeactivatedEvent::class.java))
 201         }
 202
 203         @Test
 204         fun `preferences start with fcp interface active default value`() {
 205                 assertThat(preferences.fcpInterfaceActive, equalTo(false))
 206         }
 207
 208         @Test
 209         fun `preferences retain fcp full access required of no`() {
 210                 preferences.newFcpFullAccessRequired = NO
 211                 assertThat(preferences.fcpFullAccessRequired, equalTo(NO))
 212                 verifyFullAccessRequiredChangedEvent(NO)
 213         }
 214
 215         private fun verifyFullAccessRequiredChangedEvent(
 216                         fullAccessRequired: FullAccessRequired) {
 217                 verify(eventBus).post(eventsCaptor.capture())
 218                 assertThat(eventsCaptor.value, instanceOf(FullAccessRequiredChanged::class.java))
 219                 assertThat((eventsCaptor.value as FullAccessRequiredChanged).fullAccessRequired,
 220                                 equalTo(fullAccessRequired))
 221         }
 222
 223         @Test
 224         fun `preferences retain fcp full access required of writing`() {
 225                 preferences.newFcpFullAccessRequired = WRITING
 226                 assertThat(preferences.fcpFullAccessRequired, equalTo(WRITING))
 227                 verifyFullAccessRequiredChangedEvent(WRITING)
 228         }
 229
 230         @Test
 231         fun `preferences retain fcp full access required of always`() {
 232                 preferences.newFcpFullAccessRequired = ALWAYS
 233                 assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS))
 234                 verifyFullAccessRequiredChangedEvent(ALWAYS)
 235         }
 236
 237         @Test
 238         fun `preferences return default value when fcp full access required is set to null`() {
 239                 preferences.newFcpFullAccessRequired = null
 240                 assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS))
 241                 verifyFullAccessRequiredChangedEvent(ALWAYS)
 242         }
 243
 244         @Test
 245         fun `preferences start with fcp full access required default value`() {
 246                 assertThat(preferences.fcpFullAccessRequired, equalTo(ALWAYS))
 247         }
 248
 249         @Test
 250         fun `setting insertion delay to valid value sends change event`() {
 251                 testPreferencesChangedEvent("InsertionDelay", { preferences.newInsertionDelay = it }, 30)
 252         }
 253
 254         @Test
 255         fun `setting posts per page to valid value sends change event`() {
 256                 testPreferencesChangedEvent("PostsPerPage", { preferences.newPostsPerPage = it }, 31)
 257         }
 258
 259         private fun <T : Any> testPreferencesChangedEvent(name: String, setter: (T) -> Unit, value: T) {
 260                 setter(value)
 261                 verify(eventBus, atLeastOnce()).post(eventsCaptor.capture())
 262                 assertThat(eventsCaptor.allValues, hasItem(PreferenceChangedEvent(name, value)))
 263         }
 264
 265 }