How to use

TermFacetExpression

in

io.sphere.sdk.search

@Test
public void buildsTermFacetExpressionWithAlias() throws Exception {
  final TermFacetExpression<Object> facet = TermFacetExpression.of(ATTRIBUTE_PATH + AS_ALIAS);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + AS_ALIAS);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isNull();
  assertThat(facet.alias()).isEqualTo(ALIAS);
  assertThat(facet.resultPath()).isEqualTo(ALIAS);
}

public TermFacetExpression<T, V> all() {
  return new TermFacetExpression<>(this, typeSerializer, alias);
}

  @Override
  public boolean equals(Object o) {
    return o != null && o instanceof FacetExpression && toSphereFacet().equals(((FacetExpression) o).toSphereFacet());
  }
}

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

@Test
public void usesAlias() throws Exception {
  final RangeTermFacetSearchModel<ProductProjection, BigDecimal> path = FACET_ATTR.ofNumber("size");
  assertThat(path.withAlias("my-facet").allTerms().expression()).isEqualTo("variants.attributes.size as my-facet");
  assertThat(path.withAlias("my-facet").onlyTerm(valueOf(38)).expression()).isEqualTo("variants.attributes.size:38 as my-facet");
  assertThat(path.withAlias("my-facet").onlyLessThan(valueOf(38)).expression()).isEqualTo("variants.attributes.size:range(* to 38) as my-facet");
}

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

public TermFacetResult getFacetResult(final TermFacetExpression<T> facetExpression) {
  return getTermFacetResult(facetExpression.resultPath());
}

@Test
public void canAccessNumberCustomAttributes() throws Exception {
  final String attrName = "length";
  assertThat(FACET_ATTR.ofNumber(attrName).allTerms().expression()).isEqualTo("variants.attributes.length");
  assertThat(FILTER_ATTR.ofNumber(attrName).is(valueOf(4))).extracting(expression()).containsExactly("variants.attributes.length:4");
  assertThat(SORT_ATTR.ofNumber(attrName).descWithMinValue().expression()).isEqualTo("variants.attributes.length desc.min");
}

@Test
public void buildsTermFacetExpression() throws Exception {
  final TermFacetExpression<Object> facet = TermFacetExpression.of(ATTRIBUTE_PATH);
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isNull();
  assertThat(facet.alias()).isNull();
  assertThat(facet.resultPath()).isEqualTo(ATTRIBUTE_PATH);
}

private <T> void testPagedSearchResult(final Consumer<PagedSearchResult<T>> test) {
  final Map<String, FacetResult> facets = new HashMap<>();
  facets.put(TERM_FACET_EXPR.resultPath(), TERM_FACET_RESULT);
  facets.put(RANGE_FACET_EXPR.resultPath(), RANGE_FACET_RESULT);
  facets.put(FILTERED_FACET_EXPR.resultPath(), FILTERED_FACET_RESULT);
  final PagedSearchResult<T> result = pagedSearchResult(facets);
  test.accept(result);
}

@Test
public void canAccessTextCustomAttributes() throws Exception {
  final String attrName = "brand";
  assertThat(FACET_ATTR.ofString(attrName).allTerms().expression()).isEqualTo("variants.attributes.brand");
  assertThat(FILTER_ATTR.ofString(attrName).is("Apple")).extracting(expression()).containsExactly("variants.attributes.brand:\"Apple\"");
  assertThat(SORT_ATTR.ofString(attrName).ascWithMaxValue().expression()).isEqualTo("variants.attributes.brand asc.max");
}

@Test
public void buildsTermFacetExpression() throws Exception {
  final TermFacetExpression<Object> facet = TermFacetSearchModel.of(ATTRIBUTE_PATH, ofString()).allTerms();
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isNull();
  assertThat(facet.alias()).isNull();
  assertThat(facet.resultPath()).isEqualTo(ATTRIBUTE_PATH);
}

@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 canAccessBooleanCustomAttributes() throws Exception {
  final String attrName = "isHandmade";
  assertThat(FACET_ATTR.ofBoolean(attrName).allTerms().expression()).isEqualTo("variants.attributes.isHandmade");
  assertThat(FILTER_ATTR.ofBoolean(attrName).is(true)).extracting(expression()).containsExactly("variants.attributes.isHandmade:true");
  assertThat(SORT_ATTR.ofBoolean(attrName).ascWithMaxValue().expression()).isEqualTo("variants.attributes.isHandmade asc.max");
}

@Test
public void buildsTermFacetExpressionWithAlias() throws Exception {
  final TermFacetExpression<Object> facet = TermFacetSearchModel.of(ATTRIBUTE_PATH, ofString()).withAlias(ALIAS).allTerms();
  assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + AS_ALIAS);
  assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH);
  assertThat(facet.value()).isNull();
  assertThat(facet.alias()).isEqualTo(ALIAS);
  assertThat(facet.resultPath()).isEqualTo(ALIAS);
}

@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 canCreateDateTimeAttributeExpressions() throws Exception {
  final String attrName = "createdDate";
  assertThat(FACET_ATTR.ofDateTime(attrName).allTerms().expression()).isEqualTo("variants.attributes.createdDate");
  assertThat(FILTER_ATTR.ofDateTime(attrName).is(dateTime("2001-09-11T22:05:09.203+00:00"))).extracting(expression()).containsExactly("variants.attributes.createdDate:\"2001-09-11T22:05:09.203Z\"");
  assertThat(SORT_ATTR.ofDateTime(attrName).ascWithMaxValue().expression()).isEqualTo("variants.attributes.createdDate asc.max");
}

@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 canAccessLastModifiedAt() throws Exception {
  assertThat(FACET_MODEL.lastModifiedAt().allTerms().expression()).isEqualTo("lastModifiedAt");
  assertThat(FILTER_MODEL.lastModifiedAt().is(dateTime("2001-09-11T22:05:09.203+00:00"))).extracting(expression()).containsExactly("lastModifiedAt:\"2001-09-11T22:05:09.203Z\"");
  assertThat(SORT_MODEL.lastModifiedAt().asc().expression()).isEqualTo("lastModifiedAt asc");
}

@Test
public void canCreateDateAttributeExpressions() throws Exception {
  final String attrName = "expirationDate";
  assertThat(FACET_ATTR.ofDate(attrName).allTerms().expression()).isEqualTo("variants.attributes.expirationDate");
  assertThat(FILTER_ATTR.ofDate(attrName).is(date("2001-09-11"))).extracting(expression()).containsExactly("variants.attributes.expirationDate:\"2001-09-11\"");
  assertThat(SORT_ATTR.ofDateTime(attrName).ascWithMaxValue().expression()).isEqualTo("variants.attributes.expirationDate asc.max");
}