@Override public final boolean equals(Object o) { return o != null && o instanceof SortExpression && expression().equals(((SortExpression) o).expression()); }
@Test public void buildsSortExpression() throws Exception { final SortExpression<Object> sort = SortExpression.of(ATTRIBUTE_PATH + " " + ASC_MAX); assertThat(sort.expression()).isEqualTo(ATTRIBUTE_PATH + " " + ASC_MAX); assertThat(sort.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(sort.value()).isEqualTo(ASC_MAX.toString()); }
@Test public void buildsSingleValuedSortExpression() throws Exception { final SortExpression<Object> sort = SingleValueSortSearchModel.of(ATTRIBUTE_PATH).asc(); assertThat(sort.expression()).isEqualTo(ATTRIBUTE_PATH + " " + ASC); assertThat(sort.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(sort.value()).isEqualTo(ASC.toString()); }
@Test public void sortWithSimpleExpression() { final SortExpression<ProductProjection> sort = SortExpression.of("variants.attributes." + ATTR_NAME_SIZE + " asc.max"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().withSort(sort); testResultIds(search, resultIds -> assertThat(resultIds).containsExactly(product3.getId(), product2.getId(), product1.getId())); }
@Test public void buildsMultiValuedSortExpression() throws Exception { final SortExpression<Object> sort = MultiValueSortSearchModel.of(ATTRIBUTE_PATH).ascWithMaxValue(); assertThat(sort.expression()).isEqualTo(ATTRIBUTE_PATH + " " + ASC_MAX); assertThat(sort.attributePath()).isEqualTo(ATTRIBUTE_PATH); assertThat(sort.value()).isEqualTo(ASC_MAX.toString()); }
@Test public void buildsAscendingSortExpression() throws Exception { assertThat(sortModel().asc().expression()).isEqualTo("variants.attributes.size asc"); }
@Test public void buildsDescendingSortExpression() throws Exception { assertThat(sortModel().desc().expression()).isEqualTo("variants.attributes.size desc"); }
@Test public void buildsDescendingSortExpressionWithAppendedParameter() throws Exception { assertThat(sortModel().descWithMinValue().expression()).isEqualTo("variants.attributes.size desc.min"); }
@Test public void buildsAscendingSortExpressionWithAppendedParameter() throws Exception { assertThat(sortModel().ascWithMaxValue().expression()).isEqualTo("variants.attributes.size asc.max"); }
String queryParametersToString(final boolean urlEncoded) { final UrlQueryBuilder builder = UrlQueryBuilder.of(); Optional.ofNullable(text()).ifPresent(t -> builder.add(TEXT + "." + t.getLocale().toLanguageTag(), t.getValue(), urlEncoded)); facets().forEach(f -> builder.add(FACET, f.expression(), urlEncoded)); Optional.ofNullable(isFuzzy()).ifPresent(b -> builder.add(FUZZY, b.toString(), urlEncoded)); Optional.ofNullable(fuzzyLevel()).ifPresent(b -> builder.add(FUZZY_LEVEL, b.toString(), urlEncoded)); resultFilters().forEach(f -> builder.add(FILTER_RESULTS, f.expression(), urlEncoded)); queryFilters().forEach(f -> builder.add(FILTER_QUERY, f.expression(), urlEncoded)); facetFilters().forEach(f -> builder.add(FILTER_FACETS, f.expression(), urlEncoded)); facetedSearch().forEach(f -> { builder.add(FACET, f.facetExpression().expression(), urlEncoded); f.filterExpressions().forEach(filter -> { builder.add(FILTER_RESULTS, filter.expression(), urlEncoded); builder.add(FILTER_FACETS, filter.expression(), urlEncoded); }); }); sort().forEach(s -> builder.add(SORT, s.expression(), urlEncoded)); if (!facets().isEmpty() || !facetedSearch().isEmpty()) { builder.add("formatBooleanFacet", Boolean.TRUE.toString(), urlEncoded); } Optional.ofNullable(limit()).ifPresent(l -> builder.add(LIMIT, l.toString(), urlEncoded)); Optional.ofNullable(offset()).ifPresent(o -> builder.add(OFFSET, o.toString(), urlEncoded)); expansionPaths().forEach(path -> builder.add(EXPAND, path.toSphereExpand(), urlEncoded)); additionalQueryParameters().forEach(p -> builder.add(p.getName(), p.getValue(), urlEncoded)); return builder.build(); }
@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 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 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 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 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"); }
@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 canAccessCreatedAt() throws Exception { assertThat(FACET_MODEL.createdAt().allTerms().expression()).isEqualTo("createdAt"); assertThat(FILTER_MODEL.createdAt().is(dateTime("2001-09-11T22:05:09.203+00:00"))).extracting(expression()).containsExactly("createdAt:\"2001-09-11T22:05:09.203Z\""); assertThat(SORT_MODEL.createdAt().desc().expression()).isEqualTo("createdAt desc"); }
@Test public void canCreateTimeAttributeExpressions() throws Exception { final String attrName = "deliveryHours"; assertThat(FACET_ATTR.ofTime(attrName).allTerms().expression()).isEqualTo("variants.attributes.deliveryHours"); assertThat(FILTER_ATTR.ofTime(attrName).is(time("22:05:09.203"))).extracting(expression()).containsExactly("variants.attributes.deliveryHours:\"22:05:09.203\""); assertThat(SORT_ATTR.ofTime(attrName).descWithMinValue().expression()).isEqualTo("variants.attributes.deliveryHours desc.min"); }
@Test public void canAccessScopedPriceDiscounted() throws Exception { assertThat(FACET_MODEL.allVariants().scopedPriceDiscounted().allTerms().expression()).isEqualTo("variants.scopedPriceDiscounted"); assertThat(FILTER_MODEL.allVariants().scopedPriceDiscounted().is(true)).extracting(expression()).containsExactly("variants.scopedPriceDiscounted:true"); assertThat(SORT_MODEL.allVariants().scopedPriceDiscounted().asc().expression()).isEqualTo("variants.scopedPriceDiscounted asc"); }
@Test public void canAccessLocEnumKeyCustomAttributes() throws Exception { final String attrName = "color"; assertThat(FACET_ATTR.ofLocalizedEnum(attrName).key().allTerms().expression()).isEqualTo("variants.attributes.color.key"); assertThat(FILTER_ATTR.ofLocalizedEnum(attrName).key().is("ROT")).extracting(expression()).containsExactly("variants.attributes.color.key:\"ROT\""); assertThat(SORT_ATTR.ofLocalizedEnum(attrName).key().descWithMinValue().expression()).isEqualTo("variants.attributes.color.key desc.min"); }