Projet

Général

Profil

0001-wf-backoffice_fields-only-log-condition-errors-as-fu.patch

Thomas Noël, 19 juin 2018 15:05

Télécharger (7,12 ko)

Voir les différences:

Subject: [PATCH] wf/backoffice_fields: only log condition errors as functional
 errors (#24645)

 tests/test_workflows.py     | 30 ++++++++++++++++++++++++++++++
 wcs/wf/backoffice_fields.py | 17 +++++++++++++----
 wcs/workflows.py            | 19 ++++++++++++++++---
 3 files changed, 59 insertions(+), 7 deletions(-)
tests/test_workflows.py
3014 3014
    formdata = formdef.data_class().get(formdata.id)
3015 3015
    assert formdata.data['bo1'] == 'HELLO GOODBYE'
3016 3016

  
3017
    assert LoggedError.count() == 0
3018

  
3019
    item.fields = [{'field_id': 'bo1', 'value': '= ~ invalid python ~'}]
3020
    item.perform(formdata)
3021
    formdata = formdef.data_class().get(formdata.id)
3022
    assert LoggedError.count() == 1
3023
    logged_error = LoggedError.select()[0]
3024
    assert logged_error.summary.startswith('Failed to evaluate Python expression')
3025
    assert logged_error.formdata_id == str(formdata.id)
3026

  
3027
    LoggedError.wipe()
3028
    item.fields = [{'field_id': 'bo1', 'value': '{% if bad django %}'}]
3029
    item.perform(formdata)
3030
    formdata = formdef.data_class().get(formdata.id)
3031
    assert LoggedError.count() == 1
3032
    logged_error = LoggedError.select()[0]
3033
    assert logged_error.summary.startswith('Failed to evaluate template')
3034
    assert logged_error.formdata_id == str(formdata.id)
3035

  
3017 3036
def test_set_backoffice_field_file(http_requests, two_pubs):
3018 3037
    Workflow.wipe()
3019 3038
    FormDef.wipe()
......
3135 3154
        item = SetBackofficeFieldsWorkflowStatusItem()
3136 3155
        item.parent = st1
3137 3156
        item.fields = [{'field_id': 'bo1', 'value': value}]
3157

  
3158
        LoggedError.wipe()
3138 3159
        item.perform(formdata)
3139 3160

  
3140 3161
        formdata = formdef.data_class().get(formdata.id)
3141 3162
        if value is not None:  # wrong value : do nothing
3142 3163
            assert formdata.data['bo1'].base_filename == 'hello.txt'
3143 3164
            assert formdata.data['bo1'].get_content() == 'HELLO WORLD'
3165
            assert LoggedError.count() == 1
3166
            logged_error = LoggedError.select()[0]
3167
            assert logged_error.summary.startswith('Failed to convert')
3168
            assert logged_error.formdata_id == str(formdata.id)
3144 3169
        else:  # empty value : remove field
3145 3170
            assert formdata.data['bo1'] is None
3171
            assert LoggedError.count() == 0
3146 3172

  
3147 3173
    # check wrong field
3148 3174
    item = SetBackofficeFieldsWorkflowStatusItem()
......
3353 3379
    assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23)
3354 3380

  
3355 3381
    # invalid values => do nothing
3382
    assert LoggedError.count() == 0
3356 3383
    for value in ('plop', {}, []):
3357 3384
        item = SetBackofficeFieldsWorkflowStatusItem()
3358 3385
        item.parent = st1
3359 3386
        item.fields = [{'field_id': 'bo1', 'value': value}]
3360 3387

  
3388
        LoggedError.wipe()
3361 3389
        item.perform(formdata)
3362 3390
        formdata = formdef.data_class().get(formdata.id)
3363 3391
        assert datetime.date(*formdata.data['bo1'][:3]) == datetime.date(2017, 3, 23)
3392
        assert LoggedError.count() == 1
3393
        assert LoggedError.select()[0].summary.startswith('Failed to convert')
3364 3394

  
3365 3395
    # None : empty date
3366 3396
    item = SetBackofficeFieldsWorkflowStatusItem()
wcs/wf/backoffice_fields.py
97 97
                continue
98 98

  
99 99
            try:
100
                new_value = self.compute(field['value'], raises=True)
100
                new_value = self.compute(field['value'], raises=True,
101
                                         formdata=formdata, status_item=self)
101 102
            except:
102
                get_publisher().notify_of_exception(sys.exc_info(), context='[BO_FIELDS]')
103 103
                continue
104 104

  
105 105
            if formdef_field.convert_value_from_anything:
106 106
                try:
107 107
                    new_value = formdef_field.convert_value_from_anything(new_value)
108
                except ValueError:
109
                    get_publisher().notify_of_exception(sys.exc_info(), context='[BO_FIELDS]')
108
                except ValueError as e:
109
                    from wcs.logged_errors import LoggedError
110
                    summary = _('Failed to convert %(result)r (%(class)s computed from %(value)s) '
111
                                'to a %(kind)s field (%(id)s)') % {
112
                                    'result': new_value,
113
                                    'class': new_value.__class__.__name__,
114
                                    'value': field['value'],
115
                                    'kind': getattr(formdef_field, 'key', 'unknown'),
116
                                    'id': field['field_id'],
117
                                }
118
                    LoggedError.record(summary, formdata=formdata, status_item=self)
110 119
                    continue
111 120

  
112 121
            formdata.data['%s' % field['field_id']] = new_value
wcs/workflows.py
1677 1677
        return {'type': expression_type, 'value': expression_value}
1678 1678

  
1679 1679
    @classmethod
1680
    def compute(cls, var, render=True, raises=False, context=None):
1680
    def compute(cls, var, render=True, raises=False, formdata=None, status_item=None, context=None):
1681 1681
        if not isinstance(var, basestring):
1682 1682
            return var
1683 1683

  
......
1692 1692
        vars = get_publisher().substitutions.get_context_variables()
1693 1693
        vars.update(context or {})
1694 1694

  
1695
        def log_error(message):
1696
            from wcs.logged_errors import LoggedError
1697
            summary = _('Failed to evaluate %(type)s "%(value)s": %(message)s') % {
1698
                            'type': {'text': _('text'),
1699
                                     'template': _('template'),
1700
                                     'python': _('Python expression')}.get(expression['type']),
1701
                            'value': expression['value'],
1702
                            'message': message
1703
                        }
1704
            LoggedError.record(summary, formdata=formdata, status_item=status_item)
1705

  
1695 1706
        if expression['type'] == 'template':
1696 1707
            try:
1697 1708
                return Template(expression['value'], raises=raises, autoescape=False).render(vars)
1698
            except TemplateError:
1709
            except TemplateError as e:
1710
                log_error(str(e))
1699 1711
                if raises:
1700 1712
                    raise
1701 1713
                return var
1702 1714

  
1703 1715
        try:
1704 1716
            return eval(expression['value'], get_publisher().get_global_eval_dict(), vars)
1705
        except:
1717
        except Exception as e:
1718
            log_error(str(e))
1706 1719
            if raises:
1707 1720
                raise
1708 1721
            return var
1709
-