encadre

Encadre, petit framework web Python (Flask) : contrôleurs en greffons, validation, tests
git clone https://git.schurger.org/encadre.git
Log | Files | Refs

__init__.py (4623B)


      1 import unittest
      2 import random
      3 from encadre import Controller, validate
      4 
      5 
      6 class Hello(Controller):
      7     """ A very polite controller """
      8 
      9     def index__(self):
     10         """ Says hello ! """
     11         return "Hello world"
     12 
     13     def test_index__(self):
     14         self.assertTrue(self.index__() == "Hello world")
     15 
     16     def config(self):
     17         """ Dump the config """
     18         from encadre import config
     19         return config
     20 
     21     def test_config(self):
     22         from encadre import config
     23         k = 'test_%s' % random.randint(0, 1000)
     24         v = random.randint(0, 1000)
     25         config.update({k: v})
     26         self.assertTrue(self.config()[k] == v)
     27 
     28     @validate({
     29         'title': 'Dummy test',
     30         'type': 'object',
     31         'properties': {
     32             'numbers': {
     33                 'description': "We want an array of numbers",
     34                 'type': 'array',
     35                 'items': {
     36                     'type': 'integer'
     37                 },
     38                 'minItems': 1
     39             }
     40         },
     41         'required': ['numbers']
     42     })
     43     def i_am_validated_POST(self):
     44         from encadre import request
     45         return request.json
     46 
     47     def test_i_am_validated_POST(self):
     48         from encadre import request
     49         request.json = {'numbers': [1, 2]}
     50         self.assertTrue(self.i_am_validated_POST() == {
     51             'numbers': [1, 2]})
     52 
     53     @validate({
     54         'title': 'Dummy test',
     55         'type': 'object',
     56         'properties': {
     57             'numbers': {
     58                 'description': "We want an array of numbers",
     59                 'type': 'array',
     60                 'items': {
     61                     'type': 'integer'
     62                 },
     63                 'minItems': 1
     64             }
     65         },
     66         'required': ['numbers']
     67     })
     68     def i_will_not_pass_validation_POST(self):
     69         from encadre import request
     70         return request.json
     71 
     72     def test_i_will_not_pass_validation_POST(self):
     73         from encadre import request
     74         request.json = {'xnumbers': [1, 2]}
     75         self.i_am_validated_POST()
     76         self.assertRaises(Exception)
     77 
     78 
     79 class Hello_2(Controller):
     80     """ A very polite controller (version 2) """
     81 
     82     def index__(self):
     83         """ Says hello ! """
     84         return "Hello world (2)"
     85 
     86     def test_index__(self):
     87         self.assertTrue(self.index__() == "Hello world (2)")
     88 
     89     def to(self, who):
     90         """ Says hello to whom ask for """
     91         return "Hello %s !" % who
     92 
     93     def test_to(self):
     94         assert True
     95 
     96     def foo(self):
     97         return "Foo"
     98 
     99     def test_foo(self):
    100         assert True
    101 
    102     def foo_(self):
    103         return "Foo with an '_' at the end !"
    104 
    105     def test_foo_(self):
    106         assert True
    107 
    108     def bar_GET(self):
    109         return "Bar"
    110 
    111     def test_bar_GET(self):
    112         assert True
    113 
    114     def baz_POST(self):
    115         from encadre import request
    116         return request.json
    117 
    118     def test_baz_POST(self):
    119         from encadre import request
    120         k = 'test_%s' % random.randint(0, 1000)
    121         v = random.randint(0, 1000)
    122         request.json = {k: v}
    123         self.assertTrue(self.baz_POST()[k] == v)
    124 
    125     def qux_GET_POST(self):
    126         return "Qux"
    127 
    128     def test_qux_GET_POST(self):
    129         assert True
    130 
    131     def args(self):
    132         from encadre import request
    133         return request.args.get('qwe', "no 'qwe' arg")
    134 
    135     def test_args(self):
    136         from encadre import request
    137         v = 'test_%s' % random.randint(0, 1000)
    138         request.args['qwe'] = v
    139         self.assertTrue(self.args() == v)
    140 
    141 
    142 class Hello_3(Hello_2):
    143     """ A very polite controller """
    144 
    145     def index__(self):
    146         """ Says hello ! """
    147         return "Hello world (3)"
    148 
    149     def test_index__(self):
    150         self.assertTrue(self.index__() == "Hello world (3)")
    151 
    152     def bar_GET(self):
    153         """ Better 'bar' """
    154         return "Better Bar"
    155 
    156     def test_bar_GET(self):
    157         assert True
    158 
    159     def bar_POST(self):
    160         """ That one handle POST too ! """
    161         return "Handle POST too."
    162 
    163     def test_bar_POST(self):
    164         assert True
    165 
    166     def send_bytes(self):
    167         return self.framework.send_bytes(
    168             open("/etc/passwd", "rb"),
    169             as_attachment=True,
    170             attachment_filename='etc-passwd.txt',
    171             mimetype='text/plain')
    172 
    173     def test_send_bytes(self):
    174         self.assertTrue(b'root' in self.send_bytes())
    175 
    176     def dividebyzero(self):
    177         return 1 / 0
    178 
    179     def test_dividebyzero(self):
    180         self.assertRaises(ZeroDivisionError, self.dividebyzero)
    181 
    182 
    183 class StrangeTestCase(unittest.TestCase):
    184 
    185     def setUp(self):
    186         pass
    187 
    188     def tearDown(self):
    189         pass
    190 
    191 
    192 class Hello_4(Hello_3):
    193 
    194     testcase_cls = StrangeTestCase