Handle Meta-Annotations about archunit HOT 8 CLOSED

@Test
void serviceAnnotation() {
  JavaClasses classes = new ClassFileImporter().importPackagesOf(DummyBean.class);

  classes()
      .that().areAssignableTo(DummyBean.class)
      .should(beMetaAnnotatedWith(Service.class))
      .check(classes);
}

private ArchCondition<JavaClass> beMetaAnnotatedWith(
    final Class<? extends Annotation> annotationType) {

  final String annotationName = annotationType.getSimpleName();
  return new ArchCondition<JavaClass>("be meta-annotated with @" + annotationName) {
    @Override
    public void check(JavaClass javaClass, ConditionEvents events) {
      if (!isMetaAnnotated(javaClass)) {
        events.add(SimpleConditionEvent.violated(javaClass,
            String.format("Class %s is not meta-annotated with @%s",
                javaClass.getName(), annotationName)));
      }
    }

    private boolean isMetaAnnotated(JavaClass javaClass) {
      if (javaClass.isAnnotatedWith(annotationType)) {
        return true;
      }

      for (JavaClass metaAnnotationType : getMetaAnnotationTypes(javaClass.getAnnotations())) {
        if (metaAnnotationType.isAnnotatedWith(annotationType)) {
          return true;
        }
      }
      return false;
    }

    private Set<JavaClass> getMetaAnnotationTypes(Set<JavaAnnotation> annotations) {
      Set<JavaClass> types = new HashSet<>();
      for (JavaAnnotation annotation : annotations) {
        types.add(annotation.getType());
        types.addAll(getMetaAnnotationTypes(annotation.getType().getAnnotations()));
      }
      return types;
    }
  };
}

@Test
void serviceAnnotation() {
  JavaClasses classes = new ClassFileImporter().importPackagesOf(DummyBean.class);

  classes()
      .that().areAssignableTo(DummyBean.class)
      .should().beAnnotatedWith(metaAnnotation(Service.class))
      .check(classes);
}

private DescribedPredicate<JavaAnnotation> metaAnnotation(
    final Class<? extends Annotation> annotationType) {

  return new DescribedPredicate<JavaAnnotation>("meta-annotation @" + annotationType.getSimpleName()) {
    @Override
    public boolean apply(JavaAnnotation annotation) {
      return annotation.getType().isEquivalentTo(annotationType) ||
          getMetaAnnotations(annotation).stream()
              .anyMatch(type -> type.isAnnotatedWith(annotationType));
    }

    private Set<JavaClass> getMetaAnnotations(JavaAnnotation annotation) {
      Set<JavaClass> types = new HashSet<>(singleton(annotation.getType()));
      annotation.getType().getAnnotations().stream()
          .map(this::getMetaAnnotations)
          .forEach(types::addAll);
      return types;
    }
  };
}

@Deprecated
public class ExampleTest {

  @Test
  public void demo() {
    ArchRule rule = classes()
        .that().haveSimpleName("ExampleTest")
        .should().beAnnotatedWith(metaAnnotation(Retention.class));

    ClassFileImporter importer = new ClassFileImporter();

    // this check succeeds
    JavaClasses allClasses = importer.importClasses(ExampleTest.class, Deprecated.class);
    rule.check(allClasses);

    // this check fails, but should succeed
    JavaClasses myClasses = importer.importClasses(ExampleTest.class);
    rule.check(myClasses);
  }

  private DescribedPredicate<? super JavaAnnotation> metaAnnotation(final Class<? extends Annotation> type) {
    return new DescribedPredicate<JavaAnnotation>("meta-annotation @" + type.getSimpleName()) {
      @Override
      public boolean apply(JavaAnnotation input) {
        return input.getType().isAnnotatedWith(type);
      }
    };
  }

}

foo
 |-- bar/MyAnnotation.class
 |-- baz/AnnotatedClass.class