How to use

TermFacetResult

in

io.sphere.sdk.search

  public static TermFacetResult of(final Long missing, final Long total, final Long other, final List<TermStats> terms) {
    return new TermFacetResult(missing, total, other, terms);
  }
}

@Test
public void parsesTermFacetResults() throws Exception {
  final TermFacetResult termFacet = searchResult.getTermFacetResult(TERM_FACET_KEY);
  assertThat(termFacet.getMissing()).isEqualTo(44);
  assertThat(termFacet.getTotal()).isEqualTo(6937);
  assertThat(termFacet.getOther()).isEqualTo(0);
  assertThat(termFacet.getTerms()).hasSize(21);
  assertThat(termFacet.getTerms().get(2)).isEqualTo(TermStats.of("4B432E_1", 585L));
}

@Test
public void parsesTermFacetResultsProductCounts() throws Exception {
  final TermFacetResult termFacet = searchResult.getTermFacetResult(TERM_FACET_COUNTING_PRODUCTS_KEY);
  assertThat(termFacet.getTerms()).hasSize(2);
  assertThat(termFacet.getTerms().get(0).getProductCount()).isEqualTo(372);
  assertThat(termFacet.getTerms().get(1).getProductCount()).isEqualTo(195);
}

@Test
public void facetAndFilter() {
  final ReviewRatingStatisticsFacetedSearchSearchModel<ProductProjection> reviewRatingsModel
      = ProductProjectionSearchModel.of().facetedSearch().reviewRatingStatistics();
  final TermFacetedSearchExpression<ProductProjection> count = reviewRatingsModel.count().is("20");
  final TermFacetedSearchExpression<ProductProjection> averageRating = reviewRatingsModel.averageRating().is("2.7");
  final TermFacetedSearchExpression<ProductProjection> highestRating = reviewRatingsModel.highestRating().is(String.valueOf(HIGHEST_RATING));
  final TermFacetedSearchExpression<ProductProjection> lowestRating = reviewRatingsModel.lowestRating().is(String.valueOf(LOWEST_RATING));
  final ProductProjectionSearch productProjectionSearch = ProductProjectionSearch.ofStaged()
      .withQueryFilters(m -> m.id().is(product.getId()))
      .plusFacetedSearch(asList(count, averageRating, highestRating, lowestRating));
  assertEventually(() -> {
    final PagedSearchResult<ProductProjection> result = client().executeBlocking(productProjectionSearch);
    final List<ProductProjection> productProjectionList = result.getResults();
    assertThat(productProjectionList).isNotEmpty();
    assertThat(productProjectionList.get(0).getId()).isEqualTo(product.getId());
    assertThat(result.getFacetResult(count).getTotal()).as("count facet").isEqualTo(1L);
    assertThat(result.getFacetResult(averageRating).getTotal()).as("averageRating facet").isEqualTo(1L);
    assertThat(result.getFacetResult(highestRating).getTotal()).as("highestRating facet").isEqualTo(1L);
    assertThat(result.getFacetResult(lowestRating).getTotal()).as("lowestRating facet").isEqualTo(1L);
  });
}

@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)));
  });
}

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);
}

@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)));
  });
}

  public static <T> TermFacetResult<T> of(final long missing, final long total, final long other, final List<TermStats<T>> terms) {
    return new TermFacetResult<>(missing, total, other, terms);
  }
}

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 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 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)));
}

@Test
public void facetSearchByScopedPriceDiscounted() {
  withProductOfPrices(asList(PriceDraft.of(EURO_20), PriceDraft.of(EURO_30).withCountry(DE)), product1 -> {
    withProductOfPrices(asList(PriceDraft.of(EURO_30), PriceDraft.of(EURO_40).withCountry(DE)), product2 -> {
      withProductOfPrices(asList(PriceDraft.of(EURO_40), PriceDraft.of(EURO_25).withCountry(DE)), product3 -> {
        final ProductDiscountDraft productDiscountDraft1 = discountDraftOfAbsoluteValue(product1, EURO_5);
        withProductDiscount(client(), productDiscountDraft1, productDiscount1 -> {
          assertEventually(s -> {
            final TermFacetExpression<ProductProjection> facetExpression = ProductProjectionSearchModel.of()
                .facet().allVariants().scopedPriceDiscounted().allTerms();
            final ProductProjectionSearch search = ProductProjectionSearch.ofStaged()
                .withPriceSelection(PriceSelection.of(EUR).withPriceCountry(DE))
                .plusQueryFilters(m -> m.id().isIn(asList(product1.getId(), product2.getId(), product3.getId())))
                .withFacets(facetExpression);
            final PagedSearchResult<ProductProjection> results = client().executeBlocking(search);
            assertThat(results.getResults()).hasSize(3);
            final List<TermStats> termStats = results.getFacetResult(facetExpression).getTerms();
            s.assertThat(termStats).containsOnly(
                TermStats.of(BOOL_TRUE, 1L),
                TermStats.of(BOOL_FALSE, 2L));
          });
        });
      });
    });
  });
}