← Back to branch summary

~barry/mailman/events-and-web

« back to all changes in this revision

Viewing changes to src/mailman/rules/tests/test_approved.py

  • Committer: Barry Warsaw
  • Date: 2012-04-05 05:43:40 UTC
  • Revision ID: barry@list.org-20120405054340-tcpcksw951pr76nr
 * A mailing list's *moderator password* is no longer stored in the clear; it
   is hashed with the currently selected scheme.

Also:

 - Simplify and rewrite the approved.rst doctest.  Now just document the good
   path, and only describe its functionality using the Approved: header, which
   is the recommended header.
 - Greatly expand the unittests for the approved rule.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mailman/rules/tests/test_approved.py
15
15
# You should have received a copy of the GNU General Public License along with
16
16
# GNU Mailman.  If not, see <http://www.gnu.org/licenses/>.
17
17
 
18
 
"""Test the mime_delete handler."""
 
18
"""Test the `approved` handler."""
19
19
 
20
20
from __future__ import absolute_import, print_function, unicode_literals
21
21
 
22
22
__metaclass__ = type
23
23
__all__ = [
24
24
    'TestApproved',
 
25
    'TestApprovedNonASCII',
 
26
    'TestApprovedPseudoHeader',
 
27
    'TestApprovedPseudoHeaderMIME',
25
28
    ]
26
29
 
27
30
 
28
31
import unittest
29
32
 
 
33
from flufl.password import lookup, make_secret
 
34
 
30
35
from mailman.app.lifecycle import create_list
 
36
from mailman.config import config
31
37
from mailman.rules import approved
32
38
from mailman.testing.helpers import (
33
39
    specialized_message_from_string as mfs)
42
48
 
43
49
    def setUp(self):
44
50
        self._mlist = create_list('test@example.com')
 
51
        scheme = lookup(config.passwords.password_scheme.upper())
 
52
        self._mlist.moderator_password = make_secret('super secret', scheme)
 
53
        self._rule = approved.Approved()
 
54
        self._msg = mfs("""\
 
55
From: anne@example.com
 
56
To: test@example.com
 
57
Subject: A Message with non-ascii body
 
58
Message-ID: <ant>
 
59
MIME-Version: 1.0
 
60
 
 
61
A message body.
 
62
""")
 
63
 
 
64
    def test_approved_header(self):
 
65
        self._msg['Approved'] = 'super secret'
 
66
        result = self._rule.check(self._mlist, self._msg, {})
 
67
        self.assertTrue(result)
 
68
 
 
69
    def test_approve_header(self):
 
70
        self._msg['Approve'] = 'super secret'
 
71
        result = self._rule.check(self._mlist, self._msg, {})
 
72
        self.assertTrue(result)
 
73
 
 
74
    def test_x_approved_header(self):
 
75
        self._msg['X-Approved'] = 'super secret'
 
76
        result = self._rule.check(self._mlist, self._msg, {})
 
77
        self.assertTrue(result)
 
78
 
 
79
    def test_x_approve_header(self):
 
80
        self._msg['X-Approve'] = 'super secret'
 
81
        result = self._rule.check(self._mlist, self._msg, {})
 
82
        self.assertTrue(result)
 
83
 
 
84
    def test_approved_header_wrong_password(self):
 
85
        self._msg['Approved'] = 'not the password'
 
86
        result = self._rule.check(self._mlist, self._msg, {})
 
87
        self.assertFalse(result)
 
88
 
 
89
    def test_approve_header_wrong_password(self):
 
90
        self._msg['Approve'] = 'not the password'
 
91
        result = self._rule.check(self._mlist, self._msg, {})
 
92
        self.assertFalse(result)
 
93
 
 
94
    def test_x_approved_header_wrong_password(self):
 
95
        self._msg['X-Approved'] = 'not the password'
 
96
        result = self._rule.check(self._mlist, self._msg, {})
 
97
        self.assertFalse(result)
 
98
 
 
99
    def test_x_approve_header_wrong_password(self):
 
100
        self._msg['X-Approve'] = 'not the password'
 
101
        result = self._rule.check(self._mlist, self._msg, {})
 
102
        self.assertFalse(result)
 
103
 
 
104
    def test_removes_approved_header(self):
 
105
        self._msg['Approved'] = 'super secret'
 
106
        self._rule.check(self._mlist, self._msg, {})
 
107
        self.assertEqual(self._msg['approved'], None)
 
108
 
 
109
    def test_removes_approve_header(self):
 
110
        self._msg['Approve'] = 'super secret'
 
111
        self._rule.check(self._mlist, self._msg, {})
 
112
        self.assertEqual(self._msg['approve'], None)
 
113
 
 
114
    def test_removes_x_approved_header(self):
 
115
        self._msg['X-Approved'] = 'super secret'
 
116
        self._rule.check(self._mlist, self._msg, {})
 
117
        self.assertEqual(self._msg['x-approved'], None)
 
118
 
 
119
    def test_removes_x_approve_header(self):
 
120
        self._msg['X-Approve'] = 'super secret'
 
121
        self._rule.check(self._mlist, self._msg, {})
 
122
        self.assertEqual(self._msg['x-approve'], None)
 
123
 
 
124
    def test_removes_approved_header_wrong_password(self):
 
125
        self._msg['Approved'] = 'not the password'
 
126
        self._rule.check(self._mlist, self._msg, {})
 
127
        self.assertEqual(self._msg['approved'], None)
 
128
 
 
129
    def test_removes_approve_header_wrong_password(self):
 
130
        self._msg['Approve'] = 'not the password'
 
131
        self._rule.check(self._mlist, self._msg, {})
 
132
        self.assertEqual(self._msg['approve'], None)
 
133
 
 
134
    def test_removes_x_approved_header_wrong_password(self):
 
135
        self._msg['X-Approved'] = 'not the password'
 
136
        self._rule.check(self._mlist, self._msg, {})
 
137
        self.assertEqual(self._msg['x-approved'], None)
 
138
 
 
139
    def test_removes_x_approve_header_wrong_password(self):
 
140
        self._msg['X-Approve'] = 'not the password'
 
141
        self._rule.check(self._mlist, self._msg, {})
 
142
        self.assertEqual(self._msg['x-approve'], None)
 
143
 
 
144
 
 
145
 
 
146
class TestApprovedPseudoHeader(unittest.TestCase):
 
147
    """Test the approved handler."""
 
148
 
 
149
    layer = ConfigLayer
 
150
 
 
151
    def setUp(self):
 
152
        self._mlist = create_list('test@example.com')
 
153
        scheme = lookup(config.passwords.password_scheme.upper())
 
154
        self._mlist.moderator_password = make_secret('super secret', scheme)
 
155
        self._rule = approved.Approved()
 
156
        self._msg = mfs("""\
 
157
From: anne@example.com
 
158
To: test@example.com
 
159
Subject: A Message with non-ascii body
 
160
Message-ID: <ant>
 
161
MIME-Version: 1.0
 
162
 
 
163
""")
 
164
 
 
165
    def test_approved_pseudo_header(self):
 
166
        self._msg.set_payload("""\
 
167
Approved: super secret
 
168
        """)
 
169
        result = self._rule.check(self._mlist, self._msg, {})
 
170
        self.assertTrue(result)
 
171
 
 
172
    def test_approve_pseudo_header(self):
 
173
        self._msg.set_payload("""\
 
174
Approve: super secret
 
175
        """)
 
176
        result = self._rule.check(self._mlist, self._msg, {})
 
177
        self.assertTrue(result)
 
178
 
 
179
    def test_x_approved_pseudo_header(self):
 
180
        self._msg.set_payload("""\
 
181
X-Approved: super secret
 
182
        """)
 
183
        result = self._rule.check(self._mlist, self._msg, {})
 
184
        self.assertTrue(result)
 
185
 
 
186
    def test_x_approve_pseudo_header(self):
 
187
        self._msg.set_payload("""\
 
188
X-Approve: super secret
 
189
        """)
 
190
        result = self._rule.check(self._mlist, self._msg, {})
 
191
        self.assertTrue(result)
 
192
 
 
193
    def test_approved_pseudo_header_wrong_password(self):
 
194
        self._msg.set_payload("""\
 
195
Approved: not the password
 
196
        """)
 
197
        result = self._rule.check(self._mlist, self._msg, {})
 
198
        self.assertFalse(result)
 
199
 
 
200
    def test_approve_pseudo_header_wrong_password(self):
 
201
        self._msg.set_payload("""\
 
202
Approve: not the password
 
203
        """)
 
204
        result = self._rule.check(self._mlist, self._msg, {})
 
205
        self.assertFalse(result)
 
206
 
 
207
    def test_x_approved_pseudo_header_wrong_password(self):
 
208
        self._msg.set_payload("""\
 
209
X-Approved: not the password
 
210
        """)
 
211
        result = self._rule.check(self._mlist, self._msg, {})
 
212
        self.assertFalse(result)
 
213
 
 
214
    def test_x_approve_pseudo_header_wrong_password(self):
 
215
        self._msg.set_payload("""\
 
216
X-Approve: not the password
 
217
        """)
 
218
        result = self._rule.check(self._mlist, self._msg, {})
 
219
        self.assertFalse(result)
 
220
 
 
221
    def test_removes_approved_pseudo_header(self):
 
222
        self._msg.set_payload("""\
 
223
Approved: super secret
 
224
        """)
 
225
        self._rule.check(self._mlist, self._msg, {})
 
226
        self.assertFalse('Approved' in self._msg.get_payload())
 
227
 
 
228
    def test_removes_approve_pseudo_header(self):
 
229
        self._msg.set_payload("""\
 
230
Approve: super secret
 
231
        """)
 
232
        self._rule.check(self._mlist, self._msg, {})
 
233
        self.assertFalse('Approve' in self._msg.get_payload())
 
234
 
 
235
    def test_removes_x_approved_pseudo_header(self):
 
236
        self._msg.set_payload("""\
 
237
X-Approved: super secret
 
238
        """)
 
239
        self._rule.check(self._mlist, self._msg, {})
 
240
        self.assertFalse('X-Approved' in self._msg.get_payload())
 
241
 
 
242
    def test_removes_x_approve_pseudo_header(self):
 
243
        self._msg.set_payload("""\
 
244
X-Approve: super secret
 
245
        """)
 
246
        self._rule.check(self._mlist, self._msg, {})
 
247
        self.assertFalse('X-Approve' in self._msg.get_payload())
 
248
 
 
249
    def test_removes_approved_pseudo_header_wrong_password(self):
 
250
        self._msg.set_payload("""\
 
251
Approved: not the password
 
252
        """)
 
253
        self._rule.check(self._mlist, self._msg, {})
 
254
        self.assertFalse('Approved' in self._msg.get_payload())
 
255
 
 
256
    def test_removes_approve_pseudo_header_wrong_password(self):
 
257
        self._msg.set_payload("""\
 
258
Approve: not the password
 
259
        """)
 
260
        self._rule.check(self._mlist, self._msg, {})
 
261
        self.assertFalse('Approve' in self._msg.get_payload())
 
262
 
 
263
    def test_removes_x_approved_pseudo_header_wrong_password(self):
 
264
        self._msg.set_payload("""\
 
265
X-Approved: not the password
 
266
        """)
 
267
        self._rule.check(self._mlist, self._msg, {})
 
268
        self.assertFalse('X-Approved' in self._msg.get_payload())
 
269
 
 
270
    def test_removes_x_approve_pseudo_header_wrong_password(self):
 
271
        self._msg.set_payload("""\
 
272
X-Approve: not the password
 
273
        """)
 
274
        self._rule.check(self._mlist, self._msg, {})
 
275
        self.assertFalse('X-Approve' in self._msg.get_payload())
 
276
 
 
277
 
 
278
 
 
279
class TestApprovedPseudoHeaderMIME(unittest.TestCase):
 
280
    """Test the approved handler."""
 
281
 
 
282
    layer = ConfigLayer
 
283
 
 
284
    def setUp(self):
 
285
        self._mlist = create_list('test@example.com')
 
286
        scheme = lookup(config.passwords.password_scheme.upper())
 
287
        self._mlist.moderator_password = make_secret('super secret', scheme)
 
288
        self._rule = approved.Approved()
 
289
        self._msg_text_template = """\
 
290
From: anne@example.com
 
291
To: test@example.com
 
292
Subject: A Message with non-ascii body
 
293
Message-ID: <ant>
 
294
MIME-Version: 1.0
 
295
Content-Type: multipart/mixed; boundary="AAA"
 
296
 
 
297
--AAA
 
298
Content-Type: application/x-ignore
 
299
 
 
300
{0}: not the password
 
301
The above line will be ignored.
 
302
 
 
303
--AAA
 
304
Content-Type: text/plain
 
305
 
 
306
{0}: {1}
 
307
An important message.
 
308
 
 
309
"""
 
310
 
 
311
    def test_approved_pseudo_header_mime(self):
 
312
        msg = mfs(self._msg_text_template.format('Approved', 'super secret'))
 
313
        result = self._rule.check(self._mlist, msg, {})
 
314
        self.assertTrue(result)
 
315
 
 
316
    def test_approve_pseudo_header_mime(self):
 
317
        msg = mfs(self._msg_text_template.format('Approve', 'super secret'))
 
318
        result = self._rule.check(self._mlist, msg, {})
 
319
        self.assertTrue(result)
 
320
 
 
321
    def test_x_approved_pseudo_header_mime(self):
 
322
        msg = mfs(self._msg_text_template.format('X-Approved', 'super secret'))
 
323
        result = self._rule.check(self._mlist, msg, {})
 
324
        self.assertTrue(result)
 
325
 
 
326
    def test_x_approve_pseudo_header_mime(self):
 
327
        msg = mfs(self._msg_text_template.format('X-Approve', 'super secret'))
 
328
        result = self._rule.check(self._mlist, msg, {})
 
329
        self.assertTrue(result)
 
330
 
 
331
    def test_approved_pseudo_header_wrong_password_mime(self):
 
332
        msg = mfs(self._msg_text_template.format('Approved', 'not password'))
 
333
        result = self._rule.check(self._mlist, msg, {})
 
334
        self.assertFalse(result)
 
335
 
 
336
    def test_approve_pseudo_header_wrong_password_mime(self):
 
337
        msg = mfs(self._msg_text_template.format('Approve', 'not password'))
 
338
        result = self._rule.check(self._mlist, msg, {})
 
339
        self.assertFalse(result)
 
340
 
 
341
    def test_x_approved_pseudo_header_wrong_password_mime(self):
 
342
        msg = mfs(self._msg_text_template.format('X-Approved', 'not password'))
 
343
        result = self._rule.check(self._mlist, msg, {})
 
344
        self.assertFalse(result)
 
345
 
 
346
    def test_x_approve_pseudo_header_wrong_password_mime(self):
 
347
        msg = mfs(self._msg_text_template.format('X-Approve', 'not password'))
 
348
        result = self._rule.check(self._mlist, msg, {})
 
349
        self.assertFalse(result)
 
350
 
 
351
    def test_removes_approved_pseudo_header_mime(self):
 
352
        msg = mfs(self._msg_text_template.format('Approved', 'super secret'))
 
353
        self._rule.check(self._mlist, msg, {})
 
354
        self.assertFalse('Approved' in msg.get_payload(1).get_payload())
 
355
 
 
356
    def test_removes_approve_pseudo_header_mime(self):
 
357
        msg = mfs(self._msg_text_template.format('Approve', 'super secret'))
 
358
        self._rule.check(self._mlist, msg, {})
 
359
        self.assertFalse('Approve' in msg.get_payload(1).get_payload())
 
360
 
 
361
    def test_removes_x_approved_pseudo_header_mime(self):
 
362
        msg = mfs(self._msg_text_template.format('X-Approved', 'super secret'))
 
363
        self._rule.check(self._mlist, msg, {})
 
364
        self.assertFalse('X-Approved' in msg.get_payload(1).get_payload())
 
365
 
 
366
    def test_removes_x_approve_pseudo_header_mime(self):
 
367
        msg = mfs(self._msg_text_template.format('X-Approve', 'super secret'))
 
368
        self._rule.check(self._mlist, msg, {})
 
369
        self.assertFalse('X-Approve' in msg.get_payload(1).get_payload())
 
370
 
 
371
    def test_removes_approved_pseudo_header_wrong_password_mime(self):
 
372
        msg = mfs(self._msg_text_template.format('Approved', 'not password'))
 
373
        self._rule.check(self._mlist, msg, {})
 
374
        self.assertFalse('Approved' in msg.get_payload(1).get_payload())
 
375
 
 
376
    def test_removes_approve_pseudo_header_wrong_password_mime(self):
 
377
        msg = mfs(self._msg_text_template.format('Approve', 'not password'))
 
378
        self._rule.check(self._mlist, msg, {})
 
379
        self.assertFalse('Approve' in msg.get_payload(1).get_payload())
 
380
 
 
381
    def test_removes_x_approved_pseudo_header_wrong_password_mime(self):
 
382
        msg = mfs(self._msg_text_template.format('X-Approved', 'not password'))
 
383
        self._rule.check(self._mlist, msg, {})
 
384
        self.assertFalse('X-Approved' in msg.get_payload(1).get_payload())
 
385
 
 
386
    def test_removes_x_approve_pseudo_header_wrong_password_mime(self):
 
387
        msg = mfs(self._msg_text_template.format('X-Approve', 'not password'))
 
388
        self._rule.check(self._mlist, msg, {})
 
389
        self.assertFalse('X-Approve' in msg.get_payload(1).get_payload())
 
390
 
 
391
 
 
392
 
 
393
class TestApprovedNonASCII(unittest.TestCase):
 
394
    """Test the approved handler with non-ascii messages."""
 
395
 
 
396
    layer = ConfigLayer
 
397
 
 
398
    def setUp(self):
 
399
        self._mlist = create_list('test@example.com')
45
400
        self._rule = approved.Approved()
46
401
        self._msg = mfs("""\
47
402
From: anne@example.com
53
408
Content-Transfer-Encoding: quoted-printable
54
409
 
55
410
This is a message body with a non-ascii character =E4
56
 
 
57
411
""")
58
412
 
59
413
    def test_nonascii_body_missing_header(self):