src/test/kotlin/net/pterodactylus/sone/web/pages/OptionsPageTest.kt

   1 package net.pterodactylus.sone.web.pages
   2
   3 import net.pterodactylus.sone.data.SoneOptions.DefaultSoneOptions
   4 import net.pterodactylus.sone.data.SoneOptions.LoadExternalContent.FOLLOWED
   5 import net.pterodactylus.sone.data.SoneOptions.LoadExternalContent.TRUSTED
   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.test.whenever
  11 import net.pterodactylus.sone.web.pages.OptionsPage
  12 import net.pterodactylus.util.web.Method.GET
  13 import net.pterodactylus.util.web.Method.POST
  14 import org.hamcrest.MatcherAssert.assertThat
  15 import org.hamcrest.Matchers.equalTo
  16 import org.hamcrest.Matchers.hasItem
  17 import org.hamcrest.Matchers.nullValue
  18 import org.junit.Before
  19 import org.junit.Test
  20
  21 /**
  22  * Unit test for [OptionsPage].
  23  */
  24 class OptionsPageTest : WebPageTest() {
  25
  26         private val page = OptionsPage(template, webInterface)
  27
  28         override fun getPage() = page
  29
  30         @Before
  31         fun setupPreferences() {
  32                 core.preferences.insertionDelay = 1
  33                 core.preferences.charactersPerPost = 50
  34                 core.preferences.fcpFullAccessRequired = WRITING
  35                 core.preferences.imagesPerPage = 4
  36                 core.preferences.isFcpInterfaceActive = true
  37                 core.preferences.isRequireFullAccess = true
  38                 core.preferences.negativeTrust = 7
  39                 core.preferences.positiveTrust = 8
  40                 core.preferences.postCutOffLength = 51
  41                 core.preferences.postsPerPage = 10
  42                 core.preferences.trustComment = "11"
  43         }
  44
  45         @Before
  46         fun setupSoneOptions() {
  47                 whenever(currentSone.options).thenReturn(DefaultSoneOptions().apply {
  48                         isAutoFollow = true
  49                         isShowNewPostNotifications = true
  50                         isShowNewReplyNotifications = true
  51                         isShowNewSoneNotifications = true
  52                         isSoneInsertNotificationEnabled = true
  53                         loadLinkedImages = FOLLOWED
  54                         showCustomAvatars = FOLLOWED
  55                 })
  56         }
  57
  58         @Test
  59         fun `get request stores all preferences in the template context`() {
  60                 request("", GET)
  61                 page.handleRequest(freenetRequest, templateContext)
  62                 assertThat(templateContext["auto-follow"], equalTo<Any>(true))
  63                 assertThat(templateContext["show-notification-new-sones"], equalTo<Any>(true))
  64                 assertThat(templateContext["show-notification-new-posts"], equalTo<Any>(true))
  65                 assertThat(templateContext["show-notification-new-replies"], equalTo<Any>(true))
  66                 assertThat(templateContext["enable-sone-insert-notifications"], equalTo<Any>(true))
  67                 assertThat(templateContext["load-linked-images"], equalTo<Any>("FOLLOWED"))
  68                 assertThat(templateContext["show-custom-avatars"], equalTo<Any>("FOLLOWED"))
  69                 assertThat(templateContext["insertion-delay"], equalTo<Any>(1))
  70                 assertThat(templateContext["characters-per-post"], equalTo<Any>(50))
  71                 assertThat(templateContext["fcp-full-access-required"], equalTo<Any>(1))
  72                 assertThat(templateContext["images-per-page"], equalTo<Any>(4))
  73                 assertThat(templateContext["fcp-interface-active"], equalTo<Any>(true))
  74                 assertThat(templateContext["require-full-access"], equalTo<Any>(true))
  75                 assertThat(templateContext["negative-trust"], equalTo<Any>(7))
  76                 assertThat(templateContext["positive-trust"], equalTo<Any>(8))
  77                 assertThat(templateContext["post-cut-off-length"], equalTo<Any>(51))
  78                 assertThat(templateContext["posts-per-page"], equalTo<Any>(10))
  79                 assertThat(templateContext["trust-comment"], equalTo<Any>("11"))
  80         }
  81
  82         @Test
  83         fun `get request without sone does not store sone-specific preferences in the template context`() {
  84                 request("", GET)
  85                 unsetCurrentSone()
  86                 page.handleRequest(freenetRequest, templateContext)
  87                 assertThat(templateContext["auto-follow"], nullValue())
  88                 assertThat(templateContext["show-notification-new-sones"], nullValue())
  89                 assertThat(templateContext["show-notification-new-posts"], nullValue())
  90                 assertThat(templateContext["show-notification-new-replies"], nullValue())
  91                 assertThat(templateContext["enable-sone-insert-notifications"], nullValue())
  92                 assertThat(templateContext["load-linked-images"], nullValue())
  93                 assertThat(templateContext["show-custom-avatars"], nullValue())
  94         }
  95
  96         private fun <T> verifyThatOptionCanBeSet(option: String, setValue: Any?, expectedValue: T, getter: () -> T) {
  97                 request("", POST)
  98                 addHttpRequestPart("show-custom-avatars", "ALWAYS")
  99                 addHttpRequestPart("load-linked-images", "ALWAYS")
 100                 addHttpRequestPart(option, setValue.toString())
 101                 verifyRedirect("options.html") {
 102                         assertThat(getter(), equalTo(expectedValue))
 103                 }
 104         }
 105
 106         @Test
 107         fun `auto-follow option can be set`() {
 108                 verifyThatOptionCanBeSet("auto-follow", "checked", true) { currentSone.options.isAutoFollow }
 109         }
 110
 111         @Test
 112         fun `show new sone notification option can be set`() {
 113                 verifyThatOptionCanBeSet("show-notification-new-sones", "checked", true) { currentSone.options.isShowNewSoneNotifications }
 114         }
 115
 116         @Test
 117         fun `show new post notification option can be set`() {
 118                 verifyThatOptionCanBeSet("show-notification-new-posts", "checked", true) { currentSone.options.isShowNewPostNotifications }
 119         }
 120
 121         @Test
 122         fun `show new reply notification option can be set`() {
 123                 verifyThatOptionCanBeSet("show-notification-new-replies", "checked", true) { currentSone.options.isShowNewReplyNotifications }
 124         }
 125
 126         @Test
 127         fun `enable sone insert notifications option can be set`() {
 128                 verifyThatOptionCanBeSet("enable-sone-insert-notifications", "checked", true) { currentSone.options.isSoneInsertNotificationEnabled }
 129         }
 130
 131         @Test
 132         fun `load linked images option can be set`() {
 133                 verifyThatOptionCanBeSet("load-linked-images", "TRUSTED", TRUSTED) { currentSone.options.loadLinkedImages }
 134         }
 135
 136         @Test
 137         fun `show custom avatar option can be set`() {
 138                 verifyThatOptionCanBeSet("show-custom-avatars", "TRUSTED", TRUSTED) { currentSone.options.showCustomAvatars }
 139         }
 140
 141         private fun verifyThatWrongValueForPreferenceIsDetected(name: String, value: String) {
 142                 unsetCurrentSone()
 143                 request("", POST)
 144                 addHttpRequestPart(name, value)
 145                 page.handleRequest(freenetRequest, templateContext)
 146                 assertThat(templateContext["fieldErrors"] as Iterable<*>, hasItem(name))
 147         }
 148
 149         private fun <T> verifyThatPreferencesCanBeSet(name: String, setValue: String?, expectedValue: T, getter: () -> T) {
 150                 unsetCurrentSone()
 151                 request("", POST)
 152                 addHttpRequestPart(name, setValue)
 153                 verifyRedirect("options.html") {
 154                         assertThat(getter(), equalTo(expectedValue))
 155                 }
 156         }
 157
 158         @Test
 159         fun `insertion delay can not be set to less than 0 seconds`() {
 160                 verifyThatWrongValueForPreferenceIsDetected("insertion-delay", "-1")
 161         }
 162
 163         @Test
 164         fun `insertion delay can be set to 0 seconds`() {
 165                 verifyThatPreferencesCanBeSet("insertion-delay", "0", 0) { core.preferences.insertionDelay }
 166         }
 167
 168         @Test
 169         fun `setting insertion to an invalid value will reset it`() {
 170                 verifyThatPreferencesCanBeSet("insertion-delay", "foo", 60) { core.preferences.insertionDelay }
 171         }
 172
 173         @Test
 174         fun `characters per post can not be set to less than -1`() {
 175                 verifyThatWrongValueForPreferenceIsDetected("characters-per-post", "-2")
 176         }
 177
 178         @Test
 179         fun `characters per post can be set to -1`() {
 180                 verifyThatPreferencesCanBeSet("characters-per-post", "-1", -1) { core.preferences.charactersPerPost }
 181         }
 182
 183         @Test
 184         fun `characters per post can not be set to 0`() {
 185                 verifyThatWrongValueForPreferenceIsDetected("characters-per-post", "0")
 186         }
 187
 188         @Test
 189         fun `characters per post can not be set to 49`() {
 190                 verifyThatWrongValueForPreferenceIsDetected("characters-per-post", "49")
 191         }
 192
 193         @Test
 194         fun `characters per post can be set to 50`() {
 195                 verifyThatPreferencesCanBeSet("characters-per-post", "50", 50) { core.preferences.charactersPerPost }
 196         }
 197
 198         @Test
 199         fun `fcp full acess required option can be set to always`() {
 200                 verifyThatPreferencesCanBeSet("fcp-full-access-required", "2", ALWAYS) { core.preferences.fcpFullAccessRequired }
 201         }
 202
 203         @Test
 204         fun `fcp full acess required option can be set to writing`() {
 205                 verifyThatPreferencesCanBeSet("fcp-full-access-required", "1", WRITING) { core.preferences.fcpFullAccessRequired }
 206         }
 207
 208         @Test
 209         fun `fcp full acess required option can be set to no`() {
 210                 verifyThatPreferencesCanBeSet("fcp-full-access-required", "0", NO) { core.preferences.fcpFullAccessRequired }
 211         }
 212
 213         @Test
 214         fun `fcp full acess required option is not changed if invalid value is set`() {
 215                 verifyThatPreferencesCanBeSet("fcp-full-access-required", "foo", WRITING) { core.preferences.fcpFullAccessRequired }
 216         }
 217
 218         @Test
 219         fun `images per page can not be set to 0`() {
 220                 verifyThatWrongValueForPreferenceIsDetected("images-per-page", "0")
 221         }
 222
 223         @Test
 224         fun `images per page can be set to 1`() {
 225                 verifyThatPreferencesCanBeSet("images-per-page", "1", 1) { core.preferences.imagesPerPage }
 226         }
 227
 228         @Test
 229         fun `images per page is set to 9 if invalid value is requested`() {
 230                 verifyThatPreferencesCanBeSet("images-per-page", "foo", 9) { core.preferences.imagesPerPage }
 231         }
 232
 233         @Test
 234         fun `fcp interface can be set to true`() {
 235                 verifyThatPreferencesCanBeSet("fcp-interface-active", "checked", true) { core.preferences.isFcpInterfaceActive }
 236         }
 237
 238         @Test
 239         fun `fcp interface can be set to false`() {
 240                 verifyThatPreferencesCanBeSet("fcp-interface-active", null, false) { core.preferences.isFcpInterfaceActive }
 241         }
 242
 243         @Test
 244         fun `require full access can be set to true`() {
 245                 verifyThatPreferencesCanBeSet("require-full-access", "checked", true) { core.preferences.isRequireFullAccess }
 246         }
 247
 248         @Test
 249         fun `require full access can be set to false`() {
 250                 verifyThatPreferencesCanBeSet("require-full-access", null, false) { core.preferences.isRequireFullAccess }
 251         }
 252
 253         @Test
 254         fun `negative trust can not be set to -101`() {
 255                 verifyThatWrongValueForPreferenceIsDetected("negative-trust", "-101")
 256         }
 257
 258         @Test
 259         fun `negative trust can be set to -100`() {
 260                 verifyThatPreferencesCanBeSet("negative-trust", "-100", -100) { core.preferences.negativeTrust }
 261         }
 262
 263         @Test
 264         fun `negative trust can be set to 100`() {
 265                 verifyThatPreferencesCanBeSet("negative-trust", "100", 100) { core.preferences.negativeTrust }
 266         }
 267
 268         @Test
 269         fun `negative trust can not be set to 101`() {
 270                 verifyThatWrongValueForPreferenceIsDetected("negative-trust", "101")
 271         }
 272
 273         @Test
 274         fun `negative trust is set to default on invalid value`() {
 275                 verifyThatPreferencesCanBeSet("negative-trust", "invalid", -25) { core.preferences.negativeTrust }
 276         }
 277
 278         @Test
 279         fun `positive trust can not be set to -1`() {
 280                 verifyThatWrongValueForPreferenceIsDetected("positive-trust", "-1")
 281         }
 282
 283         @Test
 284         fun `positive trust can be set to 0`() {
 285                 verifyThatPreferencesCanBeSet("positive-trust", "0", 0) { core.preferences.positiveTrust }
 286         }
 287
 288         @Test
 289         fun `positive trust can be set to 100`() {
 290                 verifyThatPreferencesCanBeSet("positive-trust", "100", 100) { core.preferences.positiveTrust }
 291         }
 292
 293         @Test
 294         fun `positive trust can not be set to 101`() {
 295                 verifyThatWrongValueForPreferenceIsDetected("positive-trust", "101")
 296         }
 297
 298         @Test
 299         fun `positive trust is set to default on invalid value`() {
 300                 verifyThatPreferencesCanBeSet("positive-trust", "invalid", 75) { core.preferences.positiveTrust }
 301         }
 302
 303         @Test
 304         fun `post cut off length can not be set to -49`() {
 305                 verifyThatWrongValueForPreferenceIsDetected("post-cut-off-length", "-49")
 306         }
 307
 308         @Test
 309         fun `post cut off length can be set to 50`() {
 310                 verifyThatPreferencesCanBeSet("post-cut-off-length", "50", 50) { core.preferences.postCutOffLength }
 311         }
 312
 313         @Test
 314         fun `post cut off length is set to default on invalid value`() {
 315                 verifyThatPreferencesCanBeSet("post-cut-off-length", "invalid", 200) { core.preferences.postCutOffLength }
 316         }
 317
 318         @Test
 319         fun `posts per page can not be set to 0`() {
 320                 verifyThatWrongValueForPreferenceIsDetected("posts-per-page", "-49")
 321         }
 322
 323         @Test
 324         fun `posts per page can be set to 1`() {
 325                 verifyThatPreferencesCanBeSet("posts-per-page", "1", 1) { core.preferences.postsPerPage }
 326         }
 327
 328         @Test
 329         fun `posts per page is set to default on invalid value`() {
 330                 verifyThatPreferencesCanBeSet("posts-per-page", "invalid", 10) { core.preferences.postsPerPage }
 331         }
 332
 333         @Test
 334         fun `trust comment can be set`() {
 335                 verifyThatPreferencesCanBeSet("trust-comment", "trust", "trust") { core.preferences.trustComment }
 336         }
 337
 338         @Test
 339         fun `trust comment is set to default when set to empty value`() {
 340                 verifyThatPreferencesCanBeSet("trust-comment", "", "Set from Sone Web Interface") { core.preferences.trustComment }
 341         }
 342
 343 }