@Stanislav-Zabramnyi let's skip the word should in tests.
E.g. constructor throws exception if parameter is null

For those tests where we user @DisplayName, lets' start with a capital letter.
A constructor throws exception if parameter is null

This test is redundant, since it's covered by the next test.

@DisplayName("Constructor throws an exception when the target type has no Comparable fields")

@Stanislav-Zabramnyi let's follow the same naming convention. E.g. in other tests I usually go with something like this Method compare throws an exception when any param is null

I guess the pattern X does Y when Z

@DisplayName("Method compare returns 1 when the first field value is null")

⛔️ My implementation didn't pass the tests not because it was incorrect, but because the name of the field was targetField not fieldToCompare.

What we want to do is either explicitly say in the test that which field name you expect. E.g. have a test
A class has a field called fieldToCompare of type Field – but I don't think it's a good idea in this exercise.

Or just be more flexible and let people come up with any name for that field.
For instance, you can rely on type instead of the name

 private Field getFieldToCompare() {
 return Arrays.stream(randomFieldComparator.getClass().getDeclaredFields())
 .filter(f -> f.getType().equals(Field.class))
 .findAny()
 .orElseThrow();
 }

Please replace this method with
Comparable.class.isAssignableFrom(type)

Your filter logic will ignore all primitive fields 😅 which is not cool.

When you can to the Comparable, it would be better to force the type. So you know that value1 and value2 have the same type comparable type (currently you use Comparable as a raw type). I'm not sure if you know what I mean. I can show it later.

The following logic is a natural null-safe compression. So I'd use Comparator.nullsLast(Comparator.naturalOrder()). What do you think?

Yes, I thought about this way of implementation, but then I decided that it is not obvious and may increase the cognitive load of the person doing this exercise, since this logic with Comparator is not related to the topic of reflection. In short, case with 'if' more readable.