How to use ArchUnit tests in Parametrized tests (checking one JavaClass after the next and not all JavaClasses at once)

[mrtnlhmnn]

First: ArchUnit really rocks, great work. Very helpful, so thanks very much for your work! ❤️ 👍

Actually I was coming around the following problem these days. In my tests I want to ensure that some classes (actually domain classes in an onion architecture) fulfill some condition(s).

I have an ArchUnit test which looks like this:

  static final GivenClassesConjunction domainClasses = ArchRuleDefinition.classes()
            .that()
            .resideInAnyPackage(PACKAGE_FOO_DOMAIN_MODEL,
                    PACKAGE_BAR_DOMAIN_MODEL)
            .and()
            .areNotEnums()
            .and()
            .areNotInnerClasses()
            .and()
            .areNotRecords();
...
    static ArchCondition<JavaClass> satisfiesMyCondition() {
        return new ArchCondition<>("satisfies my condition") {
            @Override
            public void check(JavaClass javaClass, ConditionEvents events) {
                if (... check on javaClass fails ...) {
                    String message = "condition failed on " + javaClass;
                    events.add(SimpleConditionEvent.violated(javaClass, message));
                }
            }
        };
    }
...
    @Test
    void test_DomainClassesFullfillMyCondition() {
        JavaClasses allJavaClassesToCheck = new ClassFileImporter()
                .withImportOption(ImportOption.Predefined.DO_NOT_INCLUDE_TESTS)
                .importPackages("some.package.prefix");

        // arrange
        ArchRule archRule = domainClasses.should(satisfiesMyCondition());

        // act
        EvaluationResult evaluationResult = archRule.evaluate( allJavaClassesToCheck );

        // assert
        assertThat(evaluationResult.getFailureReport().getDetails()).isEmpty();
    }

So this works well, no problem so far.

Actually now I came across the idea that perhaps I can rewrite this to a ParametrizedTest. So not checking all JavaClasses from the ClassFileImporter at once but filtering out the domainClasses, put them to a Stream<JavaClass> and then check one JavaClass after the next. I would appreciate some advice here. Not sure if this is even possible today.

I see a bunch of hurdles:
(1) Trivial enough: the ArchRule's methods check and evaluate always get JavaClasses, not a single JavaClass . I have an ugly workaround for this - by reimporting all classes and then filtering only the JavaClass I want to check (not nice, totally inefficient). Ok, so be it. (I tried also to create a JavaClasses instance out of the JavaClass but its constructors are (package) private.)

(2) My bigger issue: Ideally, I would like to use the GivenClassesConjunction as shown above. Nice API, fluent and verbose methods like for example resideInAnyPackage(...). Is there a way to create a Stream<JavaClass> out of this? If so, I could write some parametrized test like this (pseudo code):

    @ParameterizedTest
    @MethodSource("retrieveJavaClassesFromGivenClassesConjunction")
    void testMyConditionOnJavaClass(JavaClass javaClass) {
        ArchRule rule = classes().should(myCondition());
        rule.check(javaClass); // does not work, see (1) above
    }

Is something like this possible? What am I missing? Any help and advice very much appreciated! ❤️

PS: I understand, that I could create a Stream like this:

    Stream<JavaClass> getFilteredClasses() {
        JavaClasses javaClasses = new ClassFileImporter()
                .withImportOption(new ImportOption.DoNotIncludeTests())
                .importPackages("com.your.package");
        return javaClasses.that( someFiltering ).stream();
    }

My problem (or lack of understanding?) is here, that someFiltering is then a DescribedPredicate<JavaClass> . Actually I would really like to re-use the fluent API of GivenClassesConjunction like for example resideInAnyPackage(...) directly - and not to reimplement its functionality by checking in the predicate's test method, if the JavaClass's package is in any of the packages (including the wildcard functionality you have already implemented).

[hankem]

I'm glad that you like ArchUnit! Here are some ideas how to address your hurdles:

(1) javaClasses.that(describedPredicate) returns a JavaClasses object. You can always start filtering from the same instance of imported classes; there's no need to reimport them:

    static final JavaClasses importedClasses = new ClassFileImporter().// ...

    @ParameterizedTest
    @MethodSource("domainClasses")
    void testMyConditionOnJavaClass(JavaClass javaClass) {
        ArchRule rule = classes().should(myCondition());
        JavaClasses selectedClass = importedClasses.that(have(name(javaClass.getName())));
        rule.check(selectedClass);
    }

(2) To retrieve individual classes from a given conjunction, I can think of a workaround evaluating a rule where the condition does nothing but dump the objects selected by the given conjunction:

    static List<JavaClass> domainClasses() {
        return extractGivenObjects(domainClasses, importedClasses);
    }

    static <T> List<T> extractGivenObjects(GivenConjunction<T> conjunction, JavaClasses classes) {
        List<T> filteredObjects = new ArrayList<>();
        conjunction.should(new ArchCondition<T>("just a hack to retrieve the filtered") {
            @Override
            public void check(T item, ConditionEvents events) {
                filteredObjects.add(item);
            }
        }).evaluate(classes);
        return filteredObjects;
    }

Does this help?