def test_delete_user(self, delete_account_mock):
factories.UserFactory(last_login=timezone.now())
user2 = factories.UserFactory()
tasks.user_suspended_delete_user(kwargs={"last_login__isnull": True})
self.assertEqual(delete_account_mock.chunks.call_count, 1)
self.assertEqual(delete_account_mock.chunks.call_args,
(([(user2.pk, )], 500), {}))
def test_domain_queryset_methods(self):
user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
# all the permutations of Domains
for args in itertools.product([True, False], [user, other_user, None]):
factories.DomainFactory(enabled=args[0], owner=args[1])
self.assertEqual(models.Domain.objects.available(user).count(), 2)
self.assertEqual(models.Domain.objects.receiving().count(), 3)
def test_disable_emails(self):
user1 = factories.UserFactory(last_login=timezone.now())
user1.inboxenprofile
user2 = factories.UserFactory()
user2.inboxenprofile
tasks.user_suspended_disable_emails(
kwargs={"last_login__isnull": True})
# there should only be one, an exception will be raised otherwise
profile = models.UserProfile.objects.get(receiving_emails=False)
self.assertEqual(profile.user, user2)
def test_delete_emails(self, delete_inboxen_item_mock):
user1 = factories.UserFactory(last_login=timezone.now())
user2 = factories.UserFactory()
factories.EmailFactory(inbox__user=user1)
user2_email = factories.EmailFactory(inbox__user=user2)
tasks.user_suspended_delete_emails(kwargs={"last_login__isnull": True})
self.assertEqual(delete_inboxen_item_mock.chunks.call_count, 1)
self.assertEqual(delete_inboxen_item_mock.chunks.call_args,
(([("email", user2_email.pk)], 500), {}))
def setUp(self):
super(SettingsTestCase, self).setUp()
self.user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
for args in itertools.product([True, False], [self.user, other_user, None]):
factories.DomainFactory(enabled=args[0], owner=args[1])
login = self.client.login(username=self.user.username, password="******", request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_inbox_from_string(self):
user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
inbox = factories.InboxFactory(user=user)
email = "%s@%s" % (inbox.inbox, inbox.domain.domain)
inbox2 = user.inbox_set.from_string(email=email)
self.assertEqual(inbox, inbox2)
with self.assertRaises(models.Inbox.DoesNotExist):
other_user.inbox_set.from_string(email=email)
def test_delete_never_logged_in_user(self, delete_account_mock):
now = timezone.now()
factories.UserFactory(date_joined=now - timedelta(days=40),
last_login=now)
user2 = factories.UserFactory(date_joined=now - timedelta(days=40),
last_login=None)
factories.UserFactory(date_joined=now, last_login=None)
tasks.user_suspended_delete_user_never_logged_in(
kwargs={"last_login__lt": now - timedelta(days=30)})
self.assertEqual(delete_account_mock.chunks.call_count, 1)
self.assertEqual(delete_account_mock.chunks.call_args,
(([(user2.pk, )], 500), {}))
def test_inbox_viewable(self):
user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
# all the permutations of Inboxes that can be viewed
params = (
[0, models.Inbox.flags.deleted, ~models.Inbox.flags.deleted],
[user, other_user, None],
)
for args in itertools.product(*params):
factories.InboxFactory(flags=args[0], user=args[1])
count = models.Inbox.objects.viewable(user).count()
self.assertEqual(count, 2)
def test_full_run(self):
# create users and emails, check user profiles
user1 = factories.UserFactory()
user2 = factories.UserFactory()
user1_email_count = 11
user2_email_count = 4
other_users_email_count = 9
factories.EmailFactory.create_batch(user1_email_count, inbox__user=user1)
factories.EmailFactory.create_batch(user2_email_count, inbox__user=user2)
factories.EmailFactory.create_batch(other_users_email_count)
models.Email.objects.update(seen=True)
models.Inbox.objects.update(new=True)
user1.inboxenprofile.unified_has_new_messages = True
user1.inboxenprofile.save()
user2.inboxenprofile.unified_has_new_messages = True
user2.inboxenprofile.save()
tasks.calculate_quota.delay()
user1.inboxenprofile.refresh_from_db()
user2.inboxenprofile.refresh_from_db()
self.assertEqual(user1.inboxenprofile.quota_percent_usage, 100)
self.assertEqual(user1.inboxenprofile.unified_has_new_messages, True)
self.assertEqual(user2.inboxenprofile.quota_percent_usage, 40)
self.assertEqual(user2.inboxenprofile.unified_has_new_messages, True)
self.assertEqual(models.Email.objects.filter(inbox__user=user1).count(), user1_email_count)
self.assertEqual(models.Email.objects.filter(inbox__user=user2).count(), user2_email_count)
# flags only get changed if there was deleting
self.assertEqual(models.Inbox.objects.filter(new=True).count(),
user1_email_count + user2_email_count + other_users_email_count)
# now enable deleting
models.UserProfile.objects.update(quota_options=models.UserProfile.DELETE_MAIL)
tasks.calculate_quota.delay()
user1.inboxenprofile.refresh_from_db()
user2.inboxenprofile.refresh_from_db()
self.assertEqual(user1.inboxenprofile.quota_percent_usage, 100)
self.assertEqual(user1.inboxenprofile.unified_has_new_messages, False)
self.assertEqual(user2.inboxenprofile.quota_percent_usage, 40)
self.assertEqual(user2.inboxenprofile.unified_has_new_messages, True)
self.assertEqual(models.Email.objects.filter(inbox__user=user1).count(), user1_email_count - 1)
self.assertEqual(models.Email.objects.filter(inbox__user=user2).count(), user2_email_count)
self.assertEqual(models.Inbox.objects.count(), user1_email_count + user2_email_count + other_users_email_count)
self.assertEqual(models.Inbox.objects.filter(new=True).count(),
user1_email_count + user2_email_count + other_users_email_count - 1)
def setUp(self):
"""Create the client and grab the user"""
self.user = factories.UserFactory()
self.other_user = factories.UserFactory(username="******")
for args in itertools.product([True, False],
[self.user, self.other_user, None]):
factories.DomainFactory(enabled=args[0], owner=args[1])
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_inbox_viewable(self):
user = factories.UserFactory()
other_user = factories.UserFactory(username="******")
# all the permutations of Inboxes that can be viewed
params = (
[True, False], # deleted
[True, False], # disabled
[user, other_user, None], # user
)
for args in itertools.product(*params):
factories.InboxFactory(deleted=args[0], disabled=args[1], user=args[2])
count = models.Inbox.objects.viewable(user).count()
self.assertEqual(count, 2)
def setUp(self):
super(QuestionDetailTestCase, self).setUp()
self.user = factories.UserFactory()
self.other_user = factories.UserFactory(username="******")
self.question = QuestionFactory(author=self.user,
status=models.Question.NEW)
self.page = AppPage.objects.get(app="tickets.urls")
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_blog_post(self):
user = factories.UserFactory()
user.is_staff = True
user.save()
models.BlogPost.objects.create(author=user, subject=SUBJECT, draft=True, body=BODY)
post = models.BlogPost.objects.get()
self.assertEqual(post.subject, SUBJECT)
self.assertEqual(post.body, BODY)
self.assertEqual(post.date, None)
self.assertEqual(six.text_type(post), "{} (draft)".format(post.subject))
url = urlresolvers.reverse('blog-post', kwargs={"slug": post.slug})
response = self.client.get(url)
self.assertEqual(response.status_code, 404)
old_mod = post.modified
post.draft = False
post.save()
post = models.BlogPost.objects.get()
self.assertNotEqual(post.date, None)
self.assertNotEqual(post.modified, old_mod)
self.assertEqual(six.text_type(post), "{}".format(post.subject))
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_inbox_disowned(self):
factories.InboxFactory(user=factories.UserFactory())
disowned = factories.InboxFactory(user=None)
qs = models.Inbox.objects.disowned()
self.assertEqual(len(qs), 1)
self.assertEqual(qs[0].id, disowned.id)
def test_after_and_before(self):
user = factories.UserFactory()
inboxes = factories.InboxFactory.create_batch(settings.SEARCH_PAGE_SIZE + 3, user=user, description="bizz")
result = utils.search(self.key, Inbox.objects.search("bizz"), None, None)
expected_results = [i.id for i in inboxes]
expected_results.reverse()
self.assertEqual(result["results"], expected_results[:-3])
self.assertEqual(result["has_next"], True)
self.assertEqual(result["has_previous"], False)
self.assertNotEqual(result["last"], None)
self.assertNotEqual(result["first"], None)
result_2nd = utils.search(self.key, Inbox.objects.search("bizz"), None, result["last"])
self.assertEqual(result_2nd["results"], expected_results[-3:])
self.assertEqual(result_2nd["has_next"], False)
self.assertEqual(result_2nd["has_previous"], True)
self.assertTrue(result_2nd["last"])
self.assertNotEqual(result["last"], result_2nd["last"])
self.assertTrue(result_2nd["first"])
self.assertNotEqual(result["first"], result_2nd["first"])
result_3rd = utils.search(self.key, Inbox.objects.search("bizz"), result_2nd["first"], None)
self.assertEqual(result_3rd["results"], expected_results[:-3])
self.assertEqual(result_3rd["has_next"], True)
self.assertEqual(result_3rd["has_previous"], False)
self.assertEqual(result["first"], result_3rd["first"])
self.assertEqual(result["last"], result_3rd["last"])
def setUp(self):
self.user = factories.UserFactory()
self.tmp_dir = tempfile.mkdtemp()
assert self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
def test_post(self):
grant_sudo(self.client)
other_user = factories.UserFactory(username=self.user.username + "2")
new_username = self.user.username + "1"
old_username = self.user.username
other_username = other_user.username
user_count = get_user_model().objects.count()
# invalid form
params = {"username": new_username, "username2": old_username}
response = self.client.post(self.get_url(), params)
self.user.refresh_from_db()
other_user.refresh_from_db()
# username should remain unchanged
self.assertEqual(response.status_code, 200)
self.assertEqual(self.user.username, old_username)
self.assertEqual(other_user.username, other_username)
self.assertEqual(get_user_model().objects.count(), user_count)
# valid form
params = {"username": new_username, "username2": new_username}
response = self.client.post(self.get_url(), params)
self.user.refresh_from_db()
other_user.refresh_from_db()
# username should changed
self.assertEqual(response.status_code, 302)
self.assertEqual(response["Location"], urlresolvers.reverse("user-settings"))
self.assertEqual(self.user.username, new_username)
self.assertEqual(other_user.username, other_username)
self.assertEqual(get_user_model().objects.count(), user_count)
def test_task(self):
params = [
[True, False], # important
[True, False], # read
[True, False], # auto-delete
[
# received_date
timedelta(days=settings.INBOX_AUTO_DELETE_TIME - 1),
timedelta(days=settings.INBOX_AUTO_DELETE_TIME),
timedelta(days=settings.INBOX_AUTO_DELETE_TIME + 1),
],
]
now = timezone.now()
for args in itertools.product(*params):
email = factories.EmailFactory(important=args[0],
read=args[1],
received_date=now - args[3],
inbox__user=factories.UserFactory())
email.inbox.user.inboxenprofile.auto_delete = args[2]
email.inbox.user.inboxenprofile.save()
self.assertEqual(models.Email.objects.count(), 24)
tasks.auto_delete_emails.delay()
# 2/3 of emails will be old enough
# 1/2 not marked import
# 1/2 users have auto-deleted enabled
# therefore 1/6 emails can be deleted
self.assertEqual(models.Email.objects.count(), 20)
def test_flag_setting(self):
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
with mock.patch(
"inboxen.router.app.server.make_email") as mock_make_email:
process_message(None, inbox.inbox, inbox.domain.domain)
self.assertTrue(mock_make_email.called)
user = get_user_model().objects.get(id=user.id)
profile = user.inboxenprofile
inbox = models.Inbox.objects.get(id=inbox.id)
self.assertTrue(inbox.new)
self.assertTrue(profile.unified_has_new_messages)
# reset some bools
inbox.new = False
inbox.exclude_from_unified = True
inbox.save(update_fields=["new", "exclude_from_unified"])
profile.unified_has_new_messages = False
profile.save(update_fields=["unified_has_new_messages"])
with mock.patch(
"inboxen.router.app.server.make_email") as mock_make_email:
process_message(None, inbox.inbox, inbox.domain.domain)
self.assertTrue(mock_make_email.called)
user = get_user_model().objects.get(id=user.id)
profile = user.inboxenprofile
inbox = models.Inbox.objects.get(id=inbox.id)
self.assertTrue(inbox.new)
self.assertFalse(profile.unified_has_new_messages)
def test_flag_setting(self):
# import here, that way we don't have to fiddle with sys.path in the global scope
from router.app.server import process_message
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
with mock.patch("router.app.server.make_email") as mock_make_email:
process_message(None, inbox.inbox, inbox.domain.domain)
self.assertTrue(mock_make_email.called)
user = get_user_model().objects.get(id=user.id)
profile = user.inboxenprofile
inbox = models.Inbox.objects.get(id=inbox.id)
self.assertTrue(inbox.flags.new)
self.assertTrue(profile.flags.unified_has_new_messages)
# reset some flags
inbox.flags.new = False
inbox.flags.exclude_from_unified = True
inbox.save(update_fields=["flags"])
profile.flags.unified_has_new_messages = False
profile.save(update_fields=["flags"])
with mock.patch("router.app.server.make_email") as mock_make_email:
process_message(None, inbox.inbox, inbox.domain.domain)
self.assertTrue(mock_make_email.called)
user = get_user_model().objects.get(id=user.id)
profile = user.inboxenprofile
inbox = models.Inbox.objects.get(id=inbox.id)
self.assertTrue(inbox.flags.new)
self.assertFalse(profile.flags.unified_has_new_messages)
def test_cycle_session(self):
user = factories.UserFactory()
request = MockRequest(user)
# session will expire in more than a week
request.session.set_expiry(dj_settings.SESSION_COOKIE_AGE * 0.75)
session_key = request.session.session_key
self.middleware.process_request(request)
self.assertEqual(request.session.session_key, session_key)
self.assertEqual(request.session.get_expiry_age(), dj_settings.SESSION_COOKIE_AGE * 0.75)
# session will expire in exactly a week
request.session.set_expiry(dj_settings.SESSION_COOKIE_AGE * 0.5)
session_key = request.session.session_key
self.middleware.process_request(request)
self.assertNotEqual(request.session.session_key, session_key)
self.assertEqual(request.session.get_expiry_age(), dj_settings.SESSION_COOKIE_AGE)
# session will expire in less than a week
request.session.set_expiry(dj_settings.SESSION_COOKIE_AGE* 0.25)
session_key = request.session.session_key
self.middleware.process_request(request)
self.assertNotEqual(request.session.session_key, session_key)
self.assertEqual(request.session.get_expiry_age(), dj_settings.SESSION_COOKIE_AGE)
# no change in expiry, so session key should not change
session_key = request.session.session_key
self.middleware.process_request(request)
self.assertEqual(request.session.session_key, session_key)
def setUp(self):
super(BadEmailTestCase, self).setUp()
self.user = factories.UserFactory()
self.email = factories.EmailFactory(inbox__user=self.user)
body = factories.BodyFactory(data=BODY)
part = factories.PartListFactory(email=self.email, body=body)
factories.HeaderFactory(part=part, name="From")
factories.HeaderFactory(part=part, name="Subject")
factories.HeaderFactory(part=part,
name="Content-Type",
data="text/html; charset=\"windows-1252\"")
factories.HeaderFactory(part=part,
name="Content-Disposition",
data="inline; filename=\"He\n\rl\rlo\nß.jpg\"")
self.email_metaless = factories.EmailFactory(inbox__user=self.user)
body = factories.BodyFactory(data=METALESS_BODY)
part = factories.PartListFactory(email=self.email_metaless, body=body)
factories.HeaderFactory(part=part, name="From")
factories.HeaderFactory(part=part, name="Subject")
factories.HeaderFactory(part=part,
name="Content-Type",
data="text/html; charset=\"ascii\"")
login = self.client.login(username=self.user.username,
password="******",
request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def test_cycle_session_no_cycle(self):
user = factories.UserFactory()
request = MockRequest(user)
request.session.save(must_create=True)
session_key = request.session.session_key
self.middleware(request)
self.assertEqual(request.session.session_key, session_key)
def setUp(self):
self.user = factories.UserFactory()
self.user.inboxenprofile # autocreate a profile
now = timezone.now()
models.Request.objects.create(amount=200, date=now, succeeded=True, requester=self.user, authorizer=self.user)
self.waiting = models.Request.objects.create(amount=200, date=now, requester=self.user)
def setUp(self):
self.user = factories.UserFactory()
self.inbox = factories.InboxFactory(user=self.user)
login = self.client.login(username=self.user.username, password="******", request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def setUp(self):
super(DeleteTestCase, self).setUp()
self.user = factories.UserFactory()
login = self.client.login(username=self.user.username, password="******", request=MockRequest(self.user))
if not login:
raise Exception("Could not log in")
def setUp(self):
super(FlagTestCase, self).setUp()
self.user = factories.UserFactory()
self.inboxes = [
factories.InboxFactory(user=self.user, flags=0),
factories.InboxFactory(user=self.user, flags=models.Inbox.flags.new),
]
self.emails = factories.EmailFactory.create_batch(10, inbox=self.inboxes[0])
self.emails.extend(factories.EmailFactory.create_batch(10, inbox=self.inboxes[1]))
def test_ajax_user(self):
user = factories.UserFactory()
user.inboxenprofile.receiving_emails = False
user.inboxenprofile.save()
request = MockRequest(user)
request.META["HTTP_X_REQUESTED_WITH"] = "jQuery"
response = self.middleware(request)
self.assertEqual(response, {})
def test_last_login(self):
user = factories.UserFactory()
request = MockRequest(user)
request.session.save(must_create=True)
# no change, so no last_login
self.middleware(request)
user.refresh_from_db()
self.assertEqual(user.last_login, None)
def test_routes(self):
from salmon.routing import Router
user = factories.UserFactory()
inbox = factories.InboxFactory(user=user)
Router.load(['app.server'])
with mock.patch("router.app.server.Relay") as relay_mock, \
mock.patch("router.app.server.make_email") as mock_make_email, \
mock.patch("salmon.server.smtplib.SMTP") as smtp_mock:
deliver_mock = mock.Mock()
relay_mock.return_value.deliver = deliver_mock
message = MailRequest("locahost", "test@localhost", str(inbox), TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 1)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
Router.deliver(message)
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 1)
self.assertEqual(deliver_mock.call_count, 1)
self.assertEqual(message, deliver_mock.call_args[0][0])
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
message = MailRequest("locahost", "test@localhost", "root1@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 550)
self.assertEqual(excp.exception.message, "No such address")
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
mock_make_email.reset_mock()
relay_mock.reset_mock()
deliver_mock.reset_mock()
smtp_mock.return_value.sendmail.side_effect = Exception()
message = MailRequest("locahost", "test@localhost", "root@localhost", TEST_MSG)
with self.assertRaises(SMTPError) as excp:
Router.deliver(message)
self.assertEqual(excp.exception.code, 450)
self.assertEqual(excp.exception.message, "Error while forwarding admin message %s" % id(message))
self.assertEqual(mock_make_email.call_count, 0)
self.assertEqual(relay_mock.call_count, 0)
self.assertEqual(deliver_mock.call_count, 0)
