Exemple #1
0
 def setUp(self):
     self.ten_btc = Price(10, currency='BTC')
     self.twenty_btc = Price(20, currency='BTC')
     self.thirty_btc = Price(30, currency='BTC')
     self.forty_btc = Price(40, currency='BTC')
     self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
     self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)
Exemple #2
0
 def setUp(self):
     self.ten_btc = Price(10, currency='BTC')
     self.twenty_btc = Price(20, currency='BTC')
     self.thirty_btc = Price(30, currency='BTC')
     self.forty_btc = Price(40, currency='BTC')
     self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
     self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)
Exemple #3
0
def test_quantize():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range = PriceRange(price1, price2)
    result = price_range.quantize()
    assert str(result.min_price.net.value) == '10.00'
    assert str(result.max_price.net.value) == '30.00'
Exemple #4
0
 def test_discounted_product_price(self):
     another_discount = models.Discount.objects.create(
         name='Flying Sale', rate=50)
     another_hat = models.Hat.objects.create(name='Silly Hat',
                                             slug='silly-hat',
                                             price=10,
                                             discount=another_discount)
     another_hat_simple_variant = another_hat.variants.create(
         price_offset=0, sku='silly-hat-simple')
     another_hat_offset_variant = another_hat.variants.create(
         price_offset=10, sku='silly-hat-offset')
     self.assertEqual(another_hat_simple_variant.get_price(),
                      Price(5, currency='EUR'))
     self.assertEqual(another_hat_offset_variant.get_price(),
                      Price(10, currency='EUR'))
     self.assertEqual(another_hat.get_price_range(),
                      PriceRange(Price(5, currency='EUR'),
                                 Price(10, currency='EUR')))
     self.assertEqual(another_hat_simple_variant.get_price(discount=False),
                      Price(10, currency='EUR'))
     self.assertEqual(another_hat_offset_variant.get_price(discount=False),
                      Price(20, currency='EUR'))
     self.assertEqual(another_hat.get_price_range(discount=False),
                      PriceRange(Price(10, currency='EUR'),
                                 Price(20, currency='EUR')))
Exemple #5
0
 def test_equality(self):
     pr1 = PriceRange(self.ten_btc, self.twenty_btc)
     pr2 = PriceRange(self.ten_btc, self.twenty_btc)
     pr3 = PriceRange(self.ten_btc, self.ten_btc)
     pr4 = PriceRange(self.twenty_btc, self.twenty_btc)
     self.assertEqual(pr1, pr2)
     self.assertNotEqual(pr1, pr3)
     self.assertNotEqual(pr1, pr4)
     self.assertNotEqual(pr1, self.ten_btc)
Exemple #6
0
 def get_price_range(self, discounts=None):
     if self.variants.exists():
         prices = [
             self.get_price_per_item(variant, discounts=discounts)
             for variant in self
         ]
         return PriceRange(min(prices), max(prices))
     price = calculate_discounted_price(self, self.price, discounts)
     return PriceRange(price, price)
Exemple #7
0
def test_construction():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range = PriceRange(price1, price2)
    assert price_range.min_price == price1
    assert price_range.max_price == price2
    with pytest.raises(ValueError):
        PriceRange(price1, Price(Amount(20, 'PLN'), Amount(20, 'PLN')))
    with pytest.raises(ValueError):
        PriceRange(price2, price1)
Exemple #8
0
def test_replace():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price3 = Price(Amount(20, 'EUR'), Amount(30, 'EUR'))
    price_range = PriceRange(price1, price2)
    result = price_range.replace(max_price=price3)
    assert result.min_price == price1
    assert result.max_price == price3
    result = price_range.replace(min_price=price3)
    assert result.min_price == price3
    assert result.max_price == price2
Exemple #9
0
def test_comparison():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range1 = PriceRange(price1, price2)
    price3 = Price(Amount(40, 'EUR'), Amount(60, 'EUR'))
    price4 = Price(Amount(80, 'EUR'), Amount(120, 'EUR'))
    price_range2 = PriceRange(price3, price4)
    assert price_range1 == PriceRange(price1, price2)
    assert price_range1 != price_range2
    assert price_range1 != PriceRange(price1, price1)
    assert price_range1 != PriceRange(
        Price(Amount(10, 'USD'), Amount(15, 'USD')),
        Price(Amount(30, 'USD'), Amount(45, 'USD')))
    assert price_range1 != price1
Exemple #10
0
def test_repr():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range = PriceRange(price1, price2)
    assert repr(price_range) == (
        "PriceRange(Price(net=Amount('10', 'EUR'), gross=Amount('15', 'EUR')), Price(net=Amount('30', 'EUR'), gross=Amount('45', 'EUR')))"
    )
Exemple #11
0
 def test_repr(self):
     pr1 = self.range_thirty_forty
     pr2 = PriceRange(self.ten_btc, self.ten_btc)
     self.assertEqual(
         repr(pr1), "PriceRange(Price('30', currency='BTC'),"
         " Price('40', currency='BTC'))")
     self.assertEqual(repr(pr2), "PriceRange(Price('10', currency='BTC'))")
Exemple #12
0
 def get_price_range(self, discounts=None, **kwargs):
     if not self.variants.exists():
         price = calculate_discounted_price(self, self.price, discounts,
                                            **kwargs)
         return PriceRange(price, price)
     else:
         return super().get_price_range(discounts=discounts, **kwargs)
Exemple #13
0
 def test_non_taxed_product_price(self):
     # no tax group - tax should be zero
     self.assertEqual(self.cockatoo_variant.get_price(currency='PLN'),
                      Price(5, currency='PLN'))
     pr = self.cockatoo.get_price_range(currency='PLN')
     self.assertEqual(pr, PriceRange(min_price=Price(5, currency='PLN'),
                                     max_price=Price(5, currency='PLN')))
Exemple #14
0
def get_product_costs_data(product):
    zero_price = Price(0, 0, currency=settings.DEFAULT_CURRENCY)
    zero_price_range = PriceRange(zero_price, zero_price)
    purchase_costs_range = zero_price_range
    gross_margin = (0, 0)

    if not product.variants.exists():
        return purchase_costs_range, gross_margin

    variants = product.variants.all()
    costs, margins = get_cost_data_from_variants(variants)

    if costs:
        purchase_costs_range = PriceRange(min(costs), max(costs))
    if margins:
        gross_margin = (margins[0], margins[-1])
    return purchase_costs_range, gross_margin
Exemple #15
0
def exchange_currency(price, to_currency):
    if isinstance(price, PriceRange):
        return PriceRange(exchange_currency(price.min_price, to_currency),
                          exchange_currency(price.max_price, to_currency))
    if price.currency != BASE_CURRENCY:
        # Convert to default currency
        price = convert_price(price, BASE_CURRENCY)
    return convert_price(price, to_currency)
Exemple #16
0
def test_pricerange():
    tax_name = '2x Tax'
    tax = LinearTax(1, name=tax_name)
    price_range = PriceRange(
        Price(Amount(10, 'BTC'), Amount(10, 'BTC')),
        Price(Amount(20, 'BTC'), Amount(20, 'BTC')))
    result = tax.apply(price_range)
    assert result.min_price == Price(Amount(10, 'BTC'), Amount(20, 'BTC'))
    assert result.max_price == Price(Amount(20, 'BTC'), Amount(40, 'BTC'))
Exemple #17
0
 def test_taxed_product_price(self):
     # 8% VAT
     self.assertEqual(self.macaw_variant.get_price(currency='PLN'),
                      Price(5, Decimal('5.40'), currency='PLN'))
     pr = self.macaw.get_price_range(currency='PLN')
     self.assertEqual(pr, PriceRange(min_price=Price(5, Decimal('5.40'),
                                                     currency='PLN'),
                                     max_price=Price(5, Decimal('5.40'),
                                                     currency='PLN')))
Exemple #18
0
 def get_gross_price_range(self, discounts=None):
     grosses = [
         self.get_price_per_item(variant, discounts=discounts)
         for variant in self
     ]
     if not grosses:
         return None
     grosses = sorted(grosses, key=lambda x: x.tax)
     return PriceRange(min(grosses), max(grosses))
def test_discount():
    price = Price(Amount(100, 'BTC'), Amount(100, 'BTC'))
    discount = FractionalDiscount(factor='0.25')
    result = discount.apply(price)
    assert result.net == Amount(75, 'BTC')
    assert result.gross == Amount(75, 'BTC')
    price_range = PriceRange(price, price)
    result = discount.apply(price_range)
    assert result.min_price == Price(Amount(75, 'BTC'), Amount(75, 'BTC'))
    assert result.max_price == Price(Amount(75, 'BTC'), Amount(75, 'BTC'))
Exemple #20
0
def test_discount():
    price = Price(Amount(100, 'BTC'), Amount(100, 'BTC'))
    discount = percentage_discount(value=10, name='Ten percent off')
    result = discount.apply(price)
    assert result.net == Amount(90, 'BTC')
    assert result.gross == Amount(90, 'BTC')
    price_range = PriceRange(price, price)
    result = discount.apply(price_range)
    assert result.min_price == Price(Amount(90, 'BTC'), Amount(90, 'BTC'))
    assert result.max_price == Price(Amount(90, 'BTC'), Amount(90, 'BTC'))
Exemple #21
0
def get_shipment_options(country_code):
    shipping_methods_qs = ShippingMethodCountry.objects.select_related(
        'shipping_method')
    shipping_methods = shipping_methods_qs.filter(country_code=country_code)
    if not shipping_methods.exists():
        shipping_methods = shipping_methods_qs.filter(country_code='')
    if shipping_methods:
        shipping_methods = shipping_methods.values_list('price', flat=True)
        return PriceRange(min_price=min(shipping_methods),
                          max_price=max(shipping_methods))
Exemple #22
0
def test_membership():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range = PriceRange(price1, price2)
    assert price1 in price_range
    assert price2 in price_range
    assert (price1 + price2) / 2 in price_range
    assert price1 + price2 not in price_range
    with pytest.raises(TypeError):
        15 in price_range
Exemple #23
0
def test_subtraction():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range1 = PriceRange(price1, price2)
    price3 = Price(Amount(40, 'EUR'), Amount(60, 'EUR'))
    price4 = Price(Amount(80, 'EUR'), Amount(120, 'EUR'))
    price_range2 = PriceRange(price3, price4)
    result = price_range2 - price_range1
    assert result.min_price == price3 - price1
    assert result.max_price == price4 - price2
    result = price_range2 - price1
    assert result.min_price == price3 - price1
    assert result.max_price == price4 - price1
    with pytest.raises(ValueError):
        price_range2 - PriceRange(Price(Amount(1, 'BTC'), Amount(1, 'BTC')),
                                  Price(Amount(2, 'BTC'), Amount(2, 'BTC')))
    with pytest.raises(ValueError):
        price_range2 - Price(Amount(1, 'BTC'), Amount(1, 'BTC'))
    with pytest.raises(TypeError):
        price_range2 - 1
Exemple #24
0
def test_addition():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range1 = PriceRange(price1, price2)
    price3 = Price(Amount(40, 'EUR'), Amount(60, 'EUR'))
    price4 = Price(Amount(80, 'EUR'), Amount(120, 'EUR'))
    price_range2 = PriceRange(price3, price4)
    result = price_range1 + price_range2
    assert result.min_price == price1 + price3
    assert result.max_price == price2 + price4
    result = price_range1 + price3
    assert result.min_price == price1 + price3
    assert result.max_price == price2 + price3
    with pytest.raises(ValueError):
        price_range1 + PriceRange(Price(Amount(1, 'BTC'), Amount(1, 'BTC')),
                                  Price(Amount(2, 'BTC'), Amount(2, 'BTC')))
    with pytest.raises(ValueError):
        price_range1 + Price(Amount(1, 'BTC'), Amount(1, 'BTC'))
    with pytest.raises(TypeError):
        price_range1 + 1
Exemple #25
0
def test_application():
    price = Price(Amount(30, 'BTC'), Amount(30, 'BTC'))
    discount = FixedDiscount(Amount(10, 'BTC'), name='Ten off')
    result = discount.apply(price)
    assert result.net == Amount(20, 'BTC')
    assert result.gross == Amount(20, 'BTC')
    price_range = PriceRange(price, price)
    result = discount.apply(price_range)
    assert result.min_price == Price(Amount(20, 'BTC'), Amount(20, 'BTC'))
    assert result.max_price == Price(Amount(20, 'BTC'), Amount(20, 'BTC'))
    with pytest.raises(TypeError):
        discount.apply(1)
Exemple #26
0
def get_cart_data(cart, shipping_range, currency, discounts):
    cart_total = None
    local_cart_total = None
    shipping_required = False
    total_with_shipping = None
    local_total_with_shipping = None
    if cart:
        cart_total = cart.get_total(discounts=discounts)
        local_cart_total = to_local_currency(cart_total, currency)
        shipping_required = cart.is_shipping_required()
        total_with_shipping = PriceRange(cart_total)
        if shipping_required and shipping_range:
            total_with_shipping = shipping_range + cart_total
        local_total_with_shipping = to_local_currency(
            total_with_shipping, currency)

    return {
        'cart_total': cart_total,
        'local_cart_total': local_cart_total,
        'shipping_required': shipping_required,
        'total_with_shipping': total_with_shipping,
        'local_total_with_shipping': local_total_with_shipping}
Exemple #27
0
def get_cart_data(cart, shipping_range, currency, discounts):
    """Return a JSON-serializable representation of the cart."""
    cart_total = None
    local_cart_total = None
    shipping_required = False
    total_with_shipping = None
    local_total_with_shipping = None
    if cart:
        cart_total = cart.get_total(discounts=discounts)
        local_cart_total = to_local_currency(cart_total, currency)
        shipping_required = cart.is_shipping_required()
        total_with_shipping = PriceRange(cart_total)
        if shipping_required and shipping_range:
            total_with_shipping = shipping_range + cart_total
        local_total_with_shipping = to_local_currency(
            total_with_shipping, currency)

    return {
        'cart_total': cart_total,
        'local_cart_total': local_cart_total,
        'shipping_required': shipping_required,
        'total_with_shipping': total_with_shipping,
        'taxed_total_with_shipping': price_range_get_taxed(total_with_shipping),
        'local_total_with_shipping': local_total_with_shipping}
Exemple #28
0
 def price_range(self):
     prices = [country.price for country in self.price_per_country.all()]
     if prices:
         return PriceRange(min(prices), max(prices))
Exemple #29
0
 def get_gross_price_range(self, **kwargs):
     grosses = [self.get_price_per_item(item, **kwargs) for item in self]
     if not grosses:
         return None
     grosses = sorted(grosses, key=lambda x: x.tax)
     return PriceRange(min(grosses), max(grosses))
Exemple #30
0
 def get_price_range(self, **kwargs):
     prices = [self.get_price_per_item(item, **kwargs) for item in self]
     if not prices:
         raise AttributeError(
             'Calling get_price_range() on an empty item range')
     return PriceRange(min(prices), max(prices))
Exemple #31
0
class PriceRangeTest(unittest.TestCase):

    def setUp(self):
        self.ten_btc = Price(10, currency='BTC')
        self.twenty_btc = Price(20, currency='BTC')
        self.thirty_btc = Price(30, currency='BTC')
        self.forty_btc = Price(40, currency='BTC')
        self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
        self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)

    def test_basics(self):
        self.assertEqual(self.range_ten_twenty.min_price, self.ten_btc)
        self.assertEqual(self.range_ten_twenty.max_price, self.twenty_btc)

    def test_valid_addition(self):
        pr1 = self.range_ten_twenty + self.range_thirty_forty
        self.assertEqual(pr1.min_price, self.ten_btc + self.thirty_btc)
        self.assertEqual(pr1.max_price, self.twenty_btc + self.forty_btc)
        pr2 = self.range_ten_twenty + self.ten_btc
        self.assertEqual(pr2.min_price, self.ten_btc + self.ten_btc)
        self.assertEqual(pr2.max_price, self.twenty_btc + self.ten_btc)

    def test_invalid_addition(self):
        self.assertRaises(TypeError, lambda: self.range_ten_twenty + 10)

    def test_subtraction(self):
        pr1 = self.range_thirty_forty - self.range_ten_twenty
        self.assertEqual(pr1.min_price, self.thirty_btc - self.ten_btc)
        self.assertEqual(pr1.max_price, self.forty_btc - self.twenty_btc)

    def test_valid_membership(self):
        '''
        Prices can fit in a pricerange.
        '''
        self.assertTrue(self.ten_btc in self.range_ten_twenty)
        self.assertTrue(self.twenty_btc in self.range_ten_twenty)
        self.assertFalse(self.thirty_btc in self.range_ten_twenty)

    def test_invalid_membership(self):
        '''
        Non-prices can't fit in a pricerange.
        '''
        self.assertRaises(TypeError, lambda: 15 in self.range_ten_twenty)

    def test_replacement(self):
        pr1 = self.range_ten_twenty.replace(max_price=self.thirty_btc)
        self.assertEqual(pr1.min_price, self.ten_btc)
        self.assertEqual(pr1.max_price, self.thirty_btc)
        pr2 = self.range_thirty_forty.replace(min_price=self.twenty_btc)
        self.assertEqual(pr2.min_price, self.twenty_btc)
        self.assertEqual(pr2.max_price, self.forty_btc)

    def test_tax(self):
        tax_name = '2x Tax'
        tax = LinearTax(1, name=tax_name)
        pr = self.range_ten_twenty + tax
        self.assertEqual(pr.min_price.net, self.ten_btc.net)
        self.assertEqual(pr.min_price.gross, self.ten_btc.gross * 2)
        self.assertEqual(pr.min_price.currency, self.ten_btc.currency)
        self.assertEqual(pr.max_price.net, self.twenty_btc.net)
        self.assertEqual(pr.max_price.gross, self.twenty_btc.gross * 2)
        self.assertEqual(pr.max_price.currency, self.twenty_btc.currency)
Exemple #32
0
class PriceRangeTest(unittest.TestCase):

    def setUp(self):
        self.ten_btc = Price(10, currency='BTC')
        self.twenty_btc = Price(20, currency='BTC')
        self.thirty_btc = Price(30, currency='BTC')
        self.forty_btc = Price(40, currency='BTC')
        self.range_ten_twenty = PriceRange(self.ten_btc, self.twenty_btc)
        self.range_thirty_forty = PriceRange(self.thirty_btc, self.forty_btc)

    def test_basics(self):
        self.assertEqual(self.range_ten_twenty.min_price, self.ten_btc)
        self.assertEqual(self.range_ten_twenty.max_price, self.twenty_btc)

    def test_construction(self):
        pr = PriceRange(self.ten_btc)
        self.assertEqual(pr.min_price, self.ten_btc)
        self.assertEqual(pr.max_price, self.ten_btc)

    def test_invalid_construction(self):
        p = Price(10, currency='USD')
        self.assertRaises(ValueError, lambda: PriceRange(self.ten_btc, p))
        self.assertRaises(ValueError, lambda: PriceRange(self.twenty_btc,
                                                         self.ten_btc))

    def test_addition(self):
        pr1 = self.range_ten_twenty + self.range_thirty_forty
        self.assertEqual(pr1.min_price, self.ten_btc + self.thirty_btc)
        self.assertEqual(pr1.max_price, self.twenty_btc + self.forty_btc)
        pr2 = self.range_ten_twenty + self.ten_btc
        self.assertEqual(pr2.min_price, self.ten_btc + self.ten_btc)
        self.assertEqual(pr2.max_price, self.twenty_btc + self.ten_btc)

    def test_invalid_addition(self):
        p = Price(10, currency='USD')
        pr = PriceRange(p)
        self.assertRaises(ValueError, lambda: self.range_ten_twenty + pr)
        self.assertRaises(ValueError, lambda: self.range_ten_twenty + p)
        self.assertRaises(TypeError, lambda: self.range_ten_twenty + 10)

    def test_subtraction(self):
        pr1 = self.range_thirty_forty - self.range_ten_twenty
        pr2 = self.range_thirty_forty - self.ten_btc
        self.assertEqual(pr1.min_price, self.thirty_btc - self.ten_btc)
        self.assertEqual(pr1.max_price, self.forty_btc - self.twenty_btc)
        self.assertEqual(pr2.min_price, self.thirty_btc - self.ten_btc)
        self.assertEqual(pr2.max_price, self.forty_btc - self.ten_btc)

    def test_invalid_subtraction(self):
        p = Price(10, currency='USD')
        pr = PriceRange(p)
        self.assertRaises(ValueError, lambda: self.range_thirty_forty - pr)
        self.assertRaises(ValueError, lambda: self.range_thirty_forty - p)
        self.assertRaises(TypeError, lambda: self.range_thirty_forty - 1)

    def test_equality(self):
        pr1 = PriceRange(self.ten_btc, self.twenty_btc)
        pr2 = PriceRange(self.ten_btc, self.twenty_btc)
        pr3 = PriceRange(self.ten_btc, self.ten_btc)
        pr4 = PriceRange(self.twenty_btc, self.twenty_btc)
        self.assertEqual(pr1, pr2)
        self.assertNotEqual(pr1, pr3)
        self.assertNotEqual(pr1, pr4)
        self.assertNotEqual(pr1, self.ten_btc)

    def test_membership(self):
        self.assertTrue(self.ten_btc in self.range_ten_twenty)
        self.assertTrue(self.twenty_btc in self.range_ten_twenty)
        self.assertFalse(self.thirty_btc in self.range_ten_twenty)

    def test_invalid_membership(self):
        self.assertRaises(TypeError, lambda: 15 in self.range_ten_twenty)

    def test_replacement(self):
        pr1 = self.range_ten_twenty.replace(max_price=self.thirty_btc)
        self.assertEqual(pr1.min_price, self.ten_btc)
        self.assertEqual(pr1.max_price, self.thirty_btc)
        pr2 = self.range_thirty_forty.replace(min_price=self.twenty_btc)
        self.assertEqual(pr2.min_price, self.twenty_btc)
        self.assertEqual(pr2.max_price, self.forty_btc)

    def test_repr(self):
        pr1 = self.range_thirty_forty
        pr2 = PriceRange(self.ten_btc, self.ten_btc)
        self.assertEqual(
            repr(pr1),
            "PriceRange(Price('30', currency='BTC'),"
            " Price('40', currency='BTC'))")
        self.assertEqual(
            repr(pr2),
            "PriceRange(Price('10', currency='BTC'))")
Exemple #33
0
def test_currency():
    price1 = Price(Amount(10, 'EUR'), Amount(15, 'EUR'))
    price2 = Price(Amount(30, 'EUR'), Amount(45, 'EUR'))
    price_range = PriceRange(price1, price2)
    assert price_range.currency == 'EUR'