public Predicate<InMemoryFilterable> parse(final List<String> filterExpressions,
                                               final List<EntityAttribute> attributes) {
        if (filterExpressions == null || filterExpressions.isEmpty()) {
            return Predicates.alwaysTrue();
        }
        final Map<String, List<Filter>> groupedByField = filterExpressions.stream()
                .map(expr -> singleFilterParser.parseSingleExpression(expr, attributes))
                .collect(groupingBy(Filter::field));

        return groupedByField.values().stream()
                .map(grouped -> grouped.stream()
                        .map(Filter::toPredicate)
                        .collect(Collectors.toList()))
                .map(groupedPredicates -> groupedPredicates.stream().reduce(Predicate::or).orElse(Predicates.alwaysTrue()))
                .reduce(Predicate::and).orElse(Predicates.alwaysTrue());
    }
@Test
    void throwsExceptionOnFieldThatDoesNotExistInAttributeList() {

        assertThrows(IllegalArgumentException.class, () ->
                toTest.parse(List.of("strange_field:blabla"),
                        List.of(EntityAttribute.builder()
                                .id("owner")
                                .title("Owner")
                                .filterable(true)
                                .build())
                ));
    }