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

   1 package net.pterodactylus.sone.web.pages
   2
   3 import com.google.common.base.Optional.absent
   4 import net.pterodactylus.sone.data.Sone
   5 import net.pterodactylus.sone.test.getInstance
   6 import net.pterodactylus.sone.test.mock
   7 import net.pterodactylus.sone.utils.asOptional
   8 import net.pterodactylus.sone.web.baseInjector
   9 import net.pterodactylus.sone.web.page.*
  10 import net.pterodactylus.util.web.Method.POST
  11 import org.hamcrest.MatcherAssert.assertThat
  12 import org.hamcrest.Matchers.equalTo
  13 import org.hamcrest.Matchers.notNullValue
  14 import org.junit.Test
  15 import org.mockito.Mockito.verify
  16
  17 /**
  18  * Unit test for [CreatePostPage].
  19  */
  20 class CreatePostPageTest: WebPageTest(::CreatePostPage) {
  21
  22         @Test
  23         fun `page returns correct path`() {
  24                 assertThat(page.path, equalTo("createPost.html"))
  25         }
  26
  27         @Test
  28         fun `page requires login`() {
  29                 assertThat(page.requiresLogin(), equalTo(true))
  30         }
  31
  32         @Test
  33         fun `return page is set in template context`() {
  34                 addHttpRequestPart("returnPage", "return.html")
  35                 page.processTemplate(freenetRequest, templateContext)
  36                 assertThat(templateContext["returnPage"], equalTo<Any>("return.html"))
  37         }
  38
  39         @Test
  40         fun `post is created correctly`() {
  41                 setMethod(POST)
  42                 addHttpRequestPart("returnPage", "return.html")
  43                 addHttpRequestPart("text", "post text")
  44                 verifyRedirect("return.html") {
  45                         verify(core).createPost(currentSone, absent(), "post text")
  46                 }
  47         }
  48
  49         @Test
  50         fun `creating an empty post is denied`() {
  51                 setMethod(POST)
  52                 addHttpRequestPart("returnPage", "return.html")
  53                 addHttpRequestPart("text", "  ")
  54                 page.processTemplate(freenetRequest, templateContext)
  55                 assertThat(templateContext["errorTextEmpty"], equalTo<Any>(true))
  56         }
  57
  58         @Test
  59         fun `a sender can be selected`() {
  60                 setMethod(POST)
  61                 addHttpRequestPart("returnPage", "return.html")
  62                 addHttpRequestPart("text", "post text")
  63                 addHttpRequestPart("sender", "sender-id")
  64                 val sender = mock<Sone>()
  65                 addLocalSone("sender-id", sender)
  66                 verifyRedirect("return.html") {
  67                         verify(core).createPost(sender, absent(), "post text")
  68                 }
  69         }
  70
  71         @Test
  72         fun `a recipient can be selected`() {
  73                 setMethod(POST)
  74                 addHttpRequestPart("returnPage", "return.html")
  75                 addHttpRequestPart("text", "post text")
  76                 addHttpRequestPart("recipient", "recipient-id")
  77                 val recipient = mock<Sone>()
  78                 addSone("recipient-id", recipient)
  79                 verifyRedirect("return.html") {
  80                         verify(core).createPost(currentSone, recipient.asOptional(), "post text")
  81                 }
  82         }
  83
  84         @Test
  85         fun `text is filtered correctly`() {
  86                 setMethod(POST)
  87                 addHttpRequestPart("returnPage", "return.html")
  88                 addHttpRequestPart("text", "post http://localhost:12345/KSK@foo text")
  89                 addHttpRequestHeader("Host", "localhost:12345")
  90                 verifyRedirect("return.html") {
  91                         verify(core).createPost(currentSone, absent(), "post KSK@foo text")
  92                 }
  93         }
  94
  95         @Test
  96         fun `page can be created by dependency injection`() {
  97             assertThat(baseInjector.getInstance<CreatePostPage>(), notNullValue())
  98         }
  99
 100         @Test
 101         fun `page is annotated with correct template path`() {
 102             assertThat(page.templatePath, equalTo("/templates/createPost.html"))
 103         }
 104
 105 }