@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 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 orderStateChangedMessage() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, ChangeOrderState.of(OrderState.CANCELLED))); final Query<OrderStateChangedMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().id().is(updatedOrder.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(OrderStateChangedMessage.MESSAGE_HINT); assertEventually(() -> { final PagedQueryResult<OrderStateChangedMessage> pagedQueryResult = client().executeBlocking(query); final Optional<OrderStateChangedMessage> message = pagedQueryResult.head(); assertThat(message).isPresent(); assertThat(message.get().getOrderState()).isEqualTo(OrderState.CANCELLED); assertThat(message.get().getResource().getObj()).isNotNull(); assertThat(message.get().getResource().getId()).isEqualTo(order.getId()); }); return updatedOrder; })); }
@Test public void convertAfterQueryToSpecificMessageClassesButToTheWrongOne() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final MessageQuery query = MessageQuery.of() .withPredicates(m -> m.resource().id().is(order.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()); assertEventually(() -> { final List<Message> results = client().executeBlocking(query).getResults(); final Optional<Message> returnInfoAddedUntypedMessage = results.stream() .filter(m -> { final String messageType = ReturnInfoAddedMessage.MESSAGE_TYPE; return m.getType().equals(messageType); }) .findFirst(); assertThat(returnInfoAddedUntypedMessage).isPresent(); final DeliveryAddedMessage deliveryAddedMessage //wrong cast, but may not explodes = returnInfoAddedUntypedMessage.get().as(DeliveryAddedMessage.class); assertThat(deliveryAddedMessage.getDelivery()) .overridingErrorMessage("with wrong cast, fields can be null") .isNull(); }); return order; })); }
@Test public void changePaymentState() throws Exception { withNonUpdatedOrder(client(), order -> { final PaymentState newState = PaymentState.PAID; assertThat(order.getPaymentState()).isNotEqualTo(newState); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, ChangePaymentState.of(newState))); assertThat(updatedOrder.getPaymentState()).isEqualTo(newState); final Query<OrderPaymentStateChangedMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().id().is(updatedOrder.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(OrderPaymentStateChangedMessage.MESSAGE_HINT); assertEventually(() -> { final PagedQueryResult<OrderPaymentStateChangedMessage> pagedQueryResult = client().executeBlocking(query); final Optional<OrderPaymentStateChangedMessage> optMessage = pagedQueryResult.head(); assertThat(optMessage).isPresent(); OrderPaymentStateChangedMessage message = optMessage.get(); assertThat(message.getResource().getId()).isEqualTo(updatedOrder.getId()); assertThat(message.getPaymentState()).isEqualTo(newState); }); return updatedOrder; }); } }
.withPredicates(m -> m.resource().id().is(updatedPayment.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource())
@Test public void queryForASpecificResource() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final Query<SimpleOrderMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().id().is(order.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource()) .forMessageType(SimpleOrderMessage.MESSAGE_HINT); assertEventually(() -> { final List<SimpleOrderMessage> results = client().executeBlocking(query).getResults(); final Optional<Order> orderOptional = Optional.ofNullable(results.get(0).getResource().getObj()); assertThat(orderOptional.map(o -> o.getCreatedAt())).contains(order.getCreatedAt()); }); return order; })); }
@Test public void queryByReference() { withUpdateableType(client(), type -> { withCategory(client(), referencedCategory -> { withCategory(client(), category -> { final TypeReference<Reference<Category>> TYPE_REFERENCE = new TypeReference<Reference<Category>>() {}; final Map<String, Object> fields = new HashMap<>(); fields.put(CAT_REFERENCE_FIELD_NAME, referencedCategory.toReference()); final CategoryUpdateCommand categoryUpdateCommand = CategoryUpdateCommand.of(category, SetCustomType.ofTypeIdAndObjects(type.getId(), fields)); final ExpansionPath<Category> expansionPath = ExpansionPath.of("custom.fields." + CAT_REFERENCE_FIELD_NAME); final Category updatedCategory = client().executeBlocking(categoryUpdateCommand.withExpansionPaths(expansionPath)); final Reference<Category> createdReference = updatedCategory.getCustom().getField(CAT_REFERENCE_FIELD_NAME, TYPE_REFERENCE); final CategoryQuery categoryQuery = CategoryQuery.of() .plusExpansionPaths(expansionPath) .plusPredicates(m -> m.is(updatedCategory)) .plusPredicates(m -> m.custom().fields().ofReference(CAT_REFERENCE_FIELD_NAME).id().is(createdReference.getId())); final List<Category> results = client().executeBlocking(categoryQuery).getResults(); assertThat(results).hasSize(1); }); }); return type; }); }