Tests for evennia/utils/validatorfuncs.

- future()
- signed_integer()
- positive_integer()
- unsigned_integer()
- boolean
- timezone
- email
- lock

evennia/utils/tests/test_validatorfuncs.py

@@ -4,6 +4,7 @@ from django.test import TestCase
 from evennia.utils import validatorfuncs
 import mock
 import datetime
+import pytz
 
 
 class TestValidatorFuncs(TestCase):
@@ -15,9 +16,7 @@ class TestValidatorFuncs(TestCase):
     @mock.patch('builtins.str')
     def test_text_raises_ValueError(self, mocked_str):
         mocked_str.side_effect = Exception
-        with self.assertRaises(
-                ValueError,
-                msg='Input could not be converted to text (Exception)'):
+        with self.assertRaises(ValueError):
             validatorfuncs.text(None)
 
     def test_color_ok(self):
@@ -26,20 +25,18 @@ class TestValidatorFuncs(TestCase):
 
     def test_color_falsy_raises_ValueError(self):
         for color in [None, (), [], False, True, {}]:
-            with self.assertRaises(
-                    ValueError,
-                    msg=f'(color) is not valid Color.'):
+            with self.assertRaises(ValueError):
                 validatorfuncs.color(color)
 
     def test_datetime_ok(self):
-        for dt in ['Jan 2 12:00', 'Dec 31 00:00 2018']:
-            self.assertTrue(isinstance(validatorfuncs.datetime(dt), datetime.datetime))
+        for dt in ['Oct 12 1:00 1492', 'Jan 2 12:00 2020', 'Dec 31 00:00 2018']:
+            self.assertTrue(
+                isinstance(validatorfuncs.datetime(dt, from_tz=pytz.UTC),
+                datetime.datetime))
 
     def test_datetime_raises_ValueError(self):
         for dt in ['', 'January 1, 2019', '1/1/2019', 'Jan 1 2019']:
-            with self.assertRaises(
-                    ValueError,
-                    msg='Date must be entered in a 24-hr format such as: '):
+            with self.assertRaises(ValueError):
                 validatorfuncs.datetime(dt)
 
     def test_duration_ok(self):
@@ -54,7 +51,89 @@ class TestValidatorFuncs(TestCase):
 
     def test_duration_raises_ValueError(self):
         for d in ['', '1', '5days', '1Week']:
-            with self.assertRaises(
-                    ValueError,
-                    msg=f"Could not convert section 'd' to Duration."):
+            with self.assertRaises(ValueError):
                 validatorfuncs.duration(d)
+
+    def test_future_ok(self):
+        year = int(datetime.datetime.utcnow().strftime("%Y"))
+        for f in [f'Jan 2 12:00 {year+1}', f'Dec 31 00:00 {year+1}']:
+            self.assertTrue(
+                isinstance(validatorfuncs.future(f, from_tz=pytz.UTC),
+                datetime.timedelta))
+
+    def test_future_raises_ValueError(self):
+        year = int(datetime.datetime.utcnow().strftime("%Y"))
+        for f in [f'Jan 2 12:00 {year-1}', f'Dec 31 00:00 {year-1}']:
+            with self.assertRaises(ValueError):
+                validatorfuncs.future(f, from_tz=pytz.UTC)
+
+    def test_signed_integer_ok(self):
+        for si in ['123', '4567890', '001', '-123', '-45', '0']:
+          self.assertEqual(int(si), validatorfuncs.signed_integer(si))
+
+    @mock.patch('builtins.int')
+    def test_signed_integer_raises_ValueError(self, mocked_int):
+        for si in ['', '000', 'abc']:
+            mocked_int.side_effect = ValueError
+            with self.assertRaises(ValueError):
+                validatorfuncs.signed_integer(si)
+
+    def test_positive_integer_ok(self):
+        for pi in ['123', '4567890', '001']:
+          self.assertEqual(int(pi), validatorfuncs.positive_integer(pi))
+
+    @mock.patch('builtins.int')
+    def test_positive_integer_raises_ValueError(self, mocked_int):
+        for pi in ['', '000', 'abc', '-1']:
+            mocked_int.side_effect = ValueError
+            with self.assertRaises(ValueError):
+                validatorfuncs.positive_integer(pi)
+        
+    def test_unsigned_integer_ok(self):
+        for ui in ['123', '4567890', '001']:
+          self.assertEqual(int(ui), validatorfuncs.unsigned_integer(ui))
+
+    @mock.patch('builtins.int')
+    def test_unsigned_integer_raises_ValueError(self, mocked_int):
+        for ui in ['', '000', 'abc', '-1', '0']:
+            mocked_int.side_effect = ValueError
+            with self.assertRaises(ValueError):
+                validatorfuncs.signed_integer(ui)
+
+    def test_boolean(self):
+        for b in ['true', '1', 'on', 'ENABLED']:
+            self.assertTrue(validatorfuncs.boolean(b))
+        for b in ['FalSe', '0', 'oFF', 'disabled']:
+            self.assertFalse(validatorfuncs.boolean(b))
+
+    def test_boolean_raises_ValueError(self):
+        for b in ['', None, 1, 0, True, False, [None], {True:True}]:
+            with self.assertRaises(ValueError):
+                validatorfuncs.boolean(b)
+
+    def test_timezone_ok(self):
+        for tz in ['America/Chicago', 'GMT', 'UTC']:
+            self.assertEqual(tz, validatorfuncs.timezone(tz).zone)
+
+    def test_timezone_raises_ValueError(self):
+        for tz in ['America', None, '', 'Mars', 'DT']:
+            with self.assertRaises(ValueError):
+                validatorfuncs.timezone(tz)
+
+    def test_email_ok(self):
+        for e in ['a@a.aa', 'zeus@olympus.net']:
+            self.assertEqual(e, validatorfuncs.email(e))
+
+    def test_email_raises_ValueError(self):
+        for e in ['', None, ['abc@abc.com'], 123]:
+            with self.assertRaises(ValueError):
+                validatorfuncs.email(e)
+
+    def test_lock_ok(self):
+        for l in ['do:true;look:no', 'a:t']:
+            self.assertEqual(l, validatorfuncs.lock(l))
+
+    def test_lock_raises_ValueError(self):
+        for l in [';;;', '', ':', ':::', ';:;:']:
+            with self.assertRaises(ValueError):
+                validatorfuncs.lock(l)