Specify multiple single value extractors in flatExtracting

[joel-costigliola]

For the time being, to extract multiple values and combine them before performing assertions we have to do something like this:

// ch type is TolkienCharacter
assertThat(fellowshipOfTheRing).flatExtracting(ch -> asList(input.getName(), ch.getAge()))
                               .contains(33 ,"Frodo", "Legolas", 1000);

It would be nice to simply specify the list of extractors (Java 8) :

assertThat(fellowshipOfTheRing).flatExtracting(TolkienCharacter::getName, 
                                               TolkienCharacter::getAge))
                               .contains(33 ,"Frodo", "Legolas", 1000);

or with properties names (Java 7) :

assertThat(fellowshipOfTheRing).flatExtracting("name", "age"))
                               .contains(33 ,"Frodo", "Legolas", 1000);

[PascalSchumacher]

I already have working prototype for the multiple extractor function method. I will clean it up and submit a pull requests.

[PascalSchumacher]

Just noticed that the prototype is not working. It was expecting all collections to contain objects of the same type.

When I tried to make it work for untyped objects, there is a conflict between the two method signatures:

public <V> ListAssert<V> flatExtracting(Extractor<? super T, ? extends Collection<V>> extractor)

public ListAssert<Object> flatExtracting(Function<Object, ? extends Collection<Object>>... extractors)

so it does not seem to be possible to make this work (unless I'm missing something).

[joel-costigliola]

I think what we want is :

public ListAssert<Object> flatExtracting(Function<Object, Object>... extractors)
// or
public ListAssert<Object> flatExtracting(Extractor<Object, Object>... extractors)

and not:

public ListAssert<Object> flatExtracting(Function<Object, ? extends Collection<Object>>... extractors)

the reason being that each extractor extracts one value, combine them in a list and flatten it.
conceptually it is converting a list of single value extractors to one multi value extractor, like allAsList in guava's future.

This will solve the compilation problem I think.

As a side note, I'm not sure whether we would need to use wildcard or not, e.g:

public ListAssert<Object> flatExtracting(Extractor<? super Object, ? extends Object>... extractors)

[PascalSchumacher]

I do not understand. If we want to extract a single value why use flatExtracting? The existing method public <V> ListAssert<V> flatExtracting(Extractor<? super T, ? extends Collection<V>> extractor) does not extract single values. For extracting single values is the extracting method. Or I'm I missing something?

Anyway:

public ListAssert<Object> flatExtracting(Function<Object, Object>... extractors)
public ListAssert<Object> flatExtracting(Extractor<Object, Object>... extractors)
public ListAssert<Object> flatExtracting(Extractor<? super Object, ? extends Object>... extractors)

each cause a compile time conflict with the existing method:

public <V> ListAssert<V> flatExtracting(Extractor<? super T, ? extends Collection<V>> extractor)

[joel-costigliola]

We want to extract multiple single values as in:

assertThat(fellowshipOfTheRing).flatExtracting(TolkienCharacter::getName, 
                                               TolkienCharacter::getAge))
                               .contains(33 ,"Frodo", "Legolas", 1000);

We combine them in a list so that our users don't have to do it manually as in:

// ch type is TolkienCharacter
assertThat(fellowshipOfTheRing).flatExtracting(ch -> asList(input.getName(), ch.getAge()))
                               .contains(33 ,"Frodo", "Legolas", 1000);

@PascalSchumacher does it make sense to you ?

[PascalSchumacher]

Sure, thanks for explaining. :)

[joel-costigliola]

Done for 2.5.0 by specifying extractors by name and 3.5.0 by specifying extractors as lambdas.