src/test/kotlin/net/pterodactylus/sone/web/ajax/GetStatusAjaxPageTest.kt

   1 package net.pterodactylus.sone.web.ajax
   2
   3 import com.fasterxml.jackson.databind.JsonNode
   4 import net.pterodactylus.sone.data.Sone
   5 import net.pterodactylus.sone.data.Sone.SoneStatus.downloading
   6 import net.pterodactylus.sone.data.Sone.SoneStatus.inserting
   7 import net.pterodactylus.sone.freenet.L10nFilter
   8 import net.pterodactylus.sone.freenet.L10nText
   9 import net.pterodactylus.sone.test.deepMock
  10 import net.pterodactylus.sone.test.mock
  11 import net.pterodactylus.sone.test.whenever
  12 import net.pterodactylus.sone.text.TimeText
  13 import net.pterodactylus.sone.text.TimeTextConverter
  14 import net.pterodactylus.sone.utils.jsonArray
  15 import net.pterodactylus.util.notify.Notification
  16 import org.hamcrest.MatcherAssert.assertThat
  17 import org.hamcrest.Matchers.allOf
  18 import org.hamcrest.Matchers.containsInAnyOrder
  19 import org.hamcrest.Matchers.emptyIterable
  20 import org.hamcrest.Matchers.equalTo
  21 import org.hamcrest.Matchers.hasEntry
  22 import org.junit.Before
  23 import org.junit.Test
  24 import org.mockito.ArgumentMatchers.any
  25 import org.mockito.ArgumentMatchers.anyLong
  26 import java.util.TimeZone
  27
  28 /**
  29  * Unit test for [GetStatusAjaxPage].
  30  */
  31 class GetStatusAjaxPageTest: JsonPageTest() {
  32
  33         private val timeTextConverter = mock<TimeTextConverter>()
  34         private val l10nFilter = mock<L10nFilter>()
  35         override var page: JsonPage = GetStatusAjaxPage(webInterface, elementLoader, timeTextConverter, l10nFilter, TimeZone.getTimeZone("UTC"))
  36
  37         @Before
  38         fun setupTimeTextConverter() {
  39                 whenever(timeTextConverter.getTimeText(anyLong())).thenAnswer { TimeText(L10nText(it.getArgument<Long>(0).toString()), it.getArgument(0)) }
  40                 whenever(l10nFilter.format(any(), any(), any())).thenAnswer { it.getArgument<L10nText>(1).text }
  41         }
  42
  43         @Test
  44         fun `page returns correct path`() {
  45                 assertThat(page.path, equalTo("getStatus.ajax"))
  46         }
  47
  48         @Test
  49         fun `page does not require form password`() {
  50                 assertThat(page.needsFormPassword(), equalTo(false))
  51         }
  52
  53         @Test
  54         fun `page does not require login`() {
  55                 assertThat(page.requiresLogin(), equalTo(false))
  56         }
  57
  58         @Test
  59         fun `page returns correct attribute “loggedIn” if sone is logged in`() {
  60                 assertThat(json.get("loggedIn").asText(), equalTo("true"))
  61         }
  62
  63         @Test
  64         fun `page returns correct attribute “loggedIn” if sone is not logged in`() {
  65                 unsetCurrentSone()
  66                 assertThat(json.get("loggedIn").asText(), equalTo("false"))
  67         }
  68
  69         @Test
  70         fun `page returns options for sone if sone is logged in`() {
  71                 assertThat(json.get("options").toMap(), allOf(
  72                                 hasEntry("ShowNotification/NewSones", "false"),
  73                                 hasEntry("ShowNotification/NewPosts", "false"),
  74                                 hasEntry("ShowNotification/NewReplies", "false")
  75                 ))
  76         }
  77
  78         @Test
  79         fun `page returns empty options if sone is not logged in`() {
  80                 unsetCurrentSone()
  81                 assertThat(json.get("options"), emptyIterable())
  82         }
  83
  84         @Test
  85         fun `page returns empty sones object if no sone is logged in and no sones parameter is given`() {
  86                 unsetCurrentSone()
  87                 assertThat(json.get("sones"), emptyIterable())
  88         }
  89
  90         @Test
  91         fun `page returns a sones object with the current sone if not other sones parameter is given`() {
  92                 assertThat(json.get("sones").elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
  93                                 mapOf<String, String?>("id" to "soneId", "name" to "Sone_Id", "local" to "true", "status" to "idle", "modified" to "false", "locked" to "false", "lastUpdatedUnknown" to "false", "lastUpdated" to "Jan 1, 1970, 00:00:01", "lastUpdatedText" to "1000")
  94                 ))
  95         }
  96
  97         @Test
  98         fun `page returns some sones objects with the current sone and some sones given as sones parameter`() {
  99                 addSone(deepMock<Sone>().mock("sone1", "Sone 1", false, 2000, downloading))
 100                 addSone(deepMock<Sone>().mock("sone3", "Sone 3", true, 3000, inserting))
 101                 addRequestParameter("soneIds", "sone1,sone2,sone3")
 102                 assertThat(json.get("sones").elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
 103                                 mapOf<String, String?>("id" to "soneId", "name" to "Sone_Id", "local" to "true", "status" to "idle", "modified" to "false", "locked" to "false", "lastUpdatedUnknown" to "false", "lastUpdated" to "Jan 1, 1970, 00:00:01", "lastUpdatedText" to "1000"),
 104                                 mapOf("id" to "sone1", "name" to "Sone 1", "local" to "false", "status" to "downloading", "modified" to "false", "locked" to "false", "lastUpdatedUnknown" to "false", "lastUpdated" to "Jan 1, 1970, 00:00:02", "lastUpdatedText" to "2000"),
 105                                 mapOf("id" to "sone3", "name" to "Sone 3", "local" to "true", "status" to "inserting", "modified" to "false", "locked" to "false", "lastUpdatedUnknown" to "false", "lastUpdated" to "Jan 1, 1970, 00:00:03", "lastUpdatedText" to "3000")
 106                 ))
 107         }
 108
 109         @Test
 110         fun `page returns correct notifications hash`() {
 111                 val notifications = listOf(
 112                                 mock<Notification>().apply { whenever(this.createdTime).thenReturn(2000) },
 113                                 mock<Notification>().apply { whenever(this.createdTime).thenReturn(1000) }
 114                 )
 115                 addNotification(*notifications.toTypedArray())
 116                 assertThat(json.get("notificationHash").asInt(), equalTo(notifications.sortedBy { it.createdTime }.hashCode()))
 117         }
 118
 119         @Test
 120         fun `page returns new posts`() {
 121                 addNewPost("post1", "sone1", 1000)
 122                 addNewPost("post2", "sone2", 2000, "sone1")
 123                 assertThat(json.get("newPosts").elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
 124                                 mapOf("id" to "post1", "sone" to "sone1", "time" to "1000", "recipient" to null),
 125                                 mapOf("id" to "post2", "sone" to "sone2", "time" to "2000", "recipient" to "sone1")
 126                 ))
 127         }
 128
 129         @Test
 130         fun `page returns new replies`() {
 131                 addNewReply("reply1", "sone1", "post1", "sone11")
 132                 addNewReply("reply2", "sone2", "post2", "sone22")
 133                 assertThat(json.get("newReplies").elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
 134                                 mapOf<String, String?>("id" to "reply1", "sone" to "sone1", "post" to "post1", "postSone" to "sone11"),
 135                                 mapOf("id" to "reply2", "sone" to "sone2", "post" to "post2", "postSone" to "sone22")
 136                 ))
 137         }
 138
 139         @Test
 140         fun `page returns information about loaded elements`() {
 141                 addLinkedElement("KSK@test.png", loading = false, failed = false)
 142                 addLinkedElement("KSK@test.html", loading = true, failed = false)
 143                 addLinkedElement("KSK@test.jpeg", loading = false, failed = true)
 144                 addRequestParameter("elements", jsonArray("KSK@test.png", "KSK@test.html", "KSK@test.jpeg").toString())
 145                 assertThat(json.get("linkedElements").elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
 146                                 mapOf<String, String?>("link" to "KSK@test.png", "loading" to "false", "failed" to "false"),
 147                                 mapOf("link" to "KSK@test.html", "loading" to "true", "failed" to "false"),
 148                                 mapOf("link" to "KSK@test.jpeg", "loading" to "false", "failed" to "true")
 149                 ))
 150         }
 151
 152         private fun JsonNode.toMap() = fields().asSequence().map { it.key!! to if (it.value.isNull) null else it.value.asText()!! }.toMap()
 153
 154 }