def test_create_thread_response(self):
"""create a thread with one response,
then load thread for the user
test that only the root message is retrieved"""
root_message = self.create_thread_for_user(self.sender, self.recipient)
response = Message.objects.create_response(
sender=self.recipient,
text='some response',
parent=root_message
)
self.assertEqual(response.message_type, Message.STORED)
#assert that there is only one "seen" memo for the response
memos = MessageMemo.objects.filter(message=response)
self.assertEqual(memos.count(), 1)
self.assertEqual(memos[0].user, self.recipient)
self.assertEqual(memos[0].status, MessageMemo.SEEN)
#assert that recipients are the two people who are part of
#this conversation
recipients = set(response.recipients.all())
sender_group = get_personal_group(self.sender)
recipient_group = get_personal_group(self.recipient)
expected_recipients = set([sender_group, recipient_group])
self.assertEqual(recipients, expected_recipients)
def test_create_thread_for_user(self):
"""the basic create thread with one recipient
tests that the recipient is there"""
message = self.create_thread_for_user(self.sender, self.recipient)
# message type is stored
self.assertEqual(message.message_type, Message.STORED)
# recipient is in the list of recipients
recipients = set(message.recipients.all())
recipient_group = get_personal_group(self.recipient)
# sender_group = get_personal_group(self.sender) # maybe add this too
expected_recipients = set([recipient_group])
self.assertEqual(recipients, expected_recipients)
# self.assertRaises(
# MessageMemo.DoesNotExist,
# MessageMemo.objects.get,
# message=message
#)
# make sure that the original senders memo to the root
# message is marke ad seen
memos = MessageMemo.objects.filter(
message=message,
user=self.sender
)
self.assertEquals(memos.count(), 1)
self.assertEqual(memos[0].status, MessageMemo.SEEN)
def create_user(name):
"""creates a user and a personal group,
returns the created user"""
user = User.objects.create_user(name, name + '@example.com')
# note that askbot will take care of three lines below automatically
try:
group = get_personal_group(user)
except Group.DoesNotExist:
group = create_personal_group(user)
group_name = '_personal_%d' % user.id
group, created = Group.objects.get_or_create(name=group_name)
user.groups.add(group)
return user
def create_user(name):
"""creates a user and a personal group,
returns the created user"""
user = User.objects.create_user(name, name + '@example.com')
# note that askbot will take care of three lines below automatically
try:
group = get_personal_group(user)
except Group.DoesNotExist:
group = create_personal_group(user)
group_name = '_personal_%d' % user.id
group, created = Group.objects.get_or_create(name=group_name)
user.groups.add(group)
return user
def test_create_thread_response(self):
"""create a thread with one response,
then load thread for the user
test that only the root message is retrieved"""
root_message = self.create_thread_for_user(self.sender, self.recipient)
response = Message.objects.create_response(sender=self.recipient,
text='some response',
parent=root_message)
self.assertEqual(response.message_type, Message.STORED)
# assert that there is only one "seen" memo for the response
memos = MessageMemo.objects.filter(message=response)
self.assertEqual(memos.count(), 1)
self.assertEqual(memos[0].user, self.recipient)
self.assertEqual(memos[0].status, MessageMemo.SEEN)
# assert that recipients are the two people who are part of
# this conversation
recipients = set(response.recipients.all())
sender_group = get_personal_group(self.sender)
recipient_group = get_personal_group(self.recipient)
expected_recipients = set([sender_group, recipient_group])
self.assertEqual(recipients, expected_recipients)
def test_create_thread_for_user(self):
"""the basic create thread with one recipient
tests that the recipient is there"""
message = self.create_thread_for_user(self.recipient)
#message type is stored
self.assertEqual(message.message_type, Message.STORED)
#recipient is in the list of recipients
recipients = set(message.recipients.all())
recipient_group = get_personal_group(self.recipient)
#sender_group = get_personal_group(self.sender) #maybe add this too
expected_recipients = set([recipient_group])
self.assertEqual(recipients, expected_recipients)
self.assertRaises(
MessageMemo.DoesNotExist,
MessageMemo.objects.get,
message=message
)
def test_create_thread_for_user(self):
"""the basic create thread with one recipient
tests that the recipient is there"""
message = self.create_thread_for_user(self.sender, self.recipient)
# message type is stored
self.assertEqual(message.message_type, Message.STORED)
# recipient is in the list of recipients
recipients = set(message.recipients.all())
recipient_group = get_personal_group(self.recipient)
# sender_group = get_personal_group(self.sender) # maybe add this too
expected_recipients = set([recipient_group])
self.assertEqual(recipients, expected_recipients)
# self.assertRaises(
# MessageMemo.DoesNotExist,
# MessageMemo.objects.get,
# message=message
#)
# make sure that the original senders memo to the root
# message is marke ad seen
memos = MessageMemo.objects.filter(message=message, user=self.sender)
self.assertEquals(memos.count(), 1)
self.assertEqual(memos[0].status, MessageMemo.SEEN)
def create_thread_for_user(self, sender, recipient):
group = get_personal_group(recipient)
return self.create_thread(sender, [group])
def create_thread_for_user(self, user):
group = get_personal_group(user)
return self.create_thread([group])
def create_thread_for_user(self, sender, recipient):
group = get_personal_group(recipient)
return self.create_thread(sender, [group])
def create_thread_for_user(self, user):
group = get_personal_group(user)
return self.create_thread([group])