def test_get_courses(self):
course = CourseFactory()
student = UserFactory()
instructor = UserFactory()
course.group.user_set.add(student)
course.group.user_set.add(instructor)
course.faculty_group.user_set.add(instructor)
# as student
lst = get_courses_for_user(student)
self.assertEquals(len(lst), 1)
self.assertTrue(course in lst)
lst = get_courses_for_instructor(student)
self.assertEquals(len(lst), 0)
# as instructor
lst = get_courses_for_user(instructor)
self.assertEquals(len(lst), 1)
self.assertTrue(course in lst)
lst = get_courses_for_instructor(instructor)
self.assertEquals(len(lst), 1)
self.assertTrue(course in lst)
def test_guest_user_exists(self):
"""
Tests the case where a guest is invited to a course,
and the user already has a Locus Tempus account.
"""
addr = '*****@*****.**'
UserFactory.create(first_name='Guest',
last_name='Student',
username='******',
email=addr)
self.assertTrue(
self.client.login(username=self.faculty.username, password='******'))
response = self.client.post(reverse('course-roster-invite-user',
args=[self.sandbox_course.pk]), {
'uni-TOTAL_FORMS': '1',
'uni-INITIAL_FORMS': '0',
'uni-0-invitee': '',
'email-TOTAL_FORMS': '1',
'email-INITIAL_FORMS': '0',
'email-0-invitee': addr,
},
follow=True)
self.assertContains(
response,
'An email was sent to {} notifying the user.'.format(addr))
def test_has_permissions_put(self):
"""Tests POST permissions"""
perm = IsResponseOwnerOrFaculty()
p = ProjectFactory.create(course=self.sandbox_course)
a = ActivityFactory.create(project=p)
req = RequestFactory().put(reverse('api-response-list'),
{'activity': a.pk})
req.user = AnonymousUser()
# Patch the request object, as it doesn't seem to create the
# data attribute as expected
req.data = {'activity': a.pk}
# Anon
self.assertFalse(perm.has_permission(req, None))
# Faculty
req.user = self.faculty
self.assertFalse(perm.has_permission(req, None))
# Unrelated Student
unrelated_student = UserFactory.create(first_name='Student',
last_name='Two',
email='*****@*****.**')
self.registrar_course.group.user_set.add(unrelated_student)
req.user = unrelated_student
self.assertFalse(perm.has_permission(req, None))
# Related Student
req.user = self.student
self.assertTrue(perm.has_permission(req, None))
def test_has_object_permissions_patch(self):
"""Tests PATCH permissions"""
perm = IsFeedbackFacultyOrStudentRecipient()
p = ProjectFactory.create(course=self.sandbox_course)
a = ActivityFactory.create(project=p)
r = ResponseFactory.create(activity=a, owners=[self.student])
r.status = r.SUBMITTED
r.save()
f = FeedbackFactory(response=r)
req = RequestFactory().patch(
reverse('api-feedback-detail', args=[f.pk]), {'feedback': 'foo'})
# Anon
req.user = AnonymousUser()
self.assertFalse(perm.has_object_permission(req, None, r.feedback))
# Related Faculty
req.user = self.faculty
self.assertTrue(perm.has_object_permission(req, None, r.feedback))
# Unrelated Faculty
# Checks that faculty in a different course can not
# patch an object
unrelated_faculty = UserFactory.create(first_name='Faculty',
last_name='Two',
email='*****@*****.**')
self.registrar_course.faculty_group.user_set.add(unrelated_faculty)
req.user = unrelated_faculty
self.assertFalse(perm.has_object_permission(req, None, r.feedback))
# Student
req.user = self.student
self.assertFalse(perm.has_object_permission(req, None, r.feedback))
def test_has_permissions_put(self):
"""Tests POST permissions"""
perm = IsFeedbackFacultyOrStudentRecipient()
p = ProjectFactory.create(course=self.sandbox_course)
a = ActivityFactory.create(project=p)
r = ResponseFactory.create(activity=a, owners=[self.student])
req = RequestFactory().post(reverse('api-feedback-list'), {
'response': r.pk,
'body': 'foobar'
})
req.query_params = dict()
req.data = {'response': r.pk, 'body': 'foobar'}
# Anon
req.user = AnonymousUser()
self.assertFalse(perm.has_permission(req, None))
# Faculty
req.user = self.faculty
self.assertTrue(perm.has_permission(req, None))
# Unrelated Student
unrelated_student = UserFactory.create(first_name='Student',
last_name='Two',
email='*****@*****.**')
self.registrar_course.group.user_set.add(unrelated_student)
req.user = unrelated_student
self.assertFalse(perm.has_permission(req, None))
# Related Student
req.user = self.student
self.assertFalse(perm.has_permission(req, None))
def test_is_course_faculty_not_in_course(self):
context = Context({'course': self.sandbox_course})
some_user = UserFactory(
first_name='Random',
last_name='User',
email='*****@*****.**'
)
self.assertFalse(is_course_faculty(context, some_user))
def test_post_sis_course_id(self):
with self.settings(
COURSEAFFILS_COURSESTRING_MAPPER=CourseStringMapper):
user = UserFactory()
self.client.login(username=user.username, password='******')
data = {
'lms_course': '1234',
'lms_course_title': 'LTI Course',
'sis_course_id': 'SOCWT7113_010_2017_3'
}
response = self.client.post(reverse('lti-course-create'), data)
self.assertEqual(response.status_code, 302)
c = Course.objects.get(title='LTI Course')
self.assertEqual(
c.group.name,
't3.y2017.s010.ct7113.socw.st.course:columbia.edu')
self.assertEqual(
c.faculty_group.name,
't3.y2017.s010.ct7113.socw.fc.course:columbia.edu')
self.assertEqual(c.info.term, 3)
self.assertEqual(c.info.year, 2017)
self.assertTrue(user in c.group.user_set.all())
self.assertTrue(user in c.faculty_group.user_set.all())
self.assertEqual(len(mail.outbox), 2)
self.assertEqual(mail.outbox[0].subject,
'Locus Tempus Course Connected')
self.assertEqual(mail.outbox[0].from_email,
settings.SERVER_EMAIL)
self.assertEqual(mail.outbox[0].to,
[settings.SERVER_EMAIL])
self.assertEqual(mail.outbox[1].subject,
'Locus Tempus Course Connected')
self.assertEqual(mail.outbox[1].from_email,
settings.SERVER_EMAIL)
self.assertEqual(mail.outbox[1].to,
[user.email])
LTICourseContext.objects.get(
lms_course_context='1234',
group=c.group, faculty_group=c.faculty_group)
# try this again and make sure there is no duplication
data['lms_course_title'] = 'LTI Course With More Detail'
response = self.client.post(reverse('lti-course-create'), data)
self.assertEqual(response.status_code, 302)
Course.objects.get(title='LTI Course')
Group.objects.get(name=c.group.name)
Group.objects.get(name=c.faculty_group.name)
LTICourseContext.objects.get(
lms_course_context='1234',
group=c.group, faculty_group=c.faculty_group)
def test_non_course_user(self):
user = UserFactory.create()
self.assertTrue(
self.client.login(username=user.username, password='******'))
project = self.sandbox_course.projects.first()
response = self.client.get(
reverse('api-project-detail', args=[project.pk]))
self.assertEqual(response.status_code, 403)
def test_send_template_email(self):
user = UserFactory()
with self.settings(SERVER_EMAIL='*****@*****.**'):
send_template_email('foo', 'main/notify_lti_course_connect.txt',
{'user': user}, '*****@*****.**')
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, 'foo')
self.assertEquals(mail.outbox[0].from_email,
'*****@*****.**')
self.assertTrue(mail.outbox[0].to, ['*****@*****.**'])
def setUp(self):
self.setup_course()
self.layer_permission_helper = \
LayerPermission().layer_permission_helper
self.anon = AnonymousUser()
self.classmate = UserFactory.create(first_name='Student',
last_name='Two',
email='*****@*****.**')
self.registrar_course.group.user_set.add(self.classmate)
self.classmate_response = ResponseFactory.create(
activity=self.sandbox_course_activity, owners=[self.classmate])
self.classmate_layer = LayerFactory.create(
title='Classmate layer', content_object=self.classmate_response)
def test_has_permissions_obj_get(self):
"""Tests GET permissions"""
perm = IsFeedbackFacultyOrStudentRecipient()
self.sandbox_course_response.status = \
self.sandbox_course_response.SUBMITTED
self.sandbox_course_response.save()
feedback = FeedbackFactory(response=self.sandbox_course_response)
req = RequestFactory().get(
reverse('api-feedback-detail', args=[feedback.pk]))
# Anon
req.user = AnonymousUser()
self.assertFalse(perm.has_object_permission(req, None, feedback))
# Faculty
req.user = self.faculty
self.assertTrue(perm.has_object_permission(req, None, feedback))
# Student
req.user = self.student
self.assertTrue(perm.has_object_permission(req, None, feedback))
# Student in course, but not related to the response
classmate = UserFactory.create(first_name='Student',
last_name='Two',
email='*****@*****.**')
self.sandbox_course.group.user_set.add(classmate)
req.user = classmate
self.assertFalse(perm.has_object_permission(req, None, feedback))
# Non-course user
unrelated_student = UserFactory.create(first_name='Student',
last_name='Two',
email='*****@*****.**')
req.user = unrelated_student
self.assertFalse(perm.has_object_permission(req, None, feedback))
def test_unique_owner_per_activity(self):
"""
Test that a user can not be added as an owner to multiple responses
for a single activity.
"""
# Add a new activity response to an existing activity
student: User = UserFactory.create(first_name='Student',
last_name='One',
email='*****@*****.**')
course = RegistrarCourseFactory.create()
project = ProjectFactory.create(course=course)
activity = ActivityFactory.create(project=project)
ResponseFactory.create(activity=activity, owners=[student])
# Try adding self.student to this new response
with self.assertRaises(IntegrityError):
ResponseFactory.create(activity=activity, owners=[student])
def test_guest_user_course_affil(self):
"""
Tests that a guest user is added to the
course upon registering for an account
"""
affil = GuestUserAffil(guest_email='*****@*****.**',
course=self.sandbox_course,
invited_by=self.faculty)
affil.save()
guest = UserFactory.create(first_name='Guest',
last_name='User',
username='******',
email='*****@*****.**')
mock_sender = MagicMock()
user_activated.send(sender=mock_sender, user=guest)
self.assertTrue(self.sandbox_course.is_true_member(guest))
def test_unique_owner_per_response(self):
"""
Test that a user can not be added as an owner to response
multiple times.
Noting that Django's default behavior is to prevent
multiple instances of many to many relation.
"""
student: User = UserFactory.create(first_name='Student',
last_name='One',
email='*****@*****.**')
course = RegistrarCourseFactory.create()
project = ProjectFactory.create(course=course)
activity = ActivityFactory.create(project=project)
response = ResponseFactory.create(activity=activity, owners=[student])
self.assertEqual(response.owners.count(), 1)
response.owners.add(student)
self.assertEqual(response.owners.count(), 1)
def test_submitted_by_on(self):
student: User = UserFactory.create(
first_name='Student',
last_name='One',
email='*****@*****.**'
)
course = RegistrarCourseFactory.create()
project = ProjectFactory.create(course=course)
activity = ActivityFactory.create(project=project)
response = ResponseFactory.create(
activity=activity, owners=[student])
# Assert that submitted_* are null
self.assertIsNone(response.submitted_at)
# Then submit the assignment
response.status = response.SUBMITTED
response.save()
# Check that the fields have updated
self.assertIsNot(response.submitted_at, None)
def test_no_course(self):
"""
Tests that the courses created in the setup method
do not appear for a new user not in those courses.
"""
student = UserFactory.create(
first_name='Student',
last_name='Two',
username='******',
email='*****@*****.**'
)
self.assertTrue(
self.client.login(
username=student.username,
password='******'
)
)
response = self.client.get("/dashboard/")
self.assertEqual(response.status_code, 200)
self.assertEqual(
response.context['courses'].count(), 0)
def test_post_course_context_with_unicode(self):
with self.settings(
COURSEAFFILS_COURSESTRING_MAPPER=CourseStringMapper):
user = UserFactory()
self.client.login(username=user.username, password='******')
data = {
'lms_course': '1234',
'lms_course_title': 'LTI Course "Película", rødgrød med fløde',
'sis_course_id': '20170152049'
}
response = self.client.post(reverse('lti-course-create'), data)
self.assertEqual(response.status_code, 302)
c = Course.objects.get(
title='LTI Course "Película", rødgrød med fløde')
self.assertEqual(c.group.name, '1234')
self.assertEqual(c.faculty_group.name, '1234_faculty')
self.assertEqual(c.info.term, 1)
self.assertEqual(c.info.year, 2017)
self.assertTrue(user in c.group.user_set.all())
self.assertTrue(user in c.faculty_group.user_set.all())
LTICourseContext.objects.get(
lms_course_context='1234',
group=c.group, faculty_group=c.faculty_group)
# try this again and make sure there is no duplication
data['lms_course_title'] = 'LTI Course With More Detail'
response = self.client.post(reverse('lti-course-create'), data)
self.assertEqual(response.status_code, 302)
Course.objects.get(
title='LTI Course "Película", rødgrød med fløde')
Group.objects.get(name=c.group.name)
Group.objects.get(name=c.faculty_group.name)
LTICourseContext.objects.get(
lms_course_context='1234',
group=c.group, faculty_group=c.faculty_group)
def test_has_object_permissions_patch(self):
"""Tests PATCH permissions"""
perm = IsResponseOwnerOrFaculty()
req = RequestFactory().patch(
reverse('api-response-detail',
args=[self.sandbox_course_response.pk]),
{'reflection': 'foo'})
# Anon
req.user = AnonymousUser()
self.assertFalse(
perm.has_object_permission(req, None,
self.sandbox_course_response))
# Related Faculty
req.user = self.faculty
self.assertFalse(
perm.has_object_permission(req, None,
self.sandbox_course_response))
# Unrelated Faculty
# Checks that faculty in a different course can not
# patch an object
unrelated_faculty = UserFactory.create(first_name='Faculty',
last_name='Two',
email='*****@*****.**')
self.registrar_course.faculty_group.user_set.add(unrelated_faculty)
req.user = unrelated_faculty
self.assertFalse(
perm.has_object_permission(req, None,
self.sandbox_course_response))
# Student
req.user = self.student
self.assertTrue(
perm.has_object_permission(req, None,
self.sandbox_course_response))
def reset_test_models():
call_command('flush', verbosity=0, interactive=False)
# Create some models
UserFactory.create(username='******',
first_name='Super',
last_name='User',
email='*****@*****.**',
is_superuser=True)
# Sandbox Course
c1: Course = SandboxCourseFactory.create()
s1: User = UserFactory.create(username='******',
first_name='Student',
last_name='One',
email='*****@*****.**')
c1.group.user_set.add(s1)
f1: User = UserFactory.create(username='******',
first_name='Faculty',
last_name='One',
email='*****@*****.**')
c1.group.user_set.add(f1)
c1.faculty_group.user_set.add(f1)
project = ProjectFactory.create(course=c1)
activity = ActivityFactory.create(project=project)
ResponseFactory.create(activity=activity, owners=[s1])
# Registrar Course
c2: Course = RegistrarCourseFactory.create()
s2: User = UserFactory.create(username='******',
first_name='Student',
last_name='Two',
email='*****@*****.**')
c2.group.user_set.add(s2)
f2: User = UserFactory.create(username='******',
first_name='Faculty',
last_name='Two',
email='*****@*****.**')
c2.group.user_set.add(f2)
c2.faculty_group.user_set.add(f2)
def reset_test_models():
call_command('flush', verbosity=0, interactive=False)
# Enable some flags
Flag.objects.create(name='share_response_layers', everyone=True)
# Create some models
UserFactory.create(username='******',
first_name='Super',
last_name='User',
email='*****@*****.**',
is_superuser=True,
is_staff=True)
# Sandbox Course
c1: Course = SandboxCourseFactory.create(title='Sandbox Workspace')
s1: User = UserFactory.create(username='******',
first_name='Student',
last_name='One',
email='*****@*****.**')
c1.group.user_set.add(s1)
s1: User = UserFactory.create(username='******',
first_name='Student',
last_name='Three',
email='*****@*****.**')
c1.group.user_set.add(s1)
f1: User = UserFactory.create(username='******',
first_name='Faculty',
last_name='One',
email='*****@*****.**')
c1.group.user_set.add(f1)
c1.faculty_group.user_set.add(f1)
a1: User = UserFactory.create(username='******',
first_name='Author',
last_name='One',
email='*****@*****.**')
c1.group.user_set.add(a1)
c1.faculty_group.user_set.add(a1)
project = ProjectFactory.create(course=c1, title='Activity One')
activity = ActivityFactory.create(project=project)
ResponseFactory.create(activity=activity, owners=[s1])
# Registrar Course - generates a project too
c2: Course = RegistrarCourseFactory.create()
s2: User = UserFactory.create(username='******',
first_name='Student',
last_name='Two',
email='*****@*****.**')
c2.group.user_set.add(s2)
f2: User = UserFactory.create(username='******',
first_name='Faculty',
last_name='Two',
email='*****@*****.**')
c2.group.user_set.add(f2)
c2.faculty_group.user_set.add(f2)
# No affiliations
UserFactory.create(username='******',
first_name='Faculty',
last_name='Three',
email='*****@*****.**')
def test_non_course_user(self):
request = MagicMock(user=UserFactory())
view = MagicMock()
project = self.sandbox_course.projects.first()
self.assertFalse(
self.perm.has_object_permission(request, view, project))
def setUp(self):
self.user = UserFactory.create()
self.course = SandboxCourseFactory.create()
