def setUp(self):
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testPass')
self.client.login(username='******', password='******')
store = kittystore.get_store(SettingsModule(), debug=False)
ml = FakeList("*****@*****.**")
ml.subject_prefix = u"[example] "
# Create 3 threads
messages = []
for msgnum in range(3):
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<id%d>" % (msgnum + 1)
msg["Subject"] = "Dummy message"
msg.set_payload("Dummy message")
store.add_to_list(ml, msg)
messages.append(msg)
# 1st is unread, 2nd is read, 3rd is updated
LastView.objects.create(list_address="*****@*****.**",
user=self.user,
threadid=get_message_id_hash("<id2>"))
LastView.objects.create(list_address="*****@*****.**",
user=self.user,
threadid=get_message_id_hash("<id3>"))
msg4 = Message()
msg4["From"] = "*****@*****.**"
msg4["Message-ID"] = "<id4>"
msg4["Subject"] = "Dummy message"
msg4["In-Reply-To"] = "<id3>"
msg4.set_payload("Dummy message")
store.add_to_list(ml, msg4)
# Factory
defaults = {"kittystore.store": store, "HTTP_USER_AGENT": "testbot"}
self.factory = RequestFactory(**defaults)
def test_list_complex_rule_deletion(self):
# Test that the mailing-list header-match complex rules are read
# properly after deletion.
chain = config.chains['header-match']
header_matches = IHeaderMatchList(self._mlist)
header_matches.append('Foo', 'a+', 'reject')
header_matches.append('Bar', 'b+', 'discard')
header_matches.append('Baz', 'z+', 'accept')
links = [
link for link in chain.get_links(self._mlist, Message(), {})
if link.rule.name != 'any'
]
self.assertEqual(len(links), 3)
self.assertEqual([
(link.rule.header, link.rule.pattern, link.action, link.chain.name)
for link in links
], [
('foo', 'a+', LinkAction.jump, 'reject'),
('bar', 'b+', LinkAction.jump, 'discard'),
('baz', 'z+', LinkAction.jump, 'accept'),
]) # noqa: E124
del header_matches[0]
links = [
link for link in chain.get_links(self._mlist, Message(), {})
if link.rule.name != 'any'
]
self.assertEqual(len(links), 2)
self.assertEqual([
(link.rule.header, link.rule.pattern, link.action, link.chain.name)
for link in links
], [
('bar', 'b+', LinkAction.jump, 'discard'),
('baz', 'z+', LinkAction.jump, 'accept'),
]) # noqa: E124
def test_thread_neighbors(self):
ml = FakeList("example-list")
# Create 3 threads
msg_t1_1 = Message()
msg_t1_1["From"] = "*****@*****.**"
msg_t1_1["Message-ID"] = "<id1_1>"
msg_t1_1.set_payload("Dummy message")
self.store.add_to_list(ml, msg_t1_1)
msg_t2_1 = Message()
msg_t2_1["From"] = "*****@*****.**"
msg_t2_1["Message-ID"] = "<id2_1>"
msg_t2_1.set_payload("Dummy message")
self.store.add_to_list(ml, msg_t2_1)
msg_t3_1 = Message()
msg_t3_1["From"] = "*****@*****.**"
msg_t3_1["Message-ID"] = "<id3_1>"
msg_t3_1.set_payload("Dummy message")
self.store.add_to_list(ml, msg_t3_1)
# Check the neighbors
def check_neighbors(thread, expected_prev, expected_next):
thread_id = get_message_id_hash("<id%s_1>" % thread)
prev_th, next_th = self.store.get_thread_neighbors(
"example-list", thread_id)
# convert to something I can compare
prev_th = prev_th and prev_th.thread_id
expected_prev = expected_prev and \
get_message_id_hash("<id%s_1>" % expected_prev)
next_th = next_th and next_th.thread_id
expected_next = expected_next and \
get_message_id_hash("<id%s_1>" % expected_next)
# compare
self.assertEqual(prev_th, expected_prev)
self.assertEqual(next_th, expected_next)
# Order should be: 1, 2, 3
check_neighbors(1, None, 2)
check_neighbors(2, 1, 3)
check_neighbors(3, 2, None)
# now add a new message in thread 1, which becomes the most recently
# active
msg_t1_2 = Message()
msg_t1_2["From"] = "*****@*****.**"
msg_t1_2["Message-ID"] = "<id1_2>"
msg_t1_2["In-Reply-To"] = "<id1_1>"
msg_t1_2.set_payload("Dummy message")
self.store.add_to_list(ml, msg_t1_2)
# Order should be: 2, 3, 1
check_neighbors(2, None, 3)
check_neighbors(3, 2, 1)
check_neighbors(1, 3, None)
def _get_msg(self):
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg["Message-ID-Hash"] = "QKODQBCADMDSP5YPOPKECXQWEQAMXZL3"
msg.set_payload("Dummy message")
return msg
def setUp(self):
self.user = User.objects.create_user('testuser', '*****@*****.**',
'testPass')
self.user.is_staff = True
self.user.save()
self.client.login(username='******', password='******')
self.store = kittystore.get_store(SettingsModule(),
debug=False,
auto_create=True)
self.client.defaults = {
"kittystore.store": self.store,
"HTTP_USER_AGENT": "testbot",
}
ml = FakeList("*****@*****.**")
ml.subject_prefix = u"[example] "
# Create 2 threads
self.messages = []
for msgnum in range(2):
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<id%d>" % (msgnum + 1)
msg["Subject"] = "Dummy message"
msg.set_payload("Dummy message")
msg["Message-ID-Hash"] = self.store.add_to_list(ml, msg)
self.messages.append(msg)
def test_vote_cancel(self):
ml = FakeList("*****@*****.**")
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<msg1>"
msg.set_payload("Dummy message")
self.store.add_to_list(ml, msg)
msg.replace_header("Message-ID", "<msg2>")
self.store.add_to_list(ml, msg)
msg1 = self.store.get_message_by_id_from_list("*****@*****.**",
"msg1")
msg1.vote(1, u"testuser")
msg2 = self.store.get_message_by_id_from_list("*****@*****.**",
"msg2")
msg2.vote(-1, u"testuser")
self.assertEqual(msg1.likes, 1)
self.assertEqual(msg2.dislikes, 1)
for msg in (msg1, msg2):
url = reverse('message_vote',
args=("*****@*****.**", msg.message_id_hash))
resp = self.client.post(url, {"vote": "0"})
self.assertEqual(resp.status_code, 200)
self.assertEqual(msg.likes, 0)
self.assertEqual(msg.dislikes, 0)
result = json.loads(resp.content)
self.assertEqual(result["like"], 0)
self.assertEqual(result["dislike"], 0)
def process(self, mlist, msg, msgdata):
"""See `IHandler`."""
# Short circuit for non-digestable messages.
if not mlist.digestable or msgdata.get('isdigest'):
return
# Open the mailbox that will be used to collect the current digest.
mailbox_path = os.path.join(mlist.data_path, 'digest.mmdf')
# Lock the mailbox and append the message.
with Mailbox(mailbox_path, create=True) as mbox:
mbox.add(msg)
# Calculate the current size of the mailbox file. This will not tell
# us exactly how big the resulting MIME and rfc1153 digest will
# actually be, but it's the most easily available metric to decide
# whether the size threshold has been reached.
size = os.path.getsize(mailbox_path)
if size >= mlist.digest_size_threshold * 1024.0:
# The digest is ready to send. Because we don't want to hold up
# this process with crafting the digest, we're going to move the
# digest file to a safe place, then craft a fake message for the
# DigestRunner as a trigger for it to build and send the digest.
mailbox_dest = os.path.join(
mlist.data_path,
'digest.{0.volume}.{0.next_digest_number}.mmdf'.format(mlist))
volume = mlist.volume
digest_number = mlist.next_digest_number
bump_digest_number_and_volume(mlist)
os.rename(mailbox_path, mailbox_dest)
config.switchboards['digest'].enqueue(Message(),
listid=mlist.list_id,
digest_path=mailbox_dest,
volume=volume,
digest_number=digest_number)
def test_message_has_sender(self):
msg = Message()
msg['From'] = '*****@*****.**'
msgdata = {}
result = self._rule.check(self._mlist, msg, msgdata)
self.assertFalse(result)
self.assertEqual(msgdata, {})
def test_on_new_message_userid(self):
# Check that the user_id is set on a new message
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload("Dummy message")
# setup Mailman's reply
new_user_id = FakeMMUser()
uid = uuid.uuid1()
new_user_id.user_id = uid.int
self.mm_client.get_user.side_effect = lambda addr: new_user_id
# check the User does not exist yet
self.assertEqual(0,
self.store.get_message_count_by_user_id(uid))
# do the test and check
self.store.add_to_list("example-list", msg)
dbmsg = self.store.get_message_by_id_from_list(
"example-list", "dummy")
self.assertEqual(dbmsg.sender.user_id, uid)
self.assertTrue(dbmsg.sender.user is not None,
"A 'User' instance was not created")
self.assertEqual(dbmsg.sender.user.id, uid)
self.assertEqual(1,
self.store.get_message_count_by_user_id(uid))
self.assertEqual(self.store.get_users_count(), 1)
def test_join_bad_argument_no_equal(self):
# Try to subscribe a member with a bad argument via join.
msg = Message()
msg['From'] = '*****@*****.**'
results = Results()
self._command.process(self._mlist, msg, {}, ('digest', ), results)
self.assertIn('bad argument: digest', str(results))
def test_add_in_classical_thread(self):
# msg1
# |-msg2
# | `-msg4
# `-msg3
ml = FakeList("example-list")
msgs = []
for num in range(1, 5):
msg = Message()
msg["From"] = "*****@*****.**" % num
msg["Message-ID"] = "<msg%d>" % num
msg.set_payload("message %d" % num)
msgs.append(msg)
msgs[1]["In-Reply-To"] = "<msg1>"
msgs[2]["In-Reply-To"] = "<msg1>"
msgs[3]["In-Reply-To"] = "<msg2>"
for msg in msgs:
self.store.add_to_list(ml, msg)
msgs = []
for num in range(1, 5):
msg = self.store.get_message_by_id_from_list(
"example-list", "msg%d" % num)
msgs.append(msg)
msg1, msg2, msg3, msg4 = msgs
self.assertEqual(msg1.thread_order, 0)
self.assertEqual(msg1.thread_depth, 0)
self.assertEqual(msg2.thread_order, 1)
self.assertEqual(msg2.thread_depth, 1)
self.assertEqual(msg3.thread_order, 3)
self.assertEqual(msg3.thread_depth, 1)
self.assertEqual(msg4.thread_order, 2)
self.assertEqual(msg4.thread_depth, 2)
def test_re_only_mixed(self):
# Incoming subject is only Re:.
msg = Message()
msg['Subject'] = '=?utf-8?Q?Re:?='
self._process(self._mlist, msg, {})
subject = msg['subject']
self.assertEqual(str(subject), '[Test] Re: ')
def test_sync_mailman_user(self):
# Check that the user_id is set when sync_mailman_user is run
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload("Dummy message")
self.store.add_to_list("example-list", msg)
dbmsg = self.store.get_message_by_id_from_list(
"example-list", "dummy")
self.assertEqual(dbmsg.sender.user_id, None)
# setup Mailman's reply
uid = uuid.uuid1()
new_user_id = FakeMMUser()
new_user_id.user_id = uid.int
self.mm_client.get_user.side_effect = lambda addr: new_user_id
# do the test and check
mailman_user.sync_mailman_user(self.store)
#dbmsg = self.store.get_message_by_id_from_list(
# "example-list", "dummy")
self.assertEqual(dbmsg.sender.user_id, uid)
self.assertTrue(dbmsg.sender.user is not None,
"A 'User' instance was not created")
self.assertEqual(dbmsg.sender.user.id, uid)
self.assertEqual(1,
self.store.get_message_count_by_user_id(uid))
def test_re_prefix(self):
# The subject has a Re: prefix. Make sure that gets preserved, but
# after the list prefix.
msg = Message()
msg['Subject'] = 'Re: [Test] A test message'
self._process(self._mlist, msg, {})
self.assertEqual(str(msg['subject']), '[Test] Re: A test message')
def test_properties_on_new_message(self):
ml = FakeList("example-list")
ml.display_name = "name 1"
ml.subject_prefix = "[prefix 1]"
ml.description = "desc 1"
kittystore.utils.MM_CLIENT.get_list.side_effect = lambda n: ml
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload("Dummy message")
self.store.add_to_list("example-list", msg)
ml_db = self.store.get_lists()[0]
self.assertEqual(ml_db.display_name, "name 1")
self.assertEqual(ml_db.subject_prefix, "[prefix 1]")
ml.display_name = "name 2"
ml.subject_prefix = "[prefix 2]"
ml.description = "desc 2"
ml.archive_policy = "private"
msg.replace_header("Message-ID", "<dummy2>")
self.store.add_to_list("example-list", msg)
ml_db = self.store.get_lists()[0]
#ml_db = self.store.db.find(List).one()
self.assertEqual(ml_db.display_name, "name 2")
self.assertEqual(ml_db.subject_prefix, "[prefix 2]")
self.assertEqual(ml_db.description, "desc 2")
self.assertEqual(ml_db.archive_policy, ArchivePolicy.private)
def test_fasttrack(self):
# Messages internally crafted are 'fast tracked' and don't get their
# Subjects prefixed either.
msg = Message()
msg['Subject'] = 'A test message'
self._process(self._mlist, msg, dict(_fasttrack=True))
self.assertEqual(str(msg['subject']), 'A test message')
def test_prefix(self):
# The Subject gets prefixed. The prefix gets automatically set by the
# list style when the list gets created.
msg = Message()
msg['Subject'] = 'A test message'
self._process(self._mlist, msg, {})
self.assertEqual(str(msg['subject']), '[Test] A test message')
def test_whitespace_only_prefix(self):
# If the Subject prefix only contains whitespace, ignore it.
self._mlist.subject_prefix = ' '
msg = Message()
msg['Subject'] = 'A test message'
self._process(self._mlist, msg, {})
self.assertEqual(str(msg['subject']), 'A test message')
def test_starting_message_1(self):
# A basic thread: msg2 replies to msg1
ml = FakeList("example-list")
msg1 = Message()
msg1["From"] = "*****@*****.**"
msg1["Message-ID"] = "<msg1>"
msg1.set_payload("message 1")
self.store.add_to_list(ml, msg1)
msg2 = Message()
msg2["From"] = "*****@*****.**"
msg2["Message-ID"] = "<msg2>"
msg2.set_payload("message 2")
msg2["In-Reply-To"] = msg1["Message-ID"]
self.store.add_to_list(ml, msg2)
thread = self.store.db.find(Thread).one()
self.assertEqual(thread.starting_email.message_id, "msg1")
def test_on_new_message_invalidate(self):
# Check that the cache is invalidated on new message
msg = Message()
msg["From"] = "*****@*****.**"
msg["Message-ID"] = "<dummy>"
msg.set_payload("Dummy message")
today = datetime.datetime.utcnow().date() # don't use datetime.date.today(), we need UTC
self.store.add_to_list("example-list", msg)
# calls to cache.delete() -- invalidation
delete_args = [ call[0][0] for call in
self.store.db.cache.delete.call_args_list ]
#from pprint import pprint; pprint(delete_args)
self.assertEqual(set(delete_args), set([
u'list:example-list:recent_participants_count',
u'list:example-list:recent_threads_count',
u'list:example-list:participants_count:%d:%d' % (today.year, today.month),
u'list:example-list:thread:QKODQBCADMDSP5YPOPKECXQWEQAMXZL3:emails_count',
u'list:example-list:thread:QKODQBCADMDSP5YPOPKECXQWEQAMXZL3:participants_count'
]))
# calls to cache.get_or_create() -- repopulation
goc_args = [ call[0][0] for call in
self.store.db.cache.get_or_create.call_args_list ]
#from pprint import pprint; pprint(goc_args)
self.assertEqual(set(goc_args), set([
u'list:example-list:recent_participants_count',
u'list:example-list:recent_threads_count',
u'list:example-list:participants_count:%d:%d' % (today.year, today.month),
u'list:example-list:threads_count:%d:%d' % (today.year, today.month),
u'list:example-list:thread:QKODQBCADMDSP5YPOPKECXQWEQAMXZL3:emails_count',
u'list:example-list:thread:QKODQBCADMDSP5YPOPKECXQWEQAMXZL3:participants_count',
u'list:example-list:thread:QKODQBCADMDSP5YPOPKECXQWEQAMXZL3:starting_email_id',
]))
def test_prefix_only_mixed(self):
# Incoming subject is only the prefix.
msg = Message()
msg['Subject'] = '=?utf-8?Q?[Test]_?='
self._process(self._mlist, msg, {})
subject = msg['subject']
self.assertEqual(str(subject), '[Test] ')
def test_bad_configuration_line(self):
# Take a mark on the error log file.
mark = LogFileMark('mailman.error')
# A bad value in [antispam]header_checks should just get ignored, but
# with an error message logged.
chain = config.chains['header-match']
# The links are created dynamically; the rule names will all start
# with the same prefix, but have a variable suffix. The actions will
# all be to jump to the named chain. Do these checks now, while we
# collect other useful information.
post_checks = []
saw_any_rule = False
for link in chain.get_links(self._mlist, Message(), {}):
if link.rule.name == 'any':
saw_any_rule = True
self.assertEqual(link.action, LinkAction.jump)
elif saw_any_rule:
raise AssertionError("'any' rule was not last")
else:
self.assertEqual(link.rule.name[:13], 'header-match-')
self.assertEqual(link.action, LinkAction.defer)
post_checks.append((link.rule.header, link.rule.pattern))
self.assertListEqual(post_checks, [
('Foo', 'foo'),
('Bar', 'bar'),
])
# Check the error log.
self.assertEqual(mark.readline()[-77:-1],
'Configuration error: [antispam]header_checks '
'contains bogus line: A-bad-line')
def test_isdigest(self):
# If the message is destined for the digest, the Subject header does
# not get touched.
msg = Message()
msg['Subject'] = 'A test message'
self._process(self._mlist, msg, dict(isdigest=True))
self.assertEqual(str(msg['subject']), 'A test message')
def test_save_original_subject(self):
# When the Subject gets prefixed, the original is saved in the message
# metadata.
msgdata = {}
msg = Message()
msg['Subject'] = 'A test message'
self._process(self._mlist, msg, msgdata)
self.assertEqual(msgdata['original_subject'], 'A test message')
def test_join_other_bogus(self):
# Try to subscribe a bogus different address via join.
msg = Message()
msg['From'] = '*****@*****.**'
results = Results()
self._command.process(self._mlist, msg, {}, ('address=bogus', ),
results)
self.assertIn('Invalid email address: bogus', str(results))
def test_no_welcome_message(self):
# When configured not to send a welcome message, none is sent.
self._mlist.send_welcome_message = False
status = self._command.process(self._mlist, Message(), {},
(self._token, ), Results())
self.assertEqual(status, ContinueProcessing.yes)
# There will be no messages in the queue.
get_queue_messages('virgin', expected_count=0)
def test_join_digest(self):
# Subscribe a member to digest via join.
msg = Message()
msg['From'] = '*****@*****.**'
results = Results()
self._command.process(self._mlist, msg, {}, ('digest=mime', ), results)
self.assertIn('Confirmation email sent to [email protected]',
str(results))
def test_join_posting_address(self):
# Try to subscribe the list posting address.
msg = Message()
msg['From'] = self._mlist.posting_address
results = Results()
self._command.process(self._mlist, msg, {}, (), results)
self.assertEqual(
str(results).splitlines()[-1], 'List posting address not allowed')
def test_no_subject_returns_reason(self):
msg = Message()
msg['Subject'] = Header('')
msgdata = {}
result = self._rule.check(self._mlist, msg, msgdata)
self.assertTrue(result)
self.assertEqual(msgdata['moderation_reasons'],
['Message has no subject'])
def test_starting_message_2(self):
# A partially-imported thread: msg1 replies to something we don't have
ml = FakeList("example-list")
msg1 = Message()
msg1["From"] = "*****@*****.**"
msg1["Message-ID"] = "<msg1>"
msg1["In-Reply-To"] = "<msg0>"
msg1.set_payload("message 1")
self.store.add_to_list(ml, msg1)
msg2 = Message()
msg2["From"] = "*****@*****.**"
msg2["Message-ID"] = "<msg2>"
msg2["In-Reply-To"] = msg1["Message-ID"]
msg2.set_payload("message 2")
self.store.add_to_list(ml, msg2)
thread = self.store.db.find(Thread).one()
self.assertEqual(thread.starting_email.message_id, "msg1")
