class TestSupplierModel(VokoTestCase):
def setUp(self):
self.supplier = SupplierFactory()
self.order_round = OrderRoundFactory.create()
@skip("Unable to figure out why this test won't succeed for now")
def test_has_orders_returns_true_on_paid_orders(self):
order = OrderFactory(finalized=True, paid=True, order_round=self.order_round)
OrderProductFactory(order=order, product__supplier=self.supplier)
# This all works...
self.assertEqual(OrderProduct.objects.all()[0].order, order)
self.assertEqual(OrderProduct.objects.all()[0].order.order_round, self.order_round)
self.assertEqual(OrderProduct.objects.all()[0].product.supplier, self.supplier)
# Something is going on with get_current_order_round, like it's mocked somewhere...
self.assertTrue(self.supplier.has_orders_in_current_order_round())
def test_has_orders_returns_false_on_non_paid_orders(self):
order = OrderFactory(finalized=True, paid=False, order_round=self.order_round)
OrderProductFactory(order=order, product__supplier=self.supplier)
self.assertFalse(self.supplier.has_orders_in_current_order_round())
def test_has_orders_ignores_stock_products(self):
order = OrderFactory(finalized=True,
paid=True)
OrderProductFactory(order=order,
product__supplier=self.supplier,
product__order_round=None)
self.assertFalse(
self.supplier.has_orders_in_current_order_round())
def test_suppliers_with_paid_and_unpaid_orders(self):
order_round = OrderRoundFactory()
supplier1 = SupplierFactory()
supplier2 = SupplierFactory()
paid_order = OrderFactory(paid=True,
finalized=True,
order_round=order_round)
finalized_order = OrderFactory(paid=False,
finalized=True,
order_round=order_round)
OrderProductFactory(product__supplier=supplier1, order=paid_order)
OrderProductFactory(product__supplier=supplier2, order=finalized_order)
self.assertCountEqual(order_round.suppliers(), [supplier1])
def test_supplier_total_order_sum_with_one_order(self):
order_round = OrderRoundFactory()
supplier1 = SupplierFactory()
paid_order = OrderFactory(paid=True,
finalized=True,
order_round=order_round)
supplier1_orderproduct = OrderProductFactory(
product__supplier=supplier1, order=paid_order)
self.assertCountEqual(order_round.suppliers(), [supplier1])
self.assertEqual(
order_round.supplier_total_order_sum(supplier1),
supplier1_orderproduct.product.base_price *
supplier1_orderproduct.amount)
class TestSupplierModel(VokoTestCase):
def setUp(self):
self.supplier = SupplierFactory()
self.order_round = OrderRoundFactory.create()
@skip("Unable to figure out why this test won't succeed for now")
def test_has_orders_returns_true_on_paid_orders(self):
order = OrderFactory(finalized=True,
paid=True,
order_round=self.order_round)
OrderProductFactory(order=order, product__supplier=self.supplier)
# This all works...
self.assertEqual(OrderProduct.objects.all()[0].order, order)
self.assertEqual(OrderProduct.objects.all()[0].order.order_round,
self.order_round)
self.assertEqual(OrderProduct.objects.all()[0].product.supplier,
self.supplier)
# Something is going on with get_current_order_round,
# like it's mocked somewhere...
self.assertTrue(self.supplier.has_orders_in_current_order_round())
def test_has_orders_returns_false_on_non_paid_orders(self):
order = OrderFactory(finalized=True,
paid=False,
order_round=self.order_round)
OrderProductFactory(order=order, product__supplier=self.supplier)
self.assertFalse(self.supplier.has_orders_in_current_order_round())
def test_has_orders_ignores_stock_products(self):
order = OrderFactory(finalized=True, paid=True)
OrderProductFactory(order=order,
product__supplier=self.supplier,
product__order_round=None)
self.assertFalse(self.supplier.has_orders_in_current_order_round())
def test_determine_new_product_2(self):
round1 = OrderRoundFactory()
OrderRoundFactory()
supplier = SupplierFactory()
unit = UnitFactory()
# old product
ProductFactory(order_round=round1,
name="Appels",
supplier=supplier,
unit=unit)
new_product = ProductFactory(order_round=round1,
name="Appels",
supplier=supplier,
unit=unit)
self.assertFalse(new_product.new)
new_product.determine_if_product_is_new_and_set_label()
new_product = Product.objects.get(id=new_product.id)
self.assertFalse(new_product.new)
def test_supplier_total_order_sum_with_multiple_orders(self):
order_round = OrderRoundFactory()
supplier1 = SupplierFactory()
supplier1_orderproduct1 = OrderProductFactory(
product__supplier=supplier1,
order__order_round=order_round,
order__paid=True,
order__finalized=True)
supplier1_orderproduct2 = OrderProductFactory(
product__supplier=supplier1,
order__order_round=order_round,
order__paid=True,
order__finalized=True)
expected_sum = ((supplier1_orderproduct1.product.base_price *
supplier1_orderproduct1.amount) +
(supplier1_orderproduct2.product.base_price *
supplier1_orderproduct2.amount))
self.assertEqual(order_round.supplier_total_order_sum(supplier1),
expected_sum)
def setUp(self):
self.supplier = SupplierFactory()
self.order_round = OrderRoundFactory.create()
def test_context_contains_supplier_objects(self):
suppliers = SupplierFactory.create_batch(10)
ret = self.client.get(self.url)
self.assertItemsEqual(ret.context['view'].suppliers(), suppliers)
def test_context_contains_supplier_objects(self):
suppliers = SupplierFactory.create_batch(10)
ret = self.client.get(self.url)
self.assertCountEqual(ret.context['view'].suppliers(), suppliers)
def setUp(self):
self.supplier = SupplierFactory()
self.order_round = OrderRoundFactory.create()
