def test_exclude_multiple(self):
"""Show that passing a sequence to exclude excludes them all."""
SimpleEvent.notify('*****@*****.**').activate().save()
user1 = user(email='*****@*****.**', save=True)
SimpleEvent.notify(user1).activate().save()
user2 = user(email='*****@*****.**', save=True)
SimpleEvent.notify(user2).activate().save()
SimpleEvent().fire(exclude=[user1, user2])
eq_(1, len(mail.outbox))
eq_(['*****@*****.**'], mail.outbox[0].to)
def test_filtered(self):
"""Make sure watches cull properly by additional filters."""
# A watch with just the filter we're searching for:
registered_user = user(email='*****@*****.**', save=True)
exact_watch = watch(event_type=TYPE, user=registered_user, save=True)
watch_filter(watch=exact_watch, name='color', value=1).save()
# A watch with extra filters:
extra_watch = watch(event_type=TYPE, email='*****@*****.**', save=True)
watch_filter(watch=extra_watch, name='color', value=1).save()
watch_filter(watch=extra_watch, name='flavor', value=2).save()
# A watch with no row for the filter we're searching on:
watch(event_type=TYPE, email='*****@*****.**').save()
# A watch with a mismatching filter--shouldn't be found
mismatch_watch = watch(event_type=TYPE, email='*****@*****.**',
save=True)
watch_filter(watch=mismatch_watch, name='color', value=3).save()
self._emails_eq(['*****@*****.**', '*****@*****.**', '*****@*****.**'],
FilteredEvent(), color=1)
# Search on multiple filters to test joining the filters table twice.
# We provide values that match for both filters, as [email protected]
# suffices to test exclusion.
self._emails_eq(['*****@*****.**', '*****@*****.**', '*****@*****.**'],
FilteredEvent(), color=1, flavor=2)
def test_simple(self):
"""Test whether a watch scoped only by event type fires for both
anonymous and registered users."""
registered_user = user(email='*****@*****.**', save=True)
watch(event_type=TYPE, user=registered_user).save()
watch(event_type=TYPE, email='*****@*****.**').save()
watch(event_type='something else', email='*****@*****.**').save()
self._emails_eq(['*****@*****.**', '*****@*****.**'], SimpleEvent())
def test_duplicates(self):
"""Don't return duplicate email addresses."""
watch(event_type=TYPE, user=user(email='*****@*****.**', save=True),
save=True)
watch(event_type=TYPE, email='*****@*****.**').save()
watch(event_type=TYPE, email='*****@*****.**').save()
eq_(3, Watch.objects.all().count()) # We created what we meant to.
self._emails_eq(['*****@*****.**'], SimpleEvent())
def test_merging(self):
"""Test that duplicate emails across multiple events get merged."""
watch(event_type=TYPE, email='*****@*****.**').save()
watch(event_type=TYPE, email='*****@*****.**').save()
registered_user = user(email='*****@*****.**', save=True)
watch(event_type=ANOTHER_TYPE, user=registered_user).save()
self._emails_eq(['*****@*****.**', '*****@*****.**'],
EventUnion(SimpleEvent(), AnotherEvent()))
def test_duplicates_case_insensitive(self):
"""De-duping should compare case-insensitively."""
watch(event_type=TYPE, user=user(email='*****@*****.**', save=True),
save=True)
watch(event_type=TYPE, email='*****@*****.**').save()
watch(event_type=TYPE, email='*****@*****.**').save()
eq_(3, Watch.objects.all().count()) # We created what we meant to.
addresses = [u.email
for u, w in SimpleEvent()._users_watching_by_filter()]
eq_(1, len(addresses))
eq_('*****@*****.**', addresses[0].lower())
def test_mixed(self):
"""Make sure having mixed watches claims right ones."""
# Watch before registering.
watch(email='*****@*****.**', save=True)
watch(email='*****@*****.**', save=True)
# Register nobody.
user(email='*****@*****.**', save=True)
# Then register somebody and watch something after registering.
u = user(email='*****@*****.**', save=True)
watch(user=u, save=True)
claim_watches(u)
# Original anonymous watch is claimed.
assert not Watch.objects.filter(email='*****@*****.**').exists()
eq_(2, Watch.objects.filter(email=None).count())
# No other watches are affected.
assert Watch.objects.filter(email='*****@*****.**').exists()
def test_exclude(self):
"""Assert the `exclude` arg to fire() excludes the given user."""
SimpleEvent.notify('*****@*****.**').activate().save()
registered_user = user(email='*****@*****.**', save=True)
SimpleEvent.notify(registered_user).activate().save()
SimpleEvent().fire(exclude=registered_user)
eq_(1, len(mail.outbox))
first_mail = mail.outbox[0]
eq_(['*****@*****.**'], first_mail.to)
eq_('Subject!', first_mail.subject)
def test_content_type(self):
"""Make sure watches filter properly by content type."""
watch_type = ContentType.objects.get_for_model(Watch)
content_type_type = ContentType.objects.get_for_model(ContentType)
registered_user = user(email='*****@*****.**', save=True)
watch(event_type=TYPE, content_type=content_type_type,
user=registered_user).save()
watch(event_type=TYPE, content_type=content_type_type,
email='*****@*****.**').save()
watch(event_type=TYPE, content_type=watch_type,
email='*****@*****.**').save()
self._emails_eq(['*****@*****.**', '*****@*****.**'],
ContentTypeEvent())
def test_registered_users_favored(self):
"""When removing duplicates, make sure registered users are kept in
favor of anonymous ones having the same email address."""
def make_anonymous_watches():
for x in xrange(3):
watch(event_type=TYPE, email='*****@*****.**').save()
# Throw some anonymous watches in there in the hope that they would
# come out on top if we didn't purposely favor registered users.
# Suggestions on how to make this test more reliable are welcome.
make_anonymous_watches()
# File the registered watch:
watch(event_type=TYPE,
user=user(first_name='Jed', email='*****@*****.**',
save=True)).save()
# A few more anonymous watches in case the BTrees flop in the other
# direction:
make_anonymous_watches()
users_and_watches = list(SimpleEvent()._users_watching_by_filter())
u, w = users_and_watches[0]
eq_('Jed', u.first_name)
def test_unique_by_email_watch_collection(self):
"""Make sure _unique_by_email() collects all watches in each cluster."""
w1, w2, w3 = watch(), watch(), watch(email='hi')
w4, w5, w6 = watch(), watch(), watch(email='lo')
users_and_watches = [
(user(email='hi'), [w1]),
(user(email='hi'), [w2]),
(user(), [w3]),
(user(email='lo'), [w4]),
(user(email='lo'), [w5]),
(user(), [w6])]
result = list(_unique_by_email(users_and_watches))
_, watches = result[0]
eq_(set([w1, w2, w3]), set(watches))
# Make sure the watches accumulator gets cleared between clusters:
_, watches = result[1]
eq_(set([w4, w5, w6]), set(watches))
def _users_watching(self):
return [(user(email='*****@*****.**'), [watch()])]
def test_instance_registered(self):
"""Watch with a registered user."""
registered_user = user(email='*****@*****.**', save=True)
self._test_user_or_email(registered_user)
def test_unique_by_email_user_selection(self):
"""Test the routine that sorts through users and watches having the
same email addresses."""
# Test the best in a cluster coming first, in the middle, and last.
# We mark the correct choices with first_name='a'.
users_and_watches = [
(user(first_name='a', email='hi'), [watch()]),
(user(email='hi'), [watch()]),
(user(), [watch(email='hi')]),
(user(), [watch(email='mid')]),
(user(first_name='a', email='mid'), [watch()]),
(user(), [watch(email='mid')]),
(user(), [watch(email='lo')]),
(user(), [watch(email='lo')]),
(user(first_name='a', email='lo'), [watch()]),
(user(), [watch(email='none', secret='a')]),
(user(), [watch(email='none')])]
favorites = list(_unique_by_email(users_and_watches))
eq_(4, len(favorites))
# Test that we chose the correct users, where there are distinguishable
# (registered) users to choose from:
eq_(['a'] * 3, [u.first_name for u, w in favorites[:3]])
def test_notify_idempotence(self):
"""Assure notify() returns an existing watch when possible."""
u = user(save=True)
w = FilteredContentTypeEvent.notify(u, color=3, flavor=4)
eq_(w.pk, FilteredContentTypeEvent.notify(u, color=3, flavor=4).pk)
eq_(1, Watch.objects.all().count())
def _users_watching(self):
return [(user(email='*****@*****.**'), [watch()]),
(user(email='*****@*****.**'), [watch()])]
def test_none(self):
"""No anonymous watches to claim."""
u = user(email='*****@*****.**', save=True)
claim_watches(u)
def test_unsaved_exclude(self):
"""Excluding an unsaved user should throw a ValueError."""
self.assertRaises(ValueError,
SimpleEvent()._users_watching_by_filter,
exclude=user())
