def test_product_variants_stocks_delete(staff_api_client, variant, warehouse,
permission_manage_products,
count_queries):
query = """
mutation ProductVariantStocksDelete($variantId: ID!, $warehouseIds: [ID!]!){
productVariantStocksDelete(
variantId: $variantId, warehouseIds: $warehouseIds
){
productVariant{
stocks{
id
quantity
warehouse{
slug
}
}
}
stockErrors{
field
code
message
}
}
}
"""
variant_id = graphene.Node.to_global_id("ProductVariant", variant.pk)
second_warehouse = Warehouse.objects.get(pk=warehouse.pk)
second_warehouse.slug = "second warehouse"
second_warehouse.pk = None
second_warehouse.save()
Stock.objects.bulk_create([
Stock(product_variant=variant, warehouse=warehouse, quantity=10),
Stock(product_variant=variant,
warehouse=second_warehouse,
quantity=140),
])
stocks_count = variant.stocks.count()
warehouse_ids = [
graphene.Node.to_global_id("Warehouse", second_warehouse.id)
]
variables = {"variantId": variant_id, "warehouseIds": warehouse_ids}
response = staff_api_client.post_graphql(
query,
variables,
permissions=[permission_manage_products],
)
content = get_graphql_content(response)
data = content["data"]["productVariantStocksDelete"]
assert not data["stockErrors"]
assert (len(data["productVariant"]["stocks"]) == variant.stocks.count() ==
stocks_count - 1)
def test_create_fulfillments_many_warehouses(
staff_user, order_with_lines, warehouses,
):
order = order_with_lines
warehouse1, warehouse2 = warehouses
order_line1, order_line2 = order.lines.all()
stock_w1_l1 = Stock(
warehouse=warehouse1, product_variant=order_line1.variant, quantity=3
)
stock_w1_l2 = Stock(
warehouse=warehouse1, product_variant=order_line2.variant, quantity=1
)
stock_w2_l2 = Stock(
warehouse=warehouse2, product_variant=order_line2.variant, quantity=1
)
Stock.objects.bulk_create([stock_w1_l1, stock_w1_l2, stock_w2_l2])
fulfillment_lines_for_warehouses = {
str(warehouse1.pk): [
{"order_line": order_line1, "quantity": 3},
{"order_line": order_line2, "quantity": 1},
],
str(warehouse2.pk): [{"order_line": order_line2, "quantity": 1}],
}
[fulfillment1, fulfillment2] = create_fulfillments(
staff_user, order, fulfillment_lines_for_warehouses, False
)
order.refresh_from_db()
fulfillment_lines = FulfillmentLine.objects.filter(
fulfillment__order=order
).order_by("pk")
assert fulfillment_lines[0].stock == stock_w1_l1
assert fulfillment_lines[0].quantity == 3
assert fulfillment_lines[1].stock == stock_w1_l2
assert fulfillment_lines[1].quantity == 1
assert fulfillment_lines[2].stock == stock_w2_l2
assert fulfillment_lines[2].quantity == 1
assert order.status == OrderStatus.FULFILLED
assert order.fulfillments.get(fulfillment_order=1) == fulfillment1
assert order.fulfillments.get(fulfillment_order=2) == fulfillment2
order_line1, order_line2 = order.lines.all()
assert order_line1.quantity_fulfilled == 3
assert order_line2.quantity_fulfilled == 2
assert (
Allocation.objects.filter(
order_line__order=order, quantity_allocated__gt=0
).count()
== 0
)
def test_retrieve_variant_list(product_variant_list, api_client, count_queries,
warehouse):
query = """
fragment BasicProductFields on Product {
id
name
thumbnail {
url
alt
}
thumbnail2x: thumbnail(size: 510) {
url
}
}
fragment ProductVariantFields on ProductVariant {
id
sku
name
stockQuantity
isAvailable
pricing {
discountLocalCurrency {
currency
gross {
amount
localized
}
}
price {
currency
gross {
amount
localized
}
}
priceUndiscounted {
currency
gross {
amount
localized
}
}
priceLocalCurrency {
currency
gross {
amount
localized
}
}
}
attributes {
attribute {
id
name
}
values {
id
name
value: name
}
}
}
query VariantList($ids: [ID!]) {
productVariants(ids: $ids, first: 100) {
edges {
node {
...ProductVariantFields
stockQuantity
product {
...BasicProductFields
}
}
}
}
}
"""
Stock.objects.bulk_create([
Stock(product_variant=variant, warehouse=warehouse)
for variant in product_variant_list
])
variables = {
"ids": [
graphene.Node.to_global_id("ProductVariant", variant.pk)
for variant in product_variant_list
]
}
get_graphql_content(api_client.post_graphql(query, variables))
def products_for_pagination(product_type, color_attribute, category,
warehouse):
product_type2 = ProductType.objects.create(name="Apple")
products = Product.objects.bulk_create([
Product(
name="Product1",
slug="prod1",
price=Money("10.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
description="desc1",
),
Product(
name="ProductProduct1",
slug="prod_prod1",
price=Money("15.00", "USD"),
category=category,
product_type=product_type,
is_published=False,
),
Product(
name="ProductProduct2",
slug="prod_prod2",
price=Money("8.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
),
Product(
name="Product2",
slug="prod2",
price=Money("7.00", "USD"),
category=category,
product_type=product_type,
is_published=False,
description="desc2",
),
Product(
name="Product3",
slug="prod3",
price=Money("15.00", "USD"),
category=category,
product_type=product_type2,
is_published=True,
description="desc3",
),
])
product_attrib_values = color_attribute.values.all()
associate_attribute_values_to_instance(products[1], color_attribute,
product_attrib_values[0])
associate_attribute_values_to_instance(products[3], color_attribute,
product_attrib_values[1])
variants = ProductVariant.objects.bulk_create([
ProductVariant(
product=products[0],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
ProductVariant(
product=products[2],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
ProductVariant(
product=products[4],
sku=str(uuid.uuid4()).replace("-", ""),
track_inventory=True,
),
])
Stock.objects.bulk_create([
Stock(warehouse=warehouse, product_variant=variants[0], quantity=100),
Stock(warehouse=warehouse, product_variant=variants[1], quantity=0),
Stock(warehouse=warehouse, product_variant=variants[2], quantity=0),
])
return products
def test_retrieve_variant_list(
product_variant_list,
api_client,
count_queries,
warehouse,
warehouse_no_shipping_zone,
shipping_zone_without_countries,
):
query = """
fragment BasicProductFields on Product {
id
name
thumbnail {
url
alt
}
thumbnail2x: thumbnail(size: 510) {
url
}
}
fragment ProductVariantFields on ProductVariant {
id
sku
name
stockQuantity
isAvailable
pricing {
discountLocalCurrency {
currency
gross {
amount
localized
}
}
price {
currency
gross {
amount
localized
}
}
priceUndiscounted {
currency
gross {
amount
localized
}
}
priceLocalCurrency {
currency
gross {
amount
localized
}
}
}
attributes {
attribute {
id
name
}
values {
id
name
value: name
}
}
}
query VariantList($ids: [ID!]) {
productVariants(ids: $ids, first: 100) {
edges {
node {
...ProductVariantFields
stockQuantity
quantityAvailable
quantityAvailablePl: quantityAvailable(countryCode: PL)
quantityAvailableUS: quantityAvailable(countryCode: US)
product {
...BasicProductFields
}
}
}
}
}
"""
warehouse_2 = warehouse_no_shipping_zone
warehouse_2.shipping_zones.add(shipping_zone_without_countries)
stocks = [
Stock(product_variant=variant, warehouse=warehouse, quantity=1)
for variant in product_variant_list
]
stocks.extend([
Stock(product_variant=variant, warehouse=warehouse_2, quantity=2)
for variant in product_variant_list
])
Stock.objects.bulk_create(stocks)
variables = {
"ids": [
graphene.Node.to_global_id("ProductVariant", variant.pk)
for variant in product_variant_list
]
}
get_graphql_content(api_client.post_graphql(query, variables))