@Test
public void testGeneratedIdsAreUnique() {
MustacheEngine engine = MustacheEngineBuilder.newBuilder().build();
assertNotEquals(
engine.compileMustache("foo", "{{foo}}").getGeneratedId(),
engine.compileMustache("foo", "{{foo}}").getGeneratedId());
}
@Test
public void testTemplateCacheDisabled() {
MustacheEngine engine =
MustacheEngineBuilder.newBuilder()
.setProperty(EngineConfigurationKey.TEMPLATE_CACHE_ENABLED, false)
.addTemplateLocator(
new AbstractTemplateLocator(10) {
@Override
public Reader locate(String templateId) {
return new StringReader(UUID.randomUUID().toString());
}
@Override
public Set<String> getAllIdentifiers() {
return null;
}
})
.build();
int size = 10;
Set<String> values = new HashSet<String>(size);
for (int i = 0; i < size; i++) {
values.add(engine.getMustache("foo").render(null));
}
assertEquals(size, values.size());
}
@Test
public void testDebugModeDisablesTemplateCache() {
MustacheEngine engine =
MustacheEngineBuilder.newBuilder()
.setProperty(EngineConfigurationKey.DEBUG_MODE, true)
.addTemplateLocator(new MapTemplateLocator(ImmutableMap.of("foo", "Hey!")))
.build();
assertNotEquals(engine.getMustache("foo"), engine.getMustache("foo"));
}
@Test
public void testTemplateLocatorReaderIsAlwaysClosed() {
final String template = "FOO";
final String illegalTemplate = "{{foo";
final AtomicBoolean isCloseInvoked = new AtomicBoolean(false);
TemplateLocator locator =
new AbstractTemplateLocator(1) {
@SuppressWarnings("resource")
@Override
public Reader locate(String templateId) {
return "foo".equals(templateId)
? new MyStringReader(template, isCloseInvoked)
: new MyStringReader(illegalTemplate, isCloseInvoked);
}
@Override
public Set<String> getAllIdentifiers() {
return null;
}
};
final MustacheEngine engine =
MustacheEngineBuilder.newBuilder().addTemplateLocator(locator).build();
assertEquals(template, engine.getMustacheSource("foo"));
assertTrue(isCloseInvoked.get());
engine.invalidateTemplateCache();
isCloseInvoked.set(false);
assertFalse(isCloseInvoked.get());
assertEquals(template, engine.getMustache("foo").render(null));
assertTrue(isCloseInvoked.get());
isCloseInvoked.set(false);
assertFalse(isCloseInvoked.get());
ExceptionAssert.expect(MustacheException.class)
.check(
new Runnable() {
public void run() {
engine.getMustache("whatever").render(null);
}
});
assertTrue(isCloseInvoked.get());
}
@Test
public void testTemplateCacheExpirationTimeout() throws InterruptedException {
Map<String, String> templates = new HashMap<String, String>();
templates.put("foo", "0");
long timeout = 1;
MustacheEngine engine =
MustacheEngineBuilder.newBuilder()
.setProperty(EngineConfigurationKey.TEMPLATE_CACHE_EXPIRATION_TIMEOUT, timeout)
.addTemplateLocator(new MapTemplateLocator(templates))
.build();
assertEquals("0", engine.getMustache("foo").render(null));
templates.put("foo", "1");
assertEquals("0", engine.getMustache("foo").render(null));
Thread.sleep((2 * timeout) * 1000);
assertEquals("1", engine.getMustache("foo").render(null));
}
