private static Set<ProductProjection> resultToProductSet(final PagedSearchResult<ProductProjection> result) { return result.getResults().stream().collect(toSet()); } }
protected Result renderGoodHealthStatus(final PagedSearchResult<ProductProjection> productResult) { final boolean containsProducts = !productResult.getResults().isEmpty(); if (!containsProducts) { throw new RuntimeException("Cannot find any product!"); } return ok(healthReportAsJson(true)); }
@Override public boolean matches(final PagedSearchResult<ProductProjection> value) { final Set<String> actualIds = value.getResults().stream().map(ProductProjection::getId).collect(Collectors.toSet()); return expectedIds.equals(actualIds); } }.describedAs(String.format("expected %s", expectedIds));
@Test public void skuExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySku(SKU1); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results.size()).isEqualTo(1); assertThat(results.get(0).getAllVariants().stream().anyMatch(variant -> SKU1.equals(variant.getSku()))).isEqualTo(true); }); }
@Test public void multipleSKUsExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySku(asList(SKU1, SKU2, SKU3, "thisSKUshouldn't exist")); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results).hasSize(3); }); }
@Test public void slugExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySlug(ENGLISH, SLUG1); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results.size()).isEqualTo(1); assertThat(results.get(0).getSlug().get(ENGLISH)).isEqualTo(SLUG1); }); }
@Test public void slugDontExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySlug(ENGLISH, "blafasel"); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results).isEmpty(); }); }
@Test public void skuDontExistsExample() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().bySku("thisSKUshouldn't exist"); testResult(search, result -> { final List<ProductProjection> results = result.getResults(); assertThat(results).isEmpty(); }); }
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()); }); } }
private static PagedSearchResult<ProductProjection> executeFacetedSearch(final FacetedSearchExpression<ProductProjection> facetedSearchExpr, final Consumer<List<String>> testFilter) { final PagedSearchResult<ProductProjection> result = executeSearch(ProductProjectionSearch.ofStaged().plusFacetedSearch(facetedSearchExpr)); testFilter.accept(toIds(result.getResults())); return result; } }
private static void testProductIds(final List<FilterExpression<ProductProjection>> filterExpr, final Consumer<List<String>> test) { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().withQueryFilters(filterExpr); final List<ProductProjection> results = executeSearch(search).getResults(); test.accept(toIds(results)); } }
private void checkSorting(final Function<ProductProjectionSortSearchModel, SortExpression<ProductProjection>> sortExpressionFunction, final Consumer<ProductProjection> asserter) { final ProductProjectionSearch productProjectionSearch = ProductProjectionSearch.ofStaged() .withQueryFilters(m -> m.reviewRatingStatistics().count().isGreaterThanOrEqualTo(BigDecimal.ZERO)) .withSort(sortExpressionFunction); assertEventually(Duration.ofSeconds(15), Duration.ofMillis(200), () -> { final List<ProductProjection> results = client().executeBlocking(productProjectionSearch).getResults(); assertThat(results.size()).isGreaterThanOrEqualTo(3); final ProductProjection first = results.get(0); asserter.accept(first); }); } }
private static void testProductIds(final SortExpression<ProductProjection> sortExpr, final Consumer<List<String>> test) { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().withSort(sortExpr); final List<ProductProjection> results = executeSearch(search).getResults(); assertEventually(() -> { test.accept(toIds(results)); }); } }
@Test public void filterBySku() { final List<String> skus = Stream.of(product1, product2) .map(product -> product.getMasterData().getStaged().getMasterVariant().getSku()) .collect(toList()); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.allVariants().sku().isIn(skus)); assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> { assertThat(client().executeBlocking(search).getResults()) .extracting(m -> m.getMasterVariant().getSku()) .containsOnly(skus.get(0), skus.get(1)); }); }
@Test public void fuzzySearch() { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .withText(ENGLISH, "short") .withQueryFilters(productModel -> productModel.productType().id().is(productType.getId())); assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> assertThat(client().executeBlocking(search).getResults()).matches(containsIdentifiable(product2).negate(), "not included")); assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> assertThat(client().executeBlocking(search.withFuzzy(true)).getResults()).matches(containsIdentifiable(product2), "included")); }
@Test public void findMatchingVariantByFulltextSearch() throws Exception { final Condition<ProductVariant> allMatchingVariants = new Condition<>(variant -> variant.isMatchingVariant(), "all are matching variants"); final ProductProjectionSearch search = ProductProjectionSearch.ofStaged().withMarkingMatchingVariants(true).withText(ENGLISH, "shoe"); assertThat(executeSearch(search).getResults()) .flatExtracting(p -> p.getAllVariants()) .are(allMatchingVariants); }
@Ignore // HTTP API still not having sort associated to matching variant flag @Test public void findMatchingVariantBySort() throws Exception { final ProductProjectionSearch search = ProductProjectionSearch.ofStaged() .withSort(productModel -> productModel.allVariants().attribute().ofNumber(ATTR_NAME_SIZE).ascWithMaxValue()); testResult(search, result -> assertThat(result.getResults()).are(productWithMatchingVariantsHavingMaxSize())); }
@Test public void searchForIsOnStock() { withProductOfStock(client(), 2, product -> { final ProductProjectionSearch request = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.id().is(product.getId())) .plusQueryFilters(m -> m.allVariants().availability().isOnStock().is(true)); assertEventually(() -> { final PagedSearchResult<ProductProjection> res = client().executeBlocking(request); assertThat(res.getResults()).hasSize(1); }); }); }
@Test public void searchForIsNotOnStock() { withProductOfStock(client(), 0, product -> { final ProductProjectionSearch request = ProductProjectionSearch.ofStaged() .plusQueryFilters(m -> m.id().is(product.getId())) .plusQueryFilters(m -> m.allVariants().availability().isOnStock().is(false)); assertEventually(() -> { final PagedSearchResult<ProductProjection> res = client().executeBlocking(request); assertThat(res.getResults()).hasSize(0); }); }); }
private static List<ProductProjection> searchForCategoryAndSort(final String categoryId) { final ProductProjectionSearch searchRequest = ProductProjectionSearch.ofStaged() .withQueryFilters(productModel -> productModel.categories().id().is(categoryId)) .withSort(productModel -> productModel.categoryOrderHints().category(categoryId).asc()); return client().executeBlocking(searchRequest).getResults(); }