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

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