Esempio n. 1
0
 @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());
 }
Esempio n. 2
0
 @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());
 }
Esempio n. 3
0
 @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());
 }
Esempio n. 4
0
 @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());
 }
Esempio n. 5
0
  @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);
  }
Esempio n. 6
0
 @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);
 }
Esempio n. 7
0
 @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);
 }
Esempio n. 8
0
 @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);
 }
Esempio n. 9
0
  @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());
  }
Esempio n. 10
0
  @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());
  }
Esempio n. 11
0
  @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());
  }
Esempio n. 12
0
  @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());
  }
Esempio n. 13
0
  @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());
  }
Esempio n. 14
0
  @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());
  }
Esempio n. 15
0
  @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());
  }
Esempio n. 16
0
  @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());
  }