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