Unify ParamsParser and PostvarsParser to InputsParser.

[plomtask] / tests / misc.py

diff --git a/tests/misc.py b/tests/misc.py
index 87b3a6e1bc53099e195d1a97ec5fafea3a867035..d49870fcce0a81179e03461e48bb5b1bb570cae9 100644 (file)
--- a/tests/misc.py
+++ b/tests/misc.py
@@ -1,100 +1,100 @@
 """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_non_strict(self) -> None:
+        """Test behavior of non-strict (= params) InputsParser."""
+        params = InputsParser({}, False)
+        self.assertEqual('', params.get_str('foo'))
+        params = InputsParser({}, False)
+        self.assertEqual('bar', params.get_str('foo', 'bar'))
+        params = InputsParser({'foo': []}, False)
+        self.assertEqual('bar', params.get_str('foo', 'bar'))
+        params = InputsParser({'foo': ['baz']}, False)
+        self.assertEqual('baz', params.get_str('foo', 'bar'))
+        params = InputsParser({}, False)
+        self.assertEqual(None, params.get_int_or_none('foo'))
+        params = InputsParser({'foo': []}, False)
+        self.assertEqual(None, params.get_int_or_none('foo'))
+        params = InputsParser({'foo': ['']}, False)
+        self.assertEqual(None, params.get_int_or_none('foo'))
+        params = InputsParser({'foo': ['0']}, False)
+        self.assertEqual(0, params.get_int_or_none('foo'))
         with self.assertRaises(BadFormatException):
-            ParamsParser({'foo': ['None']}).get_int_or_none('foo')
+            InputsParser({'foo': ['None']}, False).get_int_or_none('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'))
+            InputsParser({'foo': ['0.1']}, False).get_int_or_none('foo')
+        params = InputsParser({'foo': ['23']}, False)
+        self.assertEqual(23, params.get_int_or_none('foo'))
 
-    def test_postvars_parser(self) -> None:
-        """Test behavior of PostvarsParser."""
+    def test_InputsParser_strict(self) -> None:
+        """Test behavior of strict (= postvars) InputsParser."""
         self.assertEqual([],
-                         PostvarsParser({}).get_all_str('foo'))
+                         InputsParser({}).get_all_str('foo'))
         self.assertEqual([],
-                         PostvarsParser({'foo': []}).get_all_str('foo'))
+                         InputsParser({'foo': []}).get_all_str('foo'))
         self.assertEqual(['bar'],
-                         PostvarsParser({'foo': ['bar']}).get_all_str('foo'))
+                         InputsParser({'foo': ['bar']}).get_all_str('foo'))
         self.assertEqual(['bar', 'baz'],
-                         PostvarsParser({'foo': ['bar', 'baz']}).
+                         InputsParser({'foo': ['bar', 'baz']}).
                          get_all_str('foo'))
         self.assertEqual([],
-                         PostvarsParser({}).get_all_int('foo'))
+                         InputsParser({}).get_all_int('foo'))
         self.assertEqual([],
-                         PostvarsParser({'foo': []}).get_all_int('foo'))
+                         InputsParser({'foo': []}).get_all_int('foo'))
         self.assertEqual([],
-                         PostvarsParser({'foo': ['']}).get_all_int('foo'))
+                         InputsParser({'foo': ['']}).get_all_int('foo'))
         self.assertEqual([0],
-                         PostvarsParser({'foo': ['0']}).get_all_int('foo'))
+                         InputsParser({'foo': ['0']}).get_all_int('foo'))
         self.assertEqual([0, 17],
-                         PostvarsParser({'foo': ['0', '17']}).
+                         InputsParser({'foo': ['0', '17']}).
                          get_all_int('foo'))
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['0.1', '17']}).get_all_int('foo')
+            InputsParser({'foo': ['0.1', '17']}).get_all_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['None', '17']}).get_all_int('foo')
+            InputsParser({'foo': ['None', '17']}).get_all_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_str('foo')
+            InputsParser({}).get_str('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_str('foo')
+            InputsParser({'foo': []}).get_str('foo')
         self.assertEqual('bar',
-                         PostvarsParser({'foo': ['bar']}).get_str('foo'))
+                         InputsParser({'foo': ['bar']}).get_str('foo'))
         self.assertEqual('',
-                         PostvarsParser({'foo': ['', 'baz']}).get_str('foo'))
+                         InputsParser({'foo': ['', 'baz']}).get_str('foo'))
         with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_int('foo')
+            InputsParser({}).get_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_int('foo')
+            InputsParser({'foo': []}).get_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['']}).get_int('foo')
+            InputsParser({'foo': ['']}).get_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['bar']}).get_int('foo')
+            InputsParser({'foo': ['bar']}).get_int('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['0.1']}).get_int('foo')
+            InputsParser({'foo': ['0.1']}).get_int('foo')
         self.assertEqual(0,
-                         PostvarsParser({'foo': ['0']}).get_int('foo'))
+                         InputsParser({'foo': ['0']}).get_int('foo'))
         self.assertEqual(17,
-                         PostvarsParser({'foo': ['17', '23']}).get_int('foo'))
+                         InputsParser({'foo': ['17', '23']}).get_int('foo'))
         with self.assertRaises(BadFormatException):
-            PostvarsParser({}).get_float('foo')
+            InputsParser({}).get_float('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': []}).get_float('foo')
+            InputsParser({'foo': []}).get_float('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['']}).get_float('foo')
+            InputsParser({'foo': ['']}).get_float('foo')
         with self.assertRaises(BadFormatException):
-            PostvarsParser({'foo': ['bar']}).get_float('foo')
+            InputsParser({'foo': ['bar']}).get_float('foo')
         self.assertEqual(0,
-                         PostvarsParser({'foo': ['0']}).get_float('foo'))
+                         InputsParser({'foo': ['0']}).get_float('foo'))
         self.assertEqual(0.1,
-                         PostvarsParser({'foo': ['0.1']}).get_float('foo'))
+                         InputsParser({'foo': ['0.1']}).get_float('foo'))
         self.assertEqual(1.23,
-                         PostvarsParser({'foo': ['1.23', '456']}).
+                         InputsParser({'foo': ['1.23', '456']}).
                          get_float('foo'))