public final TimestampSortingModel<T> lastModifiedAt() { return new TimestampSortingModel<>(Optional.of(this), "lastModifiedAt"); } }
@Test public void queryForCreatedAtIs() { createdAtTest((m, date) -> m.is(date)); }
@Test public void queryForCreatedAtIsGreaterThan() { createdAtTest((m, date) -> m.isGreaterThan(date.minusSeconds(1))); }
@Test public void queryForCreatedAtIsIn() { createdAtTest((m, date) -> m.isIn(singletonList(date))); }
@Test public void queryForCreatedAtIsGreaterThanOrEqualTo() { createdAtTest((m, date) -> m.isGreaterThanOrEqualTo(date.minusSeconds(1))); }
@Test public void queryForCreatedAtIsLessThan() { createdAtTest((m, date) -> m.isLessThan(date.plusSeconds(1))); }
@Test public void queryByDateTime() { checkQuery(fields -> fields.ofDateTime(DATETIME_FIELD_NAME).isGreaterThan(ZONED_DATE_TIME.minusMinutes(1))); }
private void check(final Function<CustomerQueryModel, QueryPredicate<Customer>> f, final boolean checkDistraction) { final CustomerQueryModel model = CustomerQueryModel.of(); final QueryPredicate<Customer> predicate = f.apply(model); final Query<Customer> query = CustomerQuery.of().withPredicates(predicate).withSort(model.createdAt().sort().desc()); final List<Customer> results = client().executeBlocking(query).getResults(); final List<String> ids = results.stream().map(x -> x.getId()).collect(toList()); assertThat(ids).contains(customer.getId()); if (checkDistraction) { assertThat(ids.contains(distraction.getId())).isFalse(); } }
public final TimestampSortingModel<T> createdAt() { return new TimestampSortingModel<>(Optional.of(this), "createdAt"); }
@Test public void sortBySyncedAt() throws Exception { assertThat(OrderQueryModel.of().syncInfo().syncedAt().sort().asc().toSphereSort()) .isEqualTo("syncInfo.syncedAt asc"); } }
@Test public void queryPureJson() throws Exception { withCustomObject(client(), existingCustomObject -> { final CustomObjectQuery<JsonNode> clientRequest = CustomObjectQuery.ofJsonNode() .withSort(m -> m.createdAt().sort().desc()); final PagedQueryResult<CustomObject<JsonNode>> result = client().executeBlocking(clientRequest); assertThat(result.getResults().stream().filter(item -> item.hasSameIdAs(existingCustomObject)).count()) .isGreaterThanOrEqualTo(1); final String expected = existingCustomObject.getValue().getBar(); final CustomObject<JsonNode> loadedCustomObject = result.head().get(); final JsonNode jsonNode = loadedCustomObject.getValue(); final String actual = jsonNode.get("bar").asText("it is not present"); assertThat(actual).isEqualTo(expected); }); }
@Test public void plusSort() { final List<QuerySort<Category>> sort = CategoryQuery.of() .withSort(m -> m.externalId().sort().asc()) .plusSort(m -> m.createdAt().sort().desc()).sort(); assertThat(sort).hasSize(2); assertThat(sort).extractingResultOf("toSphereSort").containsExactly("externalId asc", "createdAt desc"); }
private CartQuery decorateQueryWithAdditionalInfo(final CartQuery query) { return query .plusPredicates(cart -> cart.cartState().is(CartState.ACTIVE)) .plusExpansionPaths(c -> c.shippingInfo().shippingMethod()) // TODO use run hook on cart query instead .plusExpansionPaths(c -> c.paymentInfo().payments()) .withSort(cart -> cart.lastModifiedAt().sort().desc()) .withLimit(1); } }
@Test public void queryByNotName() throws Exception { withCategory(client(), category1 -> withCategory(client(), category2 -> { final Query<Category> query = CategoryQuery.of(). withPredicates(m -> m.name().lang(Locale.ENGLISH).isNot(category1.getName().get(Locale.ENGLISH))) .withSort(m -> m.createdAt().sort().desc()); final boolean category1IsPresent = client().executeBlocking(query).getResults().stream().anyMatch(cat -> cat.getId().equals(category1.getId())); assertThat(category1IsPresent).isFalse(); }) ); }
@Test public void messageGetPayload() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final Query<Message> query = MessageQuery.of() .withPredicates(m -> m.type().is(ReturnInfoAddedMessage.MESSAGE_HINT).and(m.resource().is(order))) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L); assertEventually(() -> { final PagedQueryResult<Message> pagedQueryResult = client().executeBlocking(query); final Optional<Message> message = pagedQueryResult.head(); assertThat(message).isPresent(); final String fetchedItemId = message.get().getPayload().get("returnInfo").get("items").get(0).get("id").asText(); final String actualItemId = returnInfo.getItems().get(0).getId(); assertThat(fetchedItemId).isEqualTo(actualItemId).isNotNull(); }); return order; })); }
@Test public void getReviewsForOneProduct() { final String productId = product.getId(); final ReviewQuery reviewQuery = ReviewQuery.of() .withPredicates(m -> m.target().id().is(productId)) .withSort(m -> m.createdAt().sort().desc()) .withLimit(REVIEWS_PER_PRODUCT); final List<Review> reviews = client().executeBlocking(reviewQuery).getResults(); assertThat(reviews).hasSize(REVIEWS_PER_PRODUCT); assertThat(reviews).extracting(r -> r.getTarget().getId()).containsOnlyElementsOf(singletonList(productId)); }
@Test public void queryForASpecificMessage() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final Query<ReturnInfoAddedMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(ReturnInfoAddedMessage.MESSAGE_HINT); assertEventually(() -> { final PagedQueryResult<ReturnInfoAddedMessage> pagedQueryResult = client().executeBlocking(query); final Optional<ReturnInfoAddedMessage> message = pagedQueryResult.head(); assertThat(message).isPresent(); assertThat(message.get().getReturnInfo()).isEqualTo(returnInfo); assertThat(message.get().getResource().getObj()).isNotNull(); assertThat(message.get().getResource().getId()).isEqualTo(order.getId()); }); return order; })); }
@Test public void getApprovedReviewsForOneProduct() { final String productId = product.getId(); final ReviewQuery reviewQuery = ReviewQuery.of() .withPredicates(review -> review.includedInStatistics().is(true).and(review.target().id().is(productId))) .withSort(m -> m.createdAt().sort().desc()) .withLimit(REVIEWS_PER_PRODUCT); final List<Review> reviews = client().executeBlocking(reviewQuery).getResults(); assertThat(reviews).hasSize(REVIEWS_PER_PRODUCT); assertThat(reviews).extracting(r -> r.getTarget().getId()).containsOnlyElementsOf(singletonList(productId)); assertThat(reviews).extracting(r -> r.isIncludedInStatistics()).containsOnlyElementsOf(singletonList(true)); }
@Test public void queryForAllMessages() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final MessageQuery query = MessageQuery.of() //example predicate to fetch for a specific message type .withPredicates(m -> m.type().is("ReturnInfoAdded").and(m.resource().is(order))) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L); assertEventually(() -> { final Optional<Message> message = client().executeBlocking(query).head(); assertThat(message).isPresent(); assertThat(message.get().getResource().getObj()).isNotNull(); assertThat(message.get().getResource()).isEqualTo(order.toReference()); assertThat(message.get().getResource().getId()).isEqualTo(order.getId()); }); return order; })); } }