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)
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))
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)
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))
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")
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 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')
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'))
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)
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)
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)
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")
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)
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))
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)
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)
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)
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)
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 setUp(self): self.method = methods.FixedPrice( D('10.00'), D('12.00')) basket = Basket() self.method.set_basket(basket)
def setUp(self): self.creator = OrderCreator() self.basket = Basket()
def test_includes_tax(self): basket = Basket() self.method.set_basket(basket) self.assertTrue(self.method.is_tax_known)
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())
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)
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())
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())
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())
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)
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())
def test_returns_zero_for_empty_basket(self): basket = Basket() scale = Scale(attribute_code='weight') self.assertEqual(0, scale.weigh_basket(basket))
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()
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)
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()
def test_empty_baskets_have_zero_lines(self): self.assertTrue(Basket().num_lines == 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)
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)
def setUp(self): self.method = methods.Free() self.basket = Basket() self.charge = self.method.calculate(self.basket)
def setUp(self): self.condition = custom.create_condition(BasketOwnerCalledBarry) self.offer = models.ConditionalOffer(condition=self.condition) self.basket = Basket()
def setUp(self): self.basket = Basket() self.product = create_product()
def setUp(self): self.method = methods.NoShippingRequired() basket = Basket() self.charge = self.method.calculate(basket)
def setUp(self): self.method = methods.FixedPrice(D('10.00')) basket = Basket() self.charge = self.method.calculate(basket)