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_firsts_of_key_prefixed(self) -> None:
  40         """Test InputsParser.get_firsts_of_key_prefixed."""
  41         parser = InputsParser({})
  42         self.assertEqual({},
  43                          parser.get_firsts_of_key_prefixed(''))
  44         self.assertEqual({},
  45                          parser.get_firsts_of_key_prefixed('foo'))
  46         parser = InputsParser({'foo': ['bar']})
  47         self.assertEqual({'foo': 'bar'},
  48                          parser.get_firsts_of_key_prefixed(''))
  49         parser = InputsParser({'x': ['y']})
  50         self.assertEqual({'x': 'y'},
  51                          parser.get_firsts_of_key_prefixed('x'))
  52         parser = InputsParser({'xx': ['y']})
  53         self.assertEqual({'xx': 'y'},
  54                          parser.get_firsts_of_key_prefixed('x'))
  55         parser = InputsParser({'xx': ['y']})
  56         self.assertEqual({},
  57                          parser.get_firsts_of_key_prefixed('xxx'))
  58         parser = InputsParser({'xxx': ['x'], 'xxy': ['y'], 'xyy': ['z']})
  59         self.assertEqual({'xxx': 'x', 'xxy': 'y'},
  60                          parser.get_firsts_of_key_prefixed('xx'))
  61         parser = InputsParser({'xxx': ['x', 'y', 'z'], 'xxy': ['y', 'z']})
  62         self.assertEqual({'xxx': 'x', 'xxy': 'y'},
  63                          parser.get_firsts_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_or_none(self) -> None:
 102         """Test InputsParser.get_all_str."""
 103         parser = InputsParser({})
 104         self.assertEqual(None, parser.get_bool_or_none('foo'))
 105         parser = InputsParser({'val': ['foo']})
 106         self.assertEqual(None, parser.get_bool_or_none('foo'))
 107         parser = InputsParser({'val': ['True']})
 108         self.assertEqual(None, parser.get_bool_or_none('foo'))
 109         parser = InputsParser({'foo': []})
 110         self.assertEqual(None, parser.get_bool_or_none('foo'))
 111         parser = InputsParser({'foo': ['None']})
 112         self.assertEqual(False, parser.get_bool_or_none('foo'))
 113         parser = InputsParser({'foo': ['0']})
 114         self.assertEqual(False, parser.get_bool_or_none('foo'))
 115         parser = InputsParser({'foo': ['']})
 116         self.assertEqual(False, parser.get_bool_or_none('foo'))
 117         parser = InputsParser({'foo': ['bar']})
 118         self.assertEqual(False, parser.get_bool_or_none('foo'))
 119         parser = InputsParser({'foo': ['bar', 'baz']})
 120         self.assertEqual(False, parser.get_bool_or_none('foo'))
 121         parser = InputsParser({'foo': ['False']})
 122         self.assertEqual(False, parser.get_bool_or_none('foo'))
 123         parser = InputsParser({'foo': ['true']})
 124         self.assertEqual(True, parser.get_bool_or_none('foo'))
 125         parser = InputsParser({'foo': ['True']})
 126         self.assertEqual(True, parser.get_bool_or_none('foo'))
 127         parser = InputsParser({'foo': ['1']})
 128         self.assertEqual(True, parser.get_bool_or_none('foo'))
 129         parser = InputsParser({'foo': ['on']})
 130         self.assertEqual(True, parser.get_bool_or_none('foo'))
 131
 132     def test_InputsParser_get_all_str(self) -> None:
 133         """Test InputsParser.get_all_str."""
 134         parser = InputsParser({})
 135         self.assertEqual([], parser.get_all_str('foo'))
 136         parser = InputsParser({'foo': []})
 137         self.assertEqual([], parser.get_all_str('foo'))
 138         parser = InputsParser({'foo': ['bar']})
 139         self.assertEqual(['bar'], parser.get_all_str('foo'))
 140         parser = InputsParser({'foo': ['bar', 'baz']})
 141         self.assertEqual(['bar', 'baz'], parser.get_all_str('foo'))
 142
 143     def test_InputsParser_strict_get_all_int(self) -> None:
 144         """Test InputsParser.get_all_int."""
 145         parser = InputsParser({})
 146         self.assertEqual([], parser.get_all_int('foo'))
 147         parser = InputsParser({'foo': []})
 148         self.assertEqual([], parser.get_all_int('foo'))
 149         parser = InputsParser({'foo': ['']})
 150         self.assertEqual([], parser.get_all_int('foo'))
 151         parser = InputsParser({'foo': ['0']})
 152         self.assertEqual([0], parser.get_all_int('foo'))
 153         parser = InputsParser({'foo': ['0', '17']})
 154         self.assertEqual([0, 17], parser.get_all_int('foo'))
 155         parser = InputsParser({'foo': ['0.1', '17']})
 156         with self.assertRaises(BadFormatException):
 157             parser.get_all_int('foo')
 158         parser = InputsParser({'foo': ['None', '17']})
 159         with self.assertRaises(BadFormatException):
 160             parser.get_all_int('foo')
 161
 162
 163 class TestsWithServer(TestCaseWithServer):
 164     """Tests against our HTTP server/handler (and database)."""
 165
 166     def test_do_GET(self) -> None:
 167         """Test GET / redirect, and unknown targets failing."""
 168         self.conn.request('GET', '/')
 169         self.check_redirect('/day')
 170         self.check_get('/foo', 404)
 171
 172     def test_do_POST(self) -> None:
 173         """Test POST to / and other unknown targets failing."""
 174         self.check_post({}, '/', 404)
 175         self.check_post({}, '/foo', 404)