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

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