Ticket #1105: improved-api-for-validate-dec.patch

File improved-api-for-validate-dec.patch, 26.2 kB (added by bjourne, 2 years ago)

Big patch implementing most of the suggestions in this bug.

  • turbogears/controllers.py

    old new  
    9494class BadFormatError(Exception): 
    9595    """Output-format exception.""" 
    9696 
    97 def validate(form=None, validators=None, state_factory=None): 
    98     """Validate input. 
     97def validate(validator, state_factory=None): 
     98    """ 
     99    Decorates a function with validation. 
    99100 
    100     @param form form to validate input from 
    101     @param validators individual validators to use for parameters 
    102     @param state_factory callable which returns the initial state instance for 
    103            validation 
     101    A decorator that validates parameters to the decorated function 
     102    and converts them to Python types. Only the parameters that have 
     103    the same names as fields in the schema are validated. Other 
     104    parameters are left untouched. 
     105 
     106    Validation results in four attributes of cherrypy.request being 
     107    set. 
     108 
     109    validation_errors: A dictionary containing names of the parameters 
     110    that failed validation as keys and error messages for each failing 
     111    field as values. 
     112 
     113    input_values: A dictionary containing names of the parameters that 
     114    failed validation as keys and the fields values as values. 
     115 
     116    validated_entity: The validator that was passed to the validate 
     117    decorator. 
     118 
     119    validation_state: State of validation. 
     120 
     121    @param validator Usually a subclass of formencode.Schema, but any 
     122                     object that has a to_python() method which raises 
     123                     formencode.api.Invalid exceptions work. A factory 
     124                     function or class that creates an instance with a 
     125                     to_python() method also works. 
     126                      
     127    @param state_factory Callable which returns the initial state 
     128                         instance for validation 
    104129    """ 
    105130    def entangle(func): 
    106131        recursion_guard = dict(func=func) 
    107         if callable(form) and not hasattr(form, "validate"): 
    108             init_form = lambda self: form(self) 
     132        if callable(validator) and not hasattr(validator, "to_python"): 
     133            init_validator = lambda self: validator(self) 
    109134        else: 
    110             init_form = lambda self: form 
     135            init_validator = lambda self: validator 
    111136 
    112137        def validate(func, *args, **kw): 
    113138            if tg_util.call_on_stack("validate", recursion_guard, 4): 
    114139                return func(*args, **kw) 
    115             form = init_form(args and args[0] or kw["self"]) 
     140            validator = init_validator(args and args[0] or kw["self"]) 
    116141            args, kw = tg_util.to_kw(func, args, kw) 
    117  
    118             errors = {} 
     142             
    119143            if state_factory is not None: 
    120144                state = state_factory() 
    121145            else: 
    122146                state = None 
    123147 
    124             if form: 
    125                 value = kw.copy() 
    126                 try: 
    127                     kw.update(form.validate(value, state)) 
    128                 except Invalid, e: 
    129                     errors = e.unpack_errors() 
    130                     cherrypy.request.validation_exception = e 
    131                 cherrypy.request.validated_form = form 
     148            errors = {} 
     149            value = kw.copy() 
     150            try: 
     151                kw.update(validator.to_python(value, state)) 
     152            except Invalid, e: 
     153                errors = e.unpack_errors() 
    132154 
    133             if validators: 
    134                 if isinstance(validators, dict): 
    135                     for field, validator in validators.iteritems(): 
    136                         try: 
    137                             kw[field] = validator.to_python( 
    138                                 kw.get(field, None), state 
    139                                 ) 
    140                         except Invalid, error: 
    141                             errors[field] = error 
    142                 else: 
    143                     try: 
    144                         value = kw.copy() 
    145                         kw.update(validators.to_python(value, state)) 
    146                     except Invalid, e: 
    147                         errors = e.unpack_errors() 
    148                         cherrypy.request.validation_exception = e 
    149155            cherrypy.request.validation_errors = errors 
     156            cherrypy.request.tg_validator = validator 
    150157            cherrypy.request.input_values = kw.copy() 
    151158            cherrypy.request.validation_state = state 
    152159 
    153  
    154160            args, kw = tg_util.from_kw(func, args, kw) 
    155161            return errorhandling.run_with_errors(errors, func, *args, **kw) 
    156162 

  • turbogears/tests/test_form_controllers.py

    old new  
    3333        self.name = name 
    3434        self.age = age 
    3535        self.date = date 
    36     testform = turbogears.validate(form=myform)(testform) 
     36    testform = turbogears.validate(myform)(testform) 
    3737    testform = turbogears.expose(html="turbogears.tests.othertemplate")( 
    3838                                 testform) 
    3939 
    …… 
    4343        self.name = name 
    4444        self.age = age 
    4545        self.date = date 
    46     testform_new_style = turbogears.validate(form=myform)(testform_new_style) 
     46    testform_new_style = turbogears.validate(myform)(testform_new_style) 
    4747    testform_new_style = turbogears.expose()(testform_new_style) 
    4848 
    4949 
    …… 
    126126class TestValidationState(TestCase): 
    127127 
    128128    class Controller(controllers.RootController): 
    129         @turbogears.validate(validators=AddingNestedSchema(),  
    130                              state_factory=State) 
     129        @turbogears.validate(AddingNestedSchema(), state_factory=State) 
    131130        @turbogears.expose() 
    132131        def validate(self, a, b, c): 
    133132            return 'counter: %d' % cherrypy.request.validation_state.counter 

  • turbogears/tests/test_errorhandling.py

    old new  
    77from turbogears.failsafe import values_atom_continuation, map_errors_continuation, \ 
    88                                defaults_continuation, values_dict_continuation 
    99from turbogears.util import bind_args 
    10 from turbogears import validators 
     10from turbogears.validators import Email, Int, String, StringBoolean 
    1111from turbogears import testutil 
     12from turbogears.testutil import simple_schema 
    1213 
    1314 
    1415def _errors_to_str(errors): 
    …… 
    3132    def defaulterror(self, bar=""): 
    3233        return dict(title="Default error provider") 
    3334    defaulterror = error_handler(defaulterrorhandler)(defaulterror) 
    34     defaulterror = validate(validators={"bar":validators.StringBoolean()})( 
    35                             defaulterror) 
     35    defaulterror = validate(simple_schema(bar = StringBoolean()))( 
     36        defaulterror) 
    3637    defaulterror = expose()(defaulterror) 
    3738 
    3839    def specialisederror(self, bar="", baz=""): 
    …… 
    4142                                             specialisederror) 
    4243    specialisederror = error_handler(specialisederrorhandler, 
    4344                                     "'baz' in tg_errors")(specialisederror) 
    44     specialisederror = validate(validators={"bar":validators.Int(), 
    45                                             "baz":validators.Email()})( 
    46                                 specialisederror) 
     45    specialisederror = validate(simple_schema(bar = Int(), baz = Email()))( 
     46        specialisederror) 
    4747    specialisederror = expose()(specialisederror) 
    4848 
    4949    def exceptionerror(self): 
    …… 
    6262        else: 
    6363            return dict(title="Recursive error provider") 
    6464    recursiveerror = error_handler()(recursiveerror) 
    65     recursiveerror = validate(validators={"bar":validators.Int()})( 
    66                               recursiveerror) 
     65    recursiveerror = validate(simple_schema(bar = Int()))(recursiveerror) 
    6766    recursiveerror = expose()(recursiveerror) 
    6867 
    6968    def impliciterror(self, tg_errors=None, bar=""): 
    …… 
    7271                        tg_errors=str(tg_errors)) 
    7372        else: 
    7473            return dict(title="Implicit error provider") 
    75     impliciterror = validate(validators={"bar":validators.Int()})( 
    76                              impliciterror) 
     74    impliciterror = validate(simple_schema(bar = Int()))(impliciterror) 
    7775    impliciterror = expose()(impliciterror) 
    7876 
    7977    def normalmethod(self): 
    …… 
    8381    def normalmethodcaller(self, bar=""): 
    8482        return dict(title="Normal method caller") 
    8583    normalmethodcaller = error_handler(normalmethod)(normalmethodcaller) 
    86     normalmethodcaller = validate(validators={ 
    87                                   "bar":validators.StringBoolean()})( 
    88                          normalmethodcaller) 
     84    normalmethodcaller = validate(simple_schema(bar = StringBoolean()))( 
     85        normalmethodcaller) 
    8986    normalmethodcaller = expose()(normalmethodcaller) 
    9087 
    9188    def infiniteloop(self): 
    …… 
    105102                    args=args, bar=kw["bar"]) 
    106103    positionalargs = error_handler(defaulterrorhandler)( 
    107104                                   positionalargs) 
    108     positionalargs = validate(validators={"bar":validators.StringBoolean(), 
    109                                           "second":validators.Int()})( 
    110                               positionalargs) 
     105    positionalargs = validate(simple_schema(bar = StringBoolean(), 
     106                                            second = Int()))(positionalargs) 
    111107    positionalargs = expose()(positionalargs) 
    112108 
    113109    def missingargs(self, bar=""): 
    114110        return dict(title="Missing args provider") 
    115111    missingargs = error_handler(defaulterrorhandler)(missingargs) 
    116     missingargs = validate(validators={"bar":validators.Int(not_empty=True)})(missingargs) 
     112    missingargs = validate(simple_schema(bar = Int(not_empty = True)))( 
     113        missingargs) 
    117114    missingargs = expose()(missingargs) 
    118115 
    119116    def nohandler2(self, bar=""): 
    120117        return dict(title="No handler inner") 
    121     nohandler2 = validate(validators={"bar":validators.Int()})(nohandler2) 
     118    nohandler2 = validate(simple_schema(bar = Int()))(nohandler2) 
    122119    nohandler2 = expose()(nohandler2) 
    123120 
    124121    def nohandler(self): 
    …… 
    136133    def bindargs(self, bar=""): 
    137134        return dict(title="Bind arguments to error handler") 
    138135    bindargs = error_handler(bind_args(baz=123)(simpleerrorhandler))(bindargs) 
    139     bindargs = validate(validators={"bar":validators.Int(not_empty=True)})(bindargs) 
     136    bindargs = validate(simple_schema(bar = Int(not_empty=True)))(bindargs) 
    140137    bindargs = expose()(bindargs) 
    141138 
    142139    def notexposed(self, bar, tg_errors = None): 
    …… 
    144141            return dict(title="Not exposed error", bar=bar) 
    145142        else: 
    146143            return dict(title="Not exposed", bar=bar) 
    147     notexposed = validate(validators={"bar":validators.Int()})(notexposed) 
     144    notexposed = validate(simple_schema(bar = Int()))(notexposed) 
    148145 
    149146    def notexposedcaller(self, foo="", bar="", baz=""): 
    150147        return self.notexposed(bar) 
    …… 
    157154    def continuationcaller(self, bar=""): 
    158155        return dict(title="Continuation caller") 
    159156    continuationcaller = error_handler(continuation)(continuationcaller) 
    160     continuationcaller = validate(validators={"bar":validators.Int()})( 
    161                                   continuationcaller) 
     157    continuationcaller = validate(simple_schema(bar = Int()))( 
     158        continuationcaller) 
    162159    continuationcaller = expose()(continuationcaller) 
    163160 
    164161    def nest(self, bar=""): 
    165162        return dict(title="Nested") 
    166163    nest = error_handler(defaulterrorhandler)(nest) 
    167     nest = validate(validators={"bar":validators.Int()})(nest) 
     164    nest = validate(simple_schema(bar = Int()))(nest) 
    168165    nest = expose()(nest) 
    169166 
    170167    def failsafevaluesdict(self, tg_errors=None, bar="", baz=""): 
    171168        return dict(title="Failsafe values-dict", bar=bar, baz=baz) 
    172169    failsafevaluesdict = error_handler(values_dict_continuation({"bar":1, "baz":2}))(failsafevaluesdict) 
    173     failsafevaluesdict = validate(validators={"bar":validators.Int(), 
    174         "baz":validators.Int()})(failsafevaluesdict) 
     170    failsafevaluesdict = validate(simple_schema(bar = Int(), 
     171                                                baz = Int()))( 
     172        failsafevaluesdict) 
    175173    failsafevaluesdict = expose()(failsafevaluesdict) 
    176174 
    177175    def failsafevaluesatom(self, tg_errors=None, bar="", baz=""): 
    178176        return dict(title="Failsafe values-atom", bar=bar, baz=baz) 
    179177    failsafevaluesatom = error_handler(values_atom_continuation(13))(failsafevaluesatom) 
    180     failsafevaluesatom = validate(validators={"bar":validators.Int(), 
    181         "baz":validators.Int()})(failsafevaluesatom) 
     178    failsafevaluesatom = validate(simple_schema(bar = Int(), baz = Int()))( 
     179        failsafevaluesatom) 
    182180    failsafevaluesatom = expose()(failsafevaluesatom) 
    183181 
    184182    def failsafemaperrors(self, tg_errors=None, bar="", baz=""): 
    185183        return dict(title="Failsafe map errors", bar=str(bar), baz=str(baz)) 
    186184    failsafemaperrors = error_handler(map_errors_continuation())(failsafemaperrors) 
    187     failsafemaperrors = validate(validators={"bar":validators.Int(), 
    188         "baz":validators.Int()})(failsafemaperrors) 
     185    failsafemaperrors = validate(simple_schema(bar = Int(), baz = Int()))( 
     186        failsafemaperrors) 
    189187    failsafemaperrors = expose()(failsafemaperrors) 
    190188 
    191189    def failsafeformencode(self, tg_errors=None, bar="", baz=""): 
    192190        return dict(title="Formencode if_invalid", bar=bar, baz=baz) 
    193     failsafeformencode = validate(validators={"bar":validators.Int( 
    194         if_invalid=1), "baz":validators.Int(if_invalid=2)})(failsafeformencode) 
     191    failsafeformencode = validate(simple_schema(bar = Int(if_invalid = 1), 
     192                                                baz = Int(if_invalid = 2)))( 
     193        failsafeformencode) 
    195194    failsafeformencode = expose()(failsafeformencode) 
    196195 
    197196    def failsafedefaults(self, tg_errors=None, bar=1, baz=2): 
    198197        return dict(title="Failsafe map defaults", bar=bar, baz=baz) 
    199198    failsafedefaults = error_handler(defaults_continuation())(failsafedefaults) 
    200     failsafedefaults = validate(validators={"bar":validators.Int(), 
    201         "baz":validators.Int()})(failsafedefaults) 
     199    failsafedefaults = validate(simple_schema(bar = Int(), baz = Int()))( 
     200        failsafedefaults) 
    202201    failsafedefaults = expose()(failsafedefaults) 
    203202 
    204203class NestedController(Controller): 
    …… 
    206205    def nest(self, bar=""): 
    207206        return dict(title="Nested") 
    208207    nest = error_handler()(nest) 
    209     nest = validate(validators={"bar":validators.Int()})(nest) 
     208    nest = validate(simple_schema(bar = Int()))(nest) 
    210209    nest = expose()(nest) 
    211210 
    212211 
    …… 
    219218    def test_defaultErrorHandler(self): 
    220219        """ Default error handler. """ 
    221220        testutil.createRequest("/defaulterror?bar=abc") 
     221 
     222        print cherrypy.response.body[0] 
     223         
    222224        self.failUnless("Default error handler" in cherrypy.response.body[0]) 
    223225        testutil.createRequest("/defaulterror?bar=true") 
    224226        self.failUnless("Default error provider" in cherrypy.response.body[0]) 

  • turbogears/tests/test_controllers.py

    old new  
    77from turbogears import validators 
    88from turbogears import database 
    99from turbogears import testutil 
     10from turbogears.testutil import simple_schema 
    1011import cherrypy 
    1112import formencode 
    1213import pkg_resources 
    …… 
    7273        self.value = value 
    7374        return str(value) 
    7475    istrue = turbogears.error_handler(validation_error_handler)(istrue) 
    75     istrue = turbogears.validate(validators={ 
    76                 'value': validators.StringBoolean()})(istrue) 
     76    istrue = turbogears.validate( 
     77        simple_schema(value = validators.StringBoolean))(istrue) 
    7778    istrue = turbogears.expose()(istrue) 
    7879 
    7980 
    …… 
    109110        self.fullname = "%s %s" % (self.firstname, self.lastname) 
    110111        return self.fullname 
    111112    save = turbogears.error_handler(validation_error_handler)(save) 
    112     save = turbogears.validate(validators={ 
    113         "firstname": validators.String(min=2, not_empty=True), 
    114         "lastname": validators.String()})(save) 
     113    save = turbogears.validate( 
     114        simple_schema(firstname = validators.String(min = 2, not_empty=True), 
     115                      lastname = validators.String()))(save) 
    115116    save = turbogears.expose()(save) 
    116117 
    117118    class Registration(formencode.Schema): 
    …… 
    122123    def save2(self, submit, firstname, lastname="Miller"): 
    123124        return self.save(submit, firstname, lastname) 
    124125    save2 = turbogears.error_handler(validation_error_handler)(save2) 
    125     save2 = turbogears.validate(validators=Registration())(save2) 
     126    save2 = turbogears.validate(Registration())(save2) 
    126127    save2 = turbogears.expose()(save2) 
    127128 
    128129    def useother(self): 
    …… 
    311312        testutil.createRequest("/save?submit=send&firstname=D&lastname=") 
    312313        assert len(cherrypy.root.errors) == 1 
    313314        assert cherrypy.root.errors.has_key("firstname") 
    314         assert "characters" in cherrypy.root.errors["firstname"].msg.lower() 
     315 
     316        print cherrypy.root.errors["firstname"] 
     317         
     318        assert "characters" in cherrypy.root.errors["firstname"].lower() 
    315319        testutil.createRequest("/save?submit=send&firstname=&lastname=") 
    316320        assert len(cherrypy.root.errors) == 1 
    317321        assert cherrypy.root.errors.has_key("firstname") 

  • turbogears/testutil.py

    old new  
    7474    response = cherrypy.serving.response 
    7575    return output, response 
    7676 
     77def simple_schema(**fields): 
     78    """ Non-declarative way of creating a FormEncode schema. """ 
     79    schema = validators.Schema() 
     80    for name, validator in fields.items(): 
     81        schema.fields[name] = validator 
     82    return schema 
    7783 
    7884class DBTest(unittest.TestCase): 
    7985    model = None 
    …… 
    9298 
    9399    def tearDown(self): 
    94100        database.rollback_all() 
    95 <<<<<<< .mine 
    96101        for item in self.model.__dict__.values(): 
    97102            if inspect.isclass(item) and issubclass(item, 
    98103                sqlobject.SQLObject) and item != sqlobject.SQLObject \ 
    99104                and item != InheritableSQLObject: 
    100                 item.dropTable() 
    101 ======= 
    102         for item in self.model.__dict__.values(): 
    103             if inspect.isclass(item) and issubclass(item, 
    104                 sqlobject.SQLObject) and item != sqlobject.SQLObject \ 
    105                 and item != InheritableSQLObject: 
    106105                item.dropTable(ifExists=True) 
    107 >>>>>>> .theirs 
    108106 
    109107def reset_cp(): 
    110108    cherrypy.root = None 
    …… 
    113111    """ Catches and unpacks validation errors. For testing purposes. """ 
    114112    errors = {} 
    115113    try: 
    116         value = widget.validate(value) 
     114        value = widget.to_python(value) 
    117115    except validators.Invalid, e: 
    118116        if hasattr(e, 'unpack_errors'): 
    119117            errors = e.unpack_errors() 

  • turbogears/widgets/tests/test_nested_form_controllers.py

    old new  
    2121            self.has_errors = True 
    2222        self.name = p_data['name'] 
    2323        self.age = p_data['age'] 
    24     testform = turbogears.validate(form=myform)(testform) 
     24    testform = turbogears.validate(myform)(testform) 
    2525    testform = turbogears.expose(html="turbogears.tests.othertemplate")( 
    2626                                 testform) 
    2727 
    …… 
    3131    def testform_new_style(self, p_data): 
    3232        self.name = p_data['name'] 
    3333        self.age = p_data['age'] 
    34     testform_new_style = turbogears.validate(form=myform)(testform_new_style) 
     34    testform_new_style = turbogears.validate(myform)(testform_new_style) 
    3535    testform_new_style = turbogears.error_handler(set_errors)(testform_new_style) 
    3636    testform_new_style = turbogears.expose()(testform_new_style) 
    3737 

  • turbogears/widgets/tests/test_new_validation.py

    old new  
    6161        form = SimpleForm() 
    6262        value = dict(age="22", phone="5555555") 
    6363 
    64         value = form.validate(value) 
     64        value = form.to_python(value) 
    6565        print value 
    6666        assert value == dict(age=22, phone=5555555) 
    6767 
    …… 
    9494        form = SimpleForm(validator=NotSoSimpleSchema()) 
    9595        value = dict(age="22", phone="5555555") 
    9696 
    97         value = form.validate(value) 
     97        value = form.to_python(value) 
    9898        print value 
    9999        assert value == dict(phoneage=5555577) 
    100100 
    …… 
    106106        value = dict(age="22", phone="5555555",  
    107107                     fs=dict(age="22", phone="5555555")) 
    108108 
    109         value = form.validate(value) 
     109        value = form.to_python(value) 
    110110        print value 
    111111        assert value == dict(age=22, phone=5555555,  
    112112                             fs=dict(age=22, phone=5555555)) 

  • turbogears/widgets/tests/test_forms.py

    old new  
    3636                      widgets.TextField("age", validator=validators.Int())], 
    3737                      submit_text="Submit") 
    3838    values = dict(name="ed", age="15") 
    39     values = form.validate(values) 
     39    values = form.to_python(values) 
    4040    assert values["name"] == "ed" 
    4141    assert values["age"] == 15 
    4242    assert not values.has_key("submit") 
    …… 
    175175    def checkform(self, foo): 
    176176        self.foo = foo 
    177177    checkform = expose()(checkform) 
    178     checkform = validate(form=nestedform)(checkform) 
     178    checkform = validate(nestedform)(checkform) 
    179179 
    180180def test_nested_variables(): 
    181181    cherrypy.request = oldrequest 

  • turbogears/widgets/tests/test_request_related_features.py

    old new  
    5151        def test(self): 
    5252            return dict(form1=form1, form2=form2) 
    5353        test = turbogears.expose(template=".two_forms")(test) 
    54         test = turbogears.validate(form=form1)(test) 
     54        test = turbogears.validate(form1)(test) 
    5555        test = turbogears.error_handler(test)(test) 
    5656         
    5757        def test2(self): 
    5858            return dict(form=form2) 
    5959        test2 = turbogears.expose(template=".form")(test2) 
    60         test2 = turbogears.validate(form=form2)(test2) 
     60        test2 = turbogears.validate(form2)(test2) 
    6161        test2 = turbogears.error_handler(test2)(test2) 
    6262         
    6363        def test3(self): 
    6464            return dict(form=form1) 
    6565        test3 = turbogears.expose(template=".form")(test3) 
    66         test3 = turbogears.validate(form=form2)(test3) 
     66        test3 = turbogears.validate(form2)(test3) 
    6767        test3 = turbogears.error_handler(test3)(test3) 
    6868 
    6969    cherrypy.root = MyRoot() 
    …… 
    7171    output = cherrypy.response.body[0].lower() 
    7272    iv = cherrypy.request.input_values 
    7373    validation_errors = cherrypy.request.validation_errors 
    74     validated_form = cherrypy.request.validated_form 
     74    tg_validator = cherrypy.request.tg_validator 
    7575     
    7676    print output 
    7777    print iv 
    7878    print validation_errors 
    79     print validated_form 
    80     assert form1 is validated_form  
     79    print tg_validator 
     80    assert form1 is tg_validator 
    8181    assert form1.is_validated 
    82     assert form2 is not validated_form 
     82    assert form2 is not tg_validator 
    8383    assert not form2.is_validated 
    8484    value_p = 'value="foo"' 
    8585    id_p = 'id="form1_age"' 
    …… 
    9797    output = cherrypy.response.body[0].lower() 
    9898    iv = cherrypy.request.input_values 
    9999    validation_errors = cherrypy.request.validation_errors 
    100     validated_form = cherrypy.request.validated_form 
     100    tg_validator = cherrypy.request.tg_validator 
    101101     
    102102    print output 
    103103    print iv 
    104104    print validation_errors 
    105     print validated_form 
    106     assert form1 is not validated_form  
     105    print tg_validator 
     106    assert form1 is not tg_validator 
    107107    assert not form1.is_validated 
    108     assert form2 is validated_form 
     108    assert form2 is tg_validator 
    109109    assert form2.is_validated 
    110110    assert 'value="foo"' in output 
    111111    assert '>bar<' in output 
    …… 
    116116    output = cherrypy.response.body[0].lower() 
    117117    iv = cherrypy.request.input_values 
    118118    validation_errors = cherrypy.request.validation_errors 
    119     validated_form = cherrypy.request.validated_form 
     119    tg_validator = cherrypy.request.tg_validator 
    120120     
    121121    print output 
    122122    print iv 
    123123    print validation_errors 
    124     print validated_form 
    125     assert form1 is not validated_form  
     124    print tg_validator 
     125    assert form1 is not tg_validator 
    126126    assert not form1.is_validated 
    127     assert form2 is validated_form 
     127    assert form2 is tg_validator 
    128128    assert form2.is_validated 
    129129    assert 'value="foo"' not in output 
    130130    assert '>bar<' not in output 
    …… 
    155155        def test_validation(self): 
    156156            return dict(form=form) 
    157157        test_validation = turbogears.expose(template=".form")(test_validation) 
    158         test_validation = turbogears.validate(form=form)(test_validation) 
     158        test_validation = turbogears.validate(form)(test_validation) 
    159159        test_validation = turbogears.error_handler(test_validation)(test_validation) 
    160160 
    161161    cherrypy.root = MyRoot() 

  • turbogears/widgets/forms.py

    old new  
    158158 
    159159    def _get_is_validated(self): 
    160160        if self.path: 
    161             validated_form = getattr(request, "validated_form", None) 
     161            tg_validator = getattr(request, "tg_validator", None) 
    162162            form = self.path[0].widget 
    163             if form is validated_form: 
     163            if form is tg_validator: 
    164164                return True 
    165165            else: 
    166166                return False 
    …… 
    10681068        if self.file_upload: 
    10691069            d["form_attrs"]['enctype'] = "multipart/form-data" 
    10701070 
    1071     def validate(self, value, state=None): 
     1071    def to_python(self, value, state=None): 
    10721072        if self.validator: 
    10731073            return self.validator.to_python(value, state) 
    10741074