def test_should_export_product_rule_data(self):
# GIVEN
ProductBusinessRule.generate()
# WHEN
actual = ProductBusinessRule.get_rule_data()
# THEN
expected = self._get_rule_data()
self.assertDictEqual(actual, expected)
def test_form_should_update_rule(self):
# GIVEN
ProductBusinessRule.generate()
update_data = {'rules': '{"key1": "value1"}'}
# WHEN
response = self.client.post(reverse(
'django_business_rules:business-rule-form', kwargs={'pk': 1}),
data=update_data)
# THEN
self.assertEqual(response.status_code, 302, response.content)
self.assertEqual(ProductBusinessRule.get_rules(), {'key1': 'value1'})
def test_should_use_correct_template_to_render_business_rule_form(self):
# GIVEN
ProductBusinessRule.generate()
# WHEN
response = self.client.post(
# not the best idea to put '1'
# but no other idea how to do it without using model
reverse('dbr:business-rule-form', kwargs={'pk': 1}))
# THEN
self.assertEqual(response.status_code, 200, response.content)
self.assertTemplateUsed(
response, 'django_business_rules/business_rule_form.html')
def test_should_save_rule_in_database(self):
# GIVEN
with self.assertRaises(BusinessRuleModel.DoesNotExist):
ProductBusinessRule.get_rule_data()
out = StringIO()
try:
# WHEN
call_command(self.COMMAND_NAME, verbosity=2, stdout=out)
# THEN
self.assertEqual(self._get_rule_data(),
ProductBusinessRule.get_rule_data())
except Exception:
self._print_output(out)
raise
def _assert_rule_executed(self, product_for_order, product_not_for_order):
mommy.make(ProductOrder,
product=product_for_order,
expiration_date=datetime.datetime.now() +
timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_order,
expiration_date=datetime.datetime.now() +
timezone.timedelta(days=4))
self.assertFalse(
ProductOrder.objects.filter(product=product_for_order,
quantity=40).exists())
self.assertFalse(
ProductOrder.objects.filter(product=product_not_for_order,
quantity=40).exists())
ProductBusinessRule.generate()
ProductBusinessRule.save_rules(self._get_rules())
# WHEN
for product in Product.objects.all():
ProductBusinessRule.run_all(product)
# THEN
self.assertTrue(
ProductOrder.objects.filter(product=product_for_order,
quantity=40).exists())
self.assertFalse(
ProductOrder.objects.filter(product=product_not_for_order,
quantity=40).exists())
def test_should_execute_rules_1(self):
# GIVEN
product_for_sale = mommy.make(Product, current_inventory=21, price=200)
product_not_for_sale_1 = mommy.make(Product,
current_inventory=20,
price=200)
product_not_for_sale_2 = mommy.make(Product,
current_inventory=21,
price=200)
mommy.make(ProductOrder,
product=product_for_sale,
expiration_date=timezone.now() + timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_sale_1,
expiration_date=timezone.now() + timezone.timedelta(days=4))
mommy.make(ProductOrder,
product=product_not_for_sale_2,
expiration_date=timezone.now() + timezone.timedelta(days=5))
ProductBusinessRule.generate()
ProductBusinessRule.save_rules(self._get_rules())
# WHEN
for product in Product.objects.all():
ProductBusinessRule.run_all(product)
# THEN
product_for_sale.refresh_from_db()
product_not_for_sale_1.refresh_from_db()
product_not_for_sale_2.refresh_from_db()
self.assertEqual(product_for_sale.price, 150)
self.assertEqual(product_not_for_sale_1.price, 200)
self.assertEqual(product_not_for_sale_2.price, 200)
def execute_product_business_rules(sender, instance, **kwargs):
ProductBusinessRule.run_all(instance)