How to use

assertEventually

method

in

io.sphere.sdk.test.SphereTestUtils

  public static void assertEventually(final Runnable block) {
    final Duration maxWaitTime = Duration.ofSeconds(30);
    final Duration waitBeforeRetry = Duration.ofMillis(100);
    assertEventually(maxWaitTime, waitBeforeRetry, block);
  }
}

  public static void assertEventually(final Runnable block) {
    final Boolean useLongTimeout = "true".equals(System.getenv("TRAVIS"))
        || StringUtils.isNotEmpty(System.getenv("TEAMCITY_VERSION"));
    final Duration maxWaitTime = Duration.ofSeconds(useLongTimeout ? 60 : 30);
    final Duration waitBeforeRetry = Duration.ofMillis(100);
    assertEventually(maxWaitTime, waitBeforeRetry, block);
  }
}

public static void assertEventually(final Consumer<SoftAssertions> assertionsConsumer) {
  final Runnable block = () -> {
    final SoftAssertions softly = new SoftAssertions();
    assertionsConsumer.accept(softly);
    softly.assertAll();
  };
  assertEventually(block);
}

private static void assertWithQueryResult(final Consumer<QueryResult> assertions) {
  assertEventually(() -> {
    final QueryResult result = doQuery();
    assertions.accept(result);
  });
}

  private static void testResult(final ProductProjectionSearch search, final Consumer<PagedSearchResult<ProductProjection>> test) {
    assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> test.accept(executeSearch(search)));
  }
}

  private static void testResult(final ProductProjectionSearch search, final Consumer<PagedSearchResult<ProductProjection>> test) {
    assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> test.accept(executeSearch(search)));
  }
}

private static void testResultIds(final ProductProjectionSearch search, final Consumer<List<String>> test) {
  assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> {
    final PagedSearchResult<ProductProjection> result = executeSearch(search);
    test.accept(resultsToIds(result));
  });
}

  private static void testResultIds(final ProductProjectionSearch search, final Consumer<List<String>> test) {
    assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> {
      final PagedSearchResult<ProductProjection> result = executeSearch(search);
      test.accept(resultsToIds(result));
    });
  }
}

  private static void testResultIds(final ProductProjectionSearch search, final Consumer<List<String>> test) {
    assertEventually(Duration.ofSeconds(45), Duration.ofMillis(200), () -> {
      final PagedSearchResult<ProductProjection> result = executeSearch(search);
      test.accept(resultsToIds(result));
    });
  }
}

  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 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 filterByEvilCharacterWord() throws Exception {
  final ProductProjectionSearch search = ProductProjectionSearch.ofStaged()
      .plusQueryFilters(productModel -> productModel.allVariants().attribute().ofString(ATTR_NAME_EVIL).is(EVIL_CHARACTER_WORD));
  assertEventually(Duration.ofSeconds(60), Duration.ofMillis(200), () -> {
    final PagedSearchResult<ProductProjection> result = executeEvilSearch(search);
    assertThat(result.getTotal()).as("total").isEqualTo(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 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 score() {
  final ProductProjectionSearch baseRequest = ProductProjectionSearch.ofStaged()
      .withQueryFilters(m -> m.id().isIn(getAllIds()));
  final ProductProjectionSearch asc = baseRequest.withSort(m -> m.score().asc());
  assertEventually(() -> {
    final PagedSearchResult<ProductProjection> ascResult = client().executeBlocking(asc);
    assertThat(ascResult.getTotal()).isEqualTo(getAllIds().size());
  });
}

public void deleteByID(Supplier<SubscriptionDraftBuilder> subscriptionDraftBuilderSupplier) throws Exception {
  final Subscription subscription = createSubscription(client(), withCategoryChanges(subscriptionDraftBuilderSupplier.get()));
  final SubscriptionDeleteCommand subscriptionDeleteCommand = SubscriptionDeleteCommand.of(subscription);
  client().executeBlocking(subscriptionDeleteCommand);
  assertEventually(() -> {
    final SubscriptionQuery subscriptionQuery = SubscriptionQuery.of().withPredicates(m -> m.is(subscription));
    assertThat(client().executeBlocking(subscriptionQuery).head()).isEmpty();
  });
}

public void deleteByKey(Supplier<SubscriptionDraftBuilder> subscriptionDraftBuilderSupplier) throws Exception {
  final Subscription subscription = createSubscription(client(), withCategoryChanges(subscriptionDraftBuilderSupplier.get()));
  final SubscriptionDeleteCommand subscriptionDeleteCommand = SubscriptionDeleteCommand.ofKey(subscription.getKey(), subscription.getVersion());
  client().executeBlocking(subscriptionDeleteCommand);
  assertEventually(() -> {
    final SubscriptionQuery subscriptionQuery = SubscriptionQuery.of().withPredicates(m -> m.is(subscription));
    assertThat(client().executeBlocking(subscriptionQuery).head()).isEmpty();
  });
}

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