def cart_draft(client):
product_1 = client.products.create(
types.ProductDraft(
key=f"product-1",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
publish=True,
))
product_2 = client.products.create(
types.ProductDraft(
key=f"product-2",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product-2"),
slug=types.LocalizedString(en=f"my-product-2"),
publish=True,
))
return types.CartDraft(
customer_id=str(uuid.uuid4()),
customer_email="*****@*****.**",
currency="GBP",
anonymous_id=str(uuid.uuid4()),
country="GB",
inventory_mode=types.InventoryMode.NONE,
tax_mode=types.TaxMode.PLATFORM,
tax_rounding_mode=types.RoundingMode.HALF_EVEN,
tax_calculation_mode=types.TaxCalculationMode.LINE_ITEM_LEVEL,
line_items=[
types.LineItemDraft(product_id=product_1.id, quantity=1),
types.LineItemDraft(product_id=product_2.id, quantity=2),
],
locale="en",
origin=types.CartOrigin.CUSTOMER,
)
def test_product_query(client):
client.products.create(
types.ProductDraft(
key=f"product-1",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
publish=True,
)
)
client.products.create(
types.ProductDraft(
key=f"product-2",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product-2"),
slug=types.LocalizedString(en=f"my-product-2"),
publish=True,
)
)
# single sort query
result = client.products.query(sort="id asc", limit=2)
assert len(result.results) == 2
assert result.total == 2
# multiple sort queries
result = client.products.query(sort=["id asc", "name asc"])
assert len(result.results) == 2
assert result.total == 2
def test_equality():
obj_1 = types.ProductDraft(slug="test-1")
obj_2 = types.ProductDraft(slug="test-2")
assert obj_1 != obj_2
obj_1 = types.ProductDraft(slug="test-1")
obj_2 = types.ProductDraft(slug="test-1")
assert obj_1 == obj_2
def test_non_equality():
obj_1 = types.ProductDraft(
slug=types.LocalizedString(en="test-2"),
name=types.LocalizedString(en="test-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
)
obj_2 = types.ProductDraft(
slug=types.LocalizedString(en="test-1"),
name=types.LocalizedString(en="test-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
)
assert obj_1 != obj_2
def test_product_query(client):
client.products.create(types.ProductDraft(key="test-product1"))
client.products.create(types.ProductDraft(key="test-product2"))
# single sort query
result = client.products.query(sort="id asc", limit=2)
assert len(result.results) == 2
assert result.total == 2
# multiple sort queries
result = client.products.query(sort=["id asc", "name asc"])
assert len(result.results) == 2
assert result.total == 2
def test_product_query_where(client):
client.products.create(
types.ProductDraft(
key="test-product1",
master_variant=types.ProductVariantDraft(
prices=[
types.PriceDraft(
country="NL",
value=types.CentPrecisionMoneyDraft(
cent_amount=8750, currency_code="EUR"
),
)
]
),
)
)
client.products.create(
types.ProductDraft(
key="test-product-2",
master_variant=types.ProductVariantDraft(
prices=[
types.PriceDraft(
country="UK",
value=types.CentPrecisionMoneyDraft(
cent_amount=8750, currency_code="EUR"
),
)
]
),
)
)
client.products.create(types.ProductDraft(key="test-product2"))
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='NL'))))"
)
assert len(result.results) == 1
assert result.total == 1
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='UK'))))"
)
assert len(result.results) == 1
assert result.total == 1
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='UK' or country='NL'))))"
)
assert len(result.results) == 2
assert result.total == 2
def test_resource_delete_conflict(client):
"""Test the return value of the update methods.
It doesn't test the actual update itself.
TODO: See if this is worth testing since we're using a mocking backend
"""
product = client.products.create(
types.ProductDraft(
key="test-product",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name={"en": "my-product"},
slug={"en": "foo-bar"},
))
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(
nl="nl-slug2"))
],
)
assert product.version == 2
# This should raise a version conflict error
with pytest.raises(CommercetoolsError) as exc:
product = client.products.delete_by_id(id=product.id, version=1)
assert exc.value.response.status_code == 409
assert exc.value.response.errors[0].current_version == 2
# Force it
client.products.delete_by_id(id=product.id, version=1, force_delete=True)
def test_get_by_key(client):
product = client.products.create(
types.ProductDraft(
master_variant=types.ProductVariantDraft(sku="123"),
publish=True,
name=types.LocalizedString(nl="Test product"),
slug=types.LocalizedString(en="my-product"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
))
variant = product.master_data.current.master_variant
shopping_list = client.shopping_lists.create(draft=types.ShoppingListDraft(
key="test-shopping-list",
name=types.LocalizedString({"nl": "Verlanglijstje"}),
description=types.LocalizedString({"nl": "Verlanglijstje van LabD"}),
line_items=[
types.ShoppingListLineItemDraft(sku=variant.sku, quantity=1)
],
))
assert shopping_list.key
shopping_list = client.shopping_lists.get_by_key("test-shopping-list")
assert shopping_list.name["nl"] == "Verlanglijstje"
assert shopping_list.description["nl"] == "Verlanglijstje van LabD"
assert shopping_list.line_items[0].variant.sku == "123"
assert shopping_list.line_items[0].quantity == 1
def test_products_create(client):
custom_type = client.types.create(
types.TypeDraft(name=types.LocalizedString(en="myType"),
resource_type_ids=[types.ResourceTypeId.ASSET],
field_definitions=[types.FieldDefinition(name="foo")]))
assert custom_type.id
draft = types.ProductDraft(
key="test-product",
publish=True,
master_variant=types.ProductVariantDraft(
assets=[
types.AssetDraft(custom=types.CustomFieldsDraft(
type=types.TypeResourceIdentifier(id=custom_type.id),
fields=types.FieldContainer(foo="bar"),
))
],
prices=[
types.PriceDraft(
value=types.CentPrecisionMoneyDraft(cent_amount=1000,
currency_code="EUR"),
country="NL",
)
],
),
)
product = client.products.create(draft)
assert product.id
assert product.master_data.current.master_variant.assets
assert product.master_data.current.master_variant.prices
def test_correlation_id_is_set_in_exception(client):
product = client.products.create(
types.ProductDraft(
key="test-product",
name=types.LocalizedString(en=f"my-product"),
slug=types.LocalizedString(en=f"my-product"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
))
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(
nl="nl-slug2"))
],
)
# This should raise a version conflict error
with pytest.raises(CommercetoolsError) as exc:
client.products.update_by_id(
id=product.id,
version=1,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(
nl="nl-slug3"))
],
)
assert exc.value.correlation_id is not None
def test_get_by_id(client):
product = client.products.create(
types.ProductDraft(
master_variant=types.ProductVariantDraft(sku="123"),
publish=True,
name=types.LocalizedString(nl="Test product"),
)
)
shopping_list = client.shopping_lists.create(
draft=types.ShoppingListDraft(
name=types.LocalizedString({"nl": "Verlanglijstje"}),
description=types.LocalizedString({"nl": "Verlanglijstje van LabD"}),
line_items=[
types.ShoppingListLineItemDraft(product_id=product.id, quantity=1)
],
)
)
assert shopping_list.id
shopping_list = client.shopping_lists.get_by_id(shopping_list.id)
assert shopping_list.name["nl"] == "Verlanglijstje"
assert shopping_list.description["nl"] == "Verlanglijstje van LabD"
assert shopping_list.line_items[0].product_id == product.id
assert shopping_list.line_items[0].quantity == 1
def test_product_update(client):
"""Test the return value of the update methods.
It doesn't test the actual update itself.
TODO: See if this is worth testing since we're using a mocking backend
"""
product = client.products.create(types.ProductDraft(key="test-product"))
assert uuid.UUID(product.id)
assert product.key == "test-product"
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(nl="nl-slug2"))
],
)
assert product.key == "test-product"
product = client.products.update_by_key(
key="test-product",
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(nl="nl-slug2"))
],
)
assert product.key == "test-product"
def test_product_update_add_price_current(client):
product = client.products.create(
types.ProductDraft(
key="test-product",
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
master_variant=types.ProductVariantDraft(sku="1", key="1"),
publish=True,
)
)
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductAddPriceAction(
sku="1",
staged=False,
price=types.PriceDraft(
value=types.Money(cent_amount=1000, currency_code="GBP")
),
)
],
)
assert product.master_data.staged is None
assert len(product.master_data.current.master_variant.prices) == 1
def test_product_update(client):
"""Test the return value of the update methods.
It doesn't test the actual update itself.
TODO: See if this is worth testing since we're using a mocking backend
"""
product = client.products.create(
types.ProductDraft(
key="test-product",
master_variant=types.ProductVariantDraft(sku="1", key="1"),
))
assert uuid.UUID(product.id)
assert product.key == "test-product"
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(
nl="nl-slug2"))
],
)
assert product.key == "test-product"
assert product.master_data.published is False
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[types.ProductPublishAction()])
assert product.master_data.published is True
assert not product.master_data.current.master_variant.prices
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductSetPricesAction(
sku="1",
prices=[
types.PriceDraft(value=types.Money(cent_amount=1000,
currency_code="GBP"))
],
staged=False,
)
],
)
assert len(product.master_data.current.master_variant.prices) == 1
product = client.products.update_by_key(
key="test-product",
version=product.version,
actions=[
types.ProductChangeSlugAction(slug=types.LocalizedString(
nl="nl-slug2"))
],
)
assert product.key == "test-product"
def test_product_projections_query(client):
for key in ["product-1", "product-2"]:
client.products.create(types.ProductDraft(key=key, publish=True))
client.products.create(types.ProductDraft(key="product-3", publish=False))
# single sort query
result = client.product_projections.query(
sort="id asc",
where=[f'slug(nl-NL="product-3")'],
expand=["parent.category"])
assert len(result.results) == 2
assert result.total == 2
assert result.results[0].key == "product-1"
assert result.results[1].key == "product-2"
# multiple sort queries
result = client.product_projections.query(sort=["id asc", "name asc"])
assert len(result.results) == 2
assert result.total == 2
def create_products(client):
for i in range(100):
client.products.create(
types.ProductDraft(
key=f"test-product-{i}",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product-{i}"),
slug=types.LocalizedString(en=f"my-product-{i}"),
)
)
def test_product_projections_query(client):
for key in ["product-1", "product-2"]:
variant = types.ProductVariantDraft()
client.products.create(
types.ProductDraft(
key=key,
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=key),
slug=types.LocalizedString(en=key),
master_variant=variant,
variants=[variant],
publish=True,
)
)
key = "product-3"
client.products.create(
types.ProductDraft(
key=key,
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=key),
slug=types.LocalizedString(en=key),
master_variant=variant,
variants=[variant],
publish=False,
)
)
# single sort query
result = client.product_projections.query(
sort="id asc", where=[f'slug(nl-NL="product-3")'], expand=["parent.category"]
)
assert len(result.results) == 2
assert result.total == 2
assert result.results[0].key == "product-1"
assert result.results[1].key == "product-2"
# multiple sort queries
result = client.product_projections.query(sort=["id asc", "name asc"])
assert len(result.results) == 2
assert result.total == 2
def test_cursor_paginator(client):
for i in range(100):
client.products.create(
types.ProductDraft(name=types.LocalizedString(en=f"Product {i}")))
paginator = paginators.CursorPaginator(client.products.query,
sort=["id asc", "name asc"])
items = []
for product in paginator:
items.append(product)
assert len(items) == 100
def test_products_get_by_key(client):
product = client.products.create(types.ProductDraft(key="test-product"))
assert product.id
assert product.key == "test-product"
product = client.products.get_by_key("test-product")
assert product.id
assert product.key == "test-product"
with pytest.raises(HTTPError) as e:
client.products.get_by_key("invalid")
def test_cursor_paginator_slice_start(client):
for i in range(100):
client.products.create(
types.ProductDraft(name=types.LocalizedString(en=f"Product {i}")))
paginator = paginators.CursorPaginator(client.products.query,
sort=["id asc", "name asc"])
items = []
with pytest.raises(ValueError):
for product in paginator[10:]:
items.append(product)
def test_page_paginator_slice_start_stop(client):
for i in range(100):
client.products.create(
types.ProductDraft(name=types.LocalizedString(en=f"Product {i}")))
paginator = paginators.Paginator(client.products.query,
sort=["id asc", "name asc"])
items = []
for product in paginator[20:-20]:
items.append(product)
if len(items) > 60:
assert False
assert len(items) == 60
def test_product_update_add_change_price_staged(client):
product = client.products.create(
types.ProductDraft(
key="test-product",
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
master_variant=types.ProductVariantDraft(sku="1", key="1"),
)
)
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductAddPriceAction(
sku="1",
price=types.PriceDraft(
value=types.Money(cent_amount=1000, currency_code="GBP")
),
)
],
)
assert product.master_data.current is None
assert len(product.master_data.staged.master_variant.prices) == 1
price = product.master_data.staged.master_variant.prices[0]
assert price.value.cent_amount == 1000
assert price.value.currency_code == "GBP"
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductChangePriceAction(
price_id=price.id,
price=types.PriceDraft(
value=types.Money(cent_amount=3000, currency_code="EUR")
),
)
],
)
assert product.master_data.current is None
assert len(product.master_data.staged.master_variant.prices) == 1
price = product.master_data.staged.master_variant.prices[0]
assert price.value.cent_amount == 3000
assert price.value.currency_code == "EUR"
def test_product_projections_get_by_key(client):
variant = types.ProductVariantDraft()
product_create = client.products.create(
types.ProductDraft(
key="test-product",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en=f"my-product"),
slug=types.LocalizedString(en=f"my-product"),
master_variant=variant,
variants=[variant],
publish=False,
)
)
product = client.product_projections.get_by_key(product_create.key, staged=True)
assert product.id == product_create.id
assert product.key == product_create.key
def test_products_get_by_key(client):
product = client.products.create(
types.ProductDraft(
key="test-product",
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
name=types.LocalizedString(en="my-product"),
slug=types.LocalizedString(en="my-product"),
publish=True,
)
)
assert product.id
assert product.key == "test-product"
product = client.products.get_by_key("test-product")
assert product.id
assert product.key == "test-product"
with pytest.raises(HTTPError) as e:
client.products.get_by_key("invalid")
def test_product_update_add_price_current(client):
product = client.products.create(
types.ProductDraft(
key="test-product",
master_variant=types.ProductVariantDraft(sku="1", key="1"),
publish=True,
))
product = client.products.update_by_id(
id=product.id,
version=product.version,
actions=[
types.ProductAddPriceAction(
sku="1",
staged=False,
price=types.PriceDraft(
value=types.Money(cent_amount=1000, currency_code="GBP")),
)
],
)
assert product.master_data.staged is None
assert len(product.master_data.current.master_variant.prices) == 1
def test_gt_lt():
obj_1 = types.ProductDraft(slug="test-1", name="foo")
obj_2 = types.ProductDraft(slug="test-1", name="bar")
assert obj_1 > obj_2
assert not obj_1 < obj_2
def test_product_projections_get_by_id(client):
product_create = client.products.create(
types.ProductDraft(key="test-product1", publish=False))
product = client.product_projections.get_by_id(product_create.id)
assert product.id == product_create.id
assert product.key == product_create.key
def test_product_query_where(client):
client.products.create(
types.ProductDraft(
key="test-product1",
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
master_variant=types.ProductVariantDraft(
prices=[
types.PriceDraft(
country="NL",
value=types.CentPrecisionMoneyDraft(
cent_amount=8750, currency_code="EUR"
),
)
]
),
)
)
client.products.create(
types.ProductDraft(
key="test-product-2",
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
master_variant=types.ProductVariantDraft(
prices=[
types.PriceDraft(
country="UK",
value=types.CentPrecisionMoneyDraft(
cent_amount=8750, currency_code="EUR"
),
)
]
),
)
)
client.products.create(
types.ProductDraft(
key="test-product2",
name=types.LocalizedString(en=f"my-product-1"),
slug=types.LocalizedString(en=f"my-product-1"),
product_type=types.ProductTypeResourceIdentifier(key="dummy"),
)
)
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='NL'))))"
)
assert len(result.results) == 1
assert result.total == 1
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='UK'))))"
)
assert len(result.results) == 1
assert result.total == 1
result = client.products.query(
where="masterData(staged(masterVariant(prices(country='UK' or country='NL'))))"
)
assert len(result.results) == 2
assert result.total == 2
