Projet

Général

Profil

0001-sessions-store-form-tokens-in-external-directory-160.patch

Frédéric Péters, 27 avril 2017 14:35

Télécharger (12,6 ko)

Voir les différences: 

Subject: [PATCH] sessions: store form tokens in external directory (#16048)


 tests/test_fields.py    | 64 ++++++++++++++++++++++++-------------------------
 wcs/qommon/publisher.py |  9 +++++++
 wcs/qommon/sessions.py  | 27 +++++++++++++++++++++
 3 files changed, 68 insertions(+), 32 deletions(-)
tests/test_fields.py
29 29 

  		




  30
  30
  
    
def test_fill_admin_form():

  		




  31
  31
  
    
    for klass in fields.field_classes:

  		




  32
  
  
    
        form = Form()

  		




  
  32
  
    
        form = Form(use_tokens=False)

  		




  33
  33
  
    
        klass().fill_admin_form(form)

  		




  34
  34
  
    

  		




  35
  35
  
    
def test_get_admin_attributes():

  		




  ......




  38
  38
  
    

  		




  39
  39
  
    
def test_add_to_form():

  		




  40
  40
  
    
    for klass in fields.field_classes:

  		




  41
  
  
    
        form = Form()

  		




  
  41
  
    
        form = Form(use_tokens=False)

  		




  42
  42
  
    
        if klass is fields.PageField:

  		




  43
  43
  
    
            with pytest.raises(AttributeError):

  		




  44
  44
  
    
                klass(label='foo').add_to_form(form)

  		




  ......




  119
  119
  
    

  		




  120
  120
  
    
def test_title():

  		




  121
  121
  
    
    field = fields.TitleField(label='Foobar')

  		




  122
  
  
    
    form = Form()

  		




  
  122
  
    
    form = Form(use_tokens=False)

  		




  123
  123
  
    
    field.add_to_form(form)

  		




  124
  124
  
    
    assert '<h3>Foobar</h3>' in str(form.render())

  		




  125
  125
  
    

  		




  126
  126
  
    
    field = fields.TitleField(label='Foobar', extra_css_class='test')

  		




  127
  
  
    
    form = Form()

  		




  
  127
  
    
    form = Form(use_tokens=False)

  		




  128
  128
  
    
    field.add_to_form(form)

  		




  129
  129
  
    
    assert '<h3 class="test">Foobar</h3>' in str(form.render())

  		




  130
  130
  
    

  		




  131
  131
  
    
def test_subtitle():

  		




  132
  132
  
    
    field = fields.SubtitleField(label='Foobar')

  		




  133
  
  
    
    form = Form()

  		




  
  133
  
    
    form = Form(use_tokens=False)

  		




  134
  134
  
    
    field.add_to_form(form)

  		




  135
  135
  
    
    assert '<h4>Foobar</h4>' in str(form.render())

  		




  136
  136
  
    

  		




  137
  137
  
    
    field = fields.SubtitleField(label='Foobar', extra_css_class='test')

  		




  138
  
  
    
    form = Form()

  		




  
  138
  
    
    form = Form(use_tokens=False)

  		




  139
  139
  
    
    field.add_to_form(form)

  		




  140
  140
  
    
    assert '<h4 class="test">Foobar</h4>' in str(form.render())

  		




  141
  141
  
    

  		




  142
  142
  
    
def test_comment():

  		




  143
  143
  
    
    field = fields.CommentField(label='Foobar')

  		




  144
  
  
    
    form = Form()

  		




  
  144
  
    
    form = Form(use_tokens=False)

  		




  145
  145
  
    
    field.add_to_form(form)

  		




  146
  146
  
    
    assert '<p class="comment-field ">Foobar</p>' in str(form.render())

  		




  147
  147
  
    

  		




  148
  148
  
    
    field = fields.CommentField(label='Foo\n\nBar\n\nBaz')

  		




  149
  
  
    
    form = Form()

  		




  
  149
  
    
    form = Form(use_tokens=False)

  		




  150
  150
  
    
    field.add_to_form(form)

  		




  151
  151
  
    
    assert '<p>Foo</p>\n<p>Bar</p>\n<p>Baz</p>' in str(form.render())

  		




  152
  152
  
    
    assert '<div class="comment-field "' in str(form.render())

  		




  ......




  154
  154
  
    
    # test for variable substitution

  		




  155
  155
  
    
    pub.substitutions.feed(MockSubstitutionVariables())

  		




  156
  156
  
    
    field = fields.CommentField(label='[bar]')

  		




  157
  
  
    
    form = Form()

  		




  
  157
  
    
    form = Form(use_tokens=False)

  		




  158
  158
  
    
    field.add_to_form(form)

  		




  159
  159
  
    
    assert '<p class="comment-field ">Foobar</p>' in str(form.render())

  		




  160
  160
  
    

  		




  161
  161
  
    
    # test for proper escaping of substitution variables

  		




  162
  162
  
    
    field = fields.CommentField(label='[foo]')

  		




  163
  
  
    
    form = Form()

  		




  
  163
  
    
    form = Form(use_tokens=False)

  		




  164
  164
  
    
    field.add_to_form(form)

  		




  165
  165
  
    
    assert '<p class="comment-field ">1 &lt; 3</p>' in str(form.render())

  		




  166
  166
  
    

  		




  167
  167
  
    
    # test for html content

  		




  168
  168
  
    
    field = fields.CommentField(label='<p>Foobar</p>')

  		




  169
  
  
    
    form = Form()

  		




  
  169
  
    
    form = Form(use_tokens=False)

  		




  170
  170
  
    
    field.add_to_form(form)

  		




  171
  171
  
    
    assert '<p>Foobar</p>' in str(form.render())

  		




  172
  172
  
    
    assert '<div class="comment-field "' in str(form.render())

  		




  ......




  191
  191
  
    

  		




  192
  192
  
    
    for item_kwargs in items_kwargs:

  		




  193
  193
  
    
        field = fields.ItemField(id='1', label='Foobar', **item_kwargs)

  		




  194
  
  
    
        form = Form()

  		




  
  194
  
    
        form = Form(use_tokens=False)

  		




  195
  195
  
    
        field.add_to_form(form)

  		




  196
  196
  
    
        assert str(form.render()).count('<option') == 3

  		




  197
  197
  
    

  		




  198
  198
  
    
        field = fields.ItemField(id='1', label='Foobar', required=False,

  		




  199
  199
  
    
                **item_kwargs)

  		




  200
  
  
    
        form = Form()

  		




  
  200
  
    
        form = Form(use_tokens=False)

  		




  201
  201
  
    
        field.add_to_form(form)

  		




  202
  202
  
    
        assert str(form.render()).count('<option') == 3

  		




  203
  203
  
    

  		




  204
  204
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  205
  205
  
    
                required=False, hint='Bla bla bla', **item_kwargs)

  		




  206
  
  
    
        form = Form()

  		




  
  206
  
    
        form = Form(use_tokens=False)

  		




  207
  207
  
    
        field.add_to_form(form)

  		




  208
  208
  
    
        assert str(form.render()).count('<option value="">Bla bla bla</option>') == 1 # ---

  		




  209
  209
  
    
        assert str(form.render()).count('<option') == 4

  		




  210
  210
  
    

  		




  211
  211
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  212
  212
  
    
                required=True, hint='Bla bla bla', **item_kwargs)

  		




  213
  
  
    
        form = Form()

  		




  
  213
  
    
        form = Form(use_tokens=False)

  		




  214
  214
  
    
        field.add_to_form(form)

  		




  215
  215
  
    
        assert str(form.render()).count('<option value="">Bla bla bla</option>') == 1 # ---

  		




  216
  216
  
    
        assert str(form.render()).count('<option') == 4

  		




  ......




  223
  223
  
    
        'value': '''[]'''}})

  		




  224
  224
  
    
    for item_kwargs in items_kwargs:

  		




  225
  225
  
    
        field = fields.ItemField(id='1', label='Foobar', **item_kwargs)

  		




  226
  
  
    
        form = Form()

  		




  
  226
  
    
        form = Form(use_tokens=False)

  		




  227
  227
  
    
        field.add_to_form(form)

  		




  228
  228
  
    
        assert str(form.render()).count('<option') == 1

  		




  229
  229
  
    

  		




  230
  230
  
    
        field = fields.ItemField(id='1', label='Foobar', required=False,

  		




  231
  231
  
    
                **item_kwargs)

  		




  232
  
  
    
        form = Form()

  		




  
  232
  
    
        form = Form(use_tokens=False)

  		




  233
  233
  
    
        field.add_to_form(form)

  		




  234
  234
  
    
        assert str(form.render()).count('<option') == 1

  		




  235
  235
  
    

  		




  236
  236
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  237
  237
  
    
                required=False, hint='Bla bla bla', **item_kwargs)

  		




  238
  
  
    
        form = Form()

  		




  
  238
  
    
        form = Form(use_tokens=False)

  		




  239
  239
  
    
        field.add_to_form(form)

  		




  240
  240
  
    
        assert str(form.render()).count('<option value="">Bla bla bla</option>') == 1 # ---

  		




  241
  241
  
    
        assert str(form.render()).count('<option') == 1

  		




  242
  242
  
    

  		




  243
  243
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  244
  244
  
    
                required=True, hint='Bla bla bla', **item_kwargs)

  		




  245
  
  
    
        form = Form()

  		




  
  245
  
    
        form = Form(use_tokens=False)

  		




  246
  246
  
    
        field.add_to_form(form)

  		




  247
  247
  
    
        assert str(form.render()).count('<option value="">Bla bla bla</option>') == 1 # ---

  		




  248
  248
  
    
        assert str(form.render()).count('<option') == 1

  		




  ......




  256
  256
  
    

  		




  257
  257
  
    
    for item_kwargs in items_kwargs:

  		




  258
  258
  
    
        field = fields.ItemField(id='1', label='Foobar', show_as_radio=True, **item_kwargs)

  		




  259
  
  
    
        form = Form()

  		




  
  259
  
    
        form = Form(use_tokens=False)

  		




  260
  260
  
    
        field.add_to_form(form)

  		




  261
  261
  
    
        assert str(form.render()).count('"radio"') == 3

  		




  262
  262
  
    

  		




  263
  263
  
    
        field = fields.ItemField(id='1', label='Foobar', required=False,

  		




  264
  264
  
    
                show_as_radio=True, **item_kwargs)

  		




  265
  
  
    
        form = Form()

  		




  
  265
  
    
        form = Form(use_tokens=False)

  		




  266
  266
  
    
        field.add_to_form(form)

  		




  267
  267
  
    
        assert str(form.render()).count('"radio"') == 3

  		




  268
  268
  
    

  		




  269
  269
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  270
  270
  
    
                show_as_radio=True, required=False, hint='Bla bla bla', **item_kwargs)

  		




  271
  
  
    
        form = Form()

  		




  
  271
  
    
        form = Form(use_tokens=False)

  		




  272
  272
  
    
        field.add_to_form(form)

  		




  273
  273
  
    
        assert str(form.render()).count('"radio"') == 3

  		




  274
  274
  
    

  		




  275
  275
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  276
  276
  
    
                show_as_radio=True, required=True, hint='Bla bla bla', **item_kwargs)

  		




  277
  
  
    
        form = Form()

  		




  
  277
  
    
        form = Form(use_tokens=False)

  		




  278
  278
  
    
        field.add_to_form(form)

  		




  279
  279
  
    
        assert str(form.render()).count('"radio"') == 3

  		




  280
  280
  
    

  		




  ......




  286
  286
  
    
        'value': '''[]'''}})

  		




  287
  287
  
    
    for item_kwargs in items_kwargs:

  		




  288
  288
  
    
        field = fields.ItemField(id='1', label='Foobar', show_as_radio=True, **item_kwargs)

  		




  289
  
  
    
        form = Form()

  		




  
  289
  
    
        form = Form(use_tokens=False)

  		




  290
  290
  
    
        field.add_to_form(form)

  		




  291
  291
  
    
        assert str(form.render()).count('"radio"') == 1

  		




  292
  292
  
    

  		




  293
  293
  
    
        field = fields.ItemField(id='1', label='Foobar', required=False,

  		




  294
  294
  
    
                show_as_radio=True, **item_kwargs)

  		




  295
  
  
    
        form = Form()

  		




  
  295
  
    
        form = Form(use_tokens=False)

  		




  296
  296
  
    
        field.add_to_form(form)

  		




  297
  297
  
    
        assert str(form.render()).count('"radio"') == 1

  		




  298
  298
  
    

  		




  299
  299
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  300
  300
  
    
                show_as_radio=True, required=False, hint='Bla bla bla', **item_kwargs)

  		




  301
  
  
    
        form = Form()

  		




  
  301
  
    
        form = Form(use_tokens=False)

  		




  302
  302
  
    
        field.add_to_form(form)

  		




  303
  303
  
    
        assert str(form.render()).count('"radio"') == 1

  		




  304
  304
  
    

  		




  305
  305
  
    
        field = fields.ItemField(id='1', label='Foobar',

  		




  306
  306
  
    
                show_as_radio=True, required=True, hint='Bla bla bla', **item_kwargs)

  		




  307
  
  
    
        form = Form()

  		




  
  307
  
    
        form = Form(use_tokens=False)

  		




  308
  308
  
    
        field.add_to_form(form)

  		




  309
  309
  
    
        assert str(form.render()).count('"radio"') == 1

  		




  310
  310
  
    

  		




  311
  311
  
    
def test_item_radio_lengths():

  		




  312
  312
  
    
    field = fields.ItemField(id='1', label='Foobar', show_as_radio=True,

  		




  313
  313
  
    
            items=['aa', 'ab', 'ac'])

  		




  314
  
  
    
    form = Form()

  		




  
  314
  
    
    form = Form(use_tokens=False)

  		




  315
  315
  
    
    field.add_to_form(form)

  		




  316
  316
  
    
    form.render()

  		




  317
  317
  
    
    assert str(form.widgets[-1].render()).count('<br') == 0

  		




  318
  318
  
    

  		




  319
  319
  
    
    field = fields.ItemField(id='1', label='Foobar', show_as_radio=True,

  		




  320
  320
  
    
            items=['aa'*30, 'ab', 'ac'])

  		




  321
  
  
    
    form = Form()

  		




  
  321
  
    
    form = Form(use_tokens=False)

  		




  322
  322
  
    
    field.add_to_form(form)

  		




  323
  323
  
    
    form.render()

  		




  324
  324
  
    
    assert str(form.widgets[-1].render()).count('<br') == 2

  		




  325
  325
  
    

  		




  326
  326
  
    
    field = fields.ItemField(id='1', label='Foobar', show_as_radio=True,

  		




  327
  327
  
    
            items=['aa', 'ab'*30, 'ac'])

  		




  328
  
  
    
    form = Form()

  		




  
  328
  
    
    form = Form(use_tokens=False)

  		




  329
  329
  
    
    field.add_to_form(form)

  		




  330
  330
  
    
    form.render()

  		




  331
  331
  
    
    assert str(form.widgets[-1].render()).count('<br') == 2

  		




  332
  332
  
    

  		




  333
  333
  
    
    field = fields.ItemField(id='1', label='Foobar', show_as_radio=True,

  		




  334
  334
  
    
            items=['aa', 'ab', 'ac', 'ad'])

  		




  335
  
  
    
    form = Form()

  		




  
  335
  
    
    form = Form(use_tokens=False)

  		




  336
  336
  
    
    field.add_to_form(form)

  		




  337
  337
  
    
    form.render()

  		




  338
  338
  
    
    assert str(form.widgets[-1].render()).count('<br') == 3

  		




  ......




  346
  346
  
    

  		




  347
  347
  
    
    for item_kwargs in items_kwargs:

  		




  348
  348
  
    
        field = fields.ItemsField(id='1', label='Foobar', **item_kwargs)

  		




  349
  
  
    
        form = Form()

  		




  
  349
  
    
        form = Form(use_tokens=False)

  		




  350
  350
  
    
        field.add_to_form(form)

  		




  351
  351
  
    
        assert str(form.render()).count('type="checkbox"') == 3

  		




  352
  352
  
    
        assert '>aa<' in str(form.render())

  		












  

    
      wcs/qommon/publisher.py
    
  





  98
  98
  
    
    gettext = lambda self, message: message

  		




  99
  99
  
    
    ngettext = lambda self, msgid1, msgid2, n: msgid1

  		




  100
  100
  
    

  		




  
  101
  
    
    app_dir = None

  		




  
  102
  
    
    form_tokens_dir = None

  		




  
  103
  
    

  		




  101
  104
  
    
    def get_root_url(self):

  		




  102
  105
  
    
        if self.get_request():

  		




  103
  106
  
    
            return self.get_request().environ['SCRIPT_NAME'] + '/'

  		




  ......




  511
  514
  
    
            except OSError, e:

  		




  512
  515
  
    
                pass

  		




  513
  516
  
    

  		




  
  517
  
    
        self.form_tokens_dir = os.path.join(self.app_dir, 'form_tokens')

  		




  
  518
  
    
        try:

  		




  
  519
  
    
            os.mkdir(self.form_tokens_dir)

  		




  
  520
  
    
        except OSError: # already exists

  		




  
  521
  
    
            pass

  		




  
  522
  
    

  		




  514
  523
  
    
    def initialize_app_dir(self):

  		




  515
  524
  
    
        '''If empty initialize the application directory with default

  		




  516
  525
  
    
        configuration. Returns True if initialization has been done.'''

  		












  

    
      wcs/qommon/sessions.py
    
  





  127
  127
  
    

  		




  128
  128
  
    
    session_id = property(get_session_id, set_session_id)

  		




  129
  129
  
    

  		




  
  130
  
    
    def get_form_token_filepath(self, token):

  		




  
  131
  
    
        return os.path.join(get_publisher().form_tokens_dir, token)

  		




  
  132
  
    

  		




  
  133
  
    
    def create_form_token(self):

  		




  
  134
  
    
        token = super(Session, self).create_form_token()

  		




  
  135
  
    
        open(self.get_form_token_filepath(token), 'w').close()

  		




  
  136
  
    
        return token

  		




  
  137
  
    

  		




  
  138
  
    
    def has_form_token(self, token):

  		




  
  139
  
    
        has_form_token = super(Session, self).has_form_token(token)

  		




  
  140
  
    
        if not os.path.exists(self.get_form_token_filepath(token)):

  		




  
  141
  
    
            has_form_token = False

  		




  
  142
  
    
        return has_form_token

  		




  
  143
  
    

  		




  130
  144
  
    
    def remove_form_token(self, token):

  		




  131
  145
  
    
        super(Session, self).remove_form_token(token)

  		




  132
  146
  
    
        self.store()

  		




  
  147
  
    
        try:

  		




  
  148
  
    
            os.unlink(self.get_form_token_filepath(token))

  		




  
  149
  
    
        except OSError:

  		




  
  150
  
    
            pass

  		




  
  151
  
    

  		




  
  152
  
    
    def clean_form_tokens(self):

  		




  
  153
  
    
        dirname = os.path.join(get_publisher().app_dir, 'form_tokens')

  		




  
  154
  
    
        for token in self._form_tokens:

  		




  
  155
  
    
            try:

  		




  
  156
  
    
                os.unlink(os.path.join(dirname, token))

  		




  
  157
  
    
            except OSError:

  		




  
  158
  
    
                pass

  		




  133
  159
  
    

  		




  134
  160
  
    
    def get_user(self):

  		




  135
  161
  
    
        user_id = QuixoteSession.get_user(self)

  		




  ......




  327
  353
  
    

  		




  328
  354
  
    
        if session:

  		




  329
  355
  
    
            session.clean_tempfiles()

  		




  
  356
  
    
            session.clean_form_tokens()

  		




  330
  357
  
    

  		




  331
  358
  
    
    def get_sessions_for_saml(self, name_identifier = Ellipsis, \

  		




  332
  359
  
    
            session_indexes = ()):

  		




  333
  
  
    
-