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