package org.jooby.thymeleaf;
import static org.easymock.EasyMock.expect;
import static org.junit.Assert.assertNotNull;
import java.util.concurrent.atomic.AtomicReference;
import org.jooby.Env;
import org.jooby.Renderer;
import org.jooby.test.MockUnit;
import org.jooby.test.MockUnit.Block;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.thymeleaf.ITemplateEngine;
import org.thymeleaf.TemplateEngine;
import org.thymeleaf.templatemode.TemplateMode;
import org.thymeleaf.templateresolver.ClassLoaderTemplateResolver;
import org.thymeleaf.templateresolver.ITemplateResolver;
import com.google.inject.Binder;
import com.google.inject.binder.AnnotatedBindingBuilder;
import com.google.inject.binder.LinkedBindingBuilder;
import com.google.inject.multibindings.Multibinder;
import com.typesafe.config.Config;
@RunWith(PowerMockRunner.class)
@PrepareForTest({Thl.class, ClassLoaderTemplateResolver.class, TemplateEngine.class,
ThlEngine.class, Multibinder.class })
public class ThlTest {
@SuppressWarnings({"rawtypes", "unchecked" })
private Block templateEngine = unit -> {
TemplateEngine engine = unit.constructor(TemplateEngine.class)
.build();
engine.setTemplateResolver(unit.get(ITemplateResolver.class));
AnnotatedBindingBuilder abb = unit.mock(AnnotatedBindingBuilder.class);
abb.toInstance(engine);
abb.toInstance(engine);
Binder binder = unit.get(Binder.class);
expect(binder.bind(TemplateEngine.class)).andReturn(abb);
expect(binder.bind(ITemplateEngine.class)).andReturn(abb);
unit.registerMock(TemplateEngine.class, engine);
};
@SuppressWarnings({"rawtypes", "unchecked" })
private Block viewEngine = unit -> {
ThlEngine vengine = unit.constructor(ThlEngine.class)
.args(TemplateEngine.class, Env.class)
.build(unit.get(TemplateEngine.class), unit.get(Env.class));
unit.mockStatic(Multibinder.class);
LinkedBindingBuilder lbb = unit.mock(LinkedBindingBuilder.class);
lbb.toInstance(vengine);
Multibinder mbinder = unit.mock(Multibinder.class);
expect(mbinder.addBinding()).andReturn(lbb);
expect(Multibinder.newSetBinder(unit.get(Binder.class), Renderer.class)).andReturn(mbinder);
};
@Test
public void defaults() throws Exception {
new MockUnit(Env.class, Config.class, Binder.class)
.expect(env("dev"))
.expect(templateResolver("/", ".html", false))
.expect(templateEngine)
.expect(viewEngine)
.run(unit -> {
new Thl()
.configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
});
}
@Test
public void doWith() throws Exception {
AtomicReference<TemplateEngine> engine = new AtomicReference<>();
new MockUnit(Env.class, Config.class, Binder.class)
.expect(env("dev"))
.expect(templateResolver("/", ".html", false))
.expect(templateEngine)
.expect(viewEngine)
.run(unit -> {
new Thl()
.doWith(engine::set)
.configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
});
assertNotNull(engine.get());
}
@Test
public void shouldSetPrefixAndSuffix() throws Exception {
new MockUnit(Env.class, Config.class, Binder.class)
.expect(env("dev"))
.expect(templateResolver("/templates", ".thl.html", false))
.expect(templateEngine)
.expect(viewEngine)
.run(unit -> {
new Thl("/templates", ".thl.html")
.configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
});
}
@Test
public void shouldSetCacheable() throws Exception {
new MockUnit(Env.class, Config.class, Binder.class)
.expect(env("prod"))
.expect(templateResolver("/", ".html", true))
.expect(templateEngine)
.expect(viewEngine)
.run(unit -> {
new Thl()
.configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
});
}
private Block env(final String env) {
return unit -> {
Env e = unit.get(Env.class);
expect(e.name()).andReturn(env);
};
}
private Block templateResolver(final String prefix, final String suffix,
final boolean cacheable) {
return unit -> {
ClassLoaderTemplateResolver tr = unit.constructor(ClassLoaderTemplateResolver.class)
.build();
tr.setCacheable(cacheable);
tr.setPrefix(prefix);
tr.setSuffix(suffix);
tr.setTemplateMode(TemplateMode.HTML);
unit.registerMock(ITemplateResolver.class, tr);
};
}
}