policies/*: remove Policy.negate, order, timeout (#39)

policies: rewrite engine to use PolicyBinding for order/negate/timeout
policies: rewrite engine to use PolicyResult instead of tuple

passbook/policies/tests/test_engine.py

@@ -5,7 +5,8 @@ from django.test import TestCase
 from passbook.core.models import User
 from passbook.policies.dummy.models import DummyPolicy
 from passbook.policies.engine import PolicyEngine
-from passbook.policies.models import Policy
+from passbook.policies.expression.models import ExpressionPolicy
+from passbook.policies.models import Policy, PolicyBinding, PolicyBindingModel
 
 
 class PolicyTestEngine(TestCase):
@@ -20,40 +21,64 @@ class PolicyTestEngine(TestCase):
         self.policy_true = DummyPolicy.objects.create(
             result=True, wait_min=0, wait_max=1
         )
-        self.policy_negate = DummyPolicy.objects.create(
-            negate=True, result=True, wait_min=0, wait_max=1
+        self.policy_wrong_type = Policy.objects.create(name="wrong_type")
+        self.policy_raises = ExpressionPolicy.objects.create(
+            name="raises", expression="{{ 0/0 }}"
         )
-        self.policy_raises = Policy.objects.create(name="raises")
 
     def test_engine_empty(self):
         """Ensure empty policy list passes"""
-        engine = PolicyEngine([], self.user)
-        self.assertEqual(engine.build().passing, True)
+        pbm = PolicyBindingModel.objects.create()
+        engine = PolicyEngine(pbm, self.user)
+        result = engine.build().result
+        self.assertEqual(result.passing, True)
+        self.assertEqual(result.messages, ())
 
     def test_engine(self):
         """Ensure all policies passes (Mix of false and true -> false)"""
-        engine = PolicyEngine(
-            DummyPolicy.objects.filter(negate__exact=False), self.user
-        )
-        self.assertEqual(engine.build().passing, False)
+        pbm = PolicyBindingModel.objects.create()
+        PolicyBinding.objects.create(target=pbm, policy=self.policy_false, order=0)
+        PolicyBinding.objects.create(target=pbm, policy=self.policy_true, order=1)
+        engine = PolicyEngine(pbm, self.user)
+        result = engine.build().result
+        self.assertEqual(result.passing, False)
+        self.assertEqual(result.messages, ("dummy",))
 
     def test_engine_negate(self):
         """Test negate flag"""
-        engine = PolicyEngine(DummyPolicy.objects.filter(negate__exact=True), self.user)
-        self.assertEqual(engine.build().passing, False)
+        pbm = PolicyBindingModel.objects.create()
+        PolicyBinding.objects.create(
+            target=pbm, policy=self.policy_true, negate=True, order=0
+        )
+        engine = PolicyEngine(pbm, self.user)
+        result = engine.build().result
+        self.assertEqual(result.passing, False)
+        self.assertEqual(result.messages, ("dummy",))
 
     def test_engine_policy_error(self):
-        """Test negate flag"""
-        engine = PolicyEngine(Policy.objects.filter(name="raises"), self.user)
-        self.assertEqual(engine.build().passing, False)
+        """Test policy raising an error flag"""
+        pbm = PolicyBindingModel.objects.create()
+        PolicyBinding.objects.create(target=pbm, policy=self.policy_raises, order=0)
+        engine = PolicyEngine(pbm, self.user)
+        result = engine.build().result
+        self.assertEqual(result.passing, False)
+        self.assertEqual(result.messages, ("division by zero",))
+
+    def test_engine_policy_type(self):
+        """Test invalid policy type"""
+        pbm = PolicyBindingModel.objects.create()
+        PolicyBinding.objects.create(target=pbm, policy=self.policy_wrong_type, order=0)
+        with self.assertRaises(TypeError):
+            engine = PolicyEngine(pbm, self.user)
+            engine.build()
 
     def test_engine_cache(self):
         """Ensure empty policy list passes"""
-        engine = PolicyEngine(
-            DummyPolicy.objects.filter(negate__exact=False), self.user
-        )
+        pbm = PolicyBindingModel.objects.create()
+        PolicyBinding.objects.create(target=pbm, policy=self.policy_false, order=0)
+        engine = PolicyEngine(pbm, self.user)
         self.assertEqual(len(cache.keys("policy_*")), 0)
         self.assertEqual(engine.build().passing, False)
-        self.assertEqual(len(cache.keys("policy_*")), 2)
+        self.assertEqual(len(cache.keys("policy_*")), 1)
         self.assertEqual(engine.build().passing, False)
-        self.assertEqual(len(cache.keys("policy_*")), 2)
+        self.assertEqual(len(cache.keys("policy_*")), 1)