How to compare LISTS recursively ignoring given fields using assertJ?

Question

Firstly, this is not a duplicate of this question. There, it is asked specifically for an object. I want to do this for a Container, specifically a List.

So, I know I can ignore a field when using usingElementComparatorIgnoringFields() But this won't do a recursive comparison.

I know I can use usingRecursiveFieldByFieldElementComparator(). But this will not allow me to exclude a given field.

How can I compare recursively, ignoring a field?

Scintillate

Answer 1

this is going to be in the next AssertJ Core version: https://github.com/joel-costigliola/assertj-core/issues/1002

Statued

Answer 2

Starting AssertJ Core 3.20.0 you can use usingRecursiveFieldByFieldElementComparatorIgnoringFields(String... fields) method:

assertThat(actualList)
        .usingRecursiveFieldByFieldElementComparatorIgnoringFields("field1", "field2")
        .isEqualTo(expectedList);

Spark

Answer 3

Meanwhile you could write this:

assertThat(actualList)
            .usingElementComparator(recursiveIgnoringComparator("excludedField1", "excludedField2", "excludedField3"))
            .containsExactlyInAnyOrder(expectedList);
}

private Comparator<T> recursiveIgnoringFieldsComparator(String... fieldNames) {
    final Map<String, Comparator<?>> comparatorByPropertyOrField =
            Arrays.stream(fieldNames)
                    .collect(toMap(
                            name -> name,
                            name -> (o1, o2) -> 0
                    ));

    return new RecursiveFieldByFieldComparator(comparatorByPropertyOrField, new TypeComparators());
}

Drawshave

Answer 4

@Arkadiusz example didn't work for me. Also, I had a recursive problems with lists, so my solution is tailored to that case. So what I did was (Kotlin code):

private fun recursiveListComparatorFactory(vararg ignoreFields: String): Comparator<List<*>> {
    return Comparator { o1, o2 ->
        assertThat(o1).hasSameSizeAs(o2)
        for (i in o1.indices) {
            assertThat(o1[i]).usingComparatorForType(recursiveListComparatorFactory(*ignoreFields), List::class.java).isEqualToIgnoringGivenFields(o2[i], *ignoreFields)
        }
        0 // return
    }
}

and then just call:

val ignoreFields = ["id", "version"]
assertThat(o1).usingComparatorForType(recursiveListComparatorFactory(ignoreFields), List::class.java).isEqualToIgnoringGivenFields(o2, ignoreFields)

Tical