~barry/mailman/events-and-web

« back to all changes in this revision

Viewing changes to src/mailman/handlers/tests/test_mimedel.py

  • Committer: Barry Warsaw
  • Date: 2012-11-25 20:56:16 UTC
  • mfrom: (7178.2.6 3.0)
  • Revision ID: barry@list.org-20121125205616-x1h66aenqkftnadh
Trunk merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
37
37
from mailman.interfaces.member import MemberRole
38
38
from mailman.interfaces.usermanager import IUserManager
39
39
from mailman.testing.helpers import (
40
 
    LogFileMark,
41
 
    get_queue_messages,
 
40
    LogFileMark, configuration, get_queue_messages,
42
41
    specialized_message_from_string as mfs)
43
42
from mailman.testing.layers import ConfigLayer
44
43
 
58
57
Message-ID: <ant>
59
58
 
60
59
""")
61
 
        # Python 2.7 has assertMultiLineEqual.  Let this work without bounds.
62
 
        self.maxDiff = None
63
 
        self.eq = getattr(self, 'assertMultiLineEqual', self.assertEqual)
64
60
        config.push('dispose', """
65
61
        [mailman]
66
62
        site_owner: noreply@example.com
67
63
        """)
 
64
        # Let assertMultiLineEqual work without bounds.
 
65
        self.maxDiff = None
68
66
 
69
67
    def tearDown(self):
70
68
        config.pop('dispose')
71
69
 
72
70
    def test_dispose_discard(self):
73
71
        self._mlist.filter_action = FilterAction.discard
74
 
        try:
 
72
        with self.assertRaises(errors.DiscardMessage) as cm:
75
73
            mime_delete.dispose(self._mlist, self._msg, {}, 'discarding')
76
 
        except errors.DiscardMessage as error:
77
 
            pass
78
 
        else:
79
 
            raise AssertionError('DiscardMessage exception expected')
80
 
        self.assertEqual(error.message, 'discarding')
 
74
        self.assertEqual(cm.exception.message, 'discarding')
81
75
        # There should be no messages in the 'bad' queue.
82
76
        self.assertEqual(len(get_queue_messages('bad')), 0)
83
77
 
84
78
    def test_dispose_bounce(self):
85
79
        self._mlist.filter_action = FilterAction.reject
86
 
        try:
 
80
        with self.assertRaises(errors.RejectMessage) as cm:
87
81
            mime_delete.dispose(self._mlist, self._msg, {}, 'rejecting')
88
 
        except errors.RejectMessage as error:
89
 
            pass
90
 
        else:
91
 
            raise AssertionError('RejectMessage exception expected')
92
 
        self.assertEqual(error.message, 'rejecting')
 
82
        self.assertEqual(cm.exception.message, 'rejecting')
93
83
        # There should be no messages in the 'bad' queue.
94
84
        self.assertEqual(len(get_queue_messages('bad')), 0)
95
85
 
103
93
        self._mlist.subscribe(bart, MemberRole.moderator)
104
94
        # Now set the filter action and dispose the message.
105
95
        self._mlist.filter_action = FilterAction.forward
106
 
        try:
 
96
        with self.assertRaises(errors.DiscardMessage) as cm:
107
97
            mime_delete.dispose(self._mlist, self._msg, {}, 'forwarding')
108
 
        except errors.DiscardMessage as error:
109
 
            pass
110
 
        else:
111
 
            raise AssertionError('DiscardMessage exception expected')
112
 
        self.assertEqual(error.message, 'forwarding')
 
98
        self.assertEqual(cm.exception.message, 'forwarding')
113
99
        # There should now be a multipart message in the virgin queue destined
114
100
        # for the mailing list owners.
115
101
        messages = get_queue_messages('virgin')
128
114
        # The body of the first part provides the moderators some details.
129
115
        part0 = message.get_payload(0)
130
116
        self.assertEqual(part0.get_content_type(), 'text/plain')
131
 
        self.eq(part0.get_payload(), """\
 
117
        self.assertMultiLineEqual(part0.get_payload(), """\
132
118
The attached message matched the Test mailing list's content
133
119
filtering rules and was prevented from being forwarded on to the list
134
120
membership.  You are receiving the only remaining copy of the discarded
143
129
        self.assertEqual(original['subject'], 'A disposable message')
144
130
        self.assertEqual(original['message-id'], '<ant>')
145
131
 
 
132
    @configuration('mailman', filtered_messages_are_preservable='no')
146
133
    def test_dispose_non_preservable(self):
147
134
        # Two actions can happen here, depending on a site-wide setting.  If
148
135
        # the site owner has indicated that filtered messages cannot be
149
136
        # preserved, then this is the same as discarding them.
150
137
        self._mlist.filter_action = FilterAction.preserve
151
 
        config.push('non-preservable', """
152
 
        [mailman]
153
 
        filtered_messages_are_preservable: no
154
 
        """)
155
 
        try:
 
138
        with self.assertRaises(errors.DiscardMessage) as cm:
156
139
            mime_delete.dispose(self._mlist, self._msg, {}, 'not preserved')
157
 
        except errors.DiscardMessage as error:
158
 
            pass
159
 
        else:
160
 
            raise AssertionError('DiscardMessage exception expected')
161
 
        finally:
162
 
            config.pop('non-preservable')
163
 
        self.assertEqual(error.message, 'not preserved')
 
140
        self.assertEqual(cm.exception.message, 'not preserved')
164
141
        # There should be no messages in the 'bad' queue.
165
142
        self.assertEqual(len(get_queue_messages('bad')), 0)
166
143
 
 
144
    @configuration('mailman', filtered_messages_are_preservable='yes')
167
145
    def test_dispose_preservable(self):
168
146
        # Two actions can happen here, depending on a site-wide setting.  If
169
147
        # the site owner has indicated that filtered messages can be
170
148
        # preserved, then this is similar to discarding the message except
171
149
        # that a copy is preserved in the 'bad' queue.
172
150
        self._mlist.filter_action = FilterAction.preserve
173
 
        config.push('preservable', """
174
 
        [mailman]
175
 
        filtered_messages_are_preservable: yes
176
 
        """)
177
 
        try:
 
151
        with self.assertRaises(errors.DiscardMessage) as cm:
178
152
            mime_delete.dispose(self._mlist, self._msg, {}, 'preserved')
179
 
        except errors.DiscardMessage as error:
180
 
            pass
181
 
        else:
182
 
            raise AssertionError('DiscardMessage exception expected')
183
 
        finally:
184
 
            config.pop('preservable')
185
 
        self.assertEqual(error.message, 'preserved')
 
153
        self.assertEqual(cm.exception.message, 'preserved')
186
154
        # There should be no messages in the 'bad' queue.
187
155
        messages = get_queue_messages('bad')
188
156
        self.assertEqual(len(messages), 1)
200
168
                       FilterAction.defer):
201
169
            self._mlist.filter_action = action
202
170
            mark = LogFileMark('mailman.error')
203
 
            try:
 
171
            with self.assertRaises(errors.DiscardMessage) as cm:
204
172
                mime_delete.dispose(self._mlist, self._msg, {}, 'bad action')
205
 
            except errors.DiscardMessage as error:
206
 
                pass
207
 
            else:
208
 
                raise AssertionError('DiscardMessage exception expected')
209
 
            self.assertEqual(error.message, 'bad action')
 
173
            self.assertEqual(cm.exception.message, 'bad action')
210
174
            line = mark.readline()[:-1]
211
175
            self.assertTrue(line.endswith(
212
176
                '{0} invalid FilterAction: test@example.com.  '