def test_verbose_availability_with_stock_3(self): OrderRoundFactory() product = ProductFactory(order_round=None) stock1 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) stock2 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) odp1 = OrderProductFactory(product=product, amount=1, order__paid=True) self.assertEqual(product.verbose_availability(), "%s in voorraad" % ((stock1.amount + stock2.amount) - odp1.amount))
def test_verbose_availability_with_stock_sold_out(self): OrderRoundFactory() product = ProductFactory(order_round=None) stock = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) OrderProductFactory(product=product, amount=stock.amount, order__paid=True) self.assertEqual(product.verbose_availability(), "uitverkocht")
def test_verbose_availability_with_stock_2(self): product = ProductFactory(order_round=None) stock1 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) stock2 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) self.assertEqual(product.verbose_availability(), "%s in voorraad" % (stock1.amount + stock2.amount))
def test_verbose_availability_with_stock_4(self): OrderRoundFactory() product = ProductFactory(order_round=None) stock1 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=10) stock2 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=5) stock3 = ProductStockFactory(product=product, type=ProductStock.TYPE_LOST, amount=3) odp1 = OrderProductFactory(product=product, amount=1, order__paid=True) self.assertEqual(product.verbose_availability(), "11 in voorraad")
def test_product_round_override(self): round1 = self.round round2 = OrderRoundFactory() products1 = ProductFactory.create_batch(50, order_round=round1) products2 = ProductFactory.create_batch(50, order_round=round2) ret = self.client.get(self.url) self.assertCountEqual(ret.context['object_list'], products1) ret = self.client.get(self.url + "?round=%d" % round2.id) self.assertCountEqual(ret.context['object_list'], products2)
def test_determine_new_product_1(self): round1 = OrderRoundFactory() round2 = OrderRoundFactory() product1 = ProductFactory(order_round=round1) product2 = ProductFactory(order_round=round2) self.assertFalse(product2.new) product2.determine_if_product_is_new_and_set_label() product2 = Product.objects.get(id=product2.id) self.assertTrue(product2.new)
def test_product_round_override(self): round1 = self.round round2 = OrderRoundFactory() products1 = ProductFactory.create_batch(50, order_round=round1) products2 = ProductFactory.create_batch(50, order_round=round2) ret = self.client.get(self.url) self.assertItemsEqual(ret.context['object_list'], products1) ret = self.client.get(self.url + "?round=%d" % round2.id) self.assertItemsEqual(ret.context['object_list'], products2)
def test_determine_new_product_1(self): round1 = OrderRoundFactory() round2 = OrderRoundFactory() # Old, new ProductFactory(order_round=round1) new_product = ProductFactory(order_round=round2) 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.assertTrue(new_product.new)
def test_verbose_availability_with_stock_3(self): OrderRoundFactory() product = ProductFactory(order_round=None) stock1 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) stock2 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) odp1 = OrderProductFactory(product=product, amount=1, order__paid=True) self.assertEqual( product.verbose_availability(), "%s in voorraad" % ((stock1.amount + stock2.amount) - odp1.amount))
def test_stock_products_without_stock_are_excluded(self): order = OrderFactory(order_round=self.round, user=self.user) product = ProductFactory(order_round=self.round) sproduct = ProductFactory(order_round=None) OrderProductFactory(order=order, product=product) OrderProductFactory(order=order, product=sproduct) ret = self.client.get(self.url) self.assertNotIn(sproduct, list(ret.context['view'].products())) self.assertIn(product, list(ret.context['view'].products()))
def test_determine_new_product_2(self): round1 = OrderRoundFactory() round2 = OrderRoundFactory() supplier = SupplierFactory() unit = UnitFactory() product1 = ProductFactory(order_round=round1, name="Appels", supplier=supplier, unit=unit) product2 = ProductFactory(order_round=round1, name="Appels", supplier=supplier, unit=unit) self.assertFalse(product2.new) product2.determine_if_product_is_new_and_set_label() product2 = Product.objects.get(id=product2.id) self.assertFalse(product2.new)
def test_verbose_availability_with_stock_4(self): OrderRoundFactory() product = ProductFactory(order_round=None) ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=10) ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=5) ProductStockFactory(product=product, type=ProductStock.TYPE_LOST, amount=3) OrderProductFactory(product=product, amount=1, order__paid=True) self.assertEqual(product.verbose_availability(), "11 in voorraad")
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_amount_ordered_only_counts_orderproducts_of_paid_orders(self): product = ProductFactory() OrderProductFactory(product=product, order__paid=False) odp2 = OrderProductFactory(product=product, order__paid=True) odp3 = OrderProductFactory(product=product, order__paid=True) self.assertEqual(product.amount_ordered, odp2.amount + odp3.amount)
def test_that_stock_product_amount_is_decreased(self): # 10 available product = ProductFactory(order_round=None) ProductStockFactory(product=product, amount=10) self.assertEqual(10, product.amount_available) order1 = OrderFactory(order_round=self.round, finalized=True, paid=True) OrderProductFactory(order=order1, product=product, amount=8) # 8 ordered, leaves 2 self.assertEqual(8, product.amount_ordered) self.assertEqual(2, product.amount_available) # attempt to order 5 order2 = OrderFactory(order_round=self.round) order2_product = OrderProductFactory(order=order2, product=product, amount=5) update_totals_for_products_with_max_order_amounts(order2) # re-fetch, amount is decreased to remaining 2 order2_product = OrderProduct.objects.get(pk=order2_product.pk) self.assertEqual(2, order2_product.amount)
def test_is_available_on_stock_product_2(self): OrderRoundFactory() product = ProductFactory(order_round=None) ProductStockFactory(product=product, amount=5) ProductStockFactory(product=product, amount=4) OrderProductFactory(product=product, amount=9, order__paid=True) self.assertFalse(product.is_available)
def test_changing_product_is_prohibited(self): ps = ProductStockFactory(type='added') ps.product = ProductFactory() with self.assertRaises(AssertionError): ps.save()
def test_amount_available_with_stock_1(self): product = ProductFactory(maximum_total_order=None, order_round=None) stock1 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) stock2 = ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED) self.assertEqual(product.amount_available, (stock1.amount + stock2.amount))
def test_attribute_is_added_to_products_with_orderproduct(self): order = OrderFactory(order_round=self.round, user=self.user) product = ProductFactory(order_round=self.round) odp1 = OrderProductFactory(order=order, product=product) ret = self.client.get(self.url) self.assertEqual( list(ret.context['view'].products())[0].ordered_amount, odp1.amount)
def test_order_more_than_max(self): product = ProductFactory(order_round=self.round, maximum_total_order=1) self.assertTrue(product.is_available) ret = self.client.post(self.url, {"order-product-%d" % product.id: 2}, follow=True) self.assertMsgInResponse( ret, "Van het product '%s' van %s is nog %s %s beschikbaar!" % (product.name, product.supplier.name, product.amount_available, product.unit_of_measurement.lower()))
def test_create_corrections_creates_corrections_for_all_orderproducts_of_paid_orders(self): product = ProductFactory() paid_odp1 = OrderProductFactory(product=product, order__paid=True) paid_odp2 = OrderProductFactory(product=product, order__paid=True) nonpaid_odp2 = OrderProductFactory(product=product, order__paid=False) self.assertItemsEqual(OrderProductCorrection.objects.all(), []) product.create_corrections() corrections = OrderProductCorrection.objects.all().order_by('id') self.assertEqual(len(corrections), 2) self.assertEqual(corrections[0].order_product, paid_odp1) self.assertEqual(corrections[0].supplied_percentage, 0) self.assertEqual(corrections[0].notes, 'Product niet geleverd: "%s" (%s) [%s]' % (paid_odp1.product.name, paid_odp1.product.supplier.name, paid_odp1.product.id)) self.assertEqual(corrections[0].charge_supplier, True) self.assertEqual(corrections[1].order_product, paid_odp2)
def test_add_stock_with_different_price_creates_new_product(self): product = ProductFactory(order_round=None, base_price=1) ProductStockFactory(product=product, amount=5) self.assertEqual(product.all_stock(), 5) ret = self.client.post(self.url, data={ 'amount': 7, 'product_id': product.id, 'type': 'added', 'notes': "foo", 'base_price': "1.5" # different than '1' }) self.assertEqual(ret.status_code, 201) prod_stock = ProductStock.objects.last() self.assertEqual(ProductStock.objects.count(), 2) new_product = Product.objects.last() self.assertEqual(prod_stock.product, new_product) self.assertEqual(prod_stock.type, 'added') self.assertEqual(prod_stock.amount, 7) self.assertEqual(prod_stock.notes, 'foo') self.assertEqual(product.all_stock(), 5) self.assertEqual(new_product.all_stock(), 7) # Check cloned product self.assertEqual(new_product.base_price, 1.5) self.assertEqual(new_product.name, product.name) self.assertEqual(new_product.unit, product.unit) self.assertEqual(new_product.unit_amount, product.unit_amount) self.assertEqual(new_product.supplier, product.supplier) self.assertEqual(new_product.order_round, product.order_round) self.assertEqual(new_product.category, product.category) self.assertEqual(new_product.new, product.new) self.assertEqual(new_product.maximum_total_order, product.maximum_total_order) self.assertEqual(new_product.enabled, product.enabled)
def test_creates_corrections_for_all_orderproducts_of_paid_orders(self): product = ProductFactory() paid_odp1 = OrderProductFactory(product=product, order__paid=True) paid_odp2 = OrderProductFactory(product=product, order__paid=True) # non paid OrderProductFactory(product=product, order__paid=False) self.assertCountEqual(OrderProductCorrection.objects.all(), []) product.create_corrections() corrections = OrderProductCorrection.objects.all().order_by('id') self.assertEqual(len(corrections), 2) self.assertEqual(corrections[0].order_product, paid_odp1) self.assertEqual(corrections[0].supplied_percentage, 0) self.assertEqual( corrections[0].notes, 'Product niet geleverd: "%s" (%s) [%s]' % (paid_odp1.product.name, paid_odp1.product.supplier.name, paid_odp1.product.id)) self.assertEqual(corrections[0].charge_supplier, True) self.assertEqual(corrections[1].order_product, paid_odp2)
def test_amount_available_with_stock_2(self): product = ProductFactory(maximum_total_order=None, order_round=None) ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=10) ProductStockFactory(product=product, type=ProductStock.TYPE_ADDED, amount=20), ProductStockFactory(product=product, type=ProductStock.TYPE_LOST, amount=5), self.assertEqual(product.amount_available, 25)
def test_new_stock(self): product = ProductFactory(order_round=None) self.assertFalse(ProductStock.objects.all()) self.assertEqual(product.all_stock(), 0) ret = self.client.post(self.url, data={ 'amount': 10, 'product_id': product.id, 'type': 'added', 'notes': "foo", 'base_price': str(product.base_price) }) self.assertEqual(ret.status_code, 201) prod_stock = ProductStock.objects.first() self.assertCountEqual(product.stock.all(), (prod_stock,)) self.assertEqual(prod_stock.product, product) self.assertEqual(prod_stock.type, 'added') self.assertEqual(prod_stock.amount, 10) self.assertEqual(prod_stock.notes, 'foo') self.assertEqual(product.all_stock(), 10)
def test_subtract_stock(self): product = ProductFactory(order_round=None) ProductStockFactory(product=product, amount=5) self.assertEqual(product.all_stock(), 5) ret = self.client.post(self.url, data={ 'amount': 3, 'product_id': product.id, 'type': 'lost', 'notes': "foo", 'base_price': str(product.base_price) }) self.assertEqual(ret.status_code, 201) prod_stock = ProductStock.objects.last() self.assertEqual(ProductStock.objects.count(), 2) self.assertEqual(prod_stock.product, product) self.assertEqual(prod_stock.type, 'lost') self.assertEqual(prod_stock.amount, 3) self.assertEqual(prod_stock.notes, 'foo') self.assertEqual(product.all_stock(), 2)
def test_order_one_product(self): self.assertFalse(OrderProduct.objects.exists()) product = ProductFactory(order_round=self.round) ret = self.client.post(self.url, {"order-product-%d" % product.id: 3}) odp = OrderProduct.objects.get() self.assertEqual(odp.product, product) self.assertEqual(odp.amount, 3) self.assertEqual(odp.order.order_round, self.round) self.assertEqual(odp.total_retail_price, product.retail_price * 3) self.assertEqual(odp.base_price, product.base_price) self.assertEqual(odp.retail_price, product.retail_price) self.assertRedirects(ret, reverse("finish_order", args=(self.order.id, )))
def test_that_sold_out_product_is_removed(self): product = ProductFactory(order_round=self.round, maximum_total_order=10) self.assertEqual(10, product.amount_available) order1 = OrderFactory(order_round=self.round, finalized=True, paid=True) OrderProductFactory(order=order1, product=product, amount=10) self.assertEqual(10, product.amount_ordered) self.assertEqual(0, product.amount_available) order2 = OrderFactory(order_round=self.round) OrderProductFactory(order=order2, amount=1) update_totals_for_products_with_max_order_amounts(order2) self.assertEqual(1, len(product.orderproducts.all()))
def test_sold_out_stock_product_is_removed(self): # 10 available product = ProductFactory(order_round=None) ProductStockFactory(product=product, amount=10) self.assertEqual(10, product.amount_available) order1 = OrderFactory(order_round=self.round, finalized=True, paid=True) OrderProductFactory(order=order1, product=product, amount=10) # 10 ordered, 0 remain self.assertEqual(10, product.amount_ordered) self.assertEqual(0, product.amount_available) # order 1 more order2 = OrderFactory(order_round=self.round) OrderProductFactory(order=order2, product=product, amount=1) self.assertEqual(2, len(product.orderproducts.all())) update_totals_for_products_with_max_order_amounts(order2) self.assertEqual(1, len(product.orderproducts.all()))
def test_verbose_availability_2(self): product = ProductFactory(maximum_total_order=None) self.assertEqual(product.verbose_availability(), "Onbeperkt")
def test_determine_new_product_with_one_order_round(self): product = ProductFactory() self.assertEqual(len(OrderRound.objects.all()), 1) self.assertIsNone(product.determine_if_product_is_new_and_set_label())
def test_verbose_availability_1(self): product = ProductFactory(maximum_total_order=99) o1 = OrderProductFactory(product=product, order__paid=True).amount o2 = OrderProductFactory(product=product, order__paid=True).amount self.assertEqual(product.verbose_availability(), "%s van 99" % (99 - (o1 + o2)))
def test_context_contains_products_ordered_by_name(self): ProductFactory.create_batch(50, order_round=self.round) ret = self.client.get(self.url) self.assertItemsEqual(ret.context['view'].products(), Product.objects.all().order_by('name'))
def test_is_available_when_not_sold_out(self): product = ProductFactory(maximum_total_order=10) OrderProductFactory(product=product, order__paid=True, amount=1) self.assertTrue(product.is_available)
def test_percentage_available_with_max(self): product = ProductFactory(maximum_total_order=10) OrderProductFactory(product=product, order__paid=True, amount=1) self.assertEqual(product.percentage_available, 90)
def test_percentage_available_is_rounded_to_int(self): product = ProductFactory(maximum_total_order=99) OrderProductFactory(product=product, order__paid=True, amount=25) self.assertEqual(product.percentage_available, 74)
def test_is_available_on_stock_product_1(self): product = ProductFactory(order_round=None) ProductStockFactory(product=product, amount=2) self.assertTrue(product.is_available)
def test_percentage_available_with_stock_is_always_0(self): product = ProductFactory() ProductStockFactory(amount=10, product=product) OrderProductFactory(product=product, order__paid=True, amount=1) self.assertEqual(product.percentage_available, 100)
def test_percentage_available_ignores_non_paid_orders(self): product = ProductFactory(maximum_total_order=10) OrderProductFactory(product=product, order__paid=False, amount=1) self.assertEqual(product.percentage_available, 100)
def test_is_available_when_no_max(self): product = ProductFactory(maximum_total_order=None) self.assertTrue(product.is_available)