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

   1 package net.pterodactylus.sone.web.pages
   2
   3 import net.pterodactylus.sone.data.Sone
   4 import net.pterodactylus.sone.test.mock
   5 import net.pterodactylus.sone.test.whenever
   6 import net.pterodactylus.util.web.Method.POST
   7 import org.hamcrest.MatcherAssert.assertThat
   8 import org.hamcrest.Matchers.equalTo
   9 import org.junit.Test
  10 import org.mockito.ArgumentMatchers
  11 import org.mockito.ArgumentMatchers.any
  12 import org.mockito.ArgumentMatchers.anyString
  13 import org.mockito.Mockito.never
  14 import org.mockito.Mockito.verify
  15
  16 /**
  17  * Unit test for [FollowSonePage].
  18  */
  19 class FollowSonePageTest : WebPageTest() {
  20
  21         private val page = FollowSonePage(template, webInterface)
  22
  23         override fun getPage() = page
  24
  25         @Test
  26         fun `page returns correct path`() {
  27             assertThat(page.path, equalTo("followSone.html"))
  28         }
  29
  30         @Test
  31         fun `page requires login`() {
  32             assertThat(page.requiresLogin(), equalTo(true))
  33         }
  34
  35         @Test
  36         fun `page returns correct title`() {
  37             whenever(l10n.getString("Page.FollowSone.Title")).thenReturn("follow sone page title")
  38                 assertThat(page.getPageTitle(freenetRequest), equalTo("follow sone page title"))
  39         }
  40
  41         @Test
  42         fun `get request does not redirect`() {
  43                 page.processTemplate(freenetRequest, templateContext)
  44         }
  45
  46         @Test
  47         fun `a single sone can be followed`() {
  48                 setMethod(POST)
  49                 val sone = mock<Sone>()
  50                 addSone("sone-id", sone)
  51                 addHttpRequestPart("sone", "sone-id")
  52                 addHttpRequestPart("returnPage", "return.html")
  53                 verifyRedirect("return.html") {
  54                         verify(core).followSone(currentSone, "sone-id")
  55                         verify(core).markSoneKnown(sone)
  56                 }
  57         }
  58
  59         @Test
  60         fun `multiple sones can be followed`() {
  61                 setMethod(POST)
  62                 val firstSone = mock<Sone>()
  63                 addSone("sone-id1", firstSone)
  64                 val secondSone = mock<Sone>()
  65                 addSone("sone-id2", secondSone)
  66                 addHttpRequestPart("sone", "sone-id1,sone-id2")
  67                 addHttpRequestPart("returnPage", "return.html")
  68                 verifyRedirect("return.html") {
  69                         verify(core).followSone(currentSone, "sone-id1")
  70                         verify(core).followSone(currentSone, "sone-id2")
  71                         verify(core).markSoneKnown(firstSone)
  72                         verify(core).markSoneKnown(secondSone)
  73                 }
  74         }
  75
  76         @Test
  77         fun `a non-existing sone is not followed`() {
  78                 setMethod(POST)
  79                 addHttpRequestPart("sone", "sone-id")
  80                 addHttpRequestPart("returnPage", "return.html")
  81                 verifyRedirect("return.html") {
  82                         verify(core, never()).followSone(ArgumentMatchers.eq(currentSone), anyString())
  83                         verify(core, never()).markSoneKnown(any<Sone>())
  84                 }
  85         }
  86
  87 }