def test_order_status_manager():
activate("en")
OrderStatusManager().ensure_default_statuses()
original_name = force_text(DefaultOrderStatus.INITIAL.label)
new_name = "New name"
status = OrderStatus.objects.get(
identifier=DefaultOrderStatus.INITIAL.value)
assert force_text(status.name) == original_name
status.name = new_name
status.save()
assert force_text(status.name) == new_name
OrderStatusManager().ensure_default_statuses()
status = OrderStatus.objects.get(
identifier=DefaultOrderStatus.INITIAL.value)
assert force_text(status.name) == new_name
old_identifier = status.identifier
status.identifier = "random_identifier"
status.save()
OrderStatusManager().ensure_default_statuses()
status = OrderStatus.objects.get(identifier=old_identifier)
assert OrderStatus.objects.get_default_initial()
assert OrderStatus.objects.get_default_processing()
assert OrderStatus.objects.get_default_complete()
assert OrderStatus.objects.get_default_canceled()
def __init__(self, **kwargs):
super(OrderStatusForm, self).__init__(**kwargs)
if self.instance.pk and OrderStatusManager().is_default(self.instance):
del self.fields['identifier']
del self.fields['role']
del self.fields['ordering']
del self.fields['is_active']
def clean(self):
if self.instance.pk and OrderStatusManager().is_default(self.instance):
data = self.cleaned_data
data["identifier"] = self.instance.identifier
data["role"] = self.instance.role
data["ordering"] = self.instance.ordering
data["is_active"] = self.instance.is_active
return data
return super(OrderStatusForm, self).clean()
def clean(self):
if self.instance.pk and OrderStatusManager().is_default(self.instance):
data = self.cleaned_data
data["identifier"] = self.instance.identifier
return data
qs = OrderStatus.objects.filter(identifier=self.cleaned_data["identifier"])
if self.instance.pk:
qs = qs.exclude(pk=self.instance.pk)
if qs.exists():
self.add_error("identifier", _("Identifier already exists."))
return super(OrderStatusForm, self).clean()
def test_shipment_events():
shop = factories.get_default_shop()
supplier = factories.get_default_supplier(shop)
customer = factories.create_random_person("en")
OrderStatusManager().ensure_default_statuses()
product = factories.create_product("p", shop, supplier, 1.0)
order = factories.create_order_with_product(product,
supplier,
1,
1,
shop=shop)
Script.objects.create(shop=shop,
event_identifier=ShipmentCreated.identifier,
name="Script 1",
enabled=True)
Script.objects.create(shop=shop,
event_identifier=ShipmentDeleted.identifier,
name="Script 2",
enabled=True)
Script.objects.create(shop=shop,
event_identifier=ShipmentSent.identifier,
name="Script 3",
enabled=True)
def get_created_mocked_cls():
return mock.MagicMock(identifier=ShipmentCreated.identifier)
def get_sent_mocked_cls():
return mock.MagicMock(identifier=ShipmentSent.identifier)
def get_soft_mocked_cls():
return mock.MagicMock(identifier=ShipmentDeleted.identifier)
with mock.patch("shuup.front.notify_events.ShipmentCreated",
new_callable=get_created_mocked_cls) as mocked1:
shipment = order.create_shipment({product: 1}, supplier=supplier)
mocked1.assert_called()
with mock.patch("shuup.front.notify_events.ShipmentSent",
new_callable=get_sent_mocked_cls) as mocked2:
shipment.set_sent()
mocked2.assert_called()
with mock.patch("shuup.front.notify_events.ShipmentDeleted",
new_callable=get_soft_mocked_cls) as mocked3:
shipment.soft_delete()
mocked3.assert_called()
def test_class_refunded():
shop = factories.get_default_shop()
supplier = factories.get_default_supplier(shop)
customer = factories.create_random_person("en")
OrderStatusManager().ensure_default_statuses()
product = factories.create_product("p", shop, supplier, 1.0)
order = factories.create_order_with_product(product,
supplier,
1,
1,
shop=shop)
# make sure to have some script enabled
Script.objects.create(shop=shop,
event_identifier="order_status_changed",
name="Script",
enabled=True)
def get_mocked_cls():
return mock.MagicMock(identifier="order_status_changed")
with mock.patch("shuup.front.notify_events.OrderStatusChanged",
new_callable=get_mocked_cls) as mocked:
order.change_status(
next_status=OrderStatus.objects.get_default_processing(),
user=customer.user)
mocked.assert_called()
order.refresh_from_db()
assert mocked.call_args[1]["order"] == order
assert mocked.call_args[1][
"old_status"] == OrderStatus.objects.get_default_initial()
assert mocked.call_args[1][
"new_status"] == OrderStatus.objects.get_default_processing()
assert order.status == OrderStatus.objects.get_default_processing()
# nothing changes
with mock.patch("shuup.front.notify_events.OrderStatusChanged",
new_callable=get_mocked_cls) as mocked:
order.change_status(
next_status=OrderStatus.objects.get_default_processing(),
user=customer.user)
mocked.assert_not_called()
def setUp(self):
OrderStatusManager().ensure_default_statuses()
product = factories.create_product("p", factories.get_default_shop(), factories.get_default_supplier())
customer = factories.create_random_person()
# Initial Order
intial_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.INITIAL.value).first()
self.order_initial = factories.create_random_order(customer=customer, products=[product])
self.order_initial.change_status(intial_status)
# Processing Order
process_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.PROCESSING.value).first()
self.order_processing = factories.create_random_order(customer=customer, products=[product])
self.order_processing.change_status(process_status)
# Complete Order
complete_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.COMPLETE.value).first()
self.order_complete = factories.create_random_order(customer=customer, products=[product])
self.order_complete.change_status(complete_status)
# Canceled Order
canceled_status = OrderStatus.objects.filter(identifier=DefaultOrderStatus.CANCELED.value).first()
self.order_canceled = factories.create_random_order(customer=customer, products=[product])
self.order_canceled.change_status(canceled_status)
def create_default_order_statuses():
OrderStatusManager().ensure_default_statuses()
def test_basket_with_package_product(admin_user):
shop = factories.get_default_shop()
factories.get_default_shipping_method()
factories.get_default_payment_method()
OrderStatusManager().ensure_default_statuses()
client = get_client(admin_user)
response = client.post("/api/shuup/basket/new/",
format="json",
data={"shop": shop.pk})
assert response.status_code == status.HTTP_201_CREATED
basket_uuid = response.data["uuid"]
supplier = factories.get_supplier(SimpleSupplierModule.identifier,
shop=shop,
stock_managed=True)
# base product - 1kg of sand
base_sand_product = factories.create_product("Sand",
shop=shop,
supplier=supplier,
default_price="15.2",
net_weight=Decimal(1))
# 10kg bag of sand - package made by 10kg of sand
sand_bag_10kg_product = factories.create_product("Sand-bag-10-kg",
shop=shop,
supplier=supplier,
default_price="149.9",
net_weight=Decimal(10000))
sand_bag_10kg_product.make_package({base_sand_product: 10})
sand_bag_10kg_product.save()
# 18.45kg bag of sand - package made by 18.45kg of sand
sand_bag_1845kg_product = factories.create_product(
"Sand-bag-1845-kg",
shop=shop,
supplier=supplier,
default_price="179.9",
net_weight=Decimal(18450))
sand_bag_1845kg_product.make_package({base_sand_product: 18.45})
sand_bag_1845kg_product.save()
# 25kg bag of sand - package made by 25kg of sand
sand_bag_25kg_product = factories.create_product("Sand-bag-25-kg",
shop=shop,
supplier=supplier,
default_price="2450.25",
net_weight=Decimal(25000))
sand_bag_25kg_product.make_package({base_sand_product: 25})
sand_bag_25kg_product.save()
initial_stock = 55
# put 55 sands (55kg) in stock
supplier.adjust_stock(base_sand_product.id, initial_stock)
stock_status = supplier.get_stock_status(base_sand_product.id)
assert stock_status.physical_count == initial_stock
assert stock_status.logical_count == initial_stock
# zero stock for packages
assert supplier.get_stock_status(
sand_bag_10kg_product.id).logical_count == 0
assert supplier.get_stock_status(
sand_bag_1845kg_product.id).logical_count == 0
assert supplier.get_stock_status(
sand_bag_25kg_product.id).logical_count == 0
# add all the 3 packages to the basket, this will require (10 + 18.45 + 25 = 53.45 Sands)
for product in [
sand_bag_10kg_product, sand_bag_1845kg_product,
sand_bag_25kg_product
]:
response = client.post(
"/api/shuup/basket/{}/add/".format(basket_uuid),
format="json",
data={
"shop": shop.pk,
"product": product.id
},
)
assert response.status_code == status.HTTP_200_OK
# get the basket
response = client.get("/api/shuup/basket/{}/".format(basket_uuid))
assert response.status_code == status.HTTP_200_OK
assert response.data["validation_errors"] == []
# now add more 25kg and it shouldn't have enough stock
response = client.post(
"/api/shuup/basket/{}/add/".format(basket_uuid),
format="json",
data={
"shop": shop.pk,
"product": sand_bag_25kg_product.id
},
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert "Insufficient quantity" in response.data["error"]
# create order anyway
response = client.post(
"/api/shuup/basket/{}/create_order/".format(basket_uuid),
format="json")
assert response.status_code == status.HTTP_201_CREATED
order = Order.objects.get(id=response.data["id"])
line_counter = Counter()
for line in order.lines.products():
line_counter[line.product.id] += line.quantity
assert bankers_round(line_counter[base_sand_product.id]) == bankers_round(
Decimal(10) + Decimal(18.45) + Decimal(25))
assert line_counter[sand_bag_10kg_product.id] == 1
assert line_counter[sand_bag_1845kg_product.id] == 1
assert line_counter[sand_bag_25kg_product.id] == 1
def ensure_allowed_next_statuses(apps, schema_editor):
from shuup.core.models import OrderStatusManager
OrderStatusManager().ensure_allowed_next_statuses()
