def setUp(self):
self.test_profile = UserProfile.objects.create(name="TestUser",
email="*****@*****.**",
roll_no="10000001",
ldap_id='ldap')
self.test_body = Body.objects.create(name="Test Body")
self.test_event = create_event(name="Event 1",
end_time_delta=20,
image_url="https://insti.app/event1img")
self.test_event_2 = create_event(
name="Test Event 2",
end_time_delta=-1,
image_url="https://insti.app/event2img")
self.test_body.events.add(self.test_event)
self.test_body.events.add(self.test_event_2)
self.news1 = NewsEntry.objects.create(guid="https://test.com",
title="NewsIsGreat",
body=self.test_body,
blog_url="https://blog",
link="https://blog-item")
parent_body = Body.objects.create(name="Parent")
grandparent_body = Body.objects.create(name="GrandParent")
BodyChildRelation.objects.create(parent=parent_body,
child=self.test_body)
BodyChildRelation.objects.create(parent=grandparent_body,
child=parent_body)
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 test_body_get_events(self):
"""Test if get events API works."""
body = Body.objects.create(name="TestBody1")
url = '/api/bodies/' + str(body.id) + '/events'
# Create events for the body
event1 = create_event(48, 48)
event1.bodies.add(body)
event2 = create_event(4, 5)
event2.bodies.add(body)
eventP1 = create_event(-5, -4)
eventP1.bodies.add(body)
# Create an event before 1 year
eventA = create_event(-24 * 370, -24 * 370 + 2)
eventA.bodies.add(body)
response = self.client.get(url)
# Check response status and length
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
self.assertEqual(response.data[0]['id'], str(event1.id))
self.assertEqual(response.data[1]['id'], str(event2.id))
self.assertEqual(response.data[2]['id'], str(eventP1.id))
# Check response for ?archived parameter in url
response = self.client.get(url + '?archived')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 4)
self.assertEqual(response.data[3]['id'], str(eventA.id))
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 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 test_event_update9(self):
"""Event tags can be updated."""
# Add an event to an updateable body
event = create_event()
self.test_body_1.events.add(event)
# Get the response
url = '/api/events/%s' % event.id
data = self.client.get(url).data
# Create tags and assign them
category = create_usertagcategory()
tag1 = create_usertag(category, '1')
tag2 = create_usertag(category, '2')
data['user_tags'] = [str(tag1.id), str(tag2.id)]
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(event.user_tags.count(), 2)
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_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])
