X-Git-Url: https://plomlompom.com/repos/%7B%7Bprefix%7D%7D/ledger2?a=blobdiff_plain;ds=sidebyside;f=tests%2Fmisc.py;h=a27f0d0a1f8c0a3330be0e6c6906e3a7d6d53fd2;hb=refs%2Fheads%2Fmaster;hp=87b3a6e1bc53099e195d1a97ec5fafea3a867035;hpb=8bbb9ac156bdca7b9dd015b62db3f07f1e7a9e17;p=plomtask

diff --git a/tests/misc.py b/tests/misc.py
index 87b3a6e..a6df2e5 100644
--- a/tests/misc.py
+++ b/tests/misc.py
@@ -1,108 +1,159 @@
 """Miscellaneous tests."""
 from unittest import TestCase
 from tests.utils import TestCaseWithServer
-from plomtask.http import ParamsParser, PostvarsParser
+from plomtask.http import InputsParser
 from plomtask.exceptions import BadFormatException
 
 
 class TestsSansServer(TestCase):
     """Tests that do not require DB setup or a server."""
 
-    def test_params_parser(self) -> None:
-        """Test behavior of ParamsParser."""
-        self.assertEqual('',
-                         ParamsParser({}).get_str('foo'))
-        self.assertEqual('bar',
-                         ParamsParser({}).get_str('foo', 'bar'))
-        self.assertEqual('bar',
-                         ParamsParser({'foo': []}).get_str('foo', 'bar'))
-        self.assertEqual('baz',
-                         ParamsParser({'foo': ['baz']}).get_str('foo', 'bar'))
-        self.assertEqual(None,
-                         ParamsParser({}).get_int_or_none('foo'))
-        self.assertEqual(None,
-                         ParamsParser({'foo': []}).get_int_or_none('foo'))
-        self.assertEqual(None,
-                         ParamsParser({'foo': ['']}).get_int_or_none('foo'))
-        self.assertEqual(0,
-                         ParamsParser({'foo': ['0']}).get_int_or_none('foo'))
+    def test_InputsParser_get_str_or_fail(self) -> None:
+        """Test InputsParser.get_str."""
+        parser = InputsParser({})
         with self.assertRaises(BadFormatException):
-            ParamsParser({'foo': ['None']}).get_int_or_none('foo')
+            parser.get_str_or_fail('foo')
+        self.assertEqual('bar', parser.get_str_or_fail('foo', 'bar'))
+        parser = InputsParser({'foo': []})
         with self.assertRaises(BadFormatException):
-            ParamsParser({'foo': ['0.1']}).get_int_or_none('foo')
-        self.assertEqual(23,
-                         ParamsParser({'foo': ['23']}).get_int_or_none('foo'))
+            parser.get_str_or_fail('foo')
+        self.assertEqual('bar', parser.get_str_or_fail('foo', 'bar'))
+        parser = InputsParser({'foo': ['baz']})
+        self.assertEqual('baz', parser.get_str_or_fail('foo', 'bar'))
+        parser = InputsParser({'foo': ['baz', 'quux']})
+        self.assertEqual('baz', parser.get_str_or_fail('foo', 'bar'))
 
-    def test_postvars_parser(self) -> None:
-        """Test behavior of PostvarsParser."""
-        self.assertEqual([],
-                         PostvarsParser({}).get_all_str('foo'))
-        self.assertEqual([],
-                         PostvarsParser({'foo': []}).get_all_str('foo'))
-        self.assertEqual(['bar'],
-                         PostvarsParser({'foo': ['bar']}).get_all_str('foo'))
-        self.assertEqual(['bar', 'baz'],
-                         PostvarsParser({'foo': ['bar', 'baz']}).
-                         get_all_str('foo'))
-        self.assertEqual([],
-                         PostvarsParser({}).get_all_int('foo'))
-        self.assertEqual([],
-                         PostvarsParser({'foo': []}).get_all_int('foo'))
-        self.assertEqual([],
-                         PostvarsParser({'foo': ['']}).get_all_int('foo'))
-        self.assertEqual([0],
-                         PostvarsParser({'foo': ['0']}).get_all_int('foo'))
-        self.assertEqual([0, 17],
-                         PostvarsParser({'foo': ['0', '17']}).
-                         get_all_int('foo'))
-        with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['0.1', '17']}).get_all_int('foo')
-        with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['None', '17']}).get_all_int('foo')
-        with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_str('foo')
+    def test_InputsParser_get_str(self) -> None:
+        """Test InputsParser.get_str."""
+        parser = InputsParser({})
+        self.assertEqual(None, parser.get_str('foo'))
+        self.assertEqual('bar', parser.get_str('foo', 'bar'))
+        parser = InputsParser({'foo': []})
+        self.assertEqual(None, parser.get_str('foo'))
+        self.assertEqual('bar', parser.get_str('foo', 'bar'))
+        parser = InputsParser({'foo': ['baz']})
+        self.assertEqual('baz', parser.get_str('foo', 'bar'))
+        parser = InputsParser({'foo': ['baz', 'quux']})
+        self.assertEqual('baz', parser.get_str('foo', 'bar'))
+
+    def test_InputsParser_get_all_of_key_prefixed(self) -> None:
+        """Test InputsParser.get_all_of_key_prefixed."""
+        parser = InputsParser({})
+        self.assertEqual({},
+                         parser.get_all_of_key_prefixed(''))
+        self.assertEqual({},
+                         parser.get_all_of_key_prefixed('foo'))
+        parser = InputsParser({'foo': ['bar']})
+        self.assertEqual({'foo': ['bar']},
+                         parser.get_all_of_key_prefixed(''))
+        parser = InputsParser({'x': ['y', 'z']})
+        self.assertEqual({'': ['y', 'z']},
+                         parser.get_all_of_key_prefixed('x'))
+        parser = InputsParser({'xx': ['y', 'Z']})
+        self.assertEqual({'x': ['y', 'Z']},
+                         parser.get_all_of_key_prefixed('x'))
+        parser = InputsParser({'xx': ['y']})
+        self.assertEqual({},
+                         parser.get_all_of_key_prefixed('xxx'))
+        parser = InputsParser({'xxx': ['x'], 'xxy': ['y'], 'xyy': ['z']})
+        self.assertEqual({'x': ['x'], 'y': ['y']},
+                         parser.get_all_of_key_prefixed('xx'))
+        parser = InputsParser({'xxx': ['x', 'y'], 'xxy': ['y', 'z']})
+        self.assertEqual({'x': ['x', 'y'], 'y': ['y', 'z']},
+                         parser.get_all_of_key_prefixed('xx'))
+
+    def test_InputsParser_get_int_or_none(self) -> None:
+        """Test InputsParser.get_int_or_none."""
+        parser = InputsParser({})
+        self.assertEqual(None, parser.get_int_or_none('foo'))
+        parser = InputsParser({'foo': []})
+        self.assertEqual(None, parser.get_int_or_none('foo'))
+        parser = InputsParser({'foo': ['']})
+        self.assertEqual(None, parser.get_int_or_none('foo'))
+        parser = InputsParser({'foo': ['0']})
+        self.assertEqual(0, parser.get_int_or_none('foo'))
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_str('foo')
-        self.assertEqual('bar',
-                         PostvarsParser({'foo': ['bar']}).get_str('foo'))
-        self.assertEqual('',
-                         PostvarsParser({'foo': ['', 'baz']}).get_str('foo'))
+            InputsParser({'foo': ['None']}).get_int_or_none('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_int('foo')
+            InputsParser({'foo': ['0.1']}).get_int_or_none('foo')
+        parser = InputsParser({'foo': ['23']})
+        self.assertEqual(23, parser.get_int_or_none('foo'))
+
+    def test_InputsParser_get_float_or_fail(self) -> None:
+        """Test InputsParser.get_float_or_fail."""
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_int('foo')
+            InputsParser({}).get_float_or_fail('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['']}).get_int('foo')
+            InputsParser({'foo': ['']}).get_float_or_fail('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['bar']}).get_int('foo')
+            InputsParser({'foo': ['bar']}).get_float_or_fail('foo')
+        parser = InputsParser({'foo': ['0']})
+        self.assertEqual(0, parser.get_float_or_fail('foo'))
+        parser = InputsParser({'foo': ['0.1']})
+        self.assertEqual(0.1, parser.get_float_or_fail('foo'))
+        parser = InputsParser({'foo': ['1.23', '456']})
+        self.assertEqual(1.23, parser.get_float_or_fail('foo'))
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['0.1']}).get_int('foo')
-        self.assertEqual(0,
-                         PostvarsParser({'foo': ['0']}).get_int('foo'))
-        self.assertEqual(17,
-                         PostvarsParser({'foo': ['17', '23']}).get_int('foo'))
+            InputsParser({}).get_float_or_fail('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_float('foo')
+            InputsParser({'foo': []}).get_float_or_fail('foo')
+
+    def test_InputsParser_get_bool(self) -> None:
+        """Test InputsParser.get_bool."""
+        self.assertEqual(0, InputsParser({}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'val': ['foo']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'val': ['True']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': []}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['None']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['0']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['bar']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['bar',
+                                                  'baz']}).get_bool('foo'))
+        self.assertEqual(0, InputsParser({'foo': ['False']}).get_bool('foo'))
+        self.assertEqual(1, InputsParser({'foo': ['true']}).get_bool('foo'))
+        self.assertEqual(1, InputsParser({'foo': ['True']}).get_bool('foo'))
+        self.assertEqual(1, InputsParser({'foo': ['1']}).get_bool('foo'))
+        self.assertEqual(1, InputsParser({'foo': ['on']}).get_bool('foo'))
+
+    def test_InputsParser_get_all_str(self) -> None:
+        """Test InputsParser.get_all_str."""
+        parser = InputsParser({})
+        self.assertEqual([], parser.get_all_str('foo'))
+        parser = InputsParser({'foo': []})
+        self.assertEqual([], parser.get_all_str('foo'))
+        parser = InputsParser({'foo': ['bar']})
+        self.assertEqual(['bar'], parser.get_all_str('foo'))
+        parser = InputsParser({'foo': ['bar', 'baz']})
+        self.assertEqual(['bar', 'baz'], parser.get_all_str('foo'))
+
+    def test_InputsParser_get_all_int(self) -> None:
+        """Test InputsParser.get_all_int."""
+        parser = InputsParser({})
+        self.assertEqual([], parser.get_all_int('foo'))
+        parser = InputsParser({'foo': []})
+        self.assertEqual([], parser.get_all_int('foo'))
+        parser = InputsParser({'foo': ['']})
+        parser.get_all_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_float('foo')
+            parser.get_all_int('foo', fail_on_empty=True)
+        parser = InputsParser({'foo': ['0']})
+        self.assertEqual([0], parser.get_all_int('foo'))
+        parser = InputsParser({'foo': ['0', '17']})
+        self.assertEqual([0, 17], parser.get_all_int('foo'))
+        parser = InputsParser({'foo': ['0.1', '17']})
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['']}).get_float('foo')
+            parser.get_all_int('foo')
+        parser = InputsParser({'foo': ['None', '17']})
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['bar']}).get_float('foo')
-        self.assertEqual(0,
-                         PostvarsParser({'foo': ['0']}).get_float('foo'))
-        self.assertEqual(0.1,
-                         PostvarsParser({'foo': ['0.1']}).get_float('foo'))
-        self.assertEqual(1.23,
-                         PostvarsParser({'foo': ['1.23', '456']}).
-                         get_float('foo'))
+            parser.get_all_int('foo')
 
 
 class TestsWithServer(TestCaseWithServer):
     """Tests against our HTTP server/handler (and database)."""
 
     def test_do_GET(self) -> None:
-        """Test / redirect, and unknown targets failing."""
+        """Test GET / redirect, and unknown targets failing."""
         self.conn.request('GET', '/')
         self.check_redirect('/day')
         self.check_get('/foo', 404)