Simplify expression
[Sone.git] / 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("getStatus.ajax", requiresLogin = false, needsFormPassword = false) {
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 attribute “loggedIn” if sone is logged in`() {
45                 assertThat(json.get("loggedIn")?.asText(), equalTo("true"))
46         }
47
48         @Test
49         fun `page returns correct attribute “loggedIn” if sone is not logged in`() {
50                 unsetCurrentSone()
51                 assertThat(json.get("loggedIn")?.asText(), equalTo("false"))
52         }
53
54         @Test
55         fun `page returns options for sone if sone is logged in`() {
56                 assertThat(json.get("options")?.toMap(), allOf(
57                                 hasEntry("ShowNotification/NewSones", "true"),
58                                 hasEntry("ShowNotification/NewPosts", "true"),
59                                 hasEntry("ShowNotification/NewReplies", "true")
60                 ))
61         }
62
63         @Test
64         fun `page returns empty options if sone is not logged in`() {
65                 unsetCurrentSone()
66                 assertThat(json.get("options"), emptyIterable())
67         }
68
69         @Test
70         fun `page returns empty sones object if no sone is logged in and no sones parameter is given`() {
71                 unsetCurrentSone()
72                 assertThat(json.get("sones"), emptyIterable())
73         }
74
75         @Test
76         fun `page returns a sones object with the current sone if not other sones parameter is given`() {
77                 assertThat(json.get("sones")!!.elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
78                                 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")
79                 ))
80         }
81
82         @Test
83         fun `page returns some sones objects with the current sone and some sones given as sones parameter`() {
84                 addSone(deepMock<Sone>().mock("sone1", "Sone 1", false, 2000, downloading))
85                 addSone(deepMock<Sone>().mock("sone3", "Sone 3", true, 3000, inserting))
86                 addRequestParameter("soneIds", "sone1,sone2,sone3")
87                 assertThat(json.get("sones")!!.elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
88                                 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"),
89                                 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"),
90                                 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")
91                 ))
92         }
93
94         @Test
95         fun `page returns correct notifications hash`() {
96                 val notifications = listOf(
97                                 mock<Notification>().apply { whenever(this.createdTime).thenReturn(2000) },
98                                 mock<Notification>().apply { whenever(this.createdTime).thenReturn(1000) }
99                 )
100                 notifications.forEachIndexed { index, notification -> addNotification(notification, "notification$index")}
101                 assertThat(json.get("notificationHash")?.asInt(), equalTo(notifications.sortedBy { it.createdTime }.hashCode()))
102         }
103
104         @Test
105         fun `page returns new posts`() {
106                 addNewPost("post1", "sone1", 1000)
107                 addNewPost("post2", "sone2", 2000, "sone1")
108                 assertThat(json.get("newPosts")!!.elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
109                                 mapOf("id" to "post1", "sone" to "sone1", "time" to "1000", "recipient" to null),
110                                 mapOf("id" to "post2", "sone" to "sone2", "time" to "2000", "recipient" to "sone1")
111                 ))
112         }
113
114         @Test
115         fun `page returns new replies`() {
116                 addNewReply("reply1", "sone1", "post1", "sone11")
117                 addNewReply("reply2", "sone2", "post2", "sone22")
118                 assertThat(json.get("newReplies")!!.elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
119                                 mapOf<String, String?>("id" to "reply1", "sone" to "sone1", "post" to "post1", "postSone" to "sone11"),
120                                 mapOf("id" to "reply2", "sone" to "sone2", "post" to "post2", "postSone" to "sone22")
121                 ))
122         }
123
124         @Test
125         fun `page returns information about loaded elements`() {
126                 addLinkedElement("KSK@test.png", loading = false, failed = false)
127                 addLinkedElement("KSK@test.html", loading = true, failed = false)
128                 addLinkedElement("KSK@test.jpeg", loading = false, failed = true)
129                 addRequestParameter("elements", jsonArray("KSK@test.png", "KSK@test.html", "KSK@test.jpeg").toString())
130                 assertThat(json.get("linkedElements")!!.elements().asSequence().map { it.toMap() }.toList(), containsInAnyOrder(
131                                 mapOf<String, String?>("link" to "KSK@test.png", "loading" to "false", "failed" to "false"),
132                                 mapOf("link" to "KSK@test.html", "loading" to "true", "failed" to "false"),
133                                 mapOf("link" to "KSK@test.jpeg", "loading" to "false", "failed" to "true")
134                 ))
135         }
136
137         private fun JsonNode.toMap() = fields().asSequence().map { it.key!! to if (it.value.isNull) null else it.value.asText()!! }.toMap()
138
139 }