import net.pterodactylus.sone.main.SonePlugin
import net.pterodactylus.sone.test.mock
import net.pterodactylus.sone.test.whenever
-import net.pterodactylus.sone.web.pages.SoneTemplatePage
-import net.pterodactylus.sone.web.page.FreenetRequest
+import net.pterodactylus.sone.web.page.*
import net.pterodactylus.util.notify.Notification
import net.pterodactylus.util.template.TemplateContext
import net.pterodactylus.util.version.Version
-import net.pterodactylus.util.web.Method.GET
import org.hamcrest.Matcher
import org.hamcrest.MatcherAssert.assertThat
import org.hamcrest.Matchers.anyOf
import org.hamcrest.Matchers.equalTo
import org.hamcrest.Matchers.nullValue
import org.junit.Test
-import org.mockito.Mockito.verify
/**
* Unit test for [SoneTemplatePage].
*/
-class SoneTemplatePageTest : WebPageTest() {
+class SoneTemplatePageTest : WebPageTest({ webInterface, loaders, templateRenderer -> object : SoneTemplatePage("path.html", webInterface, loaders, templateRenderer, requiresLogin = true) {} }) {
- private val preferences by lazy { core.preferences!! }
- private val page = object : SoneTemplatePage("path.html", template, webInterface, true) {}
-
- @Test
- fun `current sone is retrieved from web interface`() {
- assertThat(page.getCurrentSone(toadletContext), equalTo(currentSone))
- }
-
- @Test
- fun `retrieving current sone without creation is forwarded to web interface`() {
- mock<Sone>().let {
- whenever(webInterface.getCurrentSoneWithoutCreatingSession(toadletContext)).thenReturn(it)
- assertThat(page.getCurrentSoneWithoutCreatingSession(toadletContext), equalTo(it))
- }
- }
-
- @Test
- fun `setting the current sone is forwarded to web interface`() {
- mock<Sone>().let {
- page.setCurrentSone(toadletContext, it)
- verify(webInterface).setCurrentSone(toadletContext, it)
- }
+ init {
+ request("index.html")
}
@Test
fun `page title is empty string if no page title key was given`() {
- SoneTemplatePage("path.html", template, null, webInterface).let { page ->
- assertThat(page.getPageTitle(freenetRequest), equalTo(""))
+ SoneTemplatePage("path.html", webInterface, loaders, templateRenderer, requiresLogin = false).let { page ->
+ assertThat(page.getPageTitle(soneRequest), equalTo(""))
}
}
@Test
fun `page title is retrieved from l10n if page title key is given`() {
- SoneTemplatePage("path.html", template, "page.title", webInterface).let { page ->
+ SoneTemplatePage("path.html", webInterface, loaders, templateRenderer, pageTitleKey = "page.title", requiresLogin = false).let { page ->
whenever(l10n.getString("page.title")).thenReturn("Page Title")
- assertThat(page.getPageTitle(freenetRequest), equalTo("Page Title"))
+ assertThat(page.getPageTitle(soneRequest), equalTo("Page Title"))
}
}
assertThat(page.shortcutIcon, equalTo("images/icon.png"))
}
- @Test
- fun `page requires login if require login was specified in the constructor`() {
- SoneTemplatePage("path.html", template, webInterface, true).let { page ->
- assertThat(page.requiresLogin(), equalTo(true))
- }
- }
-
- @Test
- fun `page does not require login if require login was not specified in the constructor`() {
- SoneTemplatePage("path.html", template, webInterface, false).let { page ->
- assertThat(page.requiresLogin(), equalTo(false))
- }
- }
-
private fun verifyVariableIsSet(name: String, value: Any) = verifyVariableMatches(name, equalTo<Any>(value))
private fun <T> verifyVariableMatches(name: String, matcher: Matcher<T>) {
@Test
fun `preferences are set in template context`() {
- verifyVariableIsSet("preferences", preferences)
+ verifyVariableIsSet("preferences", preferences)
}
@Test
@Test
fun `local sones are set in template context`() {
- val localSones = listOf(mock<Sone>(), mock<Sone>())
+ val localSones = listOf(mock<Sone>(), mock())
whenever(core.localSones).thenReturn(localSones)
verifyVariableMatches("localSones", containsInAnyOrder(*localSones.toTypedArray()))
}
@Test
fun `handleRequest method is called`() {
var called = false
- val page = object : SoneTemplatePage("path.html", template, webInterface, true) {
- override fun handleRequest(request: FreenetRequest, templateContext: TemplateContext) {
+ val page = object : SoneTemplatePage("path.html", webInterface, loaders, templateRenderer, requiresLogin = true) {
+ override fun handleRequest(freenetRequest: FreenetRequest, templateContext: TemplateContext) {
called = true
}
}
@Test
fun `redirect does not happen if login is not required`() {
- val page = SoneTemplatePage("page.html", template, webInterface, false)
+ val page = SoneTemplatePage("page.html", webInterface, loaders, templateRenderer, requiresLogin = false)
assertThat(page.getRedirectTarget(freenetRequest), nullValue())
}
@Test
fun `redirect does happen if sone is not logged in`() {
unsetCurrentSone()
- request("index.html", GET)
assertThat(page.getRedirectTarget(freenetRequest), equalTo("login.html?target=index.html"))
}
@Test
fun `redirect does happen with parameters encoded correctly if sone is not logged in`() {
unsetCurrentSone()
- request("index.html", GET)
addHttpRequestParameter("foo", "b=r")
addHttpRequestParameter("baz", "q&o")
assertThat(page.getRedirectTarget(freenetRequest), anyOf(
}
@Test
- fun `full access requirement is correctly forwarded from the preferences if false`() {
- assertThat(page.isFullAccessOnly, equalTo(false))
- }
-
- @Test
- fun `full access requirement is correctly forwarded from the preferences if true`() {
- core.preferences.isRequireFullAccess = true
- assertThat(page.isFullAccessOnly, equalTo(true))
- }
-
- @Test
fun `page is disabled if full access is required but request does not have full access`() {
- core.preferences.isRequireFullAccess = true
+ core.preferences.newRequireFullAccess = true
assertThat(page.isEnabled(toadletContext), equalTo(false))
}
@Test
fun `page is enabled if full access is required and request has full access and login is required and there is a current sone`() {
- core.preferences.isRequireFullAccess = true
+ core.preferences.newRequireFullAccess = true
whenever(toadletContext.isAllowedFullAccess).thenReturn(true)
assertThat(page.isEnabled(toadletContext), equalTo(true))
}
@Test
fun `page is enabled if no full access is required and login is not required`() {
- SoneTemplatePage("path.html", template, webInterface, false).let { page ->
+ SoneTemplatePage("path.html", webInterface, loaders, templateRenderer, requiresLogin = false).let { page ->
assertThat(page.isEnabled(toadletContext), equalTo(true))
}
}
+ @Test
+ fun `handle request with sone request is called`() {
+ var called = false
+ val page = object : SoneTemplatePage("path.html", webInterface, loaders, templateRenderer) {
+ override fun handleRequest(soneRequest: SoneRequest, templateContext: TemplateContext) {
+ called = true
+ }
+ }
+ page.processTemplate(freenetRequest, templateContext)
+ assertThat(called, equalTo(true))
+ }
+
}
projects / Sone.git / blobdiff