plomlompom.com Git - plomtask/blob - tests/misc.py

   1 """Miscellaneous tests."""
   2 from unittest import TestCase
   3 from tests.utils import TestCaseWithServer
   4 from plomtask.http import InputsParser
   5 from plomtask.exceptions import BadFormatException
   6
   7
   8 class TestsSansServer(TestCase):
   9     """Tests that do not require DB setup or a server."""
  10
  11     def test_InputsParser_get_str_or_fail(self) -> None:
  12         """Test InputsParser.get_str."""
  13         parser = InputsParser({})
  14         with self.assertRaises(BadFormatException):
  15             parser.get_str_or_fail('foo')
  16         self.assertEqual('bar', parser.get_str_or_fail('foo', 'bar'))
  17         parser = InputsParser({'foo': []})
  18         with self.assertRaises(BadFormatException):
  19             parser.get_str_or_fail('foo')
  20         self.assertEqual('bar', parser.get_str_or_fail('foo', 'bar'))
  21         parser = InputsParser({'foo': ['baz']})
  22         self.assertEqual('baz', parser.get_str_or_fail('foo', 'bar'))
  23         parser = InputsParser({'foo': ['baz', 'quux']})
  24         self.assertEqual('baz', parser.get_str_or_fail('foo', 'bar'))
  25
  26     def test_InputsParser_get_str(self) -> None:
  27         """Test InputsParser.get_str."""
  28         parser = InputsParser({})
  29         self.assertEqual(None, parser.get_str('foo'))
  30         self.assertEqual('bar', parser.get_str('foo', 'bar'))
  31         parser = InputsParser({'foo': []})
  32         self.assertEqual(None, parser.get_str('foo'))
  33         self.assertEqual('bar', parser.get_str('foo', 'bar'))
  34         parser = InputsParser({'foo': ['baz']})
  35         self.assertEqual('baz', parser.get_str('foo', 'bar'))
  36         parser = InputsParser({'foo': ['baz', 'quux']})
  37         self.assertEqual('baz', parser.get_str('foo', 'bar'))
  38
  39     def test_InputsParser_get_all_of_key_prefixed(self) -> None:
  40         """Test InputsParser.get_all_of_key_prefixed."""
  41         parser = InputsParser({})
  42         self.assertEqual({},
  43                          parser.get_all_of_key_prefixed(''))
  44         self.assertEqual({},
  45                          parser.get_all_of_key_prefixed('foo'))
  46         parser = InputsParser({'foo': ['bar']})
  47         self.assertEqual({'foo': ['bar']},
  48                          parser.get_all_of_key_prefixed(''))
  49         parser = InputsParser({'x': ['y', 'z']})
  50         self.assertEqual({'': ['y', 'z']},
  51                          parser.get_all_of_key_prefixed('x'))
  52         parser = InputsParser({'xx': ['y', 'Z']})
  53         self.assertEqual({'x': ['y', 'Z']},
  54                          parser.get_all_of_key_prefixed('x'))
  55         parser = InputsParser({'xx': ['y']})
  56         self.assertEqual({},
  57                          parser.get_all_of_key_prefixed('xxx'))
  58         parser = InputsParser({'xxx': ['x'], 'xxy': ['y'], 'xyy': ['z']})
  59         self.assertEqual({'x': ['x'], 'y': ['y']},
  60                          parser.get_all_of_key_prefixed('xx'))
  61         parser = InputsParser({'xxx': ['x', 'y'], 'xxy': ['y', 'z']})
  62         self.assertEqual({'x': ['x', 'y'], 'y': ['y', 'z']},
  63                          parser.get_all_of_key_prefixed('xx'))
  64
  65     def test_InputsParser_get_int_or_none(self) -> None:
  66         """Test InputsParser.get_int_or_none."""
  67         parser = InputsParser({})
  68         self.assertEqual(None, parser.get_int_or_none('foo'))
  69         parser = InputsParser({'foo': []})
  70         self.assertEqual(None, parser.get_int_or_none('foo'))
  71         parser = InputsParser({'foo': ['']})
  72         self.assertEqual(None, parser.get_int_or_none('foo'))
  73         parser = InputsParser({'foo': ['0']})
  74         self.assertEqual(0, parser.get_int_or_none('foo'))
  75         with self.assertRaises(BadFormatException):
  76             InputsParser({'foo': ['None']}).get_int_or_none('foo')
  77         with self.assertRaises(BadFormatException):
  78             InputsParser({'foo': ['0.1']}).get_int_or_none('foo')
  79         parser = InputsParser({'foo': ['23']})
  80         self.assertEqual(23, parser.get_int_or_none('foo'))
  81
  82     def test_InputsParser_get_float_or_fail(self) -> None:
  83         """Test InputsParser.get_float_or_fail."""
  84         with self.assertRaises(BadFormatException):
  85             InputsParser({}).get_float_or_fail('foo')
  86         with self.assertRaises(BadFormatException):
  87             InputsParser({'foo': ['']}).get_float_or_fail('foo')
  88         with self.assertRaises(BadFormatException):
  89             InputsParser({'foo': ['bar']}).get_float_or_fail('foo')
  90         parser = InputsParser({'foo': ['0']})
  91         self.assertEqual(0, parser.get_float_or_fail('foo'))
  92         parser = InputsParser({'foo': ['0.1']})
  93         self.assertEqual(0.1, parser.get_float_or_fail('foo'))
  94         parser = InputsParser({'foo': ['1.23', '456']})
  95         self.assertEqual(1.23, parser.get_float_or_fail('foo'))
  96         with self.assertRaises(BadFormatException):
  97             InputsParser({}).get_float_or_fail('foo')
  98         with self.assertRaises(BadFormatException):
  99             InputsParser({'foo': []}).get_float_or_fail('foo')
 100
 101     def test_InputsParser_get_bool(self) -> None:
 102         """Test InputsParser.get_bool."""
 103         self.assertEqual(0, InputsParser({}).get_bool('foo'))
 104         self.assertEqual(0, InputsParser({'val': ['foo']}).get_bool('foo'))
 105         self.assertEqual(0, InputsParser({'val': ['True']}).get_bool('foo'))
 106         self.assertEqual(0, InputsParser({'foo': []}).get_bool('foo'))
 107         self.assertEqual(0, InputsParser({'foo': ['None']}).get_bool('foo'))
 108         self.assertEqual(0, InputsParser({'foo': ['0']}).get_bool('foo'))
 109         self.assertEqual(0, InputsParser({'foo': ['']}).get_bool('foo'))
 110         self.assertEqual(0, InputsParser({'foo': ['bar']}).get_bool('foo'))
 111         self.assertEqual(0, InputsParser({'foo': ['bar',
 112                                                   'baz']}).get_bool('foo'))
 113         self.assertEqual(0, InputsParser({'foo': ['False']}).get_bool('foo'))
 114         self.assertEqual(1, InputsParser({'foo': ['true']}).get_bool('foo'))
 115         self.assertEqual(1, InputsParser({'foo': ['True']}).get_bool('foo'))
 116         self.assertEqual(1, InputsParser({'foo': ['1']}).get_bool('foo'))
 117         self.assertEqual(1, InputsParser({'foo': ['on']}).get_bool('foo'))
 118
 119     def test_InputsParser_get_all_str(self) -> None:
 120         """Test InputsParser.get_all_str."""
 121         parser = InputsParser({})
 122         self.assertEqual([], parser.get_all_str('foo'))
 123         parser = InputsParser({'foo': []})
 124         self.assertEqual([], parser.get_all_str('foo'))
 125         parser = InputsParser({'foo': ['bar']})
 126         self.assertEqual(['bar'], parser.get_all_str('foo'))
 127         parser = InputsParser({'foo': ['bar', 'baz']})
 128         self.assertEqual(['bar', 'baz'], parser.get_all_str('foo'))
 129
 130     def test_InputsParser_get_all_int(self) -> None:
 131         """Test InputsParser.get_all_int."""
 132         parser = InputsParser({})
 133         self.assertEqual([], parser.get_all_int('foo'))
 134         parser = InputsParser({'foo': []})
 135         self.assertEqual([], parser.get_all_int('foo'))
 136         parser = InputsParser({'foo': ['']})
 137         parser.get_all_int('foo')
 138         with self.assertRaises(BadFormatException):
 139             parser.get_all_int('foo', fail_on_empty=True)
 140         parser = InputsParser({'foo': ['0']})
 141         self.assertEqual([0], parser.get_all_int('foo'))
 142         parser = InputsParser({'foo': ['0', '17']})
 143         self.assertEqual([0, 17], parser.get_all_int('foo'))
 144         parser = InputsParser({'foo': ['0.1', '17']})
 145         with self.assertRaises(BadFormatException):
 146             parser.get_all_int('foo')
 147         parser = InputsParser({'foo': ['None', '17']})
 148         with self.assertRaises(BadFormatException):
 149             parser.get_all_int('foo')
 150
 151
 152 class TestsWithServer(TestCaseWithServer):
 153     """Tests against our HTTP server/handler (and database)."""
 154
 155     def test_do_GET(self) -> None:
 156         """Test GET / redirect, and unknown targets failing."""
 157         self.conn.request('GET', '/')
 158         self.check_redirect('/day')
 159         self.check_get('/foo', 404)
 160
 161     def test_do_POST(self) -> None:
 162         """Test POST to / and other unknown targets failing."""
 163         self.check_post({}, '/', 404)
 164         self.check_post({}, '/foo', 404)