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

   1 package net.pterodactylus.sone.web.pages
   2
   3 import net.pterodactylus.sone.data.Album
   4 import net.pterodactylus.sone.data.Image
   5 import net.pterodactylus.sone.data.Sone
   6 import net.pterodactylus.sone.test.mock
   7 import net.pterodactylus.sone.test.whenever
   8 import net.pterodactylus.sone.web.pages.ImageBrowserPage
   9 import net.pterodactylus.sone.web.pages.WebPageTest
  10 import net.pterodactylus.util.web.Method.GET
  11 import org.hamcrest.MatcherAssert.assertThat
  12 import org.hamcrest.Matchers.contains
  13 import org.hamcrest.Matchers.equalTo
  14 import org.junit.Test
  15
  16 /**
  17  * Unit test for [ImageBrowserPage].
  18  */
  19 class ImageBrowserPageTest : WebPageTest() {
  20
  21         private val page = ImageBrowserPage(template, webInterface)
  22
  23         @Test
  24         fun `page returns correct path`() {
  25             assertThat(page.path, equalTo("imageBrowser.html"))
  26         }
  27
  28         @Test
  29         fun `page requires login`() {
  30             assertThat(page.requiresLogin(), equalTo(true))
  31         }
  32
  33         @Test
  34         fun `page returns correct title`() {
  35                 whenever(l10n.getString("Page.ImageBrowser.Title")).thenReturn("image browser page title")
  36             assertThat(page.getPageTitle(freenetRequest), equalTo("image browser page title"))
  37         }
  38
  39         @Test
  40         fun `get request with album sets album and page in template context`() {
  41                 request("", GET)
  42                 val album = mock<Album>()
  43                 addAlbum("album-id", album)
  44                 addHttpRequestParameter("album", "album-id")
  45                 addHttpRequestParameter("page", "5")
  46                 page.handleRequest(freenetRequest, templateContext)
  47                 assertThat(templateContext["albumRequested"], equalTo<Any>(true))
  48                 assertThat(templateContext["album"], equalTo<Any>(album))
  49                 assertThat(templateContext["page"], equalTo<Any>("5"))
  50         }
  51
  52         @Test
  53         fun `get request with image sets image in template context`() {
  54                 request("", GET)
  55                 val image = mock<Image>()
  56                 addImage("image-id", image)
  57                 addHttpRequestParameter("image", "image-id")
  58                 page.handleRequest(freenetRequest, templateContext)
  59                 assertThat(templateContext["imageRequested"], equalTo<Any>(true))
  60                 assertThat(templateContext["image"], equalTo<Any>(image))
  61         }
  62
  63         @Test
  64         fun `get request with sone sets sone in template context`() {
  65                 request("", GET)
  66                 val sone = mock<Sone>()
  67                 addSone("sone-id", sone)
  68                 addHttpRequestParameter("sone", "sone-id")
  69                 page.handleRequest(freenetRequest, templateContext)
  70                 assertThat(templateContext["soneRequested"], equalTo<Any>(true))
  71                 assertThat(templateContext["sone"], equalTo<Any>(sone))
  72         }
  73
  74         @Test
  75         fun `get request with mode of gallery sets albums and page in template context`() {
  76                 request("", GET)
  77                 val firstSone = createSone("first album", "second album")
  78                 addSone("sone1", firstSone)
  79                 val secondSone = createSone("third album", "fourth album")
  80                 addSone("sone2", secondSone)
  81                 addHttpRequestParameter("mode", "gallery")
  82                 page.handleRequest(freenetRequest, templateContext)
  83                 assertThat(templateContext["galleryRequested"], equalTo<Any>(true))
  84                 @Suppress("UNCHECKED_CAST")
  85                 assertThat(templateContext["albums"] as Iterable<Album>, contains(
  86                                 firstSone.rootAlbum.albums[0],
  87                                 secondSone.rootAlbum.albums[1],
  88                                 firstSone.rootAlbum.albums[1],
  89                                 secondSone.rootAlbum.albums[0]
  90                 ))
  91         }
  92
  93         private fun createSone(firstAlbumTitle: String, secondAlbumTitle: String): Sone {
  94                 return mock<Sone>().apply {
  95                         val rootAlbum = mock<Album>()
  96                         val firstAlbum = mock<Album>()
  97                         val firstImage = mock<Image>().run { whenever(isInserted).thenReturn(true); this }
  98                         whenever(firstAlbum.images).thenReturn(listOf(firstImage))
  99                         val secondAlbum = mock<Album>()
 100                         val secondImage = mock<Image>().run { whenever(isInserted).thenReturn(true); this }
 101                         whenever(secondAlbum.images).thenReturn(listOf(secondImage))
 102                         whenever(firstAlbum.title).thenReturn(firstAlbumTitle)
 103                         whenever(secondAlbum.title).thenReturn(secondAlbumTitle)
 104                         whenever(rootAlbum.albums).thenReturn(listOf(firstAlbum, secondAlbum))
 105                         whenever(this.rootAlbum).thenReturn(rootAlbum)
 106                 }
 107         }
 108
 109         @Test
 110         fun `requesting nothing will show the albums of the current sone`() {
 111                 request("", GET)
 112                 page.handleRequest(freenetRequest, templateContext)
 113                 assertThat(templateContext["soneRequested"], equalTo<Any>(true))
 114                 assertThat(templateContext["sone"], equalTo<Any>(currentSone))
 115         }
 116
 117         @Test
 118         fun `page is link-excepted`() {
 119             assertThat(page.isLinkExcepted(null), equalTo(true))
 120         }
 121
 122 }