public Optional<FilteredFacetResult> getFilteredFacetResult(final FilteredFacetExpression<T, ?> facetExpression) { return getFacetResult(facetExpression.resultPath()).map(facetResult -> { if (facetResult instanceof FilteredFacetResult) { return (FilteredFacetResult) facetResult; } else { // TODO Use another type of exception once exception task is finished throw new RuntimeException("Facet result is not of type FilterFacetResult: " + facetResult); } }); } }
@SuppressWarnings("unchecked") public <V> Optional<TermFacetResult<V>> getTermFacetResult(final TermFacetExpression<T, V> facetExpression) { return getFacetResult(facetExpression.resultPath()).map(facetResult -> { if (facetResult instanceof TermFacetResult) { return (TermFacetResult) facetResult; } else { // TODO Use another type of exception once exception task is finished throw new RuntimeException("Facet result is not of type TermFacetResult: " + facetResult); } }); }
@SuppressWarnings("unchecked") public <V extends Comparable<? super V>> Optional<RangeFacetResult<V>> getRangeFacetResult(final RangeFacetExpression<T, V> facetExpression) { return getFacetResult(facetExpression.buildResultPath()).map(facetResult -> { if (facetResult instanceof RangeFacetResult) { return (RangeFacetResult) facetResult; } else { // TODO Use another type of exception once exception task is finished throw new RuntimeException("Facet result is not of type RangeFacetResult: " + facetResult); } }); }
private static void testRangeStats(final RangeFacetExpression<ProductProjection> facetExpr, final Consumer<RangeStats> test) { final List<RangeStats> ranges = executeSearchWithFacets(facetExpr).getFacetResult(facetExpr).getRanges(); assertThat(ranges).hasSize(1); test.accept(ranges.get(0)); }
private static void testResultWithTerms(final TermFacetedSearchExpression<ProductProjection> facetedSearchExpr, final Consumer<List<String>> testFilter, final Consumer<List<TermStats>> testTerms) { final PagedSearchResult<ProductProjection> result = executeFacetedSearch(facetedSearchExpr, testFilter); testTerms.accept(result.getFacetResult(facetedSearchExpr).getTerms()); }
private static void testTermStats(final TermFacetExpression<ProductProjection> facetExpr, final Consumer<List<TermStats>> test) { final List<TermStats> termStats = executeSearchWithFacets(facetExpr).getFacetResult(facetExpr).getTerms(); test.accept(termStats); }
private static void testResult(final ProductProjectionSearch search, final Consumer<List<String>> testFilter, final Consumer<List<TermStats>> testColors, final Consumer<List<TermStats>> testSizes) { assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> { final PagedSearchResult<ProductProjection> result = executeSearch(search); testFilter.accept(toIds(result.getResults())); testColors.accept(result.getFacetResult(COLOR_FACETED_SEARCH).getTerms()); testSizes.accept(result.getFacetResult(SIZE_FACETED_SEARCH).getTerms()); }); } }
@Test public void termFacetResult() throws Exception { testPagedSearchResult(result -> { assertThat(result.getFacetResult(TERM_FACET_EXPR)).isEqualTo(TERM_FACET_RESULT); assertThat(result.getTermFacetResult("non-existent")).isNull(); assertThatThrownBy(() -> result.getTermFacetResult(RANGE_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> result.getTermFacetResult(FILTERED_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); }); }
@Test public void filteredFacetResult() throws Exception { testPagedSearchResult(result -> { assertThat(result.getFacetResult(FILTERED_FACET_EXPR)).isEqualTo(FILTERED_FACET_RESULT); assertThat(result.getFilteredFacetResult("non-existent")).isNull(); assertThatThrownBy(() -> result.getFilteredFacetResult(TERM_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> result.getFilteredFacetResult(RANGE_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); }); }
@Test public void rangeFacetResult() throws Exception { testPagedSearchResult(result -> { assertThat(result.getFacetResult(RANGE_FACET_EXPR)).isEqualTo(RANGE_FACET_RESULT); assertThat(result.getRangeFacetResult("non-existent")).isNull(); assertThatThrownBy(() -> result.getRangeFacetResult(TERM_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> result.getRangeFacetResult(FILTERED_FACET_EXPR.resultPath())) .isInstanceOf(IllegalArgumentException.class); }); }
@Test public void simpleFacetsAreParsed() throws Exception { final TermFacetExpression<ProductProjection> facetExpr = TermFacetExpression.of("variants.attributes." + ATTR_NAME_COLOR); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { final TermFacetResult termFacetResult = result.getFacetResult(facetExpr); assertThat(termFacetResult.getMissing()).isGreaterThanOrEqualTo(3); assertThat(termFacetResult.getTotal()).isEqualTo(3); assertThat(termFacetResult.getOther()).isEqualTo(0); assertThat(termFacetResult.getTerms()).isEqualTo(asList(TermStats.of("blue", 2L), TermStats.of("red", 1L))); }); }
@Test public void rangeFacetsAreParsed() throws Exception { final RangeFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofNumber(ATTR_NAME_SIZE).onlyGreaterThanOrEqualTo(ZERO); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { final RangeStats rangeStats = result.getFacetResult(facetExpr).getRanges().get(0); assertThat(rangeStats.getLowerEndpoint()).isEqualTo("0.0"); assertThat(rangeStats.getUpperEndpoint()).isNull(); assertThat(rangeStats.getCount()).isEqualTo(6L); assertThat(rangeStats.getMin()).isEqualTo("36.0"); assertThat(rangeStats.getMax()).isEqualTo("46.0"); assertThat(rangeStats.getSum()).isEqualTo("246.0"); assertThat(rangeStats.getMean()).isEqualTo(41.0); }); }
@Test public void rangeFacetsSupportsAlias() throws Exception { final String alias = "my-facet"; final RangeFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofNumber(ATTR_NAME_SIZE).withAlias(alias).onlyGreaterThanOrEqualTo(ZERO); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { assertThat(facetExpr.resultPath()).isEqualTo(alias); final RangeStats rangeStats = result.getFacetResult(facetExpr).getRanges().get(0); assertThat(rangeStats.getLowerEndpoint()).isEqualTo("0.0"); assertThat(rangeStats.getUpperEndpoint()).isNull(); assertThat(rangeStats.getCount()).isEqualTo(6L); assertThat(rangeStats.getMin()).isEqualTo("36.0"); assertThat(rangeStats.getMax()).isEqualTo("46.0"); assertThat(rangeStats.getSum()).isEqualTo("246.0"); assertThat(rangeStats.getMean()).isEqualTo(41.0); }); }
@Test public void searchForReviewsWithAverageRatingGreaterThan2() { final List<FacetRange<BigDecimal>> facetRanges = IntStream.range(LOWEST_RATING, HIGHEST_RATING) .mapToObj(i -> FacetRange.of(new BigDecimal(i), new BigDecimal(i + 1))) .collect(toList()); assertThat(facetRanges.toString()).isEqualTo("[[0 to 1), [1 to 2), [2 to 3), [3 to 4), [4 to 5)]"); final ProductProjectionSearch searchRequest = ProductProjectionSearch.ofStaged()//in prod it would be current .withResultFilters(m -> m.reviewRatingStatistics().averageRating().isGreaterThanOrEqualTo(new BigDecimal(2))) .withFacets(m -> m.reviewRatingStatistics().averageRating().onlyRange(facetRanges)) .withSort(m -> m.reviewRatingStatistics().averageRating().desc()); assertEventually(Duration.ofSeconds(60), Duration.ofMillis(100), () -> { final PagedSearchResult<ProductProjection> result = client().executeBlocking(searchRequest); assertThat(result.getResults()).hasSize(2); final ProductProjection productProjection = result.getResults().get(0); assertThat(productProjection.getReviewRatingStatistics().getCount()).isEqualTo(REVIEWS_PER_PRODUCT); final RangeFacetResult facetResult = (RangeFacetResult) result.getFacetResult("reviewRatingStatistics.averageRating"); assertThat(facetResult.getRanges().get(2)).isEqualTo(RangeStats.of("2.0", "3.0", 2L, null, "2.2", "2.7", "4.9", 2.45)); }); }
@Test public void termFacetsAreParsed() throws Exception { final TermFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).allTerms(); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { final TermFacetResult termFacetResult = result.getFacetResult(facetExpr); assertThat(termFacetResult.getMissing()).isGreaterThanOrEqualTo(3); assertThat(termFacetResult.getTotal()).isEqualTo(3); assertThat(termFacetResult.getOther()).isEqualTo(0); assertThat(termFacetResult.getTerms()).isEqualTo(asList(TermStats.of("blue", 2L), TermStats.of("red", 1L))); }); }
@Test public void filteredFacetsSupportsAlias() throws Exception { final String alias = "my-facet"; final FilteredFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).withAlias(alias).onlyTerm("blue"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { assertThat(facetExpr.resultPath()).isEqualTo(alias); assertThat(result.getFacetResult(facetExpr).getCount()).isEqualTo(2); }); }
@Test public void filteredFacetsAreParsed() throws Exception { final FilteredFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).onlyTerm("blue"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> { final FilteredFacetResult filteredFacetResult = result.getFacetResult(facetExpr); assertThat(filteredFacetResult.getCount()).isEqualTo(2); }); }
@Test public void responseContainsRangeFacetsForAttributes() throws Exception { final RangeFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().price().centAmount().onlyGreaterThanOrEqualTo(0L); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> assertThat(result.getFacetResult(facetExpr).getRanges().get(0).getCount()).isGreaterThan(0)); }
@Test public void termFacetsSupportsAlias() throws Exception { final String allFacetAlias = "my-facet"; final String blueFacetAlias = "my-blue-facet"; final TermFacetExpression<ProductProjection> allFacetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).withAlias(allFacetAlias).allTerms(); final FilteredFacetExpression<ProductProjection> blueFacetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).withAlias(blueFacetAlias).onlyTerm("blue"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .plusFacets(allFacetExpr) .plusFacets(blueFacetExpr); testResult(search, result -> { final TermFacetResult allFacetResult = result.getFacetResult(allFacetExpr); final FilteredFacetResult blueFacetResult = result.getFilteredFacetResult(blueFacetAlias); assertThat(allFacetExpr.resultPath()).isEqualTo(allFacetAlias); assertThat(blueFacetExpr.resultPath()).isEqualTo(blueFacetAlias); assertThat(allFacetResult.getTerms()).isEqualTo(asList(TermStats.of("blue", 2L), TermStats.of("red", 1L))); assertThat(blueFacetResult.getCount()).isEqualTo(2); }); }
@Test public void responseContainsTermFacetsForAttributes() throws Exception { final TermFacetExpression<ProductProjection> facetExpr = PRODUCT_MODEL.allVariants().attribute().ofString(ATTR_NAME_COLOR).allTerms(); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().plusFacets(facetExpr); testResult(search, result -> assertThat(result.getFacetResult(facetExpr).getTerms()).containsOnly(TermStats.of("blue", 2L), TermStats.of("red", 1L))); }