ArchUnit test for Sharded fields for a domain class

[Vignesh413]

I need to write an ArchUnit test case for validating the existence of shardKey fields inside a domain class that is annotated with @Sharded my domain will like below:

public abstract class Parent<ID> {
    @Id
    private ID id;
    public final static String ID_FIELD = "_id";

    private String parent;
    public final static String PARENT_FIELD = "parent";
}


@Document(collection = COLLECTION_NAME)
@Sharded(shardKey = { "_id.studentId" })
public class Student extends Parent<Id> {
    public static final String COLLECTION_NAME = "student";

    public static class Id {

        private String studentId;
        public final static String STUDENT_ID_FIELD = "studentId";

        private String schoolId;
        public final static String SCHOOL_ID_FIELD = "schoolId";

        public Id() {}

        public Id(String studentId, String schoolId) {
            this.studentId = studentId;
            this.schoolId = schoolId;
        }
    }
}

[hankem]

There are some static methods

import static com.tngtech.archunit.base.DescribedPredicate.describe;
import static com.tngtech.archunit.lang.conditions.ArchConditions.have;
import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;

that allow you to write

@ArchTest
ArchRule shardedClassesHaveShardKey = 
    classes()
        .that().areAnnotatedWith(Sharded.class)
        .should(have(describe("a shardKey", shardedClass ->
            shardedClass.getAnnotationOfType(Sharded.class).shardKey().length > 0
        )));

[Vignesh413]

@hankem Thanks for your answer.
The solution you provide will useful for validating the mandatory existence of elements for @Sharded Annotation.
My requirement is the fields that we declared in the Sharded annotation should be available as field in the domain class.
If we create a new class with Sharded annotation and we forget to add the fields that are required in the class or we used different fields , the test will find that.

[hankem]

Ah, sorry; your requirements weren't clear to me initially. And I'm still not entirely sure. 😅
It looks like you have to recurse on a field hierarchy, which is tricky if generic types are involved.

But if all @Sharded classes inherit from Parent<ID>, which handles the _id field, and if there are no further generics, something like this might already be good enough:

@ArchTest
ArchRule shardedClassesHaveAvailableShardKeys =
    classes()
        .that().areAnnotatedWith(Sharded.class)
        .should(have(describe("available shardKeys", shardedClass ->
            stream(shardedClass.getAnnotationOfType(Sharded.class).shardKey())
                .allMatch(shardKey -> fieldExists(shardKey, shardedClass))
        )));

private boolean fieldExists(String key, JavaClass javaClass) {
    String[] parts = key.split("\\.", 2);
    String fieldName = parts[0];
    boolean hasGenericParent = javaClass.getSuperclass().map(superclass ->
        superclass instanceof JavaParameterizedType &&
        superclass.toErasure().getSimpleName().equals("Parent") // You can be more specific here. 
    ).orElse(false);
    if (fieldName.equals("_id") && hasGenericParent) {
        JavaType idType = ((JavaParameterizedType) javaClass.getSuperclass().get()).getActualTypeArguments().get(0);
        return fieldExists(parts[1], idType.toErasure());
    } else {
        var field = javaClass.getAllFields().stream()
            .filter(f -> f.getName().equals(fieldName))
            .findFirst();
        return field.isPresent() && (
            parts.length == 1 || 
            fieldExists(parts[1], field.get().getRawType()) // doesn't support generic fields
        );
    }
}