← Back to branch summary

~barry/mailman/lp1423756

« back to all changes in this revision

Viewing changes to src/mailman/runners/tests/test_outgoing.py

  • Committer: Barry Warsaw
  • Date: 2015-01-05 01:20:33 UTC
  • mfrom: (7264.4.66 py3)
  • Revision ID: barry@list.org-20150105012033-zdrw9c2odhpf22fz
Merge the Python 3 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mailman/runners/tests/test_outgoing.py
17
17
 
18
18
"""Test the outgoing runner."""
19
19
 
20
 
from __future__ import absolute_import, print_function, unicode_literals
21
 
 
22
 
__metaclass__ = type
23
20
__all__ = [
 
21
    'TestOnce',
 
22
    'TestSocketError',
 
23
    'TestSomeRecipientsFailed',
 
24
    'TestVERPSettings',
24
25
    ]
25
26
 
26
27
 
32
33
from contextlib import contextmanager
33
34
from datetime import datetime, timedelta
34
35
from lazr.config import as_timedelta
35
 
from zope.component import getUtility
36
 
 
37
36
from mailman.app.bounces import send_probe
38
37
from mailman.app.lifecycle import create_list
39
38
from mailman.config import config
45
44
from mailman.interfaces.usermanager import IUserManager
46
45
from mailman.runners.outgoing import OutgoingRunner
47
46
from mailman.testing.helpers import (
48
 
    LogFileMark,
49
 
    get_queue_messages,
50
 
    make_testable_runner,
 
47
    LogFileMark, get_queue_messages, make_testable_runner,
51
48
    specialized_message_from_string as message_from_string)
52
49
from mailman.testing.layers import ConfigLayer, SMTPLayer
53
50
from mailman.utilities.datetime import factory, now
 
51
from zope.component import getUtility
54
52
 
55
53
 
56
54
 
96
94
        deliver_after = now() + timedelta(days=10)
97
95
        self._msgdata['deliver_after'] = deliver_after
98
96
        self._outq.enqueue(self._msg, self._msgdata,
99
 
                           tolist=True, listname='test@example.com')
 
97
                           tolist=True, listid='test.example.com')
100
98
        self._runner.run()
101
99
        items = get_queue_messages('out')
102
100
        self.assertEqual(len(items), 1)
149
147
 
150
148
    def test_delivery_callback(self):
151
149
        # Test that the configuration variable calls the appropriate callback.
152
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
150
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
153
151
        self._runner.run()
154
152
        self.assertEqual(captured_mlist, self._mlist)
155
153
        self.assertEqual(captured_msg.as_string(), self._msg.as_string())
156
154
        # Of course, the message metadata will contain a bunch of keys added
157
155
        # by the processing.  We don't really care about the details, so this
158
156
        # test is a good enough stand-in.
159
 
        self.assertEqual(captured_msgdata['listname'], 'test@example.com')
 
157
        self.assertEqual(captured_msgdata['listid'], 'test.example.com')
160
158
 
161
159
    def test_verp_in_metadata(self):
162
160
        # Test that if the metadata has a 'verp' key, it is unchanged.
163
161
        marker = 'yepper'
164
162
        msgdata = dict(verp=marker)
165
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
163
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
166
164
        self._runner.run()
167
165
        self.assertEqual(captured_msgdata['verp'], marker)
168
166
 
171
169
        # indicates, messages will be VERP'd.
172
170
        msgdata = {}
173
171
        self._mlist.personalize = Personalization.individual
174
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
172
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
175
173
        with temporary_config('personalize', """
176
174
        [mta]
177
175
        verp_personalized_deliveries: yes
184
182
        # indicates, messages will be VERP'd.
185
183
        msgdata = {}
186
184
        self._mlist.personalize = Personalization.full
187
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
185
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
188
186
        with temporary_config('personalize', """
189
187
        [mta]
190
188
        verp_personalized_deliveries: yes
197
195
        # does not indicate, messages will not be VERP'd.
198
196
        msgdata = {}
199
197
        self._mlist.personalize = Personalization.full
200
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
198
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
201
199
        self._runner.run()
202
200
        self.assertFalse('verp' in captured_msgdata)
203
201
 
204
202
    def test_verp_never(self):
205
203
        # Never VERP when the interval is zero.
206
204
        msgdata = {}
207
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
205
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
208
206
        with temporary_config('personalize', """
209
207
        [mta]
210
208
        verp_delivery_interval: 0
215
213
    def test_verp_always(self):
216
214
        # Always VERP when the interval is one.
217
215
        msgdata = {}
218
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
216
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
219
217
        with temporary_config('personalize', """
220
218
        [mta]
221
219
        verp_delivery_interval: 1
227
225
        # VERP every so often, when the post_id matches.
228
226
        self._mlist.post_id = 5
229
227
        msgdata = {}
230
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
228
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
231
229
        with temporary_config('personalize', """
232
230
        [mta]
233
231
        verp_delivery_interval: 5
239
237
        # VERP every so often, when the post_id matches.
240
238
        self._mlist.post_id = 4
241
239
        msgdata = {}
242
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
240
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
243
241
        with temporary_config('personalize', """
244
242
            [mta]
245
243
            verp_delivery_interval: 5
287
285
        error_log = logging.getLogger('mailman.error')
288
286
        filename = error_log.handlers[0].filename
289
287
        filepos = os.stat(filename).st_size
290
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
288
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
291
289
        with temporary_config('port 0', """
292
290
            [mta]
293
291
            smtp_port: 0
308
306
        # that is a log message.  Start by opening the error log and reading
309
307
        # the current file position.
310
308
        mark = LogFileMark('mailman.error')
311
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
309
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
312
310
        with temporary_config('port 0', """
313
311
            [mta]
314
312
            smtp_port: 2112
369
367
        token = send_probe(member, self._msg)
370
368
        msgdata = dict(probe_token=token)
371
369
        permanent_failures.append('anne@example.com')
372
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
370
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
373
371
        self._runner.run()
374
372
        events = list(self._processor.unprocessed)
375
373
        self.assertEqual(len(events), 1)
390
388
        getUtility(IPendings).confirm(token)
391
389
        msgdata = dict(probe_token=token)
392
390
        permanent_failures.append('anne@example.com')
393
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
391
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
394
392
        self._runner.run()
395
393
        events = list(self._processor.unprocessed)
396
394
        self.assertEqual(len(events), 0)
404
402
        getUtility(IPendings).confirm(token)
405
403
        msgdata = dict(probe_token=token)
406
404
        temporary_failures.append('anne@example.com')
407
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
405
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
408
406
        self._runner.run()
409
407
        events = list(self._processor.unprocessed)
410
408
        self.assertEqual(len(events), 0)
412
410
    def test_one_permanent_failure(self):
413
411
        # Normal (i.e. non-probe) permanent failures just get registered.
414
412
        permanent_failures.append('anne@example.com')
415
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
413
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
416
414
        self._runner.run()
417
415
        events = list(self._processor.unprocessed)
418
416
        self.assertEqual(len(events), 1)
423
421
        # Two normal (i.e. non-probe) permanent failures just get registered.
424
422
        permanent_failures.append('anne@example.com')
425
423
        permanent_failures.append('bart@example.com')
426
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
424
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
427
425
        self._runner.run()
428
426
        events = list(self._processor.unprocessed)
429
427
        self.assertEqual(len(events), 2)
437
435
        # put in the retry queue, but with some metadata to prevent infinite
438
436
        # retries.
439
437
        temporary_failures.append('cris@example.com')
440
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
438
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
441
439
        self._runner.run()
442
440
        events = list(self._processor.unprocessed)
443
441
        self.assertEqual(len(events), 0)
458
456
        # retries.
459
457
        temporary_failures.append('cris@example.com')
460
458
        temporary_failures.append('dave@example.com')
461
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
459
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
462
460
        self._runner.run()
463
461
        events = list(self._processor.unprocessed)
464
462
        self.assertEqual(len(events), 0)
476
474
        permanent_failures.append('fred@example.com')
477
475
        temporary_failures.append('gwen@example.com')
478
476
        temporary_failures.append('herb@example.com')
479
 
        self._outq.enqueue(self._msg, {}, listname='test@example.com')
 
477
        self._outq.enqueue(self._msg, {}, listid='test.example.com')
480
478
        self._runner.run()
481
479
        # Let's look at the permanent failures.
482
480
        events = list(self._processor.unprocessed)
503
501
                         as_timedelta(config.mta.delivery_retry_period))
504
502
        msgdata = dict(last_recip_count=2,
505
503
                       deliver_until=deliver_until)
506
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
504
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
507
505
        self._runner.run()
508
506
        # The retry queue should have our message waiting to be retried.
509
507
        items = get_queue_messages('retry')
522
520
        deliver_until = datetime(2005, 8, 1, 7, 49, 23) + retry_period
523
521
        msgdata = dict(last_recip_count=2,
524
522
                       deliver_until=deliver_until)
525
 
        self._outq.enqueue(self._msg, msgdata, listname='test@example.com')
 
523
        self._outq.enqueue(self._msg, msgdata, listid='test.example.com')
526
524
        # Before the runner runs, several days pass.
527
525
        factory.fast_forward(retry_period.days + 1)
528
526
        mark = LogFileMark('mailman.smtp')