Replace known Sones page with Kotlin version
[Sone.git] / src / test / kotlin / net / pterodactylus / sone / web / pages / LoginPageTest.kt
1 package net.pterodactylus.sone.web.pages
2
3 import net.pterodactylus.sone.data.Sone
4 import net.pterodactylus.sone.freenet.wot.Identity
5 import net.pterodactylus.sone.freenet.wot.OwnIdentity
6 import net.pterodactylus.sone.test.mock
7 import net.pterodactylus.sone.test.thenReturnMock
8 import net.pterodactylus.sone.test.whenever
9 import net.pterodactylus.sone.web.pages.WebPageTest
10 import net.pterodactylus.sone.web.pages.LoginPage
11 import net.pterodactylus.util.web.Method.GET
12 import net.pterodactylus.util.web.Method.POST
13 import org.hamcrest.MatcherAssert.assertThat
14 import org.hamcrest.Matchers.contains
15 import org.hamcrest.Matchers.containsInAnyOrder
16 import org.hamcrest.Matchers.equalTo
17 import org.hamcrest.Matchers.nullValue
18 import org.junit.Before
19 import org.junit.Test
20 import org.mockito.Mockito.verify
21
22 /**
23  * Unit test for [LoginPage].
24  */
25 class LoginPageTest : WebPageTest() {
26
27         private val page = LoginPage(template, webInterface)
28
29         private val sones = listOf(createSone("Sone", "Test"), createSone("Test"), createSone("Sone"))
30
31         override fun getPage() = page
32
33         private fun createSone(vararg contexts: String) = mock<Sone>().apply {
34                 whenever(id).thenReturn(hashCode().toString())
35                 val identity = mock<OwnIdentity>().apply {
36                         whenever(this.contexts).thenReturn(contexts.toSet())
37                         contexts.forEach { whenever(hasContext(it)).thenReturn(true) }
38                 }
39                 whenever(this.identity).thenReturn(identity)
40                 whenever(profile).thenReturnMock()
41         }
42
43         @Before
44         fun setupSones() {
45                 addLocalSone("sone1", sones[0])
46                 addLocalSone("sone2", sones[1])
47                 addLocalSone("sone3", sones[2])
48                 addOwnIdentity(sones[0].identity as OwnIdentity)
49                 addOwnIdentity(sones[1].identity as OwnIdentity)
50                 addOwnIdentity(sones[2].identity as OwnIdentity)
51         }
52
53         @Test
54         fun `page returns correct path`() {
55             assertThat(page.path, equalTo("login.html"))
56         }
57
58         @Test
59         fun `page does not require login`() {
60             assertThat(page.requiresLogin(), equalTo(false))
61         }
62
63         @Test
64         @Suppress("UNCHECKED_CAST")
65         fun `get request stores sones in template context`() {
66                 request("", GET)
67                 page.processTemplate(freenetRequest, templateContext)
68                 assertThat(templateContext["sones"] as Iterable<Sone>, containsInAnyOrder(sones[0], sones[1], sones[2]))
69         }
70
71         @Test
72         @Suppress("UNCHECKED_CAST")
73         fun `get request stores identities without sones in template context`() {
74                 request("", GET)
75                 page.processTemplate(freenetRequest, templateContext)
76                 assertThat(templateContext["identitiesWithoutSone"] as Iterable<Identity>, contains(sones[1].identity))
77         }
78
79         @Test
80         @Suppress("UNCHECKED_CAST")
81         fun `post request with invalid sone sets sones and identities without sone in template context`() {
82                 request("", POST)
83                 page.processTemplate(freenetRequest, templateContext)
84                 assertThat(templateContext["sones"] as Iterable<Sone>, containsInAnyOrder(sones[0], sones[1], sones[2]))
85                 assertThat(templateContext["identitiesWithoutSone"] as Iterable<Identity>, contains(sones[1].identity))
86         }
87
88         @Test
89         fun `post request with valid sone logs in the sone and redirects to index page`() {
90                 request("", POST)
91                 addHttpRequestPart("sone-id", "sone2")
92                 verifyRedirect("index.html") {
93                         verify(webInterface).setCurrentSone(toadletContext, sones[1])
94                 }
95         }
96
97         @Test
98         fun `post request with valid sone and target redirects to target page`() {
99                 request("", POST)
100                 addHttpRequestPart("sone-id", "sone2")
101                 addHttpRequestParameter("target", "foo.html")
102                 verifyRedirect("foo.html") {
103                         verify(webInterface).setCurrentSone(toadletContext, sones[1])
104                 }
105         }
106
107         @Test
108         fun `redirect to index html if a sone is logged in`() {
109                 assertThat(page.getRedirectTarget(freenetRequest), equalTo("index.html"))
110         }
111
112         @Test
113         fun `do not redirect if no sone is logged in`() {
114                 unsetCurrentSone()
115                 assertThat(page.getRedirectTarget(freenetRequest), nullValue())
116         }
117
118         @Test
119         fun `page is not enabled if full access required and request is not full access`() {
120                 core.preferences.isRequireFullAccess = true
121                 assertThat(page.isEnabled(toadletContext), equalTo(false))
122         }
123
124         @Test
125         fun `page is enabled if no full access is required and there is no current sone`() {
126                 unsetCurrentSone()
127                 assertThat(page.isEnabled(toadletContext), equalTo(true))
128         }
129
130         @Test
131         fun `page is not enabled if no full access is required but there is a current sone`() {
132                 assertThat(page.isEnabled(toadletContext), equalTo(false))
133         }
134
135         @Test
136         fun `page is enabled if full access required and request is full access and there is no current sone`() {
137                 core.preferences.isRequireFullAccess = true
138                 unsetCurrentSone()
139                 whenever(toadletContext.isAllowedFullAccess).thenReturn(true)
140                 assertThat(page.isEnabled(toadletContext), equalTo(true))
141         }
142
143         @Test
144         fun `page is not enabled if full access required and request is full access but there is a current sone`() {
145                 core.preferences.isRequireFullAccess = true
146                 whenever(toadletContext.isAllowedFullAccess).thenReturn(true)
147                 assertThat(page.isEnabled(toadletContext), equalTo(false))
148         }
149
150 }