@Test public void createByJson() { final ProductTypeDraft productTypeDraft = SphereJsonUtils.readObjectFromResource("drafts-tests/productType.json", ProductTypeDraft.class); final ProductType productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); assertThat(productType.getName()).isEqualTo(getName()); assertThat(productType.getKey()).isEqualTo("product-type-from-json"); assertThat(productType.getDescription()).isEqualTo("product type from json"); final AttributeDefinition attributeDefinition = productType.getAttributes().get(0); assertThat(attributeDefinition.getAttributeType()).isEqualTo(StringAttributeType.of()); assertThat(attributeDefinition.getName()).isEqualTo("string-attribute-from-json"); final LocalizedString label = LocalizedString.of(ENGLISH, "an attribute from JSON", GERMAN, "ein Attribut von JSON"); assertThat(attributeDefinition.getLabel()).isEqualTo(label); assertThat(attributeDefinition.isRequired()).isTrue(); assertThat(attributeDefinition.getAttributeConstraint()).isEqualTo(AttributeConstraint.NONE); assertThat(attributeDefinition.getInputHint()).isEqualTo(TextInputHint.SINGLE_LINE); assertThat(attributeDefinition.isSearchable()).isTrue(); }
private void executeTest(final Class<? extends AttributeType> attributeTypeClass, final AttributeDefinition attributeDefinition, final Consumer<AttributeDefinition> furtherAttributeDefinitionAssertions) { final String productTypeName = "product type name"; final String productTypeDescription = "product type description"; final String attributeName = attributeDefinition.getName(); cleanUpByName(productTypeName); final List<AttributeDefinition> attributes = asList(attributeDefinition); final ProductTypeCreateCommand command = ProductTypeCreateCommand.of(ProductTypeDraft.of(randomKey(), productTypeName, productTypeDescription, attributes)); final ProductType productType = client().executeBlocking(command); assertThat(productType.getName()).isEqualTo(productTypeName); assertThat(productType.getDescription()).isEqualTo(productTypeDescription); assertThat(productType.getAttributes()).hasSize(1); final AttributeDefinition fetchedAttributeDefinition = productType.getAttributes().get(0); assertThat(fetchedAttributeDefinition.getName()).isEqualTo(attributeName); assertThat(fetchedAttributeDefinition.getLabel()).isEqualTo(en("label")); assertThat(fetchedAttributeDefinition.getAttributeType()).isInstanceOf(attributeTypeClass); furtherAttributeDefinitionAssertions.accept(fetchedAttributeDefinition); cleanUpByName(productTypeName); }
public void createDemo() { final ProductTypeCreateCommand command = ProductTypeCreateCommand.of(new TShirtProductTypeDraftSupplier("product-type-name").get()); final ProductType productType = client().executeBlocking(command); } }
@BeforeClass public static void createData() { ProductFixtures.deleteProductsAndProductTypes(client()); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(PRODUCT_TYPE_KEY, PRODUCT_TYPE_KEY, PRODUCT_TYPE_KEY, emptyList()); productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); }
@BeforeClass public static void createData() { ProductFixtures.deleteProductsAndProductTypes(client()); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(PRODUCT_TYPE_KEY, PRODUCT_TYPE_KEY, PRODUCT_TYPE_KEY, emptyList()); productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); }
private static ProductType createEvilProductType() { final AttributeDefinition evilAttrDef = AttributeDefinitionBuilder.of(ATTR_NAME_EVIL, LocalizedString.ofEnglish(ATTR_NAME_EVIL), StringAttributeType.of()).build(); final ProductTypeDraft evilProductTypeDraft = ProductTypeDraft.of(randomKey(), EVIL_PRODUCT_TYPE_NAME, "", singletonList(evilAttrDef)); final ProductTypeCreateCommand evilProductTypeCreateCommand = ProductTypeCreateCommand.of(evilProductTypeDraft); return client().executeBlocking(evilProductTypeCreateCommand); }
public static ProductType createProductType(final BlockingSphereClient client, final String name) { final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(randomKey(), name, "", asList()); return client.executeBlocking(ProductTypeQuery.of().byName(name)).head() .orElseGet(() -> client.executeBlocking(ProductTypeCreateCommand.of(productTypeDraft))); }
@BeforeClass public static void createBookProductType() throws Exception { final AttributeDefinition isbn = AttributeDefinitionBuilder .of(ISBN_ATTR_NAME, en("ISBN"), StringAttributeType.of()) .build(); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(randomKey(), BOOK_PRODUCT_TYPE_NAME, "books", asList(isbn)); final ProductType productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); }
@Test public void execution() throws Exception { //size attribute stuff final EnumValue S = EnumValue.of("S", "S"); final EnumValue M = EnumValue.of("M", "M"); final EnumValue X = EnumValue.of("X", "X"); final List<EnumValue> values = asList(S, M, X); final LocalizedString sizeAttributeLabel = LocalizedString.of(ENGLISH, "size").plus(GERMAN, "Größe"); final AttributeDefinition sizeAttributeDefinition = AttributeDefinitionBuilder.of("size", sizeAttributeLabel, EnumAttributeType.of(values)) .required(true) .attributeConstraint(AttributeConstraint.COMBINATION_UNIQUE) .inputTip(LocalizedString.ofEnglish("size as enum")) .build(); final String name = getName(); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(randomKey(), name, "a 'T' shaped cloth", asList(sizeAttributeDefinition)); final ProductType productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); assertThat(productType.getName()).isEqualTo(name); assertThat(productType.getDescription()).isEqualTo("a 'T' shaped cloth"); assertThat(productType.getAttributes()).contains(sizeAttributeDefinition); assertThat(productType.getAttributes()).hasSize(1); assertThat(productType.getAttributes().get(0).getInputTip()) .isEqualTo(LocalizedString.ofEnglish("size as enum")); }
final ProductTypeCreateCommand command = ProductTypeCreateCommand.of(ProductTypeDraft.of(randomKey(), productTypeName, productTypeDescription, attributes)); final ProductType productType = client().executeBlocking(command); assertThat(productType.getName()).isEqualTo(productTypeName);
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)); }
private static ProductType createProductType() { final AttributeDefinition colorAttrDef = AttributeDefinitionBuilder.of(ATTR_NAME_COLOR, LocalizedString.ofEnglish(ATTR_NAME_COLOR), StringAttributeType.of()).build(); final AttributeDefinition sizeAttrDef = AttributeDefinitionBuilder.of(ATTR_NAME_SIZE, LocalizedString.ofEnglish(ATTR_NAME_SIZE), NumberAttributeType.of()).build(); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(randomKey(), PRODUCT_TYPE_NAME, "", asList(colorAttrDef, sizeAttrDef)); final ProductTypeCreateCommand productTypeCreateCommand = ProductTypeCreateCommand.of(productTypeDraft); return client().executeBlocking(productTypeCreateCommand); }
@BeforeClass public static void prepare() throws Exception { PagedQueryResult<ProductType> queryResult = client().executeBlocking(ProductTypeQuery.of().byName(productTypeName)); queryResult.getResults().forEach(pt -> deleteProductsProductTypeAndProductDiscounts(client(), pt)); productType = client().executeBlocking(ProductTypeCreateCommand.of(new TShirtProductTypeDraftSupplier(productTypeName).get())); }
public static ProductType productReferenceProductType(final BlockingSphereClient client) { final AttributeDefinition productReferenceDefinition = AttributeDefinitionBuilder .of("productreference", en("suggested product"), ReferenceAttributeType.ofProduct()) .required(true) .build(); final ProductTypeDraft productTypeDraft = ProductTypeDraft.of(randomKey(), productReferenceProductTypeName, "has an attribute which is reference to a product", asList(productReferenceDefinition)); final Optional<ProductType> productTypeOptional = client.executeBlocking(ProductTypeQuery.of().byName(productReferenceProductTypeName)).head(); return productTypeOptional.orElseGet(() -> client.executeBlocking(ProductTypeCreateCommand.of(productTypeDraft))); }
@Before public void setUp() throws Exception { final String key = randomKey(); productType = client().executeBlocking(ProductTypeCreateCommand.of(productTypeDraft(key))); product = client().executeBlocking(ProductCreateCommand.of(productDraft(productType))); }
@Test public void execution() throws Exception { final ProductType productType = client().executeBlocking(ProductTypeCreateCommand.of(getDraft())); client().executeBlocking(ProductTypeDeleteCommand.of(productType)); final Query<ProductType> query = ProductTypeQuery.of() .withPredicates(m -> m.id().is(productType.getId())); assertThat(client().executeBlocking(query).head()).isEmpty(); }
@Test public void executionByKey() throws Exception { final ProductType productType = client().executeBlocking(ProductTypeCreateCommand.of(getDraft())); client().executeBlocking(ProductTypeDeleteCommand.ofKey(productType.getKey(), productType.getVersion())); final Query<ProductType> query = ProductTypeQuery.of() .withPredicates(m -> m.id().is(productType.getId())); assertThat(client().executeBlocking(query).head()).isEmpty(); }
@Test public void localizedEnumValue() throws Exception { final String productTypeName = ProductAttributeFlowIntegrationTest.class.getSimpleName() + "lenum"; final List<LocalizedEnumValue> localizedEnumValues = asList(A, B, C); final ProductTypeDraft draft = ProductTypeDraft.of(randomKey(), productTypeName, "", asList(AttributeDefinitionBuilder.of(LOCALIZED_ENUM_ATTR, randomSlug(), LocalizedEnumAttributeType.of(localizedEnumValues)).build())); final ProductTypeQuery query = ProductTypeQuery.of().byName(productTypeName); final ProductTypeCreateCommand createCommand = ProductTypeCreateCommand.of(draft); final ProductType productType = getOrCreate(createCommand, query); final NamedAttributeAccess<LocalizedEnumValue> namesAccess = AttributeAccess.ofLocalizedEnumValue().ofName(LOCALIZED_ENUM_ATTR); final ProductVariantDraft masterVariant = ProductVariantDraftBuilder.of().attributes(AttributeDraft.of(namesAccess, B)).build(); final ProductDraft productDraft = ProductDraftBuilder.of(productType, randomSlug(), randomSlug(), masterVariant).build(); final Product product = client().executeBlocking(ProductCreateCommand.of(productDraft)); assertThat(extractAttribute(product, namesAccess)).contains(B); final Product updatedProduct = client().executeBlocking(ProductUpdateCommand.of(product, SetAttribute.of(1, namesAccess, C))); assertThat(extractAttribute(updatedProduct, namesAccess)).contains(C); final NamedAttributeAccess<LocalizedEnumValue> getterSetter = AttributeAccess.ofLocalizedEnumValue().ofName(LOCALIZED_ENUM_ATTR); final Attribute attribute = Attribute.of(getterSetter, C); final LocalizedEnumValue value = attribute.getValue(AttributeAccess.ofLocalizedEnumValue()); assertThat(value).isEqualTo(C); }
public static void withUpdateableProductType(final BlockingSphereClient client, final Supplier<ProductTypeDraft> creator, final UnaryOperator<ProductType> user) { final SphereInternalLogger logger = SphereInternalLogger.getLogger("product-types.fixtures"); final ProductTypeDraft productTypeDraft = creator.get(); final String name = productTypeDraft.getName(); final PagedQueryResult<ProductType> queryResult = client.executeBlocking(ProductTypeQuery.of().byName(name)); queryResult.getResults().forEach(productType -> { final PagedQueryResult<Product> pagedQueryResult = client.executeBlocking(ProductQuery.of().byProductType(productType)); delete(client, pagedQueryResult.getResults()); client.executeBlocking(ProductTypeDeleteCommand.of(productType)); }); final ProductType productType = client.executeBlocking(ProductTypeCreateCommand.of(productTypeDraft)); logger.debug(() -> "created product type " + productType.getName() + " " + productType.getId()); final ProductType updated = user.apply(productType); logger.debug(() -> "attempt to delete product type " + productType.getName() + " " + productType.getId()); try { client.executeBlocking(ProductTypeDeleteCommand.of(updated)); } catch (final Exception e) { final PagedQueryResult<Product> pagedQueryResult = client.executeBlocking(ProductQuery.of().byProductType(productType)); delete(client, pagedQueryResult.getResults()); client.executeBlocking(ProductTypeDeleteCommand.of(productType)); } }
refAttrDef, booleanSetAttrDef, textSetAttrDef, textSetAttrDef2, locTextSetAttrDef, locTextAttrDef2, enumSetAttrDef, locEnumSetAttrDef, numberSetAttrDef, moneySetAttrDef, dateSetAttrDef, timeSetAttrDef, dateTimeSetAttrDef, refSetAttrDef)); final ProductTypeCreateCommand productTypeCreateCommand = ProductTypeCreateCommand.of(productTypeDraft); return client.executeBlocking(productTypeCreateCommand);