public static <T> MessageDerivateHint<T> ofResourceType(final String resourceId, final Class<T> clazz) { return new MessageDerivateHint<>(SphereJsonUtils.convertToJavaType(clazz), () -> MessageQueryModel.of().resource().typeId().is(resourceId)); }
@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 changeTransactionState() { withPaymentTransaction(client(), (Payment payment, Transaction transaction) -> { assertThat(transaction.getState()).isEqualTo(TransactionState.INITIAL); final TransactionState transactionState = TransactionState.SUCCESS; final Payment updatedPayment = client().executeBlocking(PaymentUpdateCommand.of(payment, ChangeTransactionState.of(transactionState, transaction.getId()))); final Transaction updatedTransaction = updatedPayment.getTransactions().get(0); assertThat(updatedTransaction.getState()).isEqualTo(transactionState); //check messages assertEventually(() -> { final PagedQueryResult<PaymentTransactionStateChangedMessage> messageQueryResult = client().executeBlocking(MessageQuery.of() .withPredicates(m -> m.resource().is(payment)) .forMessageType(PaymentTransactionStateChangedMessage.MESSAGE_HINT)); assertThat(messageQueryResult.head()).isPresent(); final PaymentTransactionStateChangedMessage message = messageQueryResult.head().get(); assertThat(message.getState()).isEqualTo(transactionState); assertThat(message.getTransactionId()).isEqualTo(transaction.getId()); }); return updatedPayment; }); }
@Test public void orderCreatedMessage() throws Exception { withOrderAndReturnInfo(client(), ((order, returnInfo) -> { final Query<OrderCreatedMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(OrderCreatedMessage.MESSAGE_HINT); assertEventually(() -> { final PagedQueryResult<OrderCreatedMessage> pagedQueryResult = client().executeBlocking(query); final Optional<OrderCreatedMessage> message = pagedQueryResult.head(); assertThat(message).isPresent(); assertThat(message.get().getOrder().getId()).isEqualTo(order.getId()); assertThat(message.get().getResource().getObj()).isNotNull(); assertThat(message.get().getResource().getId()).isEqualTo(order.getId()); }); return order; })); }
public static <T extends Message> MessageDerivateHint<T> ofResourceType(final String resourceId, final Class<T> clazz, final String referenceTypeId) { return new MessageDerivateHint<>(SphereJsonUtils.convertToJavaType(clazz), () -> MessageQueryModel.of().resource().typeId().is(resourceId), clazz, null, referenceTypeId); }
@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 changeSlug() throws Exception { withUpdateableProduct(client(), product -> { final LocalizedString newSlug = LocalizedString.ofEnglish("new-slug-" + RANDOM.nextInt()); final Product updatedProduct = client().executeBlocking(ProductUpdateCommand.of(product, ChangeSlug.of(newSlug))); assertThat(updatedProduct.getMasterData().getStaged().getSlug()).isEqualTo(newSlug); //query message assertEventually(() -> { final Query<ProductSlugChangedMessage> query = MessageQuery.of() .withPredicates(m -> m.resource().is(product)) .forMessageType(ProductSlugChangedMessage.MESSAGE_HINT); final List<ProductSlugChangedMessage> results = client().executeBlocking(query).getResults(); assertThat(results).hasSize(1); final ProductSlugChangedMessage message = results.get(0); assertThat(message.getSlug()).isEqualTo(newSlug); }); return updatedProduct; }); }
public static <T extends Message> MessageDerivateHint<T> ofResourceType(final String resourceId, final Class<T> clazz, final String referenceTypeId) { return new MessageDerivateHint<>(SphereJsonUtils.convertToJavaType(clazz), () -> MessageQueryModel.of().resource().typeId().is(resourceId), clazz, null, referenceTypeId); }
@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 setReturnShipmentState() throws Exception { withOrderAndReturnInfo(client(), (order, returnInfo) -> { final ReturnItem returnItem = returnInfo.getItems().get(0); final ReturnShipmentState newShipmentState = ReturnShipmentState.BACK_IN_STOCK; assertThat(returnItem.getShipmentState()).isNotEqualTo(newShipmentState); final SetReturnShipmentState action = SetReturnShipmentState.of(returnItem, newShipmentState); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, action)); final ReturnShipmentState updatedReturnItem = updatedOrder.getReturnInfo().get(0).getItems().get(0).getShipmentState(); assertThat(updatedReturnItem).isEqualTo(newShipmentState); //you can observe a message final Query<OrderReturnShipmentStateChangedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(OrderReturnShipmentStateChangedMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<OrderReturnShipmentStateChangedMessage> orderReturnShipmentStateChangedMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(orderReturnShipmentStateChangedMessageOptional).isPresent(); final OrderReturnShipmentStateChangedMessage orderReturnShipmentStateChangedMessage = orderReturnShipmentStateChangedMessageOptional.get(); assertThat(orderReturnShipmentStateChangedMessage.getReturnItemId()).isEqualTo(returnItem.getId()); assertThat(orderReturnShipmentStateChangedMessage.getReturnShipmentState()).isEqualTo(newShipmentState); }); 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 setRating() { withChannelOfRole(client(), ChannelRole.INVENTORY_SUPPLY, channel -> { withUpdateableReview(client(),builder -> builder.target(channel), (Review review) -> { final int rating = 44; final Review updatedReview = client().executeBlocking(ReviewUpdateCommand.of(review, SetRating.of(rating))); assertThat(updatedReview.getRating()).isEqualTo(rating); //you can observe a message assertEventually(() -> { final Query<ReviewRatingSetMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(review)) .forMessageType(ReviewRatingSetMessage.MESSAGE_HINT); final PagedQueryResult<ReviewRatingSetMessage> messages = client().executeBlocking(messageQuery); assertThat(messages.head()).isPresent(); final ReviewRatingSetMessage reviewRatingSetMessage = messages.head().get(); assertThat(reviewRatingSetMessage.getNewRating()).isEqualTo(rating); assertThat(reviewRatingSetMessage.getOldRating()).isEqualTo(100); assertThat(reviewRatingSetMessage.isIncludedInStatistics()).isTrue(); assertThat(reviewRatingSetMessage.getTarget()).isEqualTo(channel.toReference()); }); return updatedReview; }); }); }
@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; }); } }
@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 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; })); }
.withPredicates(m -> m.resource().is(product)) .withSort(m -> m.type().sort().asc()) .withExpansionPaths(m -> m.resource())
.withPredicates(m -> m.resource().id().is(updatedPayment.getId())) .withSort(m -> m.createdAt().sort().desc()) .withExpansionPaths(m -> m.resource())
@Test public void removeParcelFromDelivery() throws Exception { withOrder(client(), order -> { final List<ParcelDraft> parcels = asList(ParcelDraft.of(SMALL_PARCEL_MEASUREMENTS, TRACKING_DATA)); final LineItem lineItem = order.getLineItems().get(0); final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); assertThat(orderWithDelivery.getShippingInfo().getDeliveries()).hasSize(1); final Delivery delivery = orderWithDelivery.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getParcels()).hasSize(1); final Parcel parcel = delivery.getParcels().get(0); final Order orderWithoutParcel = client().executeBlocking(OrderUpdateCommand.of(orderWithDelivery, RemoveParcelFromDelivery.of(parcel.getId()))); assertThat(orderWithoutParcel.getShippingInfo().getDeliveries()).hasSize(1); final Delivery deliveryWithoutParcel = orderWithoutParcel.getShippingInfo().getDeliveries().get(0); assertThat(deliveryWithoutParcel.getParcels()).isEmpty(); //you can observe a message final Query<ParcelRemovedFromDeliveryMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(ParcelRemovedFromDeliveryMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<ParcelRemovedFromDeliveryMessage> parcelRemovedFromDeliveryMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(parcelRemovedFromDeliveryMessageOptional).isPresent(); final ParcelRemovedFromDeliveryMessage parcelRemovedFromDeliveryMessage = parcelRemovedFromDeliveryMessageOptional.get(); assertThat(parcelRemovedFromDeliveryMessage.getDeliveryId()).isEqualTo(delivery.getId()); assertThat(parcelRemovedFromDeliveryMessage.getParcel()).isEqualTo(parcel); }); }); }
@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; }); }
@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; })); }