anyOf and allOf variants for multiple ThrowingConsumer parameters

[onacit]

Feature summary

I need to assert with satisfiesAnyOf for each element in an iterable.

This may be a collection version of #1304 .

List<Some> some = getSome();

// Now each some.other should be asserted by any of multiple conditions.

some.stream.map(Some::getOther).forEach(o -> {
    assertThat(o).satisfiesAnyOf(
        o1 -> assertThat(o1).isNull(),
        o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x);     
    );
});

assertThat(some)
    .extracting(Some::getOther)
    .allSatisfy(o -> {
        assertThat(o).satisfiesAnyOf(
            o1 -> assertThat(o1).isNull(),
            o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x);     
        );
    });

Example

List<Some> some = getSome();
assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfyAnyOf( // or eachSatisfiesAnyOf
        o -> {},
        o -> {}
    );        

[joel-costigliola]

allSatisfyAnyOf could be a good addition to keep the assertion light, @scordio thoughts?

[scordio]

If I understood it correctly, we want to transform this:

assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfy(o -> {
        assertThat(o).satisfiesAnyOf(
            o1 -> assertThat(o1).isNull(),
            o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x)
        )
    });

into this:

assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfyAnyOf(
        o -> assertThat(o).isNull(),
        o -> assertThat(o).isNotNull().extracting(Other::getId).isEqualTo(x);     
    );

which is indeed easier to read.

However, this would open the door to other combinations:

• allSatisfyAllOf
• anySatisfyAllOf
• anySatisfyAnyOf

Adding anyMatch / allMatch combinations as well would mean four more methods.

Are we willing to add all of these?

With some formatting adjustments, the original example could look like this:

assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfy(o -> assertThat(o).satisfiesAnyOf(
        o1 -> assertThat(o1).isNull(),
        o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x)
    ));

which I personally consider a good compromise.

[joel-costigliola]

Fair point, we don't want to have so many combinations

[onacit]

If I may, I want to contribute to the project by sharing my solution.

I have an abstract base class for my entity classes.

public abstract class _Mapped<T extends _Mapped<T, U>, U> {

    @Transient
    protected @Nullable U _getId() {
        return ...;
    }
}

An here comes one of entities.

@Entity
@Table(name = ...)
public class Some extends _Mapped<Some, Long> {

    public void setOther(final Other other) {
        this.other = other;
        setOtherId(
                Optional.ofNullable(this.other)
                        .map(Other::getId)
                        .orElse(null)
        );
    }

    @Column(name = COLUMN_NAME_OTHER_ID, nullable = false)
    private Long otherId;

    @Valid
    @NotFound(action = NotFoundAction.IGNORE) // -> EAGER!
    @ManyToOne(optional = /*false*/true, fetch = FetchType.LAZY)
    @JoinColumn(name = COLUMN_NAME_OTEHR_ID, nullable = false, insertable = false, updatable = false,
                foreignKey = @ForeignKey(ConstraintMode.NO_CONSTRAINT))
    @EqualsAndHashCode.Exclude
    @ToString.Exclude
    private Other other; // either null or has its `id` equal to `otherId`
}

Now, with a list of selected Some instances, I want to assert that each element's other attribute is either null or its id attribute is equal to sibling otherId.

As an already applicable solution, I can do this.

List<Some> list = selectSome();
list.forEach(s -> {
    assertThat(s.getOther()).satisfiesAnyOf(
        o -> assertThat(o).isNull(),
        o -> assertThat(o).isNotNull().extracting(Other::getId).isEqualTo(s.getOtherId());
    );
});

Nothing's wrong, as already mentioned, yet the Condition can help.

public final class _MappedConditions {

    public static <T extends _Mapped<T, U>, U> Condition<T> id(final U id) {
        return new Condition<>(
                t -> {
                    assert t != null;
                    return Objects.equals(t._getId(), id);
                },
                String.format("should has id of %1$s", id)
        );
    }
}

Now the expression may look like this.

        list.forEach(s -> {
            assertThat(s.getOther()).satisfiesAnyOf(
                    o -> assertThat(o).isNull(),
                    o -> assertThat(o).isNotNull().has(id(r.getOtherId()))
            );
        });

And another Condition combining the previous condition may do more.

    public static <T extends _Mapped<T, U>, U> Condition<T> nullOrHasId(final U id) {
        final Condition<T> hasId = id(id);
        return new Condition<>(
                t -> t == null || hasId.matches(t),
                "should be null or " + hasId.description().value()
        );
    }

Which leads the statements look like this.

        list.forEach(s -> {
            assertThat(s.getOther()).is(nullOrHasId(r.getOtherId()));
        });
        // or
        assertThat(list).allSatisfy(s -> {
            assertThat(s.getOther()).is(nullOrHasId(r.getOtherId()));
        });

[scordio]

Reopening to discuss a potential improvement for this use case.

We could transform my example:

assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfy(o -> assertThat(o).satisfiesAnyOf(
        o1 -> assertThat(o1).isNull(),
        o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x)
    ));

into:

assertThat(some)
    .isNotEmpty()
    .extracting(Some::getOther)
    .allSatisfy(anyOf( // anyOf(ThrowingConsumer...) in Assertions?
        o1 -> assertThat(o1).isNull(),
        o1 -> assertThat(o1).isNotNull().extracting(Other::getId).isEqualTo(x)
    ));

where anyOf is defined as:

public static <T> ThrowingConsumer<T> anyOf(ThrowingConsumer<? super T>... assertions) {
  return e -> new ObjectAssert<>(e).satisfiesAnyOf(assertions);
}

Also, an allOf with similar pattern could be defined.

We already have other anyOf and allOf methods in Assertions but they are related to Conditions.

@joel-costigliola @onacit thoughts?

[joel-costigliola]

LGTM

[onacit]

@scordio What an elegant syntax/idiom you suggested! Thanks!

[scordio]

There is one aspect where I see a potential issue.

If we would put anyOf / allOff in Assertions, from a signature perspective there is nothing connecting the new methods to allSatisfy assertions:

public static <T> ThrowingConsumer<T> anyOf(ThrowingConsumer<? super T>... assertions) {
  ...
}

This means they would "steal" the ThrowingConsumer vararg parameter usage. This might still be ok, though.