src/test/kotlin/net/pterodactylus/sone/web/WebInterfaceModuleTest.kt

   1 package net.pterodactylus.sone.web
   2
   3 import com.google.inject.Guice.*
   4 import freenet.client.*
   5 import freenet.clients.http.*
   6 import freenet.l10n.*
   7 import freenet.support.api.*
   8 import net.pterodactylus.sone.core.*
   9 import net.pterodactylus.sone.data.*
  10 import net.pterodactylus.sone.database.*
  11 import net.pterodactylus.sone.freenet.*
  12 import net.pterodactylus.sone.freenet.wot.*
  13 import net.pterodactylus.sone.main.*
  14 import net.pterodactylus.sone.template.*
  15 import net.pterodactylus.sone.test.*
  16 import net.pterodactylus.sone.text.*
  17 import net.pterodactylus.sone.web.page.*
  18 import net.pterodactylus.util.template.*
  19 import net.pterodactylus.util.web.*
  20 import org.hamcrest.MatcherAssert.*
  21 import org.hamcrest.Matchers.*
  22 import org.junit.*
  23 import java.util.*
  24 import kotlin.test.Test
  25
  26 class WebInterfaceModuleTest {
  27
  28         private val webInterfaceModule = WebInterfaceModule()
  29         private val loaders = mock<Loaders>()
  30         private val translation = object : Translation {
  31                 override val currentLocale = Locale.ENGLISH
  32                 override fun translate(key: String) = if (key == "View.Sone.Text.UnknownDate") "unknown" else key
  33         }
  34         private val additionalModules = arrayOf(
  35                         Core::class.isProvidedByMock(),
  36                         SoneProvider::class.isProvidedByMock(),
  37                         Translation::class.isProvidedBy(translation),
  38                         SoneTextParser::class.isProvidedByMock(),
  39                         ElementLoader::class.isProvidedByMock(),
  40                         Loaders::class.isProvidedBy(loaders),
  41                         HighLevelSimpleClient::class.isProvidedByMock(),
  42                         SessionManager::class.isProvidedByMock()
  43         )
  44         private val injector = createInjector(webInterfaceModule, *additionalModules)!!
  45         private val templateContext by lazy { injector.getInstance<TemplateContextFactory>().createTemplateContext()!! }
  46
  47         @Test
  48         fun `template context factory creates template with reflection accessor for objects`() {
  49                 verifyAccessor<Any, ReflectionAccessor>()
  50         }
  51
  52         @Test
  53         fun `template context factory creates template with collection accessor for collections`() {
  54                 verifyAccessor<Collection<*>, CollectionAccessor>()
  55         }
  56
  57         @Test
  58         fun `template context contains sone accessor for sones`() {
  59                 verifyAccessor<Sone, SoneAccessor>()
  60         }
  61
  62         @Test
  63         fun `template context contains post accessor for posts`() {
  64                 verifyAccessor<Post, PostAccessor>()
  65         }
  66
  67         @Test
  68         fun `template context contains reply accessor for replies`() {
  69                 verifyAccessor<Reply<*>, ReplyAccessor>()
  70         }
  71
  72         @Test
  73         fun `template context contains album accessor for albums`() {
  74                 verifyAccessor<Album, AlbumAccessor>()
  75         }
  76
  77         @Test
  78         fun `template context contains image accessor for images`() {
  79                 verifyAccessor<Image, ImageAccessor>()
  80         }
  81
  82         @Test
  83         fun `template context contains identity accessor for identities`() {
  84                 verifyAccessor<Identity, IdentityAccessor>()
  85         }
  86
  87         @Test
  88         fun `template context contains trust accessor for trusts`() {
  89                 verifyAccessor<Trust, TrustAccessor>()
  90         }
  91
  92         @Test
  93         fun `template context contains http request accessor for http requests`() {
  94                 verifyAccessor<HTTPRequest, HttpRequestAccessor>()
  95         }
  96
  97         @Test
  98         fun `template context contains profile accessor for profiles`() {
  99                 verifyAccessor<Profile, ProfileAccessor>()
 100         }
 101
 102         private inline fun <reified O, reified A : Accessor> verifyAccessor() {
 103                 assertThat(templateContext.getAccessor(O::class.java), instanceOf(A::class.java))
 104         }
 105
 106         @Test
 107         fun `template context contains date filter`() {
 108                 verifyFilter<DateFilter>("date")
 109         }
 110
 111         @Test
 112         fun `template context contains html filter`() {
 113                 verifyFilter<HtmlFilter>("html")
 114         }
 115
 116         @Test
 117         fun `template context contains replace filter`() {
 118                 verifyFilter<ReplaceFilter>("replace")
 119         }
 120
 121         @Test
 122         fun `template context contains store filter`() {
 123                 verifyFilter<StoreFilter>("store")
 124         }
 125
 126         @Test
 127         fun `template context contains l10n filter`() {
 128                 verifyFilter<L10nFilter>("l10n")
 129         }
 130
 131         @Test
 132         fun `template context contains substring filter`() {
 133                 verifyFilter<SubstringFilter>("substring")
 134         }
 135
 136         @Test
 137         fun `template context contains xml filter`() {
 138                 verifyFilter<XmlFilter>("xml")
 139         }
 140
 141         @Test
 142         fun `template context contains change filter`() {
 143                 verifyFilter<RequestChangeFilter>("change")
 144         }
 145
 146         @Test
 147         fun `template context contains match filter`() {
 148                 verifyFilter<MatchFilter>("match")
 149         }
 150
 151         @Test
 152         fun `template context contains css filter`() {
 153                 verifyFilter<CssClassNameFilter>("css")
 154         }
 155
 156         @Test
 157         fun `template context contains js filter`() {
 158                 verifyFilter<JavascriptFilter>("js")
 159         }
 160
 161         @Test
 162         fun `template context contains parser filter`() {
 163                 verifyFilter<ParserFilter>("parse")
 164         }
 165
 166         @Test
 167         fun `template context contains shorten filter`() {
 168                 verifyFilter<ShortenFilter>("shorten")
 169         }
 170
 171         @Test
 172         fun `template context contains render filter`() {
 173                 verifyFilter<RenderFilter>("render")
 174         }
 175
 176         @Test
 177         fun `template context contains linked elements filter`() {
 178                 verifyFilter<LinkedElementsFilter>("linked-elements")
 179         }
 180
 181         @Test
 182         fun `template context contains linked elements render filter`() {
 183                 verifyFilter<LinkedElementRenderFilter>("render-linked-element")
 184         }
 185
 186         @Test
 187         fun `template context contains reparse filter`() {
 188                 verifyFilter<ReparseFilter>("reparse")
 189         }
 190
 191         @Test
 192         fun `template context contains unknown date filter`() {
 193                 verifyFilter<UnknownDateFilter>("unknown")
 194         }
 195
 196         @Test
 197         fun `unknown date filter uses correct l10n key`() {
 198                 assertThat(getFilter("unknown")!!.format(null, 0L, emptyMap()), equalTo<Any>("unknown"))
 199         }
 200
 201         @Test
 202         fun `template context contains format filter`() {
 203                 verifyFilter<FormatFilter>("format")
 204         }
 205
 206         @Test
 207         fun `template context contains duration format filter`() {
 208                 verifyFilter<DurationFormatFilter>("duration")
 209         }
 210
 211         @Test
 212         fun `template context contains collection sort filter`() {
 213                 verifyFilter<CollectionSortFilter>("sort")
 214         }
 215
 216         @Test
 217         fun `template context contains image link filter`() {
 218                 verifyFilter<ImageLinkFilter>("image-link")
 219         }
 220
 221         @Test
 222         fun `template context contains reply group filter`() {
 223                 verifyFilter<ReplyGroupFilter>("replyGroup")
 224         }
 225
 226         @Test
 227         fun `template context contains contains filter`() {
 228                 verifyFilter<ContainsFilter>("in")
 229         }
 230
 231         @Test
 232         fun `template context unique elements filter`() {
 233                 verifyFilter<UniqueElementFilter>("unique")
 234         }
 235
 236         @Test
 237         fun `template context mod filter`() {
 238                 verifyFilter<ModFilter>("mod")
 239         }
 240
 241         @Test
 242         fun `template context pagination filter`() {
 243                 verifyFilter<PaginationFilter>("paginate")
 244         }
 245
 246         private inline fun <reified F : Filter> verifyFilter(name: String) {
 247                 assertThat(getFilter(name), instanceOf(F::class.java))
 248         }
 249
 250         private fun getFilter(name: String): Filter? = templateContext.getFilter(name)
 251
 252         @Test
 253         fun `template context factory is created as singleton`() {
 254             val factory1 = injector.getInstance<TemplateContextFactory>()
 255             val factory2 = injector.getInstance<TemplateContextFactory>()
 256                 assertThat(factory1, sameInstance(factory2))
 257         }
 258
 259         @Test
 260         fun `template from classpath is returned`() {
 261                 val template = Template()
 262                 templateContext["testTemplate"] = template
 263                 assertThat(templateContext.getTemplate("testTemplate"), sameInstance(template))
 264         }
 265
 266         @Test
 267         fun `template from loaders’ provider is returned`() {
 268                 val template = Template()
 269                 whenever(loaders.templateProvider).thenReturn(TemplateProvider { _, templateName ->
 270                         template.takeIf { templateName == "testTemplate" }
 271                 })
 272                 assertThat(templateContext.getTemplate("testTemplate"), sameInstance(template))
 273         }
 274
 275         @Test
 276         fun `page toadlet factory is created with correct prefix`() {
 277                 val page = mock<Page<FreenetRequest>>()
 278             assertThat(injector.getInstance<PageToadletFactory>().createPageToadlet(page).path(), startsWith("/Sone/"))
 279         }
 280
 281 }