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