← 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
33
33
    BugNotificationFilter,
34
34
    BugNotificationSet,
35
35
    )
 
36
from lp.bugs.model.bugsubscriptionfilter import BugSubscriptionFilterMute
36
37
from lp.testing import TestCaseWithFactory
37
38
from lp.testing.factory import LaunchpadObjectFactory
38
39
from lp.testing.mail_helpers import pop_notifications
175
176
        self.addNotificationRecipient(notification, person)
176
177
        return notification
177
178
 
 
179
    def includeFilterInNotification(self, description=None, subscription=None,
 
180
                                    notification=None,
 
181
                                    create_new_filter=False):
 
182
        if subscription is None:
 
183
            subscription = self.subscription
 
184
        if notification is None:
 
185
            notification = self.notification
 
186
        if create_new_filter:
 
187
            bug_filter = subscription.newBugFilter()
 
188
        else:
 
189
            bug_filter = subscription.bug_filters.one()
 
190
        if description is not None:
 
191
            bug_filter.description = description
 
192
        BugNotificationFilter(
 
193
            bug_notification=notification,
 
194
            bug_subscription_filter=bug_filter)
 
195
 
 
196
    def prepareTwoNotificationsWithFilters(self):
 
197
        # Set up first notification and filter.
 
198
        self.includeFilterInNotification(description=u'Special Filter!')
 
199
        # Set up second notification and filter.
 
200
        self.notification2 = self.addNotification(self.subscriber)
 
201
        self.includeFilterInNotification(description=u'Another Filter!',
 
202
                                         create_new_filter=True,
 
203
                                         notification=self.notification2)
 
204
 
178
205
    def test_bug_filters_empty(self):
179
206
        # When there are no linked bug filters, it returns a ResultSet
180
207
        # with no entries.
182
209
 
183
210
    def test_bug_filters_single(self):
184
211
        # With a linked BugSubscriptionFilter, it is returned.
185
 
        bug_filter = self.subscription.bug_filters.one()
186
 
        BugNotificationFilter(
187
 
            bug_notification=self.notification,
188
 
            bug_subscription_filter=bug_filter)
189
 
        self.assertContentEqual([bug_filter],
 
212
        self.includeFilterInNotification()
 
213
        self.assertContentEqual([self.subscription.bug_filters.one()],
190
214
                                self.notification.bug_filters)
191
215
 
192
216
    def test_bug_filters_multiple(self):
217
241
    def test_getRecipientFilterData_other_persons(self):
218
242
        # When there is no named bug filter for the recipient,
219
243
        # 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())
 
244
        self.includeFilterInNotification()
223
245
        subscriber2 = self.factory.makePerson()
224
246
        subscription2 = self.bug.default_bugtask.target.addSubscription(
225
247
            subscriber2, subscriber2)
226
 
        bug_filter = subscription2.bug_filters.one()
227
 
        bug_filter.description = u'Special Filter!'
228
 
        BugNotificationFilter(
229
 
            bug_notification=self.notification,
230
 
            bug_subscription_filter=bug_filter)
 
248
        notification2 = self.addNotification(subscriber2)
 
249
        self.includeFilterInNotification(subscription=subscription2,
 
250
                                         description=u'Special Filter!',
 
251
                                         notification=notification2)
231
252
        sources = list(self.notification.recipients)
 
253
        sources2 = list(notification2.recipients)
232
254
        self.assertEqual(
233
255
            {self.subscriber: {'sources': sources,
234
 
                               'filter descriptions': []}},
 
256
                               'filter descriptions': []},
 
257
             subscriber2: {'sources': sources2, 
 
258
                           'filter descriptions': [u'Special Filter!']}},
235
259
            BugNotificationSet().getRecipientFilterData(
236
 
                {self.subscriber: sources}, [self.notification]))
 
260
                {self.subscriber: sources, subscriber2: sources2},
 
261
                [self.notification, notification2]))
237
262
 
238
263
    def test_getRecipientFilterData_match(self):
239
264
        # When there are bug filters for the recipient,
240
265
        # only those filters are returned.
241
 
        bug_filter = self.subscription.bug_filters.one()
242
 
        bug_filter.description = u'Special Filter!'
243
 
        BugNotificationFilter(
244
 
            bug_notification=self.notification,
245
 
            bug_subscription_filter=bug_filter)
 
266
        self.includeFilterInNotification(description=u'Special Filter!')
246
267
        sources = list(self.notification.recipients)
247
268
        self.assertEqual(
248
269
            {self.subscriber: {'sources': sources,
253
274
    def test_getRecipientFilterData_multiple_notifications_match(self):
254
275
        # When there are bug filters for the recipient for multiple
255
276
        # notifications, return filters for all the notifications.
256
 
        # Set up first notification and filter.
257
 
        bug_filter = self.subscription.bug_filters.one()
258
 
        bug_filter.description = u'Special Filter!'
259
 
        BugNotificationFilter(
260
 
            bug_notification=self.notification,
261
 
            bug_subscription_filter=bug_filter)
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!'
266
 
        BugNotificationFilter(
267
 
            bug_notification=notification2,
268
 
            bug_subscription_filter=bug_filter2)
 
277
        self.prepareTwoNotificationsWithFilters()
 
278
        # Perform the test.
269
279
        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)
274
 
        # Perform the test.
 
280
        sources.extend(self.notification2.recipients)
 
281
        assert(len(sources)==2)
275
282
        self.assertEqual(
276
283
            {self.subscriber: {'sources': sources,
277
284
             'filter descriptions': ['Another Filter!', 'Special Filter!']}},
278
285
            BugNotificationSet().getRecipientFilterData(
279
286
                {self.subscriber: sources},
 
287
                [self.notification, self.notification2]))
 
288
 
 
289
    def test_getRecipientFilterData_mute(self):
 
290
        # When there are bug filters for the recipient,
 
291
        # only those filters are returned.
 
292
        self.includeFilterInNotification(description=u'Special Filter!')
 
293
        # Mute the first filter.
 
294
        BugSubscriptionFilterMute(
 
295
            person=self.subscriber,
 
296
            filter=self.notification.bug_filters.one())
 
297
        sources = list(self.notification.recipients)
 
298
        self.assertEqual(
 
299
            {},
 
300
            BugNotificationSet().getRecipientFilterData(
 
301
                {self.subscriber: sources}, [self.notification]))
 
302
 
 
303
    def test_getRecipientFilterData_mute_one_person_of_two(self):
 
304
        self.includeFilterInNotification()
 
305
        # Mute the first filter.
 
306
        BugSubscriptionFilterMute(
 
307
            person=self.subscriber,
 
308
            filter=self.notification.bug_filters.one())
 
309
        subscriber2 = self.factory.makePerson()
 
310
        subscription2 = self.bug.default_bugtask.target.addSubscription(
 
311
            subscriber2, subscriber2)
 
312
        notification2 = self.addNotification(subscriber2)
 
313
        self.includeFilterInNotification(subscription=subscription2,
 
314
                                         description=u'Special Filter!',
 
315
                                         notification=notification2)
 
316
        sources = list(self.notification.recipients)
 
317
        sources2 = list(notification2.recipients)
 
318
        self.assertEqual(
 
319
            {subscriber2: {'sources': sources2, 
 
320
                           'filter descriptions': [u'Special Filter!']}},
 
321
            BugNotificationSet().getRecipientFilterData(
 
322
                {self.subscriber: sources, subscriber2: sources2},
280
323
                [self.notification, notification2]))
281
324
 
 
325
    def test_getRecipientFilterData_mute_one_filter_of_two(self):
 
326
        self.prepareTwoNotificationsWithFilters()
 
327
        # Mute the first filter.
 
328
        BugSubscriptionFilterMute(
 
329
            person=self.subscriber,
 
330
            filter=self.notification.bug_filters.one())
 
331
        sources = list(self.notification.recipients)
 
332
        sources.extend(self.notification2.recipients)
 
333
        # Perform the test.
 
334
        self.assertEqual(
 
335
            {self.subscriber: {'sources': sources,
 
336
             'filter descriptions': ['Another Filter!']}},
 
337
            BugNotificationSet().getRecipientFilterData(
 
338
                {self.subscriber: sources},
 
339
                [self.notification, self.notification2]))
 
340
 
 
341
    def test_getRecipientFilterData_mute_both_filters_mutes(self):
 
342
        self.prepareTwoNotificationsWithFilters()
 
343
        # Mute the first filter.
 
344
        BugSubscriptionFilterMute(
 
345
            person=self.subscriber,
 
346
            filter=self.notification.bug_filters.one())
 
347
        # Mute the second filter.
 
348
        BugSubscriptionFilterMute(
 
349
            person=self.subscriber,
 
350
            filter=self.notification2.bug_filters.one())
 
351
        sources = list(self.notification.recipients)
 
352
        sources.extend(self.notification2.recipients)
 
353
        # Perform the test.
 
354
        self.assertEqual(
 
355
            {},
 
356
            BugNotificationSet().getRecipientFilterData(
 
357
                {self.subscriber: sources},
 
358
                [self.notification, self.notification2]))
 
359
 
282
360
 
283
361
class TestNotificationProcessingWithoutRecipients(TestCaseWithFactory):
284
362
    """Adding notificatons without any recipients does not cause any harm.