src/test/java/net/pterodactylus/sone/template/FilesystemTemplateTest.java

   1 package net.pterodactylus.sone.template;
   2
   3 import static org.hamcrest.MatcherAssert.assertThat;
   4 import static org.hamcrest.Matchers.is;
   5 import static org.hamcrest.Matchers.notNullValue;
   6
   7 import java.io.File;
   8 import java.io.IOException;
   9 import java.io.StringWriter;
  10 import java.io.Writer;
  11 import java.util.Arrays;
  12 import java.util.concurrent.atomic.AtomicReference;
  13
  14 import net.pterodactylus.util.template.Part;
  15 import net.pterodactylus.util.template.TemplateContext;
  16 import net.pterodactylus.util.template.TemplateException;
  17
  18 import com.google.common.base.Charsets;
  19 import com.google.common.io.Files;
  20 import org.junit.Before;
  21 import org.junit.Test;
  22
  23 /**
  24  * Unit test for {@link FilesystemTemplate}.
  25  */
  26 public class FilesystemTemplateTest {
  27
  28         private final File tempFile;
  29         private final FilesystemTemplate filesystemTemplate;
  30         private final AtomicReference<StringWriter> stringWriter = new AtomicReference<StringWriter>(new StringWriter());
  31         private final TemplateContext templateContext = new TemplateContext();
  32
  33         public FilesystemTemplateTest() throws IOException {
  34                 tempFile = File.createTempFile("template-", ".dat");
  35                 writeTemplate("Text");
  36                 filesystemTemplate = new FilesystemTemplate(tempFile.getAbsolutePath());
  37         }
  38
  39         private void writeTemplate(String text) throws IOException {
  40                 Files.write(text + ".<%foreach values value><% value><%/foreach>", tempFile, Charsets.UTF_8);
  41         }
  42
  43         @Before
  44         public void setupTemplateContext() {
  45                 templateContext.set("values", Arrays.asList("a", 1));
  46         }
  47
  48         @Test(expected = FilesystemTemplate.TemplateFileNotFoundException.class)
  49         public void loadingTemplateFromNonExistingFileThrowsException() throws IOException {
  50                 FilesystemTemplate filesystemTemplate = new FilesystemTemplate("/a/b/c.dat");
  51                 filesystemTemplate.getInitialContext();
  52         }
  53
  54         @Test
  55         public void templateCanBeLoadedFromTheFilesystem() {
  56                 filesystemTemplate.render(templateContext, stringWriter.get());
  57                 assertThat(getRenderedString(), is("Text.a1"));
  58         }
  59
  60         @Test
  61         public void templateCanBeReloaded() throws IOException, InterruptedException {
  62                 filesystemTemplate.render(templateContext, stringWriter.get());
  63                 assertThat(getRenderedString(), is("Text.a1"));
  64                 Thread.sleep(1000);
  65                 writeTemplate("New");
  66                 filesystemTemplate.render(templateContext, stringWriter.get());
  67                 assertThat(getRenderedString(), is("New.a1"));
  68         }
  69
  70         @Test
  71         public void templateIsNotReloadedIfNotChanged() {
  72                 filesystemTemplate.render(templateContext, stringWriter.get());
  73                 assertThat(getRenderedString(), is("Text.a1"));
  74                 filesystemTemplate.render(templateContext, stringWriter.get());
  75                 assertThat(getRenderedString(), is("Text.a1"));
  76         }
  77
  78         private String getRenderedString() {
  79                 String renderedString = stringWriter.get().toString();
  80                 stringWriter.set(new StringWriter());
  81                 return renderedString;
  82         }
  83
  84         @Test
  85         public void initialContextIsCopiedToReloadedTemplates() throws IOException, InterruptedException {
  86                 filesystemTemplate.getInitialContext().set("values", "test");
  87                 Thread.sleep(1000);
  88                 writeTemplate("New");
  89                 assertThat(filesystemTemplate.getInitialContext().get("values"), is((Object) "test"));
  90         }
  91
  92         @Test
  93         public void partsAreCopiedToReloadedTemplates() throws InterruptedException, IOException {
  94                 filesystemTemplate.add(new Part() {
  95                         @Override
  96                         public void render(TemplateContext templateContext, Writer writer) throws TemplateException {
  97                                 try {
  98                                         writer.write(".Test");
  99                                 } catch (IOException e) {
 100                                         throw new TemplateException(e);
 101                                 }
 102                         }
 103                 });
 104                 Thread.sleep(1000);
 105                 writeTemplate("New");
 106                 filesystemTemplate.render(templateContext, stringWriter.get());
 107                 assertThat(getRenderedString(), is("New.a1.Test"));
 108         }
 109
 110         @Test
 111         public void columnOfReturnedTemplateIsReturnedAsZero() {
 112                 assertThat(filesystemTemplate.getColumn(), is(0));
 113         }
 114
 115         @Test
 116         public void lineOfReturnedTemplateIsReturnedAsZero() {
 117                 assertThat(filesystemTemplate.getLine(), is(0));
 118         }
 119
 120         @Test
 121         public void templateCanBeIteratedOver() {
 122             assertThat(filesystemTemplate.iterator(), notNullValue());
 123         }
 124
 125 }