def test_excludes(self):
excludes = [
{
'id': delimiter.join([self.course001, self.group001]),
'type': u'g'
},
{
'id': delimiter.join([self.course001, self.group002]),
'type': u'g'
},
{
'id': delimiter.join([self.course002, self.group001]),
'type': u'g'
},
]
(groups, count, _) = search(q='Group',
exclude=excludes,
user=self.admin)
self.assertEqual(1, count)
self.assertDictEqual(
{
'name': 'Course Two (Physics) - Group Two (Group)',
'id': delimiter.join([self.course002, self.group002]),
'type': u'g'
}, groups[0])
def test_search_with_single_exclude(self):
g = {
'id': delimiter.join([self.course001, self.group001]),
'type': u'g'
}
(groups, count, _) = search(q='Group One', exclude=[g], user=self.user)
self.assertEqual(1, count)
self.assertDictEqual(
{
'name': 'Course Two (Physics) - Group One (Group)',
'id': delimiter.join([self.course002, self.group001]),
'type': u'g'
}, groups[0])
def test_search_two_results_against_vle_group_id(self):
(groups, count, _) = search(q=self.group001, user=self.user)
self.assertEqual(2, count)
self.assertDictEqual(
{
'name': 'Course One (Maths) - Group One (Group)',
'id': delimiter.join([self.course001, self.group001]),
'type': u'g'
}, groups[0])
self.assertDictEqual(
{
'name': 'Course Two (Physics) - Group One (Group)',
'id': delimiter.join([self.course002, self.group001]),
'type': u'g'
}, groups[1])
def test_create_message_items(self):
m = Message.objects.create(subject='foo')
# put Cersei in the course and the group
CourseMember.objects.create(vle_course_id='001',
user=self.users['Cersei'])
GroupMember.objects.create(vle_course_id='001',
vle_group_id='001',
user=self.users['Cersei'])
# put Lancel in the course but not the group
CourseMember.objects.create(vle_course_id='001',
user=self.users['Lancel'])
# put Jaime in the course and the group
CourseMember.objects.create(vle_course_id='001',
user=self.users['Jaime'])
GroupMember.objects.create(vle_course_id='001',
vle_group_id='001',
user=self.users['Jaime'])
# send to Cersei, everyone in the course, everyone in the group
user_ids = [self.users['Cersei'].id]
group_ids = [delimiter.join(['001', '001'])]
course_ids = ['001']
all_user_ids = expand_user_group_course_ids_to_user_ids(
delimiter, user_ids, group_ids, course_ids)
MessageItem.create_message_items(m, all_user_ids)
self.assertEqual(3, MessageItem.objects.count())
# test that the three recipients are as expected
messages = MessageItem.objects.all().order_by('user__first_name')
self.assertEqual('Cersei', messages[0].user.first_name)
self.assertEqual('Jaime', messages[1].user.first_name)
self.assertEqual('Lancel', messages[2].user.first_name)
def test_search_two_results_against_name(self):
"""
there are three groups entitled "Group One" of which Sansa Stark is in two
"""
(groups, count, _) = search(q='Group One', user=self.user)
self.assertEqual(2, count)
self.assertDictEqual(
{
'name': 'Course One (Maths) - Group One (Group)',
'id': delimiter.join([self.course001, self.group001]),
'type': u'g'
}, groups[0])
self.assertDictEqual(
{
'name': 'Course Two (Physics) - Group One (Group)',
'id': delimiter.join([self.course002, self.group001]),
'type': u'g'
}, groups[1])
def test_search_one_result_against_vle_group_id(self):
(groups, count, _) = search(q=self.group002, user=self.user)
self.assertEqual(1, count)
self.assertDictEqual(
{
'name': 'Course One (Maths) - Group Two (Group)',
'id': delimiter.join([self.course001, self.group002]),
'type': u'g'
}, groups[0])
def test_search_with_multiple_excludes(self):
g1 = {
'id': delimiter.join([self.course001, self.group001]),
'type': u'g'
}
g2 = {
'id': delimiter.join([self.course002, self.group001]),
'type': u'g'
}
(groups, count, _) = search(q='Group One',
exclude=[g1, g2],
user=self.admin)
self.assertEqual(1, count)
self.assertDictEqual(
{
'name': 'Course Three (Maths) - Group One (Group)',
'id': delimiter.join([self.course003, self.group001]),
'type': u'g'
}, groups[0])
def test_search_one_result_against_name(self):
"""
there are three groups entitled "Group Two" of which Sansa Stark is in one
"""
(groups, count, _) = search(q='Group Two', user=self.user)
self.assertEqual(1, count)
self.assertDictEqual(
{
'name': 'Course One (Maths) - Group Two (Group)',
'id': delimiter.join([self.course001, self.group002]),
'type': u'g'
}, groups[0])
def setUp(self):
# some Lannisters
self.users = {}
for first_name in [
u'Cersei', u'Jaime', u'Kevan', u'Lancel', u'Tyrion', u'Tywin'
]:
u = get_user_model().objects.create_user(
username='******' % first_name.lower(),
email='*****@*****.**' % first_name.lower(),
first_name=first_name,
last_name='Lannister',
password='******')
self.users[first_name] = u
# create a group to send messages to
list(
map(
lambda p: GroupMember.objects.create(
vle_course_id='c001', vle_group_id='g001', user=p[1]),
iteritems(self.users)))
recipients = [{'id': delimiter.join(['c001', 'g001']), 'type': u'g'}]
# create a thread of messages
self.thread = Message.send_message(sender=self.users['Tywin'],
recipients=recipients,
subject="King's Landing",
body="Sort it out!")
reply1 = Message.send_message(sender=self.users['Tyrion'],
recipients=recipients,
subject="King's Landing",
body="By when?",
parent=self.thread)
Message.send_message(sender=self.users['Tywin'],
recipients=recipients,
subject="King's Landing",
body="Next Tuesday, please.",
parent=reply1)
Message.send_message(sender=self.users['Cersei'],
recipients=recipients,
subject="King's Landing",
body="Do it yourself!",
parent=self.thread)
# ensure each group member has four messages in the thread
for k, v in iteritems(self.users):
self.assertEqual(
4,
MessageItem.objects.filter(
user=v, message__tree_id=self.thread.tree_id).count())
# ensure there are 4 times the number of users message items in total
self.assertEqual(4 * len(self.users), MessageItem.objects.count())
def test_send_message(self):
recipients = [{
'id': self.users['Jaime'].id,
'type': u'u'
}, {
'id': self.users['Tywin'].id,
'type': u'u'
}, {
'id': 'c001',
'type': u'c'
}, {
'id': delimiter.join(['c002', 'g001']),
'type': u'g'
}, {
'id': delimiter.join(['c002', 'g002']),
'type': u'g'
}]
subject = 'I want him dead!'
body = 'The Imp, that is. Incase you were wondering.'
t0 = timezone.now()
message = Message.send_message(sender=self.users['Cersei'],
recipients=recipients,
subject=subject,
body=body)
# check the Message itself
self.assertIsInstance(message, Message)
self.assertEqual(self.users['Cersei'].id, message.user.id)
self.assertFalse(message.is_notification)
self.assertEqual('', message.url)
self.assertEqual(subject, message.subject)
self.assertEqual(body, message.body)
self.assertGreaterEqual(message.sent, t0)
self.assertFalse(message.target_all)
# check there's a MessageItem for each recipient
message_item = MessageItem.objects.filter(
message=message, read=None,
deleted=None).order_by('user__first_name')
self.assertEqual(2, message_item.count())
self.assertEqual(self.users['Jaime'].id, message_item[0].user.id)
self.assertEqual(self.users['Tywin'].id, message_item[1].user.id)
# check there's a MessageTargetUser for each user recipient
message_target_user = MessageTargetUser.objects.filter(
message=message).order_by('user__first_name')
self.assertEqual(2, message_target_user.count())
self.assertEqual(self.users['Jaime'].id,
message_target_user[0].user.id)
self.assertEqual(self.users['Tywin'].id,
message_target_user[1].user.id)
# check there's a MessageTargetCourse for each course recipient
message_target_course = MessageTargetCourse.objects.filter(
message=message).order_by('vle_course_id')
self.assertEqual(1, message_target_course.count())
self.assertEqual('c001', message_target_course[0].vle_course_id)
# check there's a MessageTargetGroup for each group recipient
message_target_group = MessageTargetGroup.objects.filter(
message=message).order_by('vle_course_id', 'vle_group_id')
self.assertEqual(2, message_target_group.count())
self.assertEqual('c002', message_target_group[0].vle_course_id)
self.assertEqual('g001', message_target_group[0].vle_group_id)
self.assertEqual('c002', message_target_group[1].vle_course_id)
self.assertEqual('g002', message_target_group[1].vle_group_id)