def setUp(self):
# Create bodies
body1 = create_body(name="Test WnCC",
description="<script> var js = 'XSS'; </script>")
body2 = create_body(name="Test MoodI")
# Create dummy events
event1 = create_event(name="Test Scratch")
event2 = create_event(name="Test Scratch Wncc")
event3 = create_event(name="Test Aaveg")
# Create dummy users for search
UserProfile.objects.create(name="Test User1")
UserProfile.objects.create(name="Test User2")
UserProfile.objects.create(name="Test User3", active=False)
# Associate events with bodies
event1.bodies.add(body1)
event2.bodies.add(body1)
event3.bodies.add(body2)
# Fake authenticate
self.user = get_new_user()
self.profile = self.user.profile
self.client = APIClient()
self.client.force_authenticate(self.user)
def setUp(self):
# Fake authenticate
self.user = get_new_user()
self.client = APIClient()
self.client.force_authenticate(self.user)
# A different user
self.user_2 = get_new_user()
# Dummy bodies and events
self.body_1 = create_body()
self.body_2 = create_body()
self.event_1 = create_event()
# Body roles
self.body_1_role = BodyRole.objects.create(
name="Body1Role", body=self.body_1, permissions='VerA,AddE')
def setUp(self):
# Fake authenticate
self.user = get_new_user()
self.client.force_authenticate(self.user) # pylint: disable=E1101
self.test_body_1 = create_body()
self.test_body_2 = create_body()
self.body_1_role = BodyRole.objects.create(
name="Body1Role",
body=self.test_body_1,
permissions='AddE,UpdE,DelE')
self.user.profile.roles.add(self.body_1_role)
self.update_test_event = create_event(-24, -24)
url = '/api/events/%s' % self.update_test_event.id
self.update_event_data = self.client.get(url).data
self.update_url = '/api/events/%s' % self.update_test_event.id
create_event(-24, -24)
def test_clean_images_chore(self):
"""Check clean images chore."""
res = [None] * 5
res[0] = new_upload(self)
# Create images more than an hour ago
with freeze_time(timezone.now() - timedelta(hours=3)):
for i in range(1, 5):
res[i] = new_upload(self)
event1 = create_event(image_url=res[2].data['picture'])
body1 = create_body(image_url=res[3].data['picture'])
# Get path for checking deletion
obj = lambda res: UploadedImage.objects.get(pk=res.data['id'])
obj_exists = lambda res: UploadedImage.objects.filter(pk=res.data['id']
).exists()
paths = [obj(r).picture.path for r in res]
# Check if deleting a non existent file is fine
self.assertTrue(isfile(paths[4]))
os.remove(paths[4])
self.assertFalse(isfile(paths[4]))
obj(res[4]).delete()
self.assertFalse(obj_exists(res[4]))
# Call the chore
clean = lambda: call_command('clean-images')
clean()
# Check if unclaimed images were removed
self.assertTrue(obj_exists(res[0]))
self.assertFalse(obj_exists(res[1]))
self.assertTrue(obj_exists(res[2]))
self.assertTrue(obj_exists(res[3]))
# Check if file is deleted
self.assertTrue(isfile(paths[0]))
self.assertFalse(isfile(paths[1]))
# Check after invalidating claimant
body1.image_url = 'https://insti.app'
body1.save()
clean()
self.assertTrue(obj_exists(res[2]))
self.assertFalse(obj_exists(res[3]))
# Check after deleting claimant
event1.delete()
clean()
self.assertFalse(obj_exists(res[2]))
def setUp(self):
# Create bodies
body1 = create_body(name="Test Body1")
body2 = create_body(name="Test Body2")
# Create dummy events
event1 = create_event(name="Test Event1")
event2 = create_event(name="Test Event2 Body1")
event3 = create_event(name="Test Event21")
# Create dummy users for search
UserProfile.objects.create(name="Test User1")
UserProfile.objects.create(name="Test User2")
# Associate events with bodies
event1.bodies.add(body1)
event2.bodies.add(body1)
event3.bodies.add(body2)
# Fake authenticate
self.user = get_new_user()
self.profile = self.user.profile
self.client.force_authenticate(self.user) # pylint: disable=E1101
def test_ues(self):
"""Test user-event-status APIs."""
def assert_user_ues(t_event, t_ues):
"""Test user_ues in event serializer."""
url = '/api/events/%s' % t_event.id
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['user_ues'], t_ues)
def mark_test(event, ues, count):
"""Helper to mark UES and test creation/updation."""
# Mark UES for the event
url = '/api/user-me/ues/%s?status=%s' % (event.id, str(ues))
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, 204)
# Assert creation of UES
self.assertEqual(event.ues.count(), count)
assert_user_ues(event, ues)
# Check first only if exists
if count > 0:
self.assertEqual(event.ues.first().status, ues)
# Create event with one body
test_body = create_body(name="Test Body1")
test_event = create_event(name="Test Event1")
test_event.bodies.add(test_body)
self.assertEqual(test_event.ues.count(), 0)
assert_user_ues(test_event, 0)
# Test interested, going and neutral
# When the user un-marks the event, UES must be removed
mark_test(test_event, 1, 1)
mark_test(test_event, 2, 1)
mark_test(test_event, 0, 0)
# Assert user_ues as anonymous
self.client.logout()
assert_user_ues(test_event, None)
def test_notifications(self): # pylint: disable=R0914,R0915
"""Test notifications API."""
# Fake authenticate
profile = self.profile
# Add two bodies, with the user following #1
body1 = create_body()
body2 = create_body()
profile.followed_bodies.add(body1)
# Add four events to followed body and one to other.
# Event 5 has notifications turned off
event1 = create_event()
event2 = create_event()
event3 = create_event()
event4 = create_event()
event5 = create_event()
event5.notify = False
event5.save()
# Notifications older than a week shouldn't show up
with freeze_time(timezone.now() - timedelta(days=10)):
event6 = create_event()
event6.bodies.add(body1)
# Add bodies to all events
event1.bodies.add(body1)
event2.bodies.add(body1)
event3.bodies.add(body1)
event4.bodies.add(body2)
event5.bodies.add(body1)
# Get notifications
url = '/api/notifications'
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
# Check if notifications are correct three
self.assertEqual(len(response.data), 3)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event2).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
# Mark event2 as read
e2n = [n for n in response.data if n['actor'] == EventSerializer(event2).data][0]
response = self.client.get(url + '/read/' + str(e2n['id']))
self.assertEqual(response.status_code, 204)
# Check if notifications are correct remaining two
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
# Follow event 4
uesurl = '/api/user-me/ues/' + str(event4.id) + '?status=1'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
# Update event 4
event4.name = 'UpdatedEvent4'
event4.save()
# Check if notification is added for event 4
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
self.assertIn(EventSerializer(event4).data, actors)
# Follow event 5
uesurl = '/api/user-me/ues/' + str(event5.id) + '?status=1'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
# Update event 5
event5.name = 'UpdatedEvent5'
event5.save()
# Check no notification is added for event 5
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
# Check no notification after unfollowing event - unfollow 4 and update again
uesurl = '/api/user-me/ues/' + str(event4.id) + '?status=0'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
event4.name = 'AUpdatedEvent4'
event4.save()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
# Mark all notifications as read and check
response = self.client.get(url + '/read')
self.assertEqual(response.status_code, 204)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
def test_placements_chore(self):
"""Test the placement blog chore."""
# Clear table
BlogEntry.objects.all().delete()
# Create blog bodies
placement_body = create_body(name=settings.PLACEMENTS_BLOG_BODY)
training_body = create_body(name=settings.TRAINING_BLOG_BODY)
# Create users to follow blogs
second_year = get_new_user()
final_year = get_new_user()
mentioned_user = get_new_user()
mentioned_dual = get_new_user()
second_year.profile.followed_bodies.add(training_body)
final_year.profile.followed_bodies.add(placement_body)
mentioned_user.profile.roll_no = '160010005'
mentioned_user.profile.save()
mentioned_dual.profile.roll_no = '150040010'
mentioned_dual.profile.save()
# Start mock server
mock_server = Popen(['python', 'news/test/test_server.py'])
time.sleep(1)
# Run the placement chore
call_command('placement_blog_chore')
# Check if posts were collected
placements = lambda: BlogEntry.objects.all().filter(blog_url=settings.PLACEMENTS_URL)
trainings = lambda: BlogEntry.objects.all().filter(blog_url=settings.TRAINING_BLOG_URL)
self.assertEqual(placements().count(), 3)
self.assertEqual(trainings().count(), 5)
self.assertEqual(set(x.guid for x in placements()), set('sample:p:%i' % i for i in range(1, 4)))
self.assertEqual(set(x.title for x in placements()), set('Placement Item %i' % i for i in range(1, 4)))
# Check if following blogs works
self.assertEqual(second_year.notifications.count(), 5)
self.assertEqual(final_year.notifications.count(), 3)
# Check if mentioned users got a notification
self.assertEqual(mentioned_user.notifications.count(), 1)
self.assertEqual(mentioned_user.notifications.first().actor.title, 'Mentioning Item')
self.assertEqual(mentioned_dual.notifications.count(), 1)
self.assertEqual(mentioned_dual.notifications.first().actor.title, 'Placement Item 1')
# Update placement blog URL
call_command('placement_blog_chore')
# Check if new placement blog posts are got
self.assertEqual(trainings().all().count(), 5)
self.assertEqual(placements().all().count(), 4)
self.assertEqual(set(x.guid for x in placements()), set('sample:p:%i' % i for i in range(1, 5)))
self.assertEqual(set(x.title for x in placements()), set('Placement Item %i' % i for i in range(1, 5)))
# Check if existing ones are updated
self.assertEqual(BlogEntry.objects.get(guid='sample:p:1').content, 'Updated')
# Check if notification counts are updated
self.assertEqual(second_year.notifications.count(), 5)
self.assertEqual(final_year.notifications.count(), 4)
self.assertEqual(mentioned_user.notifications.count(), 2)
self.assertEqual(mentioned_dual.notifications.count(), 2)
# Stop server
mock_server.terminate()
def test_notifications(self): # pylint: disable=R0914,R0915
"""Test notifications API."""
# Fake authenticate
profile = self.profile
profile.user.notifications.all().delete()
# Add two bodies, with the user following #1
body1 = create_body()
body2 = create_body()
profile.followed_bodies.add(body1)
# Add four events to followed body and one to other.
# Event 5 has notifications turned off
event1 = create_event()
event2 = create_event()
event3 = create_event()
event4 = create_event()
event5 = create_event()
event5.notify = False
event5.save()
# Add bodies to all events
event1.bodies.add(body1)
event2.bodies.add(body1)
event3.bodies.add(body1)
event4.bodies.add(body2)
event5.bodies.add(body1)
celery_delay()
# Get notifications
url = '/api/notifications'
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
# Check if notifications are correct three
self.assertEqual(len(response.data), 3)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event2).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
# Mark event2 as read
e2n = [
n for n in response.data
if n['actor'] == EventSerializer(event2).data
][0]
e2notif = lambda: Notification.objects.get(pk=e2n['id'])
self.assertEqual(e2notif().unread, True)
self.assertEqual(e2notif().deleted, False)
response = self.client.get(url + '/read/' + str(e2n['id']))
self.assertEqual(response.status_code, 204)
self.assertEqual(e2notif().unread, False)
self.assertEqual(e2notif().deleted, False)
# Mark event2 as deleted
response = self.client.get(url + '/read/' + str(e2n['id']) +
'?delete=1')
self.assertEqual(response.status_code, 204)
self.assertEqual(e2notif().unread, False)
self.assertEqual(e2notif().deleted, True)
celery_delay()
# Check if notifications are correct remaining two
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
# Follow event 4
uesurl = '/api/user-me/ues/' + str(event4.id) + '?status=1'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
# Update event 4
event4.name = 'UpdatedEvent4'
event4.save()
celery_delay()
# Check if notification is added for event 4
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
actors = [n['actor'] for n in response.data]
self.assertIn(EventSerializer(event1).data, actors)
self.assertIn(EventSerializer(event3).data, actors)
self.assertIn(EventSerializer(event4).data, actors)
# Follow event 5
uesurl = '/api/user-me/ues/' + str(event5.id) + '?status=1'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
# Update event 5
event5.name = 'UpdatedEvent5'
event5.save()
# Check no notification is added for event 5
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
# Check no notification after unfollowing event - unfollow 4 and update again
uesurl = '/api/user-me/ues/' + str(event4.id) + '?status=0'
response = self.client.get(uesurl, format='json')
self.assertEqual(response.status_code, 204)
event4.name = 'AUpdatedEvent4'
event4.save()
celery_delay()
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
# Mark all notifications as read and check
response = self.client.get(url + '/read')
self.assertEqual(response.status_code, 204)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
def test_event_prioritizer(self):
"""Test the event prioritizer."""
def assertOrder(events, url='/api/events'):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
for index, event in enumerate(events):
self.assertEqual(response.data['data'][index]['id'],
str(event.id))
# Events in future. event1 after event3 after event2. event4 in past
event1 = create_event(48, 48)
event2 = create_event(4, 5)
event3 = create_event(15, 16)
event4 = create_event(-5, -4)
assertOrder([event2, event3, event1, event4])
# Check followed bodies priorities
body1 = create_body()
body2 = create_body()
body3 = create_body()
body4 = create_body()
body5 = create_body()
self.user.profile.followed_bodies.add(body1, body2, body3, body4,
body5)
# After the user is following a body of event 3, it should bump up
event3.bodies.add(body1)
assertOrder([event3, event2, event1, event4])
# Test the cap on followed bodies bonus
event1.bodies.add(body1, body2, body3, body4, body5)
assertOrder([event3, event1, event2, event4])
# Check user tags - setup the user
self.user.profile.hostel = '1'
self.user.profile.department = 'ME'
self.user.profile.save()
# Add one matching and one non-matching tag to both
category1 = create_usertagcategory()
h1_tag = create_usertag(category1, '1')
h13_tag = create_usertag(category1, '13')
event1.user_tags.add(h1_tag)
event3.user_tags.add(h13_tag)
# Add one matching tag to both events
category2 = create_usertagcategory()
me_tag = create_usertag(category2, 'ME', target='department')
event1.user_tags.add(me_tag)
event3.user_tags.add(me_tag)
# Check new order
assertOrder([event1, event2, event4])
# Check if user needs to satisfy only one tag from each category
event1.user_tags.add(h13_tag)
assertOrder([event1, event2, event4])
# Test null check - now the department matching tag is non matching
self.user.profile.department = None
self.user.profile.save()
assertOrder([event2, event4])
# Test if secondary_target is working
me_tag.secondary_target = 'hostel'
me_tag.secondary_regex = '1'
me_tag.save()
assertOrder([event1, event2, event4])
# Test for anonymous user
self.client.logout()
assertOrder([event2, event4])
def test_event_prioritizer(self): # pylint: disable=R0914,R0915
"""Test the event prioritizer."""
def assertOrder(events, url='/api/events'):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
for index, event in enumerate(events):
self.assertEqual(response.data['data'][index]['id'],
str(event.id))
def assertWeightOrder(events, url='/api/events'):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
prev_weight = response.data['data'][0]['weight']
for event in events:
response_event = next(x for x in response.data['data']
if x['id'] == str(event.id))
self.assertLess(response_event['weight'], prev_weight)
prev_weight = response_event['weight']
# Events in future:
# event1 after event3 after event2
# eventP1, eventP1 in past
event1 = create_event(48, 48)
event2 = create_event(4, 5)
event3 = create_event(15, 16)
eventP1 = create_event(-5, -4)
eventP2 = create_event(-6, -5)
# These events check linear decay after 15 days
eventL1 = create_event(24 * 30, 24 * 30)
eventL2 = create_event(24 * 20, 24 * 20)
eventL3 = create_event(24 * 40, 24 * 40)
assertOrder([event2, event3, event1, eventP1, eventP2])
assertWeightOrder([eventL2, eventL1, eventL3])
# Check followed bodies priorities
body1 = create_body()
body2 = create_body()
body3 = create_body()
body4 = create_body()
body5 = create_body()
self.user.profile.followed_bodies.add(body1, body2, body3, body4,
body5)
# After the user is following a body of event 3, it should bump up
event3.bodies.add(body1)
assertOrder([event3, event2, event1, eventP1, eventP2])
# Test the cap on followed bodies bonus
event1.bodies.add(body1, body2, body3, body4, body5)
assertOrder([event3, event1, event2, eventP1, eventP2])
# Test that ended events do not receive bonus
eventP2.bodies.add(body1, body2, body3, body4)
eventP2.promotion_boost = 2000
eventP2.save()
assertOrder([event3, event1, event2, eventP1, eventP2])
# Check user tags - setup the user
self.user.profile.hostel = '1'
self.user.profile.department = 'ME'
self.user.profile.save()
# Add one matching and one non-matching tag to both
category1 = create_usertagcategory()
h1_tag = create_usertag(category1, '1')
h13_tag = create_usertag(category1, '13')
event1.user_tags.add(h1_tag)
event3.user_tags.add(h13_tag)
# Add one matching tag to both events
category2 = create_usertagcategory()
me_tag = create_usertag(category2, 'ME', target='department')
event1.user_tags.add(me_tag)
event3.user_tags.add(me_tag)
# Check new order
assertOrder([event1, event2, eventP1])
# Check if user needs to satisfy only one tag from each category
event1.user_tags.add(h13_tag)
assertOrder([event1, event2, eventP1])
# Test null check - now the department matching tag is non matching
self.user.profile.department = None
self.user.profile.save()
assertOrder([event2, eventP1])
# Test if secondary_target is working
me_tag.secondary_target = 'hostel'
me_tag.secondary_regex = '1'
me_tag.save()
assertOrder([event1, event2, eventP1])
# Test promotion boost
event2.promotion_boost = 2000
event2.save()
assertOrder([event2, event1, eventP1])
event2.promotion_boost = 0
event2.save()
# Test for anonymous user
self.client.logout()
assertOrder([event2, eventP1])
