class TestAddingAProductToABasket(TestCase):

    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(
            currency='GBP',
            product=self.product, price_excl_tax=D('10.00'))
        self.purchase_info = factories.create_purchase_info(self.record)
        self.basket.add(self.product)

    def test_creates_a_line(self):
        self.assertEqual(1, self.basket.num_lines)

    def test_sets_line_prices(self):
        line = self.basket.lines.all()[0]
        self.assertEqual(line.price_incl_tax, self.purchase_info.price.incl_tax)
        self.assertEqual(line.price_excl_tax, self.purchase_info.price.excl_tax)

    def test_adding_negative_quantity(self):
        self.assertEqual(1, self.basket.num_lines)
        self.basket.add(self.product, quantity=4)
        self.assertEqual(5, self.basket.line_quantity(self.product, self.record))
        self.basket.add(self.product, quantity=-10)
        self.assertEqual(0, self.basket.line_quantity(self.product, self.record))

    def test_means_another_currency_product_cannot_be_added(self):
        product = factories.create_product()
        factories.create_stockrecord(
            currency='USD', product=product, price_excl_tax=D('20.00'))
        with self.assertRaises(ValueError):
            self.basket.add(product)
Beispiel #2
0
    def test_weight_calculation_of_basket(self):
        basket = Basket()
        basket.add_product(create_product(attributes={'weight': 1}))
        basket.add_product(create_product(attributes={'weight': 2}))

        scales = Scales(attribute_code='weight')
        self.assertEquals(1+2, scales.weigh_basket(basket))
Beispiel #3
0
class TestBasketModel(TestCase):

    def setUp(self):
        self.basket = Basket()
        self.product = create_product()

    def test_an_empty_basket_has_zero_lines(self):
        self.assertEqual(0, self.basket.num_lines)

    def test_new_baskets_are_empty(self):
        self.assertTrue(self.basket.is_empty)

    def test_adding_product_creates_line(self):
        self.basket.add_product(self.product)
        self.assertEqual(1, self.basket.num_lines)

    def test_adding_multiproduct_line_returns_correct_number_of_items(self):
        self.basket.add_product(self.product, 10)
        self.assertEqual(self.basket.num_items, 10)
        self.assertEqual(self.basket.num_lines, 1)

    def test_add_product_creates_line(self):
        self.basket.add_product(self.product)
        self.assertTrue(self.basket.num_lines == 1)

    def test_flushing_basket_removes_all_lines(self):
        self.basket.add_product(self.product, 10)
        self.assertEqual(self.basket.num_items, 10)
        self.basket.flush()
        self.assertEqual(self.basket.num_items, 0)
Beispiel #4
0
    def test_weight_calculation_of_basket_with_line_quantity(self):
        basket = Basket()
        basket.add_product(create_product(attributes={"weight": 1}), quantity=3)
        basket.add_product(create_product(attributes={"weight": 2}), quantity=4)

        scales = Scales(attribute_code="weight")
        self.assertEquals(1 * 3 + 2 * 4, scales.weigh_basket(basket))
Beispiel #5
0
 def setUp(self):
     basket = Basket()
     basket.add_product(create_product(price=D("10.00")), 4)
     self.order = create_order(number="100002", basket=basket)
     self.line = self.order.lines.all()[0]
     self.order_placed, __ = ShippingEventType.objects.get_or_create(code="order_placed", name="Order placed")
     self.dispatched, __ = ShippingEventType.objects.get_or_create(code="dispatched", name="Dispatched")
Beispiel #6
0
 def setUp(self):
     self.product = create_product()
     self.user_basket = Basket()
     self.user_basket.add_product(self.product)
     self.cookie_basket = Basket()
     self.cookie_basket.add_product(self.product, 2)
     self.user_basket.merge(self.cookie_basket, add_quantities=False)
Beispiel #7
0
    def setUp(self):
        basket = Basket()
        basket.add_product(create_product(price=D("10.00")), 4)
        self.order = create_order(number="100002", basket=basket)
        self.line = self.order.lines.all()[0]

        self.shipped, _ = ShippingEventType.objects.get_or_create(name="Shipped")
        self.returned, _ = ShippingEventType.objects.get_or_create(name="Returned")
 def setUp(self):
     basket = Basket()
     basket.add_product(create_product(price=D('10.00')), 4)
     self.order = create_order(number='100002', basket=basket)
     self.line = self.order.lines.all()[0]
     self.order_placed,_ = ShippingEventType.objects.get_or_create(code='order_placed',
                                                                   name='Order placed')
     self.dispatched,_ = ShippingEventType.objects.get_or_create(code='dispatched',
                                                                 name='Dispatched')
Beispiel #9
0
class StockActionTests(TestCase):

    def setUp(self):
        self.product = create_product(price=D('12.00'), num_in_stock=5)
        self.basket = Basket()
        self.basket.add_product(self.product)

    def tearDown(self):
        StockAlert.objects.all().delete()

    def set_threshold(self, threshold):
        self.product.stockrecord.low_stock_threshold = threshold
        self.product.stockrecord.save()

    def test_stock_is_allocated_after_checkout(self):
        order = OrderCreator().place_order(self.basket)

        record = StockRecord.objects.get(product=self.product)
        self.assertEqual(5, record.num_in_stock)
        self.assertEqual(1, record.num_allocated)
        self.assertEqual(4, record.net_stock_level)

    def test_no_alert_raised_if_threshold_not_breached(self):
        self.set_threshold(3)
        order = OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.all()
        self.assertEqual(0, len(alerts))

    def test_alert_created_when_threhold_met(self):
        self.set_threshold(5)
        order = OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.filter(stockrecord=self.product.stockrecord)
        self.assertEqual(1, len(alerts))

    def test_alert_only_created_when_no_alert_exists_already(self):
        self.set_threshold(5)
        StockAlert.objects.create(stockrecord=self.product.stockrecord,
                                  threshold=10)
        order = OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.filter(stockrecord=self.product.stockrecord)
        self.assertEqual(1, len(alerts))

    def test_alert_closed_when_stock_replenished(self):
        self.set_threshold(5)
        order = OrderCreator().place_order(self.basket)

        alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
        self.assertEqual(StockAlert.OPEN, alert.status)

        self.product.stockrecord.num_in_stock = 15
        self.product.stockrecord.save()
        alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
        self.assertEqual(StockAlert.CLOSED, alert.status)
 def test_basket_lines_are_converted_to_xml(self):
     product = factories.create_product(price=D('12.99'))
     basket = Basket()
     basket.add_product(product)
     data = the3rdman.build_data_dict(
         basket=basket)
     doc = the3rdman.add_fraud_fields(**data)
     xml = doc.toxml()
     self.assertXmlElementEquals(xml, '3',
                                 'The3rdMan.CustomerInformation.sales_channel')
    def test_line_tax_for_zero_tax_strategies(self):
        basket = Basket()
        basket.strategy = strategy.Default()
        product = factories.create_product()
        # Tax for the default strategy will be 0
        factories.create_stockrecord(
            product, price_excl_tax=D('75.00'), num_in_stock=10)
        basket.add(product, 1)

        self.assertEqual(basket.lines.first().line_tax, D('0'))
Beispiel #12
0
class TestASubmittedBasket(TestCase):
    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.basket.submit()

    def test_has_correct_status(self):
        self.assertTrue(self.basket.is_submitted)

    def test_can_be_edited(self):
        self.assertFalse(self.basket.can_be_edited)
    def setUp(self):
        basket = Basket()
        basket.add_product(create_product(price=D('10.00')), 4)
        self.order = create_order(number='100002', basket=basket)
        self.line = self.order.lines.all()[0]

        self.shipped,_ = ShippingEventType.objects.get_or_create(name='Shipped',
                                                                 is_required=True,
                                                                 sequence_number=0)
        self.returned,_ = ShippingEventType.objects.get_or_create(name='Returned',
                                                                 is_required=False,
                                                                 sequence_number=1)
    def test_totals_for_free_products(self):
        basket = Basket()
        basket.strategy = strategy.Default()
        # Add a zero-priced product to the basket
        product = factories.create_product()
        factories.create_stockrecord(
            product, price_excl_tax=D('0.00'), num_in_stock=10)
        basket.add(product, 1)

        self.assertEqual(basket.lines.count(), 1)
        self.assertEqual(basket.total_excl_tax, 0)
        self.assertEqual(basket.total_incl_tax, 0)
Beispiel #15
0
    def setUp(self):
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(self.product, price_excl_tax=D("10.00"))
        self.purchase_info = factories.create_purchase_info(self.record)

        self.main_basket = Basket()
        self.main_basket.strategy = strategy.Default()
        self.main_basket.add(self.product, quantity=2)

        self.merge_basket = Basket()
        self.merge_basket.strategy = strategy.Default()
        self.merge_basket.add(self.product, quantity=1)

        self.main_basket.merge(self.merge_basket)
Beispiel #16
0
class TestOrderCreatorErrorCases(TestCase):

    def setUp(self):
        self.creator = OrderCreator()
        self.basket = Basket()

    def test_raises_exception_when_empty_basket_passed(self):
        with self.assertRaises(ValueError):
            self.creator.place_order(basket=self.basket)

    def test_raises_exception_if_duplicate_order_number_passed(self):
        self.basket.add_product(create_product(price=D('12.00')))
        self.creator.place_order(basket=self.basket, order_number='1234')
        with self.assertRaises(ValueError):
            self.creator.place_order(basket=self.basket, order_number='1234')
    def test_line_tax_for_unknown_tax_strategies(self):

        class UnknownTaxStrategy(strategy.Default):
            """ A test strategy where the tax is not known """

            def pricing_policy(self, product, stockrecord):
                return prices.FixedPrice('GBP', stockrecord.price_excl_tax, tax=None)

        basket = Basket()
        basket.strategy = UnknownTaxStrategy()
        product = factories.create_product()
        factories.create_stockrecord(product, num_in_stock=10)
        basket.add(product, 1)

        self.assertEqual(basket.lines.first().line_tax, None)
Beispiel #18
0
 def setUp(self):
     self.basket = Basket()
     self.basket.strategy = strategy.Default()
     self.product = factories.create_product()
     self.record = factories.create_stockrecord(self.product, price_excl_tax=D("10.00"))
     self.purchase_info = factories.create_purchase_info(self.record)
     self.basket.add(self.product, 10)
class TestANewBasket(TestCase):

    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()

    def test_has_zero_lines(self):
        self.assertEqual(0, self.basket.num_lines)

    def test_has_zero_items(self):
        self.assertEqual(0, self.basket.num_items)

    def test_doesnt_contain_vouchers(self):
        self.assertFalse(self.basket.contains_a_voucher)

    def test_can_be_edited(self):
        self.assertTrue(self.basket.can_be_edited)

    def test_is_empty(self):
        self.assertTrue(self.basket.is_empty)

    def test_is_not_submitted(self):
        self.assertFalse(self.basket.is_submitted)

    def test_has_no_applied_offers(self):
        self.assertEqual({}, self.basket.applied_offers())
    def test_basket_lines_are_converted_to_xml(self):
        product = factories.create_product(price=D("12.99"))
        basket = Basket()

        # Nasty hack to make test suite work with both Oscar 0.5 and 0.6
        try:
            from oscar.apps.partner import strategy
        except ImportError:
            pass
        else:
            basket.strategy = strategy.Default()

        basket.add_product(product)
        data = the3rdman.build_data_dict(basket=basket)
        doc = the3rdman.add_fraud_fields(**data)
        xml = doc.toxml()
        self.assertXmlElementEquals(xml, "3", "The3rdMan.CustomerInformation.sales_channel")
Beispiel #21
0
 def setUp(self):
     self.product = create_product(num_in_stock=10)
     self.user_basket = Basket()
     self.user_basket.strategy = strategy.Default()
     add_product(self.user_basket, product=self.product)
     self.cookie_basket = Basket()
     self.cookie_basket.strategy = strategy.Default()
     add_product(self.cookie_basket, quantity=2, product=self.product)
     self.user_basket.merge(self.cookie_basket, add_quantities=False)
 def setUp(self):
     self.basket = Basket()
     self.basket.strategy = strategy.Default()
     self.product = factories.create_product()
     self.record = factories.create_stockrecord(
         currency='GBP',
         product=self.product, price_excl_tax=D('10.00'))
     self.stockinfo = factories.create_stockinfo(self.record)
     self.basket.add(self.product)
Beispiel #23
0
class TestPlacingAnOrder(TestCase):

    def setUp(self):
        self.product = create_product(price=D('12.00'), num_in_stock=5)
        self.basket = Basket()
        self.basket.add_product(self.product)

    def set_threshold(self, threshold):
        self.product.stockrecord.low_stock_threshold = threshold
        self.product.stockrecord.save()

    def test_correctly_allocates_stock(self):
        OrderCreator().place_order(self.basket)

        record = StockRecord.objects.get(product=self.product)
        self.assertEqual(5, record.num_in_stock)
        self.assertEqual(1, record.num_allocated)
        self.assertEqual(4, record.net_stock_level)

    def test_does_not_raise_an_alert_if_threshold_not_broken(self):
        self.set_threshold(4)
        OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.all()
        self.assertEqual(0, len(alerts))

    def test_raises_alert_when_threshold_is_reached(self):
        self.set_threshold(5)
        OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.filter(
            stockrecord=self.product.stockrecord)
        self.assertEqual(1, len(alerts))

    def test_only_raises_an_alert_once(self):
        self.set_threshold(5)
        StockAlert.objects.create(stockrecord=self.product.stockrecord,
                                  threshold=10)
        OrderCreator().place_order(self.basket)

        alerts = StockAlert.objects.filter(
            stockrecord=self.product.stockrecord)
        self.assertEqual(1, len(alerts))
Beispiel #24
0
class TestBasketMerging(TestCase):

    def setUp(self):
        self.product = create_product(num_in_stock=10)
        self.user_basket = Basket()
        self.user_basket.strategy = strategy.Default()
        add_product(self.user_basket, product=self.product)
        self.cookie_basket = Basket()
        self.cookie_basket.strategy = strategy.Default()
        add_product(self.cookie_basket, quantity=2, product=self.product)
        self.user_basket.merge(self.cookie_basket, add_quantities=False)

    def test_cookie_basket_has_status_set(self):
        self.assertEqual(Basket.MERGED, self.cookie_basket.status)

    def test_lines_are_moved_across(self):
        self.assertEqual(1, self.user_basket.lines.all().count())

    def test_merge_line_takes_max_quantity(self):
        line = self.user_basket.lines.get(product=self.product)
        self.assertEqual(2, line.quantity)
class TestRestockingProduct(TestCase):
    def setUp(self):
        self.product = create_product(price=D('12.00'), num_in_stock=5)
        self.basket = Basket()
        self.basket.add_product(self.product)

    def set_threshold(self, threshold):
        self.product.stockrecord.low_stock_threshold = threshold
        self.product.stockrecord.save()

    def test_closes_open_alert(self):
        self.set_threshold(5)
        OrderCreator().place_order(self.basket)

        alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
        self.assertEqual(StockAlert.OPEN, alert.status)

        # Restock product
        self.product.stockrecord.num_in_stock = 15
        self.product.stockrecord.save()

        alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
        self.assertEqual(StockAlert.CLOSED, alert.status)
Beispiel #26
0
class BasketMergingTests(TestCase):

    def setUp(self):
        self.product = create_product()
        self.user_basket = Basket()
        self.user_basket.add_product(self.product)
        self.cookie_basket = Basket()
        self.cookie_basket.add_product(self.product, 2)
        self.user_basket.merge(self.cookie_basket, add_quantities=False)

    def test_cookie_basket_has_status_set(self):
        self.assertEqual('Merged', self.cookie_basket.status)

    def test_lines_are_moved_across(self):
        self.assertEqual(1, self.user_basket.lines.all().count())

    def test_merge_line_takes_max_quantity(self):
        line = self.user_basket.lines.get(product=self.product)
        self.assertEqual(2, line.quantity)
Beispiel #27
0
class TestMergingTwoBaskets(TestCase):
    def setUp(self):
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(self.product, price_excl_tax=D("10.00"))
        self.purchase_info = factories.create_purchase_info(self.record)

        self.main_basket = Basket()
        self.main_basket.strategy = strategy.Default()
        self.main_basket.add(self.product, quantity=2)

        self.merge_basket = Basket()
        self.merge_basket.strategy = strategy.Default()
        self.merge_basket.add(self.product, quantity=1)

        self.main_basket.merge(self.merge_basket)

    def test_doesnt_sum_quantities(self):
        self.assertEquals(1, self.main_basket.num_lines)

    def test_changes_status_of_merge_basket(self):
        self.assertEquals(Basket.MERGED, self.merge_basket.status)
class TestANonEmptyBasket(TestCase):
    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(self.product,
                                                   price=D('10.00'))
        self.purchase_info = factories.create_purchase_info(self.record)
        self.basket.add(self.product, 10)

    def test_can_be_flushed(self):
        self.basket.flush()
        self.assertEqual(self.basket.num_items, 0)

    def test_returns_correct_product_quantity(self):
        self.assertEqual(10, self.basket.product_quantity(self.product))

    def test_returns_correct_line_quantity_for_existing_product_and_stockrecord(
            self):
        self.assertEqual(10,
                         self.basket.line_quantity(self.product, self.record))

    def test_returns_zero_line_quantity_for_alternative_stockrecord(self):
        record = factories.create_stockrecord(self.product, price=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(self.product, record))

    def test_returns_zero_line_quantity_for_missing_product_and_stockrecord(
            self):
        product = factories.create_product()
        record = factories.create_stockrecord(product, price=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(product, record))

    def test_returns_correct_quantity_for_existing_product_and_stockrecord_and_options(
            self):
        product = factories.create_product()
        record = factories.create_stockrecord(product, price=D('5.00'))
        option = Option.objects.create(name="Message")
        options = [{"option": option, "value": "2"}]

        self.basket.add(product, options=options)
        self.assertEqual(0, self.basket.line_quantity(product, record))
        self.assertEqual(1, self.basket.line_quantity(product, record,
                                                      options))

    def test_total_sums_product_totals(self):
        product = factories.create_product()
        factories.create_stockrecord(product, price=D('5.00'))
        self.basket.add(product, 1)
        self.assertEqual(self.basket.total_excl_tax, 105)

    def test_totals_for_free_products(self):
        basket = Basket()
        basket.strategy = strategy.Default()
        # Add a zero-priced product to the basket
        product = factories.create_product()
        factories.create_stockrecord(product, price=D('0.00'), num_in_stock=10)
        basket.add(product, 1)

        self.assertEqual(basket.lines.count(), 1)
        self.assertEqual(basket.total_excl_tax, 0)
        self.assertEqual(basket.total_incl_tax, 0)

    def test_basket_prices_calculation_for_unavailable_pricing(self):
        new_product = factories.create_product()
        factories.create_stockrecord(new_product, price=D('5.00'))
        self.basket.add(new_product, 1)

        class UnavailableProductStrategy(strategy.Default):
            """ A test strategy that makes a specific product unavailable """
            def availability_policy(self, product, stockrecord):
                if product == new_product:
                    return availability.Unavailable()
                return super().availability_policy(product, stockrecord)

            def pricing_policy(self, product, stockrecord):
                if product == new_product:
                    return prices.Unavailable()
                return super().pricing_policy(product, stockrecord)

        self.basket.strategy = UnavailableProductStrategy()
        line = self.basket.all_lines()[1]
        self.assertEqual(
            line.get_warning(),
            "'D\xf9\uff4d\u03fb\u03d2 title' is no longer available")
        self.assertIsNone(line.line_price_excl_tax)
        self.assertIsNone(line.line_price_incl_tax)
        self.assertIsNone(line.line_price_excl_tax_incl_discounts)
        self.assertIsNone(line.line_price_incl_tax_incl_discounts)
        self.assertIsNone(line.line_tax)
        self.assertEqual(self.basket.total_excl_tax, 100)
        self.assertEqual(self.basket.total_incl_tax, 100)
        self.assertEqual(self.basket.total_excl_tax_excl_discounts, 100)
        self.assertEqual(self.basket.total_incl_tax_excl_discounts, 100)

    def test_max_allowed_quantity(self):
        self.basket.add_product(self.product, quantity=3)

        # max allowed here is 7 (20-10+3)
        with self.settings(OSCAR_MAX_BASKET_QUANTITY_THRESHOLD=20):
            max_allowed, basket_threshold = self.basket.max_allowed_quantity()
            self.assertEqual(max_allowed, 7)
            self.assertEqual(basket_threshold, 20)

        # but we can also completely disable the threshold
        with self.settings(OSCAR_MAX_BASKET_QUANTITY_THRESHOLD=None):
            max_allowed, basket_threshold = self.basket.max_allowed_quantity()
            self.assertEqual(max_allowed, None)
            self.assertEqual(basket_threshold, None)

    def test_is_quantity_allowed(self):
        with self.settings(OSCAR_MAX_BASKET_QUANTITY_THRESHOLD=20):
            # 7 or below is possible
            allowed, message = self.basket.is_quantity_allowed(qty=7)
            self.assertTrue(allowed)
            self.assertIsNone(message)
            # but above it's not
            allowed, message = self.basket.is_quantity_allowed(qty=11)
            self.assertFalse(allowed)
            self.assertIsNotNone(message)

        with self.settings(OSCAR_MAX_BASKET_QUANTITY_THRESHOLD=None):
            # with the treshold disabled all quantities are possible
            allowed, message = self.basket.is_quantity_allowed(qty=7)
            self.assertTrue(allowed)
            self.assertIsNone(message)
            allowed, message = self.basket.is_quantity_allowed(qty=5000)
            self.assertTrue(allowed)
            self.assertIsNone(message)
Beispiel #29
0
 def test_default_method_is_free(self):
     user, basket = User(), Basket()
     methods = self.repo.get_shipping_methods(user, basket)
     self.assertEqual(1, len(methods))
     self.assertTrue(isinstance(methods[0], Free))
 def test_delegates_is_tax_known(self):
     basket = Basket()
     charge = self.method.calculate(basket)
     self.assertTrue(charge.is_tax_known)
Beispiel #31
0
class TestANonEmptyBasket(TestCase):

    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(
            self.product, price_excl_tax=D('10.00'))
        self.purchase_info = factories.create_purchase_info(self.record)
        self.basket.add(self.product, 10)

    def test_can_be_flushed(self):
        self.basket.flush()
        self.assertEqual(self.basket.num_items, 0)

    def test_returns_correct_product_quantity(self):
        self.assertEqual(10, self.basket.product_quantity(
            self.product))

    def test_returns_correct_line_quantity_for_existing_product_and_stockrecord(self):
        self.assertEqual(10, self.basket.line_quantity(
            self.product, self.record))

    def test_returns_zero_line_quantity_for_alternative_stockrecord(self):
        record = factories.create_stockrecord(
            self.product, price_excl_tax=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(
            self.product, record))

    def test_returns_zero_line_quantity_for_missing_product_and_stockrecord(self):
        product = factories.create_product()
        record = factories.create_stockrecord(
            product, price_excl_tax=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(
            product, record))

    def test_returns_correct_quantity_for_existing_product_and_stockrecord_and_options(self):
        product = factories.create_product()
        record = factories.create_stockrecord(
            product, price_excl_tax=D('5.00'))
        option = Option.objects.create(name="Message")
        options = [{"option": option, "value": "2"}]

        self.basket.add(product, options=options)
        self.assertEqual(0, self.basket.line_quantity(
            product, record))
        self.assertEqual(1, self.basket.line_quantity(
            product, record, options))
Beispiel #32
0
 def setUp(self):
     self.method = methods.FixedPrice(
         D('10.00'), D('12.00'))
     basket = Basket()
     self.method.set_basket(basket)
Beispiel #33
0
 def setUp(self):
     self.creator = OrderCreator()
     self.basket = Basket()
Beispiel #34
0
 def test_includes_tax(self):
     basket = Basket()
     self.method.set_basket(basket)
     self.assertTrue(self.method.is_tax_known)
Beispiel #35
0
 def test_shipping_is_free(self):
     method = FreeShipping()
     basket = Basket()
     method.set_basket(basket)
     self.assertEquals(D('0.00'), method.basket_charge_incl_tax())
     self.assertEquals(D('0.00'), method.basket_charge_excl_tax())
Beispiel #36
0
 def setUp(self):
     self.method = methods.FixedPrice(charge_excl_tax=D('10.00'),
                                      charge_incl_tax=D('12.00'))
     basket = Basket()
     self.charge = self.method.calculate(basket)
Beispiel #37
0
 def setUp(self):
     self.creator = OrderCreator()
     self.basket = Basket()
Beispiel #38
0
 def test_different_values(self, value):
     method = FixedPrice(D(value))
     basket = Basket()
     method.set_basket(basket)
     self.assertEquals(D(value), method.basket_charge_excl_tax())
Beispiel #39
0
 def test_shipping_is_free_for_nonempty_basket(self):
     basket = Basket()
     basket.add_product(create_product())
     self.method.set_basket(basket)
     self.assertEquals(D('0.00'), self.method.basket_charge_incl_tax())
     self.assertEquals(D('0.00'), self.method.basket_charge_excl_tax())
Beispiel #40
0
 def test_fixed_price_shipping_charges_for_empty_basket(self):
     method = FixedPriceShipping(D('10.00'), D('10.00'))
     basket = Basket()
     method.set_basket(basket)
     self.assertEquals(D('10.00'), method.basket_charge_incl_tax())
     self.assertEquals(D('10.00'), method.basket_charge_excl_tax())
Beispiel #41
0
 def test_is_free_for_empty_basket(self):
     basket = Basket()
     self.method.set_basket(basket)
     self.assertEqual(D('0.00'), self.method.charge_incl_tax)
     self.assertEqual(D('0.00'), self.method.charge_excl_tax)
Beispiel #42
0
 def test_fixed_price_shipping_assumes_no_tax(self):
     method = FixedPriceShipping(D('10.00'))
     basket = Basket()
     method.set_basket(basket)
     self.assertEquals(D('10.00'), method.basket_charge_excl_tax())
Beispiel #43
0
    def test_returns_zero_for_empty_basket(self):
        basket = Basket()

        scale = Scale(attribute_code='weight')
        self.assertEqual(0, scale.weigh_basket(basket))
Beispiel #44
0
 def test_shipping_is_free_for_empty_basket(self):
     basket = Basket()
     self.method.set_basket(basket)
     self.assertEquals(D('0.00'), self.method.basket_charge_incl_tax())
     self.assertEquals(D('0.00'), self.method.basket_charge_excl_tax())
 def setUp(self):
     self.repo = repository.Repository()
     self.basket = Basket()
Beispiel #46
0
    def test_weight_calculation_of_empty_basket(self):
        basket = Basket()

        scales = Scales(attribute_code='weight')
        self.assertEquals(0, scales.weigh_basket(basket))
 def setUp(self):
     self.product = create_product(price=D('12.00'), num_in_stock=5)
     self.basket = Basket()
     self.basket.add_product(self.product)
Beispiel #48
0
class TestANonEmptyBasket(TestCase):
    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(self.product,
                                                   price_excl_tax=D('10.00'))
        self.purchase_info = factories.create_purchase_info(self.record)
        self.basket.add(self.product, 10)

    def test_can_be_flushed(self):
        self.basket.flush()
        self.assertEqual(self.basket.num_items, 0)

    def test_returns_correct_product_quantity(self):
        self.assertEqual(10, self.basket.product_quantity(self.product))

    def test_returns_correct_line_quantity_for_existing_product_and_stockrecord(
            self):
        self.assertEqual(10,
                         self.basket.line_quantity(self.product, self.record))

    def test_returns_zero_line_quantity_for_alternative_stockrecord(self):
        record = factories.create_stockrecord(self.product,
                                              price_excl_tax=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(self.product, record))

    def test_returns_zero_line_quantity_for_missing_product_and_stockrecord(
            self):
        product = factories.create_product()
        record = factories.create_stockrecord(product,
                                              price_excl_tax=D('5.00'))
        self.assertEqual(0, self.basket.line_quantity(product, record))

    def test_returns_correct_quantity_for_existing_product_and_stockrecord_and_options(
            self):
        product = factories.create_product()
        record = factories.create_stockrecord(product,
                                              price_excl_tax=D('5.00'))
        option = Option.objects.create(name="Message")
        options = [{"option": option, "value": "2"}]

        self.basket.add(product, options=options)
        self.assertEqual(0, self.basket.line_quantity(product, record))
        self.assertEqual(1, self.basket.line_quantity(product, record,
                                                      options))

    def test_total_sums_product_totals(self):
        product = factories.create_product()
        factories.create_stockrecord(product, price_excl_tax=D('5.00'))
        self.basket.add(product, 1)
        self.assertEqual(self.basket.total_excl_tax, 105)

    def test_total_excludes_unavailable_products_with_unknown_price(self):
        new_product = factories.create_product()
        factories.create_stockrecord(new_product, price_excl_tax=D('5.00'))
        self.basket.add(new_product, 1)

        class UnavailableProductStrategy(strategy.Default):
            """ A test strategy that makes a specific product unavailable """
            def availability_policy(self, product, stockrecord):
                if product == new_product:
                    return availability.Unavailable()
                return super(UnavailableProductStrategy,
                             self).availability_policy(product, stockrecord)

            def pricing_policy(self, product, stockrecord):
                if product == new_product:
                    return prices.Unavailable()
                return super(UnavailableProductStrategy,
                             self).pricing_policy(product, stockrecord)

        try:
            self.basket.strategy = UnavailableProductStrategy()
            self.assertEqual(
                self.basket.all_lines()[1].get_warning(),
                u"'D\xf9\uff4d\u03fb\u03d2 title' is no longer available")
            self.assertEqual(self.basket.total_excl_tax, 100)
        finally:
            self.basket.strategy = strategy.Default()
 def test_discounts_charge(self):
     basket = Basket()
     charge = self.method.calculate(basket)
     self.assertEqual(D('7.00'), charge.incl_tax)
 def setUp(self):
     self.basket = Basket()
     self.basket.strategy = strategy.Default()
Beispiel #51
0
 def test_empty_baskets_have_zero_lines(self):
     self.assertTrue(Basket().num_lines == 0)
Beispiel #52
0
 def test_for_smoke_with_basket_charge(self):
     basket = Basket()
     self.standard.set_basket(basket)
     charge = self.standard.basket_charge_incl_tax()
     self.assertEqual(D('0.00'), charge)
Beispiel #53
0
 def test_new_baskets_are_empty(self):
     self.assertTrue(Basket().is_empty)
class TestAddingAProductToABasket(TestCase):
    def setUp(self):
        self.basket = Basket()
        self.basket.strategy = strategy.Default()
        self.product = factories.create_product()
        self.record = factories.create_stockrecord(currency='GBP',
                                                   product=self.product,
                                                   price=D('10.00'))
        self.purchase_info = factories.create_purchase_info(self.record)
        self.basket.add(self.product)

    def test_creates_a_line(self):
        self.assertEqual(1, self.basket.num_lines)

    def test_sets_line_prices(self):
        line = self.basket.lines.all()[0]
        self.assertEqual(line.price_incl_tax,
                         self.purchase_info.price.incl_tax)
        self.assertEqual(line.price_excl_tax,
                         self.purchase_info.price.excl_tax)

    def test_adding_negative_quantity(self):
        self.assertEqual(1, self.basket.num_lines)
        self.basket.add(self.product, quantity=4)
        self.assertEqual(5, self.basket.line_quantity(self.product,
                                                      self.record))
        self.basket.add(self.product, quantity=-10)
        self.assertEqual(0, self.basket.line_quantity(self.product,
                                                      self.record))

    def test_means_another_currency_product_cannot_be_added(self):
        product = factories.create_product()
        factories.create_stockrecord(currency='USD',
                                     product=product,
                                     price=D('20.00'))
        with self.assertRaises(ValueError):
            self.basket.add(product)

    def test_cannot_add_a_product_without_price(self):
        product = factories.create_product(price=None)
        with self.assertRaises(ValueError):
            self.basket.add(product)
Beispiel #55
0
 def setUp(self):
     self.method = methods.Free()
     self.basket = Basket()
     self.charge = self.method.calculate(self.basket)
Beispiel #56
0
 def setUp(self):
     self.condition = custom.create_condition(BasketOwnerCalledBarry)
     self.offer = models.ConditionalOffer(condition=self.condition)
     self.basket = Basket()
Beispiel #57
0
 def setUp(self):
     self.basket = Basket()
     self.product = create_product()
Beispiel #58
0
 def setUp(self):
     self.method = methods.NoShippingRequired()
     basket = Basket()
     self.charge = self.method.calculate(basket)
 def setUp(self):
     self.product = create_product(price=D('12.00'), num_in_stock=5)
     self.basket = Basket()
     self.basket.add_product(self.product)
Beispiel #60
0
 def setUp(self):
     self.method = methods.FixedPrice(D('10.00'))
     basket = Basket()
     self.charge = self.method.calculate(basket)