def test_broken_order_lines(): with pytest.raises(ValidationError): OrderLine(type=OrderLineType.PRODUCT).save() with pytest.raises(ValidationError): OrderLine(product=get_default_product(), type=OrderLineType.PRODUCT, supplier=None).save() with pytest.raises(ValidationError): OrderLine(product=get_default_product(), type=OrderLineType.OTHER).save() with pytest.raises(ValidationError): OrderLine(product=get_default_product(), type=OrderLineType.OTHER, tax_rate=3).save()
def test_basic_order(): PRODUCTS_TO_SEND = 10 product = get_default_product() supplier = get_default_supplier() order = create_order_with_product( product, supplier=supplier, quantity=PRODUCTS_TO_SEND, taxless_base_unit_price=10, tax_rate=Decimal("0.5") ) assert order.shop.prices_include_tax is False price = order.shop.create_price currency = order.currency discount_order_line = OrderLine(order=order, quantity=1, type=OrderLineType.OTHER) discount_order_line.discount_amount = price(30) assert discount_order_line.price == price(-30) discount_order_line.save() order.cache_prices() order.check_all_verified() order.save() assert order.taxful_total_price == TaxfulPrice(PRODUCTS_TO_SEND * (10 + 5) - 30, currency) shipment = order.create_shipment_of_all_products(supplier=supplier) assert shipment.total_products == PRODUCTS_TO_SEND, "All products were shipped" assert shipment.weight == product.gross_weight * PRODUCTS_TO_SEND / 1000, "Gravity works" assert not order.get_unshipped_products(), "Nothing was left in the warehouse" order.shipping_status = ShippingStatus.FULLY_SHIPPED order.create_payment(order.taxful_total_price) assert order.payments.exists(), "A payment was created" with pytest.raises(NoPaymentToCreateException): order.create_payment(Money(6, currency)) assert order.is_paid(), "Order got paid" assert order.can_set_complete(), "Finalization is possible" order.status = OrderStatus.objects.get_default_complete() assert order.is_complete(), "Finalization done" summary = order.get_tax_summary() assert len(summary) == 2 assert summary[0].tax_rate * 100 == 50 assert summary[0].based_on == Money(100, currency) assert summary[0].tax_amount == Money(50, currency) assert summary[0].taxful == summary[0].based_on + summary[0].tax_amount assert summary[1].tax_id is None assert summary[1].tax_code == '' assert summary[1].tax_amount == Money(0, currency) assert summary[1].tax_rate == 0 assert order.get_total_tax_amount() == Money(50, currency)
def test_refunds_for_discounted_order_lines(): shop = get_default_shop() supplier = get_default_supplier() product = create_product( "test-sku", shop=get_default_shop(), default_price=10, stock_behavior=StockBehavior.STOCKED ) order = create_order_with_product(product, supplier, 2, 200, shop=shop) discount_line = OrderLine( order_id=order.id, type=OrderLineType.DISCOUNT, quantity=1, discount_amount_value=Decimal("0.54321")) discount_line.save() order.lines.add(discount_line) product_line = order.lines.filter(type=OrderLineType.PRODUCT).first() product_line.discount_amount = TaxfulPrice(100, order.currency) product_line.save() taxful_price_with_discount = product_line.taxful_price order.cache_prices() order.save() assert product_line.base_price == TaxfulPrice(400, order.currency) assert taxful_price_with_discount == TaxfulPrice(300, order.currency) # try to refund only the product line - should fail since this would result in a negative total with pytest.raises(RefundExceedsAmountException): order.create_refund([{"line": product_line, "quantity": 2, "amount": taxful_price_with_discount.amount}]) # try to refund the product line with a negative amount with pytest.raises(InvalidRefundAmountException): order.create_refund([{"line": product_line, "quantity": 1, "amount": -taxful_price_with_discount.amount}]) # try to refund the discount line with a positive amount with pytest.raises(InvalidRefundAmountException): order.create_refund([{"line": discount_line, "quantity": 1, "amount": -discount_line.taxful_price.amount}]) order.create_refund([ {"line": discount_line, "quantity": 1, "amount": discount_line.taxful_price.amount}, {"line": product_line, "quantity": 2, "amount": taxful_price_with_discount.amount} ]) assert product_line.max_refundable_amount.value == 0 assert discount_line.max_refundable_amount.value == 0 assert order.taxful_total_price.value == 0 order = create_order_with_product(product, supplier, 2, 200, shop=shop) discount_line = OrderLine( order_id=order.id, type=OrderLineType.DISCOUNT, quantity=1, discount_amount_value=Decimal("0.54321")) discount_line.save() order.lines.add(discount_line) product_line = order.lines.filter(type=OrderLineType.PRODUCT).first() product_line.discount_amount = TaxfulPrice(100, order.currency) product_line.save() order.cache_prices() order.save() order.create_full_refund(restock_products=False) assert order.taxful_total_price.value == 0
def create_package_children(self, order_line): order = order_line.order parent_product = order_line.product # :type parent_product: wshop.core.models.Product if not (parent_product and parent_product.is_package_parent()): return child_to_quantity = parent_product.get_package_child_to_quantity_map() for (child_product, child_quantity) in child_to_quantity.items(): child_order_line = OrderLine(order=order, parent_line=order_line) update_order_line_from_product( pricing_context=None, # Will use zero price order_line=child_order_line, product=child_product, quantity=(order_line.quantity * child_quantity), ) # Package children are free assert child_order_line.base_unit_price.value == 0 child_order_line.source_line = None child_order_line.parent_source_line = order_line.source_line child_order_line.supplier = order_line.supplier self._check_orderability(child_order_line) yield child_order_line
def add_product_to_order(order, supplier, product, quantity, taxless_base_unit_price, tax_rate=0, pricing_context=None): if not pricing_context: pricing_context = _get_pricing_context(order.shop, order.customer) product_order_line = OrderLine(order=order) update_order_line_from_product(pricing_context, order_line=product_order_line, product=product, quantity=quantity, supplier=supplier) base_unit_price = order.shop.create_price(taxless_base_unit_price) if order.prices_include_tax: base_unit_price *= (1 + tax_rate) product_order_line.base_unit_price = order.shop.create_price(base_unit_price) product_order_line.save() taxes = [get_test_tax(tax_rate)] price = quantity * base_unit_price taxed_price = stacked_value_added_taxes(price, taxes) order_line_tax = OrderLineTax.from_tax( taxes[0], taxed_price.taxless.amount, order_line=product_order_line, ) order_line_tax.save() # Save order line tax before linking to order_line.taxes product_order_line.taxes.add(order_line_tax)
def test_rounding(prices): expected = 0 for p in prices: expected += bankers_round(p, 2) order = create_empty_order(prices_include_tax=False) order.save() for x, price in enumerate(prices): ol = OrderLine(order=order, type=OrderLineType.OTHER, quantity=1, text="Thing", ordering=x, base_unit_price=order.shop.create_price(price)) ol.save() order.cache_prices() for x, order_line in enumerate(order.lines.all().order_by("ordering")): price = Decimal(prices[x]).quantize(Decimal(".1")**9) # make sure prices are in database with original precision assert order_line.base_unit_price == order.shop.create_price(price) # make sure the line taxless price is rounded assert order_line.taxless_price == order.shop.create_price( bankers_round(price, 2)) # Check that total prices calculated from priceful parts still matches assert _get_taxless_price(order_line) == order_line.taxless_price assert _get_taxful_price(order_line) == order_line.taxful_price # make sure the line price is rounded assert order_line.price == order.shop.create_price(price) # make sure order total is rounded assert order.taxless_total_price == order.shop.create_price( bankers_round(expected, 2))
def _get_order_and_order_line(request): order = Order( shop=request.shop, currency=request.shop.currency, prices_include_tax=request.shop.prices_include_tax, ) order.taxful_total_price = TaxfulPrice("100", request.shop.currency) order.taxless_total_price = TaxlessPrice("50", request.shop.currency) pi = _get_price_info(request.shop, Product(sku='6.0745'), quantity=2) return (order, OrderLine( order=order, base_unit_price=pi.base_unit_price, discount_amount=pi.discount_amount, quantity=pi.quantity, ))
def test_line_discount_more(): order = create_empty_order() order.save() ol = OrderLine(order=order, type=OrderLineType.OTHER) ol.quantity = 5 ol.base_unit_price = order.shop.create_price(30) ol.discount_amount = order.shop.create_price(50) ol.save() currency = order.shop.currency assert ol.taxless_base_unit_price == TaxlessPrice(30, currency) assert ol.taxless_discount_amount == TaxlessPrice(50, currency) assert ol.taxless_price == TaxlessPrice(5 * 30 - 50, currency) order_line_tax = OrderLineTax.from_tax( get_default_tax(), ol.taxless_price.amount, order_line=ol) order_line_tax.save() ol.taxes.add(order_line_tax) assert ol.taxless_discount_amount == TaxlessPrice(50, currency) assert ol.taxful_discount_amount == TaxfulPrice(75, currency) assert ol.taxless_price == TaxlessPrice(100, currency) assert ol.taxful_price == TaxfulPrice(150, currency) assert ol.taxless_base_unit_price == TaxlessPrice(30, currency) assert ol.taxful_base_unit_price == TaxfulPrice(45, currency)
def test_line_discount(): order = create_empty_order(prices_include_tax=False) order.save() currency = order.shop.currency ol = OrderLine( order=order, type=OrderLineType.OTHER, quantity=5, text="Thing" ) ol.discount_amount = order.shop.create_price(50) ol.base_unit_price = order.shop.create_price(40) ol.save() order_line_tax = OrderLineTax.from_tax( get_default_tax(), ol.taxless_price.amount, order_line=ol) order_line_tax.save() ol.taxes.add(order_line_tax) assert ol.taxless_discount_amount == order.shop.create_price(50) assert ol.taxful_discount_amount == TaxfulPrice(75, currency) assert ol.taxless_price == order.shop.create_price(150) assert ol.taxful_price == TaxfulPrice(150 + 75, currency) assert ol.taxless_base_unit_price == order.shop.create_price(40) assert ol.taxful_base_unit_price == TaxfulPrice(60, currency) assert "Thing" in six.text_type(ol)
def source_line_to_order_lines(self, order, source_line): """ Convert a source line into one or more order lines. Normally each source line will yield just one order line, but package products will yield a parent line and its child lines. :type order: wshop.core.models.Order :param order: The order :type source_line: wshop.core.order_creator.SourceLine :param source_line: The SourceLine :rtype: Iterable[OrderLine] """ order_line = OrderLine(order=order) product = source_line.product quantity = Decimal(source_line.quantity) if product: order_line.product = product if product.sales_unit: quantized_quantity = bankers_round(quantity, product.sales_unit.decimals) if quantized_quantity != quantity: raise ValueError( "Sales unit decimal conversion causes precision loss!") else: order_line.product = None def text(value): return force_text(value) if value is not None else "" order_line.quantity = quantity order_line.supplier = source_line.supplier order_line.sku = text(source_line.sku) order_line.text = (text(source_line.text))[:192] if source_line.base_unit_price: order_line.base_unit_price = source_line.base_unit_price if source_line.discount_amount: order_line.discount_amount = source_line.discount_amount order_line.type = (source_line.type if source_line.type is not None else OrderLineType.OTHER) order_line.accounting_identifier = text( source_line.accounting_identifier) order_line.require_verification = bool( source_line.require_verification) order_line.verified = (not order_line.require_verification) order_line.source_line = source_line order_line.parent_source_line = source_line.parent_line order_line.extra_data = {"source_line_id": source_line.line_id} self._check_orderability(order_line) yield order_line for child_order_line in self.create_package_children(order_line): yield child_order_line
def create_order(request, creator, customer, product): billing_address = get_address().to_immutable() shipping_address = get_address(name="Shippy Doge").to_immutable() shipping_address.save() default_pm = get_default_payment_method() default_sm = get_default_shipping_method() shop = request.shop order = Order( creator=creator, customer=customer, shop=shop, payment_method=default_pm, shipping_method=default_sm, billing_address=billing_address, shipping_address=shipping_address, order_date=now(), status=get_initial_order_status(), currency=shop.currency, prices_include_tax=shop.prices_include_tax, ) order.full_clean() order.save() supplier = get_default_supplier() product_order_line = OrderLine(order=order) update_order_line_from_product( pricing_context=request, order_line=product_order_line, product=product, quantity=5, supplier=supplier) assert product_order_line.text == product.safe_translation_getter("name") product_order_line.base_unit_price = shop.create_price(100) assert product_order_line.price.value > 0 product_order_line.save() line_tax = get_line_taxes_for(product_order_line)[0] order_line_tax = OrderLineTax.from_tax( tax=line_tax.tax, base_amount=line_tax.base_amount, order_line=product_order_line, ) order_line_tax.save() # Save order_line_tax before linking to order_line.tax product_order_line.taxes.add(order_line_tax) discount_order_line = OrderLine(order=order, quantity=1, type=OrderLineType.OTHER) discount_order_line.discount_amount = shop.create_price(30) assert discount_order_line.discount_amount.value == 30 assert discount_order_line.price.value == -30 assert discount_order_line.base_unit_price.value == 0 discount_order_line.save() order.cache_prices() order.check_all_verified() order.save() assert not order.can_set_complete() base = 5 * shop.create_price(100).amount discount = shop.create_price(30).amount tax_value = line_tax.amount if not order.prices_include_tax: assert order.taxless_total_price.amount == base - discount assert order.taxful_total_price.amount == base + tax_value - discount else: assert_almost_equal(order.taxless_total_price.amount, base - tax_value - discount) assert_almost_equal(order.taxful_total_price.amount, base - discount) assert not order.is_fully_shipped() shipment = order.create_shipment_of_all_products(supplier=supplier) assert order.is_fully_shipped() assert shipment.total_products == 5, "All products were shipped" assert shipment.weight == product.gross_weight * 5 / 1000, "Gravity works" assert not order.get_unshipped_products(), "Nothing was left in the warehouse" assert order.can_set_complete() order.create_payment(order.taxful_total_price) assert order.is_paid() assert Order.objects.paid().filter(pk=order.pk).exists(), "It was paid! Honestly!" assert order.has_products() assert order.get_available_shipping_methods() assert order.get_available_payment_methods() assert default_sm in order.get_available_shipping_methods() assert default_pm in order.get_available_payment_methods()