src/test/kotlin/net/pterodactylus/sone/web/ajax/JsonPageBaseTest.kt

   1 package net.pterodactylus.sone.web.ajax
   2
   3 import net.pterodactylus.sone.core.Preferences
   4 import net.pterodactylus.sone.test.whenever
   5 import net.pterodactylus.sone.web.page.FreenetRequest
   6 import net.pterodactylus.util.web.Response
   7 import org.hamcrest.MatcherAssert.assertThat
   8 import org.hamcrest.Matchers.containsString
   9 import org.hamcrest.Matchers.equalTo
  10 import org.junit.Before
  11 import org.junit.Test
  12 import java.io.ByteArrayOutputStream
  13 import java.util.concurrent.atomic.AtomicInteger
  14
  15 /**
  16  * Unit test for [JsonPage].
  17  */
  18 class JsonPageBaseTest : TestObjects() {
  19
  20         private var needsFormPassword = false
  21         private val pageCallCounter = AtomicInteger()
  22         private var pageResponse = { JsonReturnObject(true).put("foo", "bar") }
  23         private val outputStream = ByteArrayOutputStream()
  24         private val response = Response(outputStream)
  25
  26         private val page = object : JsonPage("path.html", webInterface) {
  27
  28                 override val needsFormPassword get() = this@JsonPageBaseTest.needsFormPassword
  29
  30                 override fun createJsonObject(request: FreenetRequest) =
  31                                 pageResponse().also { pageCallCounter.incrementAndGet() }
  32
  33         }
  34
  35         @Before
  36         fun setupWebInterface() {
  37                 whenever(webInterface.core).thenReturn(core)
  38         }
  39
  40         @Before
  41         fun setupCore() {
  42                 whenever(core.preferences).thenReturn(Preferences(eventBus))
  43         }
  44
  45         @Before
  46         fun setupFreenetRequest() {
  47                 whenever(freenetRequest.toadletContext).thenReturn(toadletContext)
  48         }
  49
  50         @Test
  51         fun `page returns 403 is full access is required but request is not full access`() {
  52                 core.preferences.isRequireFullAccess = true
  53                 page.handleRequest(freenetRequest, response)
  54                 assertThat(response.statusCode, equalTo(403))
  55                 assertThat(response.statusText, equalTo("Forbidden"))
  56                 assertThat(response.contentType, equalTo("application/json"))
  57                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to false, "error" to "auth-required")))
  58         }
  59
  60         @Test
  61         fun `page returns 403 if form password is needed but not supplied`() {
  62                 needsFormPassword = true
  63                 page.handleRequest(freenetRequest, response)
  64                 assertThat(response.statusCode, equalTo(403))
  65                 assertThat(response.statusText, equalTo("Forbidden"))
  66                 assertThat(response.contentType, equalTo("application/json"))
  67                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to false, "error" to "auth-required")))
  68         }
  69
  70         @Test
  71         fun `page returns 403 is form password is supplied but incorrect`() {
  72                 needsFormPassword = true
  73                 addRequestParameter("formPassword", formPassword + "_false")
  74                 page.handleRequest(freenetRequest, response)
  75                 assertThat(response.statusCode, equalTo(403))
  76                 assertThat(response.statusText, equalTo("Forbidden"))
  77                 assertThat(response.contentType, equalTo("application/json"))
  78                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to false, "error" to "auth-required")))
  79         }
  80
  81         @Test
  82         fun `page returns 200 if form password is required and correct`() {
  83                 needsFormPassword = true
  84                 addRequestParameter("formPassword", formPassword)
  85                 page.handleRequest(freenetRequest, response)
  86                 assertThat(response.statusCode, equalTo(200))
  87                 assertThat(response.statusText, equalTo("OK"))
  88                 assertThat(response.contentType, equalTo("application/json"))
  89                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to true, "foo" to "bar")))
  90         }
  91
  92         @Test
  93         fun `page returns 403 is login is required but current Sone is null`() {
  94                 unsetCurrentSone()
  95                 page.handleRequest(freenetRequest, response)
  96                 assertThat(response.statusCode, equalTo(403))
  97                 assertThat(response.statusText, equalTo("Forbidden"))
  98                 assertThat(response.contentType, equalTo("application/json"))
  99                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to false, "error" to "auth-required")))
 100         }
 101
 102         @Test
 103         fun `page returns content if login is required and current Sone is set`() {
 104                 page.handleRequest(freenetRequest, response)
 105                 assertThat(pageCallCounter.get(), equalTo(1))
 106                 assertThat(response.statusCode, equalTo(200))
 107                 assertThat(response.statusText, equalTo("OK"))
 108                 assertThat(response.contentType, equalTo("application/json"))
 109                 assertThat(outputStream.toString("UTF-8").asJson(), equalTo(mapOf("success" to true, "foo" to "bar")))
 110         }
 111
 112         @Test
 113         fun `page returns 500 if execution throws exception`() {
 114                 pageResponse = { throw IllegalStateException("some error occured") }
 115                 page.handleRequest(freenetRequest, response)
 116                 assertThat(response.statusCode, equalTo(500))
 117                 assertThat(response.statusText, equalTo("some error occured"))
 118                 assertThat(response.contentType, equalTo("text/plain"))
 119         }
 120
 121         @Test
 122         fun `page returns stack trace if execution throws exception`() {
 123                 pageResponse = { throw IllegalStateException() }
 124                 page.handleRequest(freenetRequest, response)
 125                 assertThat(outputStream.toString(), containsString("IllegalStateException"))
 126         }
 127
 128         @Test
 129         fun `json page is not a prefix page`() {
 130             assertThat(page.isPrefixPage, equalTo(false))
 131         }
 132
 133         private fun String.asJson() = objectMapper.readValue(this, Map::class.java) as Map<String, Any>
 134
 135 }