Check that a class has method that...

[mauromol]

I'd like to check that a class has at least one method with certain characteristics.
Something like:

classes()
   .that().areAnnotatedWith(SomeAnnotation.class)
   .should().containAnyMethodsThat().areAnnotatedWith(PreDestroy.class);

Unfortunately, the "containAnyMethodsThat" is only available as a DescribedPredicate, not as an ArchCondition.
As an alternative, I could use ArchConditions.does(...) to get an ArchCondition with a meaningful verb, but "does" is private (contrary to be(...) or have(...)), not sure why.

[hankem]

I think the verb you want to see after 'should' is already 'contain'. (I don't think that there'd ever be a 'does' after 'should'.)

ArchCondition.from(DescribedPredicate) can be used to create an ArchCondition from a DescribedPredicate with the same description. ArchConditions.be or ArchConditions.have are only needed when you want to introduce an additional verb:

classes()
    .that().areAnnotatedWith(SomeAnnotation.class)
    .should(ArchCondition.from(containAnyMethodsThat(are(annotatedWith(PreDestroy.class)))))

using these

imports

import com.tngtech.archunit.lang.ArchCondition;
import static com.tngtech.archunit.core.domain.JavaClass.Predicates.containAnyMethodsThat;
import static com.tngtech.archunit.core.domain.properties.CanBeAnnotated.Predicates.annotatedWith;
import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

produces a rule with description

classes that are annotated with @SomeAnnotation should contain any methods that are annotated with @PreDestroy

[mauromol]

Good to know, thank you, I'm relatively new to ArchUnit and it's sometimes hard for me to orient myself into its DSL. I still have to find a methodical approach that allows me to discover things without getting mad :-)
Anyway, the description coming from "from" is then fine (my idea behind "does" was as a reinforcing, but yeah, then it should be "should do contain" rather than "should does contain"...), still the code itself does not read perfectly anyway with that extraneous "from" ("should(from(contain...)))").
Anyway, if I may still give a suggestion, I found it quite hard not having conditions like "class should contain {...}" (like in this case) or simple "exist" conditions (something like: noMethods().that().areDeclaredIn(MyClass.class).and().areAnnotatedWith(MyAnnotaion.class).should().exist()).