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