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

   1 package net.pterodactylus.sone.template
   2
   3 import net.pterodactylus.util.template.*
   4 import org.hamcrest.MatcherAssert.*
   5 import org.hamcrest.Matchers.*
   6 import org.junit.*
   7 import org.junit.rules.*
   8 import java.io.*
   9 import java.lang.Thread.*
  10 import kotlin.test.Test
  11
  12 /**
  13  * Unit test for [FilesystemTemplate].
  14  */
  15 class FilesystemTemplateTest() {
  16
  17         @Rule
  18         @JvmField
  19         val expectedException: ExpectedException = ExpectedException.none()
  20
  21         private val tempFile = File.createTempFile("template-", ".dat")
  22         private val filesystemTemplate: FilesystemTemplate
  23         private val templateContext = TemplateContext()
  24
  25         private val renderedString: String
  26                 get() =
  27                         StringWriter().use { stringWriter ->
  28                                 filesystemTemplate.render(templateContext, stringWriter)
  29                                 stringWriter
  30                         }.toString()
  31
  32         init {
  33                 writeTemplate("Text")
  34                 filesystemTemplate = FilesystemTemplate(tempFile.absolutePath)
  35         }
  36
  37         private fun writeTemplate(text: String) {
  38                 tempFile.writer().use {
  39                         it.write("$text.<%foreach values value><% value><%/foreach>")
  40                 }
  41         }
  42
  43         @Before
  44         fun setupTemplateContext() {
  45                 templateContext.set("values", listOf("a", 1))
  46         }
  47
  48         @Test
  49         fun `loading template from non existing file throws exception`() {
  50                 val filesystemTemplate = FilesystemTemplate("/a/b/c.dat")
  51                 expectedException.expect(FilesystemTemplate.TemplateFileNotFoundException::class.java)
  52                 filesystemTemplate.initialContext
  53         }
  54
  55         @Test
  56         fun `template can be loaded from the filesystem`() {
  57                 assertThat(renderedString, equalTo("Text.a1"))
  58         }
  59
  60         @Test
  61         fun `template can be reloaded`() {
  62                 assertThat(renderedString, equalTo("Text.a1"))
  63                 sleep(1000)
  64                 writeTemplate("New")
  65                 assertThat(renderedString, equalTo("New.a1"))
  66         }
  67
  68         @Test
  69         fun `template is not reloaded if not changed`() {
  70                 assertThat(renderedString, equalTo("Text.a1"))
  71                 assertThat(renderedString, equalTo("Text.a1"))
  72         }
  73
  74         @Test
  75         fun `initial context is copied to reloaded templates`() {
  76                 filesystemTemplate.initialContext.set("values", "test")
  77                 sleep(1000)
  78                 writeTemplate("New")
  79                 assertThat(filesystemTemplate.initialContext.get("values"), equalTo("test" as Any))
  80         }
  81
  82         @Test
  83         fun `parts are copied to currently loaded templates`() {
  84                 writeTemplate("New")
  85                 renderedString
  86                 filesystemTemplate.add { _, writer ->
  87                         writer.write(".Test")
  88                 }
  89                 assertThat(renderedString, equalTo("New.a1.Test"))
  90         }
  91
  92         @Test
  93         fun `parts are copied to reloaded templates`() {
  94                 filesystemTemplate.add { _, writer ->
  95                         writer.write(".Test")
  96                 }
  97                 sleep(1000)
  98                 writeTemplate("New")
  99                 assertThat(renderedString, equalTo("New.a1.Test"))
 100         }
 101
 102         @Test
 103         fun `column of returned template is returned as zero`() {
 104                 assertThat(filesystemTemplate.column, equalTo(0))
 105         }
 106
 107         @Test
 108         fun `line of returned template is returned as zero`() {
 109                 assertThat(filesystemTemplate.line, equalTo(0))
 110         }
 111
 112         @Test
 113         fun `template can be iterated over`() {
 114                 assertThat<Iterator<Part>>(filesystemTemplate.iterator(), notNullValue())
 115         }
 116
 117 }