@Test public void createsWithAllVariants() { final List<ProductVariantDraft> allVariants = IntStream.range(0, 9) .mapToObj(i -> ProductVariantDraftBuilder.of().sku("sku-" + i).build()) .collect(toList()); final Reference<ProductType> productType = ProductType.referenceOfId("product-type-id"); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), allVariants).build(); assertThat(productDraft.getMasterVariant().getSku()).isEqualTo("sku-0"); assertThat(productDraft.getVariants().get(3).getSku()).isEqualTo("sku-4"); }
private ProductVariantDraft variantDraft() { final AttributeDraft attributeDraft = AttributeDraft.of(ATTR_NAME, AttributeAccess.ofLocalizedEnumValueSet(), new HashSet<>(ALL_ATTRIBUTE_VALUES)); return ProductVariantDraftBuilder.of() .attributes(attributeDraft) .sku(randomKey()) .build(); }
@BeforeClass public static void createProducts() { ProductFixtures.deleteProductsAndProductTypes(client()); productType = ProductTypeFixtures.createProductType(client(), "QueryAllProductsDemo"); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().build(); final Stream<Product> productStream = Stream.generate(() -> { final ProductDraft productDraft = ProductDraftBuilder.of(productType, en("QueryAllDemoProduct"), randomSlug(), masterVariant).build(); return client().executeBlocking(ProductCreateCommand.of(productDraft)); }); createdProducts = productStream.limit(19).sorted(BY_ID_COMPARATOR).collect(toList()); }
public static void withProduct(final BlockingSphereClient client, final UnaryOperator<ProductDraftBuilder> builderMapper, final Consumer<Product> productConsumer) { withAttributesProductType(client, productType -> { final ProductDraftBuilder builder = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), ProductVariantDraftBuilder.of().build()); final ProductDraftBuilder updatedBuilder = builderMapper.apply(builder); final Product product = client.executeBlocking(ProductCreateCommand.of(updatedBuilder.build())); productConsumer.accept(product); client.executeBlocking(ProductDeleteCommand.of(product)); }); }
public static void withSuggestProduct(final BlockingSphereClient client, final Consumer<Product> consumer) { withEmptyProductType(client, randomKey(), productType -> { final SearchKeywords searchKeywords = SearchKeywords.of( Locale.ENGLISH, asList(SearchKeyword.of("Multi tool"), SearchKeyword.of("Swiss Army Knife", WhiteSpaceSuggestTokenizer.of())), Locale.GERMAN, singletonList(SearchKeyword.of("Schweizer Messer", CustomSuggestTokenizer.of(asList("schweizer messer", "offiziersmesser", "sackmesser")))) ); final ProductDraftBuilder productDraftBuilder = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), ProductVariantDraftBuilder.of().build()) .searchKeywords(searchKeywords); withProduct(client, productDraftBuilder, consumer); }); }
public static void creatingProduct(final BlockingSphereClient client, final UnaryOperator<ProductDraftBuilder> builderMapper, final UnaryOperator<Product> op) { withProductType(client, randomKey(), productType -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().build(); final ProductDraftBuilder builder = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant); final ProductDraft productDraft = builderMapper.apply(builder).build(); final Product product = client.executeBlocking(ProductCreateCommand.of(productDraft)); final Product updatedProduct = op.apply(product); client.executeBlocking(ProductDeleteCommand.of(updatedProduct)); }); }
public static void withProductHavingAssets(final BlockingSphereClient client, final UnaryOperator<Product> op) { withUpdateableProduct(client, productDraftBuilder -> { final ProductVariantDraft masterVariant = productDraftBuilder.getMasterVariant(); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of(masterVariant) .assets(asList(getAssetDraft1(), getAssetDraft2())) .sku(randomKey()) .build(); return productDraftBuilder.masterVariant(variantDraft); }, op); } public static void withProductHavingImages(final BlockingSphereClient client, final UnaryOperator<Product> op) {
@Test public void prices() { checkFilter(builder -> { final ProductVariantDraft oldMaster = builder.getMasterVariant(); final ProductVariantDraft masterWithPrices = ProductVariantDraftBuilder.of(oldMaster) .prices(singletonList(PriceDraft.of(EURO_1))) .build(); return builder.masterVariant(masterWithPrices); }, m -> m.allVariants().prices()); }
private void withProductOfSku(final String sku, final Function<Product, Product> productProductFunction) { withUpdateableProduct(client(), builder -> { return builder.masterVariant(ProductVariantDraftBuilder.of(builder.getMasterVariant()).sku(sku).build()); }, product -> { final ProductUpdateCommand productUpdateCommand = ProductUpdateCommand.of(product, Publish.of()); final Product publishedProduct = client().executeBlocking(productUpdateCommand); return productProductFunction.apply(publishedProduct); }); }
private static void withProductInCategory(final BlockingSphereClient client, final Referenceable<Category> category, final Consumer<Product> user) { final ProductType productType = client.executeBlocking(ProductTypeCreateCommand.of(ProductTypeDraft.of(randomKey(), CategoryDocumentationIntegrationTest.class.getSimpleName(), "", asList()))); final LocalizedString name = LocalizedString.of(ENGLISH, "foo"); final Product product = client.executeBlocking(ProductCreateCommand.of(ProductDraftBuilder.of(productType, name, name.slugifiedUnique(), ProductVariantDraftBuilder.of().build()).categories(asSet(category.toReference())).build())); user.accept(product); client.executeBlocking(ProductDeleteCommand.of(product)); client.executeBlocking(ProductTypeDeleteCommand.of(productType)); }
public static void withProductHavingImages(final BlockingSphereClient client, final UnaryOperator<Product> op) { withUpdateableProduct(client, productDraftBuilder -> { final ProductVariantDraft masterVariant = productDraftBuilder.getMasterVariant(); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of(masterVariant) .images(createExternalImage()) .sku(randomKey()) .build(); return productDraftBuilder.masterVariant(variantDraft); }, op); }
private void withProductOfPrices(final List<PriceDraft> priceDrafts, final Consumer<Product> productConsumer) { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .prices(priceDrafts) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant) .publish(true) .build(); withProduct(client(), () -> productDraft, productConsumer); } }
@Test public void sku() { checkFilter(builder -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of(builder.getMasterVariant()) .sku("sku-test-" + randomKey()) .build(); return builder.masterVariant(masterVariant); }, m -> m.allVariants().sku()); }
public static Product referenceableProduct(final BlockingSphereClient client) { final ProductType productType = ProductTypeFixtures.defaultProductType(client); final ProductVariantDraft variantDraft = ProductVariantDraftBuilder.of().price(PRICE).build(); final String slugEn = "referenceable-product-2"; final ProductDraft productDraft = ProductDraftBuilder.of(productType, en("referenceable product"), en(slugEn), variantDraft).build(); return client.executeBlocking(ProductQuery.of().bySlug(ProductProjectionType.STAGED, ENGLISH, slugEn)).head() .orElseGet(() -> client.executeBlocking(ProductCreateCommand.of(productDraft))); }
public static void withProductOfPrices(final BlockingSphereClient client, final List<PriceDraft> priceDrafts, final Consumer<Product> productConsumer) { withEmptyProductType(client, randomKey(), productType -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .prices(priceDrafts) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant) .build(); ProductFixtures.withProduct(client, () -> productDraft, productConsumer); }); }
public static void withProductWithProductReference(final BlockingSphereClient client, final BiConsumer<Product, Product> consumer) { withProduct(client, referencedProduct -> { final ProductType productType = productReferenceProductType(client); final ProductVariantDraft productVariantDraft = ProductVariantDraftBuilder.of().attributes(AttributeDraft.of("productreference", referencedProduct.toReference())).build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, en("product reference name 1"), randomSlug(), productVariantDraft).build(); final Product product = client.executeBlocking(ProductCreateCommand.of(productDraft)); consumer.accept(product, referencedProduct); client.executeBlocking(ProductDeleteCommand.of(product)); }); }
private void withProductOfPrices(final List<PriceDraft> priceDrafts, final Consumer<Product> productConsumer) { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .prices(priceDrafts) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant) .key(randomKey()) .build(); ProductFixtures.withProduct(client(), () -> productDraft, productConsumer); } }
private static Product createEvilTestProduct(final ProductType productType, final String germanName, final String evilValue, final String sku) { final LocalizedString name = LocalizedString.of(GERMAN, germanName); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of() .attributes(AttributeDraft.of(ATTR_NAME_EVIL, evilValue)) .sku(sku) .build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, name, name.slugifiedUnique(), masterVariant).build(); return client().executeBlocking(ProductCreateCommand.of(productDraft)); } }
@Test public void byKey() { ProductTypeFixtures.withEmptyProductType(client(), productType -> { final String key = randomKey(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), ProductVariantDraftBuilder.of().build()).key(key).build(); final Product product = client().executeBlocking(ProductCreateCommand.of(productDraft)); final Product deletedProduct = client().executeBlocking(ProductDeleteCommand.ofKey(key, product.getVersion())); assertThat(client().executeBlocking(ProductByKeyGet.of(key))).isNull(); }); } }
@Test public void productReferenceAttribute() throws Exception { withEmptyProductType(client(), "productReferenceAttribute-testcase", productType -> { final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, LABEL, SphereTestUtils.randomSlug(), masterVariant).build(); final Product product = client().executeBlocking(ProductCreateCommand.of(productDraft)); testSingleAndSet(AttributeAccess.ofProductReference(), AttributeAccess.ofProductReferenceSet(), asSet(product.toReference().filled(null)), ReferenceAttributeType.ofProduct(), AttributeDefinitionBuilder.of("productReference", LABEL, ReferenceAttributeType.ofProduct()).build()); }); }