← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to lib/lp/bugs/tests/test_bugnotification.py

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lp/bugs/tests/test_bugnotification.py
10
10
 
11
11
from lazr.lifecycle.event import ObjectModifiedEvent
12
12
from lazr.lifecycle.snapshot import Snapshot
 
13
from storm.store import Store
13
14
from testtools.matchers import Not
14
15
from zope.event import notify
15
16
from zope.interface import providedBy
16
17
 
17
18
from canonical.config import config
 
19
from canonical.database.sqlbase import sqlvalues
18
20
from canonical.launchpad.database.message import MessageSet
19
21
from canonical.launchpad.ftests import login
20
22
from canonical.testing import (
145
147
    def setUp(self):
146
148
        super(TestNotificationsLinkToFilters, self).setUp()
147
149
        self.bug = self.factory.makeBug()
 
150
        self.subscriber = self.factory.makePerson()
 
151
        self.subscription = self.bug.default_bugtask.target.addSubscription(
 
152
            self.subscriber, self.subscriber)
 
153
        self.notification = self.addNotification(self.subscriber)
 
154
 
 
155
    def addNotificationRecipient(self, notification, person):
 
156
        # Manually insert BugNotificationRecipient for
 
157
        # construct_email_notifications to work.
 
158
        # Not sure why using SQLObject constructor doesn't work (it
 
159
        # tries to insert a row with only the ID which fails).
 
160
        Store.of(notification).execute("""
 
161
            INSERT INTO BugNotificationRecipient
 
162
              (bug_notification, person, reason_header, reason_body)
 
163
              VALUES (%s, %s, %s, %s)""" % sqlvalues(
 
164
                          notification, person,
 
165
                          u'reason header', u'reason body'))
 
166
 
 
167
    def addNotification(self, person):
 
168
        # Add a notification along with recipient data.
 
169
        # This is generally done with BugTaskSet.addNotification()
 
170
        # but that requires a more complex set-up.
148
171
        message = self.factory.makeMessage()
149
 
        self.notification = BugNotification(
150
 
            message=message, activity=None, bug=self.bug, is_comment=False,
151
 
            date_emailed=None)
 
172
        notification = BugNotification(
 
173
            message=message, activity=None, bug=self.bug,
 
174
            is_comment=False, date_emailed=None)
 
175
        self.addNotificationRecipient(notification, person)
 
176
        return notification
152
177
 
153
178
    def test_bug_filters_empty(self):
154
179
        # When there are no linked bug filters, it returns a ResultSet
157
182
 
158
183
    def test_bug_filters_single(self):
159
184
        # With a linked BugSubscriptionFilter, it is returned.
160
 
        subscriber=self.factory.makePerson()
161
 
        subscription = self.bug.default_bugtask.target.addSubscription(
162
 
            subscriber, subscriber)
163
 
        bug_filter = subscription.newBugFilter()
 
185
        bug_filter = self.subscription.bug_filters.one()
164
186
        BugNotificationFilter(
165
187
            bug_notification=self.notification,
166
188
            bug_subscription_filter=bug_filter)
167
 
 
168
189
        self.assertContentEqual([bug_filter],
169
190
                                self.notification.bug_filters)
170
191
 
171
192
    def test_bug_filters_multiple(self):
172
193
        # We can have more than one filter matched up with a single
173
194
        # notification.
174
 
        subscriber=self.factory.makePerson()
175
 
        subscription = self.bug.default_bugtask.target.addSubscription(
176
 
            subscriber, subscriber)
177
 
        bug_filter1 = subscription.newBugFilter()
178
 
        bug_filter2 = subscription.newBugFilter()
 
195
        bug_filter1 = self.subscription.bug_filters.one()
 
196
        bug_filter2 = self.subscription.newBugFilter()
179
197
        BugNotificationFilter(
180
198
            bug_notification=self.notification,
181
199
            bug_subscription_filter=bug_filter1)
186
204
        self.assertContentEqual([bug_filter1, bug_filter2],
187
205
                                self.notification.bug_filters)
188
206
 
189
 
    def test_getFiltersByRecipient_empty(self):
190
 
        # When there are no linked bug filters, it returns a ResultSet
191
 
        # with no entries.
192
 
        subscriber = self.factory.makePerson()
193
 
        self.assertTrue(
194
 
            BugNotificationSet().getFiltersByRecipient(
195
 
                [self.notification], subscriber).is_empty())
 
207
    def test_getRecipientFilterData_empty(self):
 
208
        # When there is empty input, there is empty output.
 
209
        self.assertEqual(
 
210
            BugNotificationSet().getRecipientFilterData({}, []),
 
211
            {})
 
212
        self.assertEqual(
 
213
            BugNotificationSet().getRecipientFilterData(
 
214
                {}, [self.notification]),
 
215
            {})
196
216
 
197
 
    def test_getFiltersByRecipient_other_persons(self):
198
 
        # When there is no bug filter for the recipient,
199
 
        # it returns a ResultSet with no entries.
200
 
        recipient = self.factory.makePerson()
201
 
        subscriber = self.factory.makePerson()
202
 
        subscription = self.bug.default_bugtask.target.addSubscription(
203
 
            subscriber, subscriber)
204
 
        bug_filter = subscription.newBugFilter()
 
217
    def test_getRecipientFilterData_other_persons(self):
 
218
        # When there is no named bug filter for the recipient,
 
219
        # it returns the recipient but with no filter descriptions.
 
220
        BugNotificationFilter(
 
221
            bug_notification=self.notification,
 
222
            bug_subscription_filter=self.subscription.bug_filters.one())
 
223
        subscriber2 = self.factory.makePerson()
 
224
        subscription2 = self.bug.default_bugtask.target.addSubscription(
 
225
            subscriber2, subscriber2)
 
226
        bug_filter = subscription2.bug_filters.one()
 
227
        bug_filter.description = u'Special Filter!'
205
228
        BugNotificationFilter(
206
229
            bug_notification=self.notification,
207
230
            bug_subscription_filter=bug_filter)
208
 
        self.assertTrue(
209
 
            BugNotificationSet().getFiltersByRecipient(
210
 
                [self.notification], recipient).is_empty())
 
231
        sources = list(self.notification.recipients)
 
232
        self.assertEqual(
 
233
            {self.subscriber: {'sources': sources,
 
234
                               'filter descriptions': []}},
 
235
            BugNotificationSet().getRecipientFilterData(
 
236
                {self.subscriber: sources}, [self.notification]))
211
237
 
212
 
    def test_getFiltersByRecipient_match(self):
 
238
    def test_getRecipientFilterData_match(self):
213
239
        # When there are bug filters for the recipient,
214
240
        # only those filters are returned.
215
 
        subscriber = self.factory.makePerson()
216
 
        subscription = self.bug.default_bugtask.target.addSubscription(
217
 
            subscriber, subscriber)
218
 
        bug_filter = subscription.newBugFilter()
 
241
        bug_filter = self.subscription.bug_filters.one()
 
242
        bug_filter.description = u'Special Filter!'
219
243
        BugNotificationFilter(
220
244
            bug_notification=self.notification,
221
245
            bug_subscription_filter=bug_filter)
222
 
        self.assertContentEqual(
223
 
            [bug_filter],
224
 
            BugNotificationSet().getFiltersByRecipient(
225
 
                [self.notification], subscriber))
 
246
        sources = list(self.notification.recipients)
 
247
        self.assertEqual(
 
248
            {self.subscriber: {'sources': sources,
 
249
             'filter descriptions': ['Special Filter!']}},
 
250
            BugNotificationSet().getRecipientFilterData(
 
251
                {self.subscriber: sources}, [self.notification]))
226
252
 
227
 
    def test_getFiltersByRecipients_multiple_notifications_match(self):
 
253
    def test_getRecipientFilterData_multiple_notifications_match(self):
228
254
        # When there are bug filters for the recipient for multiple
229
255
        # notifications, return filters for all the notifications.
230
256
        # Set up first notification and filter.
231
 
        subscriber = self.factory.makePerson()
232
 
        subscription = self.bug.default_bugtask.target.addSubscription(
233
 
            subscriber, subscriber)
234
 
        bug_filter = subscription.newBugFilter()
 
257
        bug_filter = self.subscription.bug_filters.one()
 
258
        bug_filter.description = u'Special Filter!'
235
259
        BugNotificationFilter(
236
260
            bug_notification=self.notification,
237
261
            bug_subscription_filter=bug_filter)
238
 
        # set up second notification and filter.
239
 
        bug2 = self.factory.makeBug()
240
 
        message2 = self.factory.makeMessage()
241
 
        notification2 = BugNotification(
242
 
            message=message2, activity=None, bug=bug2, is_comment=False,
243
 
            date_emailed=None)
244
 
        subscription2 = bug2.default_bugtask.target.addSubscription(
245
 
            subscriber, subscriber)
246
 
        bug_filter2 = subscription2.newBugFilter()
 
262
        # Set up second notification and filter.
 
263
        notification2 = self.addNotification(self.subscriber)
 
264
        bug_filter2 = self.subscription.newBugFilter()
 
265
        bug_filter2.description = u'Another Filter!'
247
266
        BugNotificationFilter(
248
267
            bug_notification=notification2,
249
268
            bug_subscription_filter=bug_filter2)
 
269
        sources = list(self.notification.recipients)
 
270
        sources.extend(notification2.recipients)
 
271
        # This first check is really just for the internal consistency of the
 
272
        # test.
 
273
        self.assertEqual(len(sources), 2)
250
274
        # Perform the test.
251
 
        self.assertContentEqual(
252
 
            set([bug_filter, bug_filter2]),
253
 
            set(BugNotificationSet().getFiltersByRecipient(
254
 
                [self.notification, notification2], subscriber)))
 
275
        self.assertEqual(
 
276
            {self.subscriber: {'sources': sources,
 
277
             'filter descriptions': ['Another Filter!', 'Special Filter!']}},
 
278
            BugNotificationSet().getRecipientFilterData(
 
279
                {self.subscriber: sources},
 
280
                [self.notification, notification2]))
255
281
 
256
282
 
257
283
class TestNotificationProcessingWithoutRecipients(TestCaseWithFactory):