src/test/kotlin/net/pterodactylus/sone/template/ParserFilterTest.kt

   1 package net.pterodactylus.sone.template
   2
   3 import com.google.inject.Guice
   4 import net.pterodactylus.sone.core.Core
   5 import net.pterodactylus.sone.data.Sone
   6 import net.pterodactylus.sone.test.getInstance
   7 import net.pterodactylus.sone.test.isProvidedByMock
   8 import net.pterodactylus.sone.test.mock
   9 import net.pterodactylus.sone.text.SoneTextParser
  10 import net.pterodactylus.sone.text.SoneTextParserContext
  11 import net.pterodactylus.util.template.TemplateContext
  12 import org.hamcrest.MatcherAssert.assertThat
  13 import org.hamcrest.Matchers.`is`
  14 import org.hamcrest.Matchers.emptyIterable
  15 import org.hamcrest.Matchers.notNullValue
  16 import org.hamcrest.Matchers.sameInstance
  17 import org.junit.Test
  18 import org.mockito.ArgumentCaptor.forClass
  19 import org.mockito.Mockito.`when`
  20 import org.mockito.Mockito.eq
  21 import org.mockito.Mockito.verify
  22
  23 /**
  24  * Unit test for [ParserFilter].
  25  */
  26 class ParserFilterTest {
  27
  28         companion object {
  29                 private const val SONE_IDENTITY = "nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI"
  30         }
  31
  32         private val core = mock<Core>()
  33         private val sone = setupSone(SONE_IDENTITY)
  34         private val soneTextParser = mock<SoneTextParser>()
  35         private val templateContext = TemplateContext()
  36         private val parameters = mutableMapOf<String, Any?>()
  37         private val filter = ParserFilter(core, soneTextParser)
  38
  39         private fun setupSone(identity: String): Sone {
  40                 val sone = mock<Sone>()
  41                 `when`(sone.id).thenReturn(identity)
  42                 `when`(core.getSone(identity)).thenReturn(sone)
  43                 return sone
  44         }
  45
  46         @Test
  47         fun `parsing null returns an empty iterable`() {
  48                 assertThat(filter.format(templateContext, null, mutableMapOf()) as Iterable<*>, emptyIterable())
  49         }
  50
  51         @Test
  52         fun `given sone is used to create parser context`() {
  53                 setupSoneAndVerifyItIsUsedInContext(sone, sone)
  54         }
  55
  56         @Test
  57         fun `sone with given sone ID is used to create parser context`() {
  58                 setupSoneAndVerifyItIsUsedInContext(SONE_IDENTITY, sone)
  59         }
  60
  61         private fun setupSoneAndVerifyItIsUsedInContext(soneOrSoneId: Any, sone: Sone) {
  62                 parameters.put("sone", soneOrSoneId)
  63                 filter.format(templateContext, "text", parameters)
  64                 val context = forClass(SoneTextParserContext::class.java)
  65                 verify(soneTextParser).parse(eq<String>("text") ?: "", context.capture())
  66                 assertThat(context.value.postingSone, `is`(sone))
  67         }
  68
  69         @Test
  70         fun `parser filter can be created by guice`() {
  71             val injector = Guice.createInjector(
  72                             Core::class.isProvidedByMock(),
  73                             SoneTextParser::class.isProvidedByMock()
  74             )
  75                 assertThat(injector.getInstance<ParserFilter>(), notNullValue())
  76         }
  77
  78         @Test
  79         fun `parser filter is created as singleton`() {
  80                 val injector = Guice.createInjector(
  81                                 Core::class.isProvidedByMock(),
  82                                 SoneTextParser::class.isProvidedByMock()
  83                 )
  84                 val firstInstance = injector.getInstance<ParserFilter>()
  85                 val secondInstance = injector.getInstance<ParserFilter>()
  86                 assertThat(firstInstance, sameInstance(secondInstance))
  87
  88         }
  89
  90 }