@Test
public void testResolve() throws Exception {
CompilerAssert<File, File> ca = compiler("plugin.less4j.resolve");
ca.assertCompile();
File f = ca.getClassOutput().getPath("plugin", "less4j", "resolve", "assets", "stylesheet.css");
assertNotNull(f);
assertTrue(f.exists());
}
@Test
public void testBootstrap() throws Exception {
CompilerAssert<File, File> ca = compiler("plugin.less4j.bootstrap");
ca.assertCompile();
File f =
ca.getClassOutput().getPath("plugin", "less4j", "bootstrap", "assets", "bootstrap.css");
assertNotNull(f);
assertTrue(f.exists());
}
@Test
public void testAbstractClass() throws Exception {
CompilerAssert<?, ?> compiler = compiler("plugin", "binding", "provider", "abstractclass");
compiler.formalErrorReporting(true);
List<CompilationError> errors = compiler.failCompile();
assertEquals(1, errors.size());
CompilationError error = errors.get(0);
assertEquals(BindingMetaModelPlugin.IMPLEMENTATION_NOT_ABSTRACT, error.getCode());
assertEquals("/plugin/binding/provider/abstractclass/package-info.java", error.getSource());
}
@Test
public void testNotAssignable() throws Exception {
CompilerAssert<?, ?> compiler = compiler("plugin", "binding", "provider", "notassignable");
compiler.formalErrorReporting(true);
List<CompilationError> errors = compiler.failCompile();
assertEquals(1, errors.size());
CompilationError error = errors.get(0);
assertEquals(BindingMetaModelPlugin.PROVIDER_NOT_ASSIGNABLE, error.getCode());
assertEquals("/plugin/binding/provider/notassignable/package-info.java", error.getSource());
}
@Test
public void testBuild() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
helper.assertCompile();
//
MetaModel mm =
Tools.unserialize(
MetaModel.class, helper.getSourceOutput().getPath("juzu", "metamodel.ser"));
//
JSON expected =
json()
.set(
"applications",
json()
.list(
"values",
json()
.list(
"controllers",
json()
.set(
"handle",
"ElementHandle.Class[fqn=model.meta.controller.A]")
.list(
"methods",
json()
.set(
"handle",
"ElementHandle.Method[fqn=model.meta.controller.A,name=index,parameterTypes[]]")
.set("id", null)
.set("name", "index")
.list("parameters")
.set("phase", "RENDER")))
.set("fqn", "model.meta.controller.ControllerApplication")
.set("handle", "ElementHandle.Package[qn=model.meta.controller]")
.list("templates")));
assertEquals(expected, mm.toJSON());
//
List<MetaModelEvent> events = mm.getQueue().clear();
ApplicationMetaModel application = mm.getChild(ApplicationsMetaModel.KEY).iterator().next();
ControllerMetaModel controller =
application.getChild(ControllersMetaModel.KEY).iterator().next();
MethodMetaModel method = controller.getMethods().iterator().next();
assertEquals(
Arrays.asList(
MetaModelEvent.createAdded(application),
MetaModelEvent.createAdded(controller),
MetaModelEvent.createAdded(method),
MetaModelEvent.createUpdated(controller)),
events);
}
@Test
public void testNotFound() throws Exception {
CompilerAssert<File, File> ca = compiler("plugin.less4j.notfound");
List<CompilationError> errors = ca.formalErrorReporting(true).failCompile();
assertEquals(1, errors.size());
assertEquals(MetaModelPluginImpl.GENERAL_PROBLEM, errors.get(0).getCode());
File f = ca.getSourcePath().getPath("plugin", "less4j", "notfound", "package-info.java");
assertEquals(f, errors.get(0).getSourceFile());
f = ca.getClassOutput().getPath("plugin", "less4j", "notfound", "assets", "stylesheet.css");
assertNull(f);
}
@Test
public void testMalformedPath() throws Exception {
CompilerAssert<File, File> ca = compiler("plugin.less4j.malformedpath");
List<CompilationError> errors = ca.formalErrorReporting(true).failCompile();
assertEquals(1, errors.size());
assertEquals(MetaModelPluginImpl.MALFORMED_PATH, errors.get(0).getCode());
File f = ca.getSourcePath().getPath("plugin", "less4j", "malformedpath", "package-info.java");
assertEquals(f, errors.get(0).getSourceFile());
f =
ca.getClassOutput()
.getPath("plugin", "less4j", "malformedpath", "assets", "stylesheet.css");
assertNull(f);
}
@Test
public void testCannotResolve() throws Exception {
CompilerAssert<File, File> ca = compiler("plugin.less4j.cannotresolve");
List<CompilationError> errors = ca.formalErrorReporting(true).failCompile();
assertEquals(1, errors.size());
assertEquals(MetaModelPluginImpl.COMPILATION_ERROR, errors.get(0).getCode());
File f = ca.getSourcePath().getPath("plugin", "less4j", "cannotresolve", "package-info.java");
assertEquals(f, errors.get(0).getSourceFile());
f =
ca.getClassOutput()
.getPath("plugin", "less4j", "cannotresolve", "assets", "stylesheet.css");
assertNull(f);
}
@Test
public void testRemoveAnnotation() throws Exception {
CompilerAssert<File, File> helper = compiler("metamodel.tag");
helper.assertCompile();
//
JavaFile file = helper.assertSource("metamodel", "tag", "package-info.java");
PackageDeclaration a = file.assertPackage();
NormalAnnotationExpr applicationDecl = (NormalAnnotationExpr) a.getAnnotations().get(0);
applicationDecl.getPairs().clear();
file.assertSave();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModelState unserialize = Tools.unserialize(MetaModelState.class, ser);
ModuleMetaModel mm = (ModuleMetaModel) unserialize.metaModel;
mm.getQueue().clear();
Tools.serialize(unserialize, ser);
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
unserialize = Tools.unserialize(MetaModelState.class, ser);
mm = (ModuleMetaModel) unserialize.metaModel;
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(2, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(TemplateMetaModel.class, events.get(0).getObject());
assertEquals(
Path.parse("/metamodel/tag/tags/foo.gtmpl"),
((TemplateMetaModel) events.get(0).getObject()).getPath());
assertEquals(MetaModelEvent.UPDATED, events.get(1).getType());
assertInstanceOf(ApplicationMetaModel.class, events.get(1).getObject());
}
@Test
public void testRemoveApplication() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
helper.assertCompile();
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
mm.getQueue().clear();
Tools.serialize(mm, ser);
//
assertDelete(
helper.getSourcePath().getPath("model", "meta", "controller", "package-info.java"));
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
mm = Tools.unserialize(MetaModel.class, ser);
//
JSON expected = json().set("applications", json().list("values"));
assertEquals(expected, mm.toJSON());
//
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(3, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(ApplicationMetaModel.class, events.get(0).getObject());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(1).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(1).getObject());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(2).getType());
assertInstanceOf(MethodMetaModel.class, events.get(2).getObject());
}
@Test
public void testRefactorPackageName() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
helper.assertCompile();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
mm.getQueue().clear();
Tools.serialize(mm, ser);
//
File file = helper.getSourcePath().getPath("model", "meta", "controller", "A.java");
File sub = new File(file.getParentFile(), "sub");
assertTrue(sub.mkdir());
File tmp = new File(sub, file.getName());
assertTrue(file.renameTo(tmp));
JavaFile javaFile = helper.assertJavaFile("model", "meta", "controller", "sub", "A.java");
javaFile
.assertCompilationUnit()
.getPackage()
.setName(ASTHelper.createNameExpr("model.meta.controller.sub"));
javaFile.assertSave();
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
mm = Tools.unserialize(MetaModel.class, ser);
//
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(5, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertEquals(
ElementHandle.Method.create(
new FQN("model.meta.controller.A"), "index", Collections.<String>emptyList()),
((MethodMetaModel) events.get(0).getObject()).getHandle());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(1).getType());
assertEquals(
ElementHandle.Class.create(new FQN("model.meta.controller.A")),
((ControllerMetaModel) events.get(1).getObject()).getHandle());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(2).getType());
assertEquals(
ElementHandle.Class.create(new FQN("model.meta.controller.sub.A")),
((ControllerMetaModel) events.get(2).getObject()).getHandle());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(3).getType());
assertEquals(
ElementHandle.Method.create(
new FQN("model.meta.controller.sub.A"), "index", Collections.<String>emptyList()),
((MethodMetaModel) events.get(3).getObject()).getHandle());
assertEquals(MetaModelEvent.UPDATED, events.get(4).getType());
assertEquals(
ElementHandle.Class.create(new FQN("model.meta.controller.sub.A")),
((ControllerMetaModel) events.get(4).getObject()).getHandle());
}
@Test
public void testUpdateAnnotation() throws Exception {
CompilerAssert<File, File> helper = compiler("metamodel.tag");
helper.assertCompile();
//
JavaFile file = helper.assertSource("metamodel", "tag", "package-info.java");
PackageDeclaration a = file.assertPackage();
NormalAnnotationExpr applicationDecl = (NormalAnnotationExpr) a.getAnnotations().get(0);
NormalAnnotationExpr tagDecl =
(NormalAnnotationExpr) applicationDecl.getPairs().get(0).getValue();
boolean changed = false;
for (MemberValuePair pair : tagDecl.getPairs()) {
if (pair.getName().equals("path")) {
pair.setValue(new StringLiteralExpr("bar.gtmpl"));
changed = true;
}
}
assertTrue(changed);
file.assertSave();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModelState unserialize = Tools.unserialize(MetaModelState.class, ser);
ModuleMetaModel mm = (ModuleMetaModel) unserialize.metaModel;
mm.getQueue().clear();
Tools.serialize(unserialize, ser);
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
unserialize = Tools.unserialize(MetaModelState.class, ser);
mm = (ModuleMetaModel) unserialize.metaModel;
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(3, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(TemplateMetaModel.class, events.get(0).getObject());
assertEquals(
Path.parse("/metamodel/tag/tags/foo.gtmpl"),
((TemplateMetaModel) events.get(0).getObject()).getPath());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(1).getType());
assertInstanceOf(TemplateMetaModel.class, events.get(1).getObject());
assertEquals(
Path.parse("/metamodel/tag/tags/bar.gtmpl"),
((TemplateMetaModel) events.get(1).getObject()).getPath());
assertEquals(MetaModelEvent.UPDATED, events.get(2).getType());
assertInstanceOf(ApplicationMetaModel.class, events.get(2).getObject());
}
@Test
public void testRemoveAnnotation() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
helper.assertCompile();
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
mm.getQueue().clear();
Tools.serialize(mm, ser);
//
JavaFile file = helper.assertJavaFile("model", "meta", "controller", "A.java");
ClassOrInterfaceDeclaration a = file.assertDeclaration();
MethodDeclaration decl = (MethodDeclaration) a.getMembers().get(0);
decl.getAnnotations().clear();
file.assertSave();
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
mm = Tools.unserialize(MetaModel.class, ser);
//
JSON expected =
json()
.set(
"applications",
json()
.list(
"values",
json()
.list("controllers")
.set("fqn", "model.meta.controller.ControllerApplication")
.set("handle", "ElementHandle.Package[qn=model.meta.controller]")
.list("templates")));
assertEquals(expected, mm.toJSON());
//
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(2, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(MethodMetaModel.class, events.get(0).getObject());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(1).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(1).getObject());
}
@Test
public void testRemoveOverloadedMethod() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
JavaFile file = helper.assertJavaFile("model", "meta", "controller", "A.java");
ClassOrInterfaceDeclaration a = file.assertDeclaration();
MethodDeclaration index = new MethodDeclaration(Modifier.PUBLIC, ASTHelper.VOID_TYPE, "index");
ASTHelper.addParameter(
index, ASTHelper.createParameter(new ClassOrInterfaceType(String.class.getName()), "s"));
index.setAnnotations(
Collections.<AnnotationExpr>singletonList(
new NormalAnnotationExpr(
ASTHelper.createNameExpr(View.class.getName()),
Collections.<MemberValuePair>emptyList())));
index.setBody(new BlockStmt());
a.getMembers().add(index);
file.assertSave();
helper.assertCompile();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
mm.getQueue().clear();
Tools.serialize(mm, ser);
//
assertTrue(a.getMembers().remove(index));
file.assertSave();
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
mm = Tools.unserialize(MetaModel.class, ser);
//
JSON expected =
json()
.set(
"applications",
json()
.list(
"values",
json()
.list(
"controllers",
json()
.set(
"handle",
"ElementHandle.Class[fqn=model.meta.controller.A]")
.list(
"methods",
json()
.set(
"handle",
"ElementHandle.Method[fqn=model.meta.controller.A,name=index,parameterTypes[]]")
.set("id", null)
.set("name", "index")
.list("parameters")
.set("phase", "RENDER")))
.set("fqn", "model.meta.controller.ControllerApplication")
.set("handle", "ElementHandle.Package[qn=model.meta.controller]")
.list("templates")));
assertEquals(expected, mm.toJSON());
//
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(1, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(MethodMetaModel.class, events.get(0).getObject());
}
@Test
public void testAddMethod() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
JavaFile file = helper.assertJavaFile("model", "meta", "controller", "A.java");
ClassOrInterfaceDeclaration a = file.assertDeclaration();
MethodDeclaration decl = (MethodDeclaration) a.getMembers().get(0);
assertTrue(a.getMembers().remove(decl));
file.assertSave();
helper.assertCompile();
//
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(1, events.size());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(0).getType());
assertTrue(events.get(0).getObject() instanceof ApplicationMetaModel);
Tools.serialize(mm, ser);
//
a.getMembers().add(decl);
file.assertSave();
helper.addClassPath(helper.getClassOutput()).assertCompile();
//
mm = Tools.unserialize(MetaModel.class, ser);
//
JSON expected =
json()
.set(
"applications",
json()
.list(
"values",
json()
.list(
"controllers",
json()
.set(
"handle",
"ElementHandle.Class[fqn=model.meta.controller.A]")
.list(
"methods",
json()
.set(
"handle",
"ElementHandle.Method[fqn=model.meta.controller.A,name=index,parameterTypes[]]")
.set("id", null)
.set("name", "index")
.list("parameters")
.set("phase", "RENDER")))
.set("fqn", "model.meta.controller.ControllerApplication")
.set("handle", "ElementHandle.Package[qn=model.meta.controller]")
.list("templates")));
assertEquals(expected, mm.toJSON());
//
events = mm.getQueue().clear();
assertEquals(3, events.size());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(0).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(0).getObject());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(1).getType());
assertInstanceOf(MethodMetaModel.class, events.get(1).getObject());
assertEquals(MetaModelEvent.UPDATED, events.get(2).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(2).getObject());
}
@Test
public void testChangeAnnotation() throws Exception {
CompilerAssert<File, File> helper = incrementalCompiler("model", "meta", "controller");
helper.assertCompile();
File ser = helper.getSourceOutput().getPath("juzu", "metamodel.ser");
MetaModel mm = Tools.unserialize(MetaModel.class, ser);
mm.getQueue().clear();
Tools.serialize(mm, ser);
//
JavaFile file = helper.assertJavaFile("model", "meta", "controller", "A.java");
ClassOrInterfaceDeclaration a = file.assertDeclaration();
MethodDeclaration decl = (MethodDeclaration) a.getMembers().get(0);
decl.getAnnotations().get(0).setName(ASTHelper.createNameExpr(Action.class.getName()));
file.assertSave();
//
helper.addClassPath(helper.getClassOutput()).assertCompile();
mm = Tools.unserialize(MetaModel.class, ser);
//
JSON expected =
json()
.set(
"applications",
json()
.list(
"values",
json()
.list(
"controllers",
json()
.set(
"handle",
"ElementHandle.Class[fqn=model.meta.controller.A]")
.list(
"methods",
json()
.set(
"handle",
"ElementHandle.Method[fqn=model.meta.controller.A,name=index,parameterTypes[]]")
.set("id", null)
.set("name", "index")
.list("parameters")
.set("phase", "ACTION")))
.set("fqn", "model.meta.controller.ControllerApplication")
.set("handle", "ElementHandle.Package[qn=model.meta.controller]")
.list("templates")));
assertEquals(expected, mm.toJSON());
//
List<MetaModelEvent> events = mm.getQueue().clear();
assertEquals(5, events.size());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(0).getType());
assertInstanceOf(MethodMetaModel.class, events.get(0).getObject());
assertEquals(MetaModelEvent.BEFORE_REMOVE, events.get(1).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(1).getObject());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(2).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(2).getObject());
assertEquals(MetaModelEvent.AFTER_ADD, events.get(3).getType());
assertInstanceOf(MethodMetaModel.class, events.get(3).getObject());
assertEquals(MetaModelEvent.UPDATED, events.get(4).getType());
assertInstanceOf(ControllerMetaModel.class, events.get(4).getObject());
}
