src/test/kotlin/net/pterodactylus/sone/web/pages/KnownSonesPageTest.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.Post
   6 import net.pterodactylus.sone.data.PostReply
   7 import net.pterodactylus.sone.data.Profile
   8 import net.pterodactylus.sone.data.Sone
   9 import net.pterodactylus.sone.freenet.wot.Identity
  10 import net.pterodactylus.sone.freenet.wot.OwnIdentity
  11 import net.pterodactylus.sone.test.mock
  12 import net.pterodactylus.sone.test.whenever
  13 import net.pterodactylus.sone.utils.Pagination
  14 import org.hamcrest.MatcherAssert.assertThat
  15 import org.hamcrest.Matchers.contains
  16 import org.hamcrest.Matchers.equalTo
  17 import org.junit.Before
  18 import org.junit.Test
  19
  20 /**
  21  * Unit test for [KnownSonesPage].
  22  */
  23 class KnownSonesPageTest: WebPageTest() {
  24
  25         private val page = KnownSonesPage(template, webInterface)
  26
  27         private val sones = listOf(
  28                         createSone(1000, 4, 7, 2, "sone2", true, true),
  29                         createSone(2000, 3, 2, 3, "Sone1", false, true),
  30                         createSone(3000, 3, 8, 1, "Sone3", true, false),
  31                         createSone(4000, 1, 6, 0, "sone0", false, false)
  32         )
  33
  34         @Before
  35         fun setupSones() {
  36                 addSone("sone1", sones[0])
  37                 addSone("sone2", sones[1])
  38                 addSone("sone3", sones[2])
  39                 addSone("sone4", sones[3])
  40         }
  41
  42         private fun createSone(time: Long, posts: Int, replies: Int, images: Int, name: String, local: Boolean, new: Boolean) = mock<Sone>().apply {
  43                 whenever(identity).thenReturn(if (local) mock<OwnIdentity>() else mock<Identity>())
  44                 whenever(this.isLocal).thenReturn(local)
  45                 whenever(isKnown).thenReturn(!new)
  46                 whenever(this.time).thenReturn(time)
  47                 whenever(this.posts).thenReturn((0..(posts - 1)).map { mock<Post>() })
  48                 whenever(this.replies).thenReturn((0..(replies - 1)).map { mock<PostReply>() }.toSet())
  49                 val album = mock<Album>()
  50                 whenever(album.images).thenReturn(((0..(images - 1)).map { mock<Image>() }))
  51                 val rootAlbum = mock<Album>().apply {
  52                         whenever(albums).thenReturn(listOf(album))
  53                 }
  54                 whenever(this.rootAlbum).thenReturn(rootAlbum)
  55                 whenever(this.profile).thenReturn(mock<Profile>())
  56                 whenever(id).thenReturn(name.toLowerCase())
  57                 whenever(this.name).thenReturn(name)
  58         }
  59
  60         private fun verifySonesAreInOrder(vararg indices: Int) {
  61                 @Suppress("UNCHECKED_CAST")
  62                 assertThat(templateContext["knownSones"] as Iterable<Sone>, contains(
  63                                 *indices.map { sones[it] }.toTypedArray()
  64                 ))
  65         }
  66
  67         private fun verifyStoredFields(sort: String, order: String, filter: String) {
  68                 assertThat(templateContext["sort"], equalTo<Any>(sort))
  69                 assertThat(templateContext["order"], equalTo<Any>(order))
  70                 assertThat(templateContext["filter"], equalTo<Any>(filter))
  71         }
  72
  73         @Test
  74         fun `page returns correct path`() {
  75                 assertThat(page.path, equalTo("knownSones.html"))
  76         }
  77
  78         @Test
  79         fun `page does not require login`() {
  80                 assertThat(page.requiresLogin(), equalTo(false))
  81         }
  82
  83         @Test
  84         fun `page returns correct title`() {
  85                 whenever(l10n.getString("Page.KnownSones.Title")).thenReturn("known sones page title")
  86                 assertThat(page.getPageTitle(freenetRequest), equalTo("known sones page title"))
  87         }
  88
  89         @Test
  90         fun `default known sones are sorted newest first`() {
  91                 page.processTemplate(freenetRequest, templateContext)
  92                 verifySonesAreInOrder(3, 2, 1, 0)
  93                 verifyStoredFields("activity", "desc", "")
  94         }
  95
  96         @Test
  97         fun `known sones can be sorted by oldest first`() {
  98                 addHttpRequestParameter("order", "asc")
  99                 page.processTemplate(freenetRequest, templateContext)
 100                 verifySonesAreInOrder(0, 1, 2, 3)
 101                 verifyStoredFields("activity", "asc", "")
 102         }
 103
 104         @Test
 105         fun `known sones can be sorted by posts, most posts first`() {
 106                 addHttpRequestParameter("sort", "posts")
 107                 page.processTemplate(freenetRequest, templateContext)
 108                 verifySonesAreInOrder(0, 2, 1, 3)
 109                 verifyStoredFields("posts", "desc", "")
 110         }
 111
 112         @Test
 113         fun `known sones can be sorted by posts, least posts first`() {
 114                 addHttpRequestParameter("sort", "posts")
 115                 addHttpRequestParameter("order", "asc")
 116                 page.processTemplate(freenetRequest, templateContext)
 117                 verifySonesAreInOrder(3, 1, 2, 0)
 118                 verifyStoredFields("posts", "asc", "")
 119         }
 120
 121         @Test
 122         fun `known sones can be sorted by images, most images first`() {
 123                 addHttpRequestParameter("sort", "images")
 124                 page.processTemplate(freenetRequest, templateContext)
 125                 verifySonesAreInOrder(1, 0, 2, 3)
 126                 verifyStoredFields("images", "desc", "")
 127         }
 128
 129         @Test
 130         fun `known sones can be sorted by images, least images first`() {
 131                 addHttpRequestParameter("sort", "images")
 132                 addHttpRequestParameter("order", "asc")
 133                 page.processTemplate(freenetRequest, templateContext)
 134                 verifySonesAreInOrder(3, 2, 0, 1)
 135                 verifyStoredFields("images", "asc", "")
 136         }
 137
 138         @Test
 139         fun `known sones can be sorted by nice name, ascending`() {
 140                 addHttpRequestParameter("sort", "name")
 141                 addHttpRequestParameter("order", "asc")
 142                 page.processTemplate(freenetRequest, templateContext)
 143                 verifySonesAreInOrder(3, 1, 0, 2)
 144                 verifyStoredFields("name", "asc", "")
 145         }
 146
 147         @Test
 148         fun `known sones can be sorted by nice name, descending`() {
 149                 addHttpRequestParameter("sort", "name")
 150                 page.processTemplate(freenetRequest, templateContext)
 151                 verifySonesAreInOrder(2, 0, 1, 3)
 152                 verifyStoredFields("name", "desc", "")
 153         }
 154
 155         @Test
 156         fun `known sones can be filtered by local sones`() {
 157                 addHttpRequestParameter("filter", "own")
 158                 page.processTemplate(freenetRequest, templateContext)
 159                 verifySonesAreInOrder(2, 0)
 160                 verifyStoredFields("activity", "desc", "own")
 161         }
 162
 163         @Test
 164         fun `known sones can be filtered by non-local sones`() {
 165                 addHttpRequestParameter("filter", "not-own")
 166                 page.processTemplate(freenetRequest, templateContext)
 167                 verifySonesAreInOrder(3, 1)
 168                 verifyStoredFields("activity", "desc", "not-own")
 169         }
 170
 171         @Test
 172         fun `known sones can be filtered by new sones`() {
 173                 addHttpRequestParameter("filter", "new")
 174                 page.processTemplate(freenetRequest, templateContext)
 175                 verifySonesAreInOrder(1, 0)
 176                 verifyStoredFields("activity", "desc", "new")
 177         }
 178
 179         @Test
 180         fun `known sones can be filtered by known sones`() {
 181                 addHttpRequestParameter("filter", "not-new")
 182                 page.processTemplate(freenetRequest, templateContext)
 183                 verifySonesAreInOrder(3, 2)
 184                 verifyStoredFields("activity", "desc", "not-new")
 185         }
 186
 187         @Test
 188         fun `known sones can be filtered by followed sones`() {
 189                 addHttpRequestParameter("filter", "followed")
 190                 listOf("sone1", "sone3").forEach { whenever(currentSone.hasFriend(it)).thenReturn(true) }
 191                 page.processTemplate(freenetRequest, templateContext)
 192                 verifySonesAreInOrder(2, 1)
 193                 verifyStoredFields("activity", "desc", "followed")
 194         }
 195
 196         @Test
 197         fun `known sones can be filtered by not-followed sones`() {
 198                 addHttpRequestParameter("filter", "not-followed")
 199                 listOf("sone1", "sone3").forEach { whenever(currentSone.hasFriend(it)).thenReturn(true) }
 200                 page.processTemplate(freenetRequest, templateContext)
 201                 verifySonesAreInOrder(3, 0)
 202                 verifyStoredFields("activity", "desc", "not-followed")
 203         }
 204
 205         @Test
 206         fun `known sones can not be filtered by followed sones if there is no current sone`() {
 207                 addHttpRequestParameter("filter", "followed")
 208                 unsetCurrentSone()
 209                 page.processTemplate(freenetRequest, templateContext)
 210                 verifySonesAreInOrder(3, 2, 1, 0)
 211                 verifyStoredFields("activity", "desc", "followed")
 212         }
 213
 214         @Test
 215         fun `known sones can not be filtered by not-followed sones if there is no current sone`() {
 216                 addHttpRequestParameter("filter", "not-followed")
 217                 unsetCurrentSone()
 218                 page.processTemplate(freenetRequest, templateContext)
 219                 verifySonesAreInOrder(3, 2, 1, 0)
 220                 verifyStoredFields("activity", "desc", "not-followed")
 221         }
 222
 223         @Test
 224         fun `pagination is set in template context`() {
 225                 page.processTemplate(freenetRequest, templateContext)
 226                 @Suppress("UNCHECKED_CAST")
 227                 assertThat((templateContext["pagination"] as Pagination<Sone>).items, contains(*listOf(3, 2, 1, 0).map { sones[it] }.toTypedArray()))
 228         }
 229
 230 }