Implement asset rules as Asset Group children objects

core/tests/trading/test_assetfilter.py

@@ -1,6 +1,6 @@
 from django.test import TestCase
 
-from core.models import AssetGroup, User
+from core.models import AssetGroup, AssetRule, User
 from core.trading import assetfilter
 
 
@@ -16,13 +16,18 @@ class AssetfilterTestCase(TestCase):
             description="Test group",
         )
 
-    def test_get_allowed_negative(self):
+    def test_get_allowed_prohibited(self):
         """
         Test that the asset filter works on negative aggregations.
         """
         # We have negative news about EUR
-        self.group.allowed = {"EUR": False}
-        self.group.save()
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=3,
+        )
+        self.asset_rule.save()
 
         # This means that:
         # * base == EUR: long is not allowed, short is allowed
@@ -41,13 +46,18 @@ class AssetfilterTestCase(TestCase):
         # Test that short on quote of EUR is not allowed
         self.assertFalse(assetfilter.get_allowed(self.group, "USD", "EUR", "short"))
 
-    def test_get_allowed_positive(self):
+    def test_get_allowed_permitted(self):
         """
         Test that the asset filter works on positive aggregations.
         """
         # We have positive news about EUR
-        self.group.allowed = {"EUR": True}
-        self.group.save()
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=2,
+        )
+        self.asset_rule.save()
 
         # This means that:
         # * base == EUR: long is allowed, short is not allowed
@@ -66,69 +76,188 @@ class AssetfilterTestCase(TestCase):
         # Test that long on quote of EUR is not allowed
         self.assertFalse(assetfilter.get_allowed(self.group, "USD", "EUR", "long"))
 
+    def test_get_allowed_no_data(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=0,
+        )
+        self.asset_rule.save()
+
+        self.assertTrue(assetfilter.get_allowed(self.group, "EUR", "USD", "long"))
+
+    def test_get_allowed_no_match(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=1,
+        )
+        self.asset_rule.save()
+
+        self.assertTrue(assetfilter.get_allowed(self.group, "EUR", "USD", "long"))
+
+    def test_get_allowed_no_aggregation(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=4,
+        )
+        self.asset_rule.save()
+
+        self.assertTrue(assetfilter.get_allowed(self.group, "EUR", "USD", "long"))
+
+    def test_get_allowed_not_in_bounds(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=5,
+        )
+        self.asset_rule.save()
+
+    def test_get_allowed_always_allow(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=6,
+        )
+        self.asset_rule.save()
+
+        self.assertTrue(assetfilter.get_allowed(self.group, "EUR", "USD", "long"))
+
+    def test_get_allowed_always_deny(self):
+        self.asset_rule = AssetRule.objects.create(
+            user=self.user,
+            group=self.group,
+            asset="EUR",
+            status=7,
+        )
+        self.asset_rule.save()
+
+        self.assertFalse(assetfilter.get_allowed(self.group, "EUR", "USD", "long"))
+
     def test_check_asset_aggregation(self):
         """
         Test that the asset aggregation works.
         """
         # Test within lower bound
-        self.assertTrue(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=None, trigger_below=2.0
-            )
+            ),
+            3,  # Prohibited
         )
 
         # Test within upper bound
-        self.assertTrue(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=0.0, trigger_below=None
-            )
+            ),
+            2,  # Permitted
         )
 
         # Test within bounds
-        self.assertTrue(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=0.0, trigger_below=2.0
-            )
-        )
-
-        # Test outside bounds
-        self.assertFalse(
-            assetfilter.check_asset_aggregation(
-                1.0, trigger_above=2.0, trigger_below=3.0
-            )
+            ),
+            3,  # Prohibited
         )
 
         # Test outside lower bound
-        self.assertFalse(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=None, trigger_below=0.0
-            )
+            ),
+            5,  # Not in bounds
         )
 
         # Test outside upper bound
-        self.assertFalse(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=2.0, trigger_below=None
-            )
+            ),
+            5,  # Not in bounds
         )
 
         # Test no bounds, just to be sure
-        self.assertFalse(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=None, trigger_below=None
-            )
+            ),
+            4,  # No aggregation
         )
 
         # Test both bounds, but inverted
-        self.assertFalse(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 1.0, trigger_above=2.0, trigger_below=0.0
-            )
+            ),
+            5,  # Not in bounds
         )
 
         # Test within negative and positive bounds
-        self.assertTrue(
+        self.assertEqual(
             assetfilter.check_asset_aggregation(
                 -1.0, trigger_above=-2.0, trigger_below=0.0
-            )
+            ),
+            3,  # Prohibited
+        )
+
+    def test_update_status_from_mappings_when_no_data(self):
+        self.group.when_no_data = 2  # Bullish
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(0, self.group),
+            2,  # Bullish
+        )
+
+    def test_update_status_from_mappings_when_no_match(self):
+        self.group.when_no_match = 2
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(1, self.group),
+            2,  # Bullish
+        )
+
+    def test_update_status_from_mappings_when_no_aggregation(self):
+        self.group.when_no_aggregation = 2
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(4, self.group),
+            2,  # Bullish
+        )
+
+    def test_update_status_from_mappings_when_not_in_bounds(self):
+        self.group.when_not_in_bounds = 2
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(5, self.group),
+            2,  # Bullish
+        )
+
+    def test_update_status_from_mappings_when_bullish(self):
+        self.group.when_bullish = 3  # Bearish
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(2, self.group),
+            3,  # Bearish
+        )
+
+    def test_update_status_from_mappings_when_bearish(self):
+        self.group.when_bearish = 2  # Bullish
+        self.group.save()
+
+        self.assertEqual(
+            assetfilter.update_status_from_mappings(3, self.group),
+            2,  # Bullish
         )