@Test public void throwsExceptionOnAccessingWrongExpression() throws Exception { final FilteredFacetExpression<Object> facet = FilteredFacetExpression.of("some wrong facet"); assertThat(facet.expression()).isEqualTo("some wrong facet"); assertThatThrownBy(() -> facet.attributePath()).isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> facet.value()).isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> facet.alias()).isInstanceOf(IllegalArgumentException.class); assertThatThrownBy(() -> facet.resultPath()).isInstanceOf(IllegalArgumentException.class); }
public FilteredFacetExpression<T, V> only(final Iterable<V> values) { return new FilteredFacetExpression<>(this, typeSerializer, values, alias); } }
@Override public boolean equals(Object o) { return o != null && o instanceof FacetExpression && toSphereFacet().equals(((FacetExpression) o).toSphereFacet()); } }
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); } }); } }
@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"); }
public FilteredFacetResult getFacetResult(final FilteredFacetExpression<T> facetExpression) { return getFilteredFacetResult(facetExpression.resultPath()); }
@Test public void buildsFilteredFacetExpressionWithAlias() throws Exception { final FilteredFacetExpression<Object> facet = FilteredFacetExpression.of(ATTRIBUTE_PATH + TERM_VALUE + AS_ALIAS); assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + TERM_VALUE + AS_ALIAS); assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(facet.value()).isEqualTo(TERM_VALUE); assertThat(facet.alias()).isEqualTo(ALIAS); assertThat(facet.resultPath()).isEqualTo(ALIAS); }
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 buildsFilteredFacetExpression() throws Exception { final FilteredFacetExpression<Object> facet = FilteredFacetExpression.of(ATTRIBUTE_PATH + TERM_VALUE); assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + TERM_VALUE); assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(facet.value()).isEqualTo(TERM_VALUE); assertThat(facet.alias()).isNull(); assertThat(facet.resultPath()).isEqualTo(ATTRIBUTE_PATH); }
@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 buildsFilteredFacetExpression() throws Exception { final FilteredFacetExpression<Object> facet = TermFacetSearchModel.of(ATTRIBUTE_PATH, ofString()).onlyTerm(TERMS); assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + TERM_VALUE); assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(facet.value()).isEqualTo(TERM_VALUE); 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 buildsFilteredFacetExpressionWithAlias() throws Exception { final FilteredFacetExpression<Object> facet = TermFacetSearchModel.of(ATTRIBUTE_PATH, ofString()).withAlias(ALIAS).onlyTerm(TERMS); assertThat(facet.expression()).isEqualTo(ATTRIBUTE_PATH + TERM_VALUE + AS_ALIAS); assertThat(facet.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(facet.value()).isEqualTo(TERM_VALUE); assertThat(facet.alias()).isEqualTo(ALIAS); assertThat(facet.resultPath()).isEqualTo(ALIAS); }
@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 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); }); }