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