def test_render_list(self):
u = UserFactory(username='******', first_name='Student',
last_name='One')
u.set_password('test')
u.save()
self.assertTrue(
self.api_client.client.login(username="******",
password="******"))
g1 = GroupFactory(name="group1")
g2 = GroupFactory(name="group2")
CourseFactory(title="Sample Course", faculty_group=g1, group=g2)
u.groups.add(g2)
UserFactory(username='******',
first_name='Instructor', last_name='One').groups.add(g2)
UserFactory(username='******').groups.add(g2)
UserFactory(username='******').groups.add(g2)
UserFactory(username='******', first_name='Student',
last_name='Two').groups.add(g2)
UserFactory(username='******',
first_name="Teacher's",
last_name=" Assistant").groups.add(g2)
sample_course = Course.objects.get(title="Sample Course")
members = UserResource().render_list(None, sample_course.members)
self.assertEquals(len(members), 6)
self.assertEquals(members[0]['public_name'], "test_instructor_two")
self.assertEquals(members[1]['public_name'], "test_student_three")
self.assertEquals(members[2]['public_name'], "Instructor One")
self.assertEquals(members[3]['public_name'], "Student One")
self.assertEquals(members[4]['public_name'], "Student Two")
self.assertEquals(members[5]['public_name'], "Teacher's Assistant")
def test_private_editors_are_owners(self):
policy = PrivateEditorsAreOwners()
collaboration = CollaborationFactory()
course = None
user = collaboration.user
self.assertTrue(policy.read(collaboration, course, user))
self.assertTrue(policy.edit(collaboration, course, user))
self.assertTrue(policy.manage(collaboration, course, user))
self.assertTrue(policy.delete(collaboration, course, user))
user = UserFactory() # random user
self.assertFalse(policy.read(collaboration, course, user))
self.assertFalse(policy.edit(collaboration, course, user))
self.assertFalse(policy.manage(
collaboration, course, user))
self.assertFalse(policy.delete(
collaboration, course, user))
collaboration.group.user_set.add(user) # now a group member
self.assertTrue(policy.read(collaboration, course, user))
self.assertTrue(policy.edit(collaboration, course, user))
self.assertTrue(policy.manage(collaboration, course, user))
self.assertTrue(policy.delete(collaboration, course, user))
user = UserFactory(is_staff=True)
self.assertTrue(policy.read(collaboration, course, user))
self.assertFalse(policy.edit(collaboration, course, user))
self.assertFalse(policy.manage(
collaboration, course, user))
self.assertFalse(policy.delete(
collaboration, course, user))
class LoggedInUserTestMixin(object):
def setUp(self):
self.u = UserFactory(username='******')
self.u.set_password('test')
self.u.save()
login = self.client.login(username='******', password='******')
assert(login is True)
class LoggedInTestMixin(object):
def setUp(self):
self.u = UserFactory(username='******')
self.u.set_password('test')
self.u.save()
login = self.client.login(username='******', password='******')
assert (login is True)
def setUp(self):
self.setup_sample_course()
self.setup_alternate_course()
self.superuser = UserFactory(is_staff=True, is_superuser=True)
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
def test_render_one(self):
u = UserFactory(username='******', first_name='Student',
last_name='One')
u.set_password('test')
u.save()
self.assertTrue(
self.api_client.client.login(username="******",
password="******"))
student_one = User.objects.get(username='******')
member = UserResource().render_one(None, student_one)
self.assertEquals(member['public_name'], "Student One")
def test_update_someone_elses_sequence_asset(self):
someone_else = UserFactory()
sa = SequenceAssetFactory(author=someone_else)
psa = ProjectSequenceAssetFactory(sequence_asset=sa)
note = SherdNoteFactory()
r = self.client.put(
reverse('sequenceasset-detail', args=(sa.pk,)),
{
'course': sa.course.pk,
'project': psa.project.pk,
'spine': note.pk,
'spine_volume': 100,
'media_elements': [],
'text_elements': [
{
'text': 'My text',
'start_time': Decimal('0'),
'end_time': Decimal('10'),
}
],
}, format='json')
self.assertEqual(r.status_code, 403)
sa.refresh_from_db()
self.assertEqual(sa.course, sa.course)
self.assertEqual(sa.author, someone_else)
self.assertEqual(sa.spine, None)
self.assertEqual(sa.spine_volume, 80)
self.assertEqual(SequenceAsset.objects.count(), 1)
self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
self.assertEqual(SequenceTextElement.objects.count(), 0)
def setUp(self):
self.u = UserFactory(username='******')
self.u.set_password('test')
self.u.save()
login = self.client.login(username='******',
password='******')
assert(login is True)
def test_user_activated_callback(self):
course = CourseFactory(title='Mediathread Guest Sandbox')
user = UserFactory()
user_activated_callback(None, user, None)
self.assertTrue(course.is_member(user))
def test_user_registered_callback(self):
user = UserFactory()
data = {'first_name': 'John',
'last_name': 'Doe',
'title': 'Professor',
'institution': 'Columbia University',
'referred_by': 'Sam Smith',
'user_story': 'Sample user story'}
request = RequestFactory().post('/', data)
user_registered_callback(None, user, request)
user.refresh_from_db()
self.assertEquals(user.first_name, 'John')
self.assertEquals(user.last_name, 'Doe')
self.assertEquals(user.profile.title, 'Professor')
self.assertEquals(user.profile.institution, 'Columbia University')
self.assertEquals(user.profile.referred_by, 'Sam Smith')
self.assertEquals(user.profile.user_story, 'Sample user story')
def test_request_superuser_nonclassmember_projectlist(self):
su = UserFactory(is_staff=True, is_superuser=True)
self.client.login(username=su.username, password='******')
self.switch_course(self.client, self.sample_course)
url = '/api/project/user/%s/' % su.username
response = self.client.get(url, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
the_json = json.loads(response.content)
self.assertFalse('compositions' in the_json)
def test_render_one(self):
u = UserFactory(username='******',
first_name='Student', last_name='One')
self.assertTrue(
self.client.login(username=u.username, password="******"))
student_one = User.objects.get(username='******')
member = UserResource().render_one(None, student_one)
self.assertEquals(member['public_name'], "Student One")
def test_get_course_list(self):
g1 = GroupFactory(name="group1")
g2 = GroupFactory(name="group2")
CourseFactory(title="Sample Course", faculty_group=g1, group=g2)
UserFactory(username='******',
first_name='Instructor', last_name='One').groups.add(g2)
secrets = {'http://testserver/': 'foobar'}
with self.settings(SERVER_ADMIN_SECRETKEYS=secrets):
url = '/api/user/courses?user=instructor_one&secret=foobar'
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_user_courses(self):
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
out = Template("{% load user_projects %}"
"{% num_courses for user as user_courses %}"
"{{user_courses}}").render(
Context({'user': self.instructor_three}))
self.assertEqual(out, "2")
def test_render_list(self):
u = UserFactory(username='******',
first_name='Student',
last_name='One')
self.assertTrue(self.client.login(username=u.username,
password="******"))
g1 = GroupFactory(name="group1")
g2 = GroupFactory(name="group2")
CourseFactory(title="Sample Course", faculty_group=g1, group=g2)
u.groups.add(g2)
UserFactory(username='******',
first_name='Instructor',
last_name='One').groups.add(g2)
UserFactory(username='******').groups.add(g2)
UserFactory(username='******').groups.add(g2)
UserFactory(username='******',
first_name='Student',
last_name='Two').groups.add(g2)
UserFactory(username='******',
first_name="Teacher's",
last_name="Assistant").groups.add(g2)
sample_course = Course.objects.get(title="Sample Course")
members = UserResource().render_list(None, sample_course.members)
self.assertEquals(len(members), 6)
self.assertEquals(members[0]['public_name'], "test_instructor_two")
self.assertEquals(members[1]['public_name'], "test_student_three")
self.assertEquals(members[2]['public_name'], "Assistant, Teacher's")
self.assertEquals(members[3]['public_name'], "One, Instructor")
self.assertEquals(members[4]['public_name'], "One, Student")
self.assertEquals(members[5]['public_name'], "Two, Student")
def test_redirect_uploader(self):
# no collection id
request = RequestFactory().post('/upload/redirect')
request.user = self.student_one
request.course = self.sample_course
view = RedirectToUploaderView()
view.request = request
with self.assertRaises(Http404):
view.post(request, [], **{'collection_id': 123})
secret_keys = {'http://ccnmtl.columbia.edu': 'a very good secret'}
with self.settings(SERVER_ADMIN_SECRETKEYS=secret_keys):
# invalid uploader url
as_user = '******' % self.student_one.username
exc = ExternalCollectionFactory(url='http://abc.def.ghi')
with self.assertRaises(Http404):
view.post(request, [], **{'collection_id': exc.id})
# successful redirect
exc = ExternalCollectionFactory(url='http://ccnmtl.columbia.edu')
response = view.post(request, [], **{'collection_id': exc.id})
self.assertEquals(response.status_code, 302)
self.assertTrue(response.url.startswith(exc.url))
self.assertTrue('nonce' in response.url)
self.assertTrue('hmac' in response.url)
self.assertTrue('redirect_url' in response.url)
self.assertTrue(as_user in response.url)
# "as" without permissions + audio
data = {'as': self.student_two.username, 'audio': 'mp4'}
request = RequestFactory().post('/upload/redirect', data)
request.user = self.student_one
request.course = self.sample_course
response = view.post(request, [], **{'collection_id': exc.id})
self.assertEquals(response.status_code, 302)
self.assertTrue(as_user in response.url)
self.assertTrue('audio=mp4' in response.url)
# "as" with permissions
data = {'as': self.student_one.username}
request = RequestFactory().post('/upload/redirect', data)
request.user = UserFactory(is_staff=True)
request.course = self.sample_course
self.add_as_faculty(request.course, request.user)
response = view.post(request, [], **{'collection_id': exc.id})
self.assertEquals(response.status_code, 302)
self.assertTrue(as_user in response.url)
def test_update(self):
author = UserFactory()
sa = SequenceAssetFactory(author=author)
note = SherdNoteFactory()
r = self.client.put(
reverse('sequenceasset-detail', args=(sa.pk,)),
{
'course': sa.course.pk,
'author': sa.author.pk,
'spine': note.pk,
'media_elements': [],
'text_elements': [],
}, format='json')
self.assertEqual(r.status_code, 403)
def test_create(self):
course = CourseFactory()
author = UserFactory()
note = SherdNoteFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'author': author.pk,
'spine': note.pk,
'media_elements': [],
'text_elements': [],
}, format='json')
self.assertEqual(r.status_code, 403)
def test_mediathread_activity_report_staff(self):
url = reverse('mediathread-activity-by-course')
# as superuser
staff = UserFactory(is_staff=True, is_superuser=True)
self.assertTrue(self.client.login(username=staff.username,
password='******'))
set_course_url = '/?set_course=%s&next=/' % \
self.sample_course.group.name
response = self.client.get(set_course_url, follow=True)
self.assertEquals(response.status_code, 200)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
def test_accept_invitation_form_duplicate_username(self):
user = UserFactory()
form = AcceptInvitationForm()
# required fields
form._errors = {}
form.cleaned_data = {
'first_name': 'Foo',
'last_name': 'Bar',
'password1': 'test',
'password2': 'test',
'username': user.username
}
form.clean()
self.assertEquals(len(form._errors.keys()), 1)
self.assertTrue('username' in form._errors)
def test_course_manage_materials_form(self):
user = UserFactory()
request = RequestFactory().post('/')
request.user = user
form = CourseDeleteMaterialsForm(request=request)
form._errors = {}
form.cleaned_data = {'username': '******', 'clear_all': True}
form.clean()
self.assertEquals(len(form._errors.keys()), 1)
self.assertTrue('username' in form._errors)
form = CourseDeleteMaterialsForm(request=request)
form._errors = {}
form.cleaned_data = {'username': user.username, 'clear_all': True}
form.clean()
self.assertEquals(len(form._errors.keys()), 0)
def setUp(self):
self.setup_sample_course()
self.setup_alternate_course()
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
# Sample Course Image Asset
self.asset1 = AssetFactory.create(course=self.sample_course,
primary_source='image',
author=self.instructor_one)
self.student_note = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',student_one_selection',
body='student one selection note',
range1=0,
range2=1)
self.student_ga = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',student_one_item',
body='student one item note',
title=None,
range1=None,
range2=None)
self.instructor_note = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_selection,',
body='instructor one selection note',
range1=0,
range2=1)
self.instructor_ga = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_item,',
body='instructor one item note',
title=None,
range1=None,
range2=None)
def test_parse_user(self):
view = AssetCreateView()
request = RequestFactory().get('/')
request.course = self.sample_course
# regular path
request.user = self.student_one
self.assertEquals(view.parse_user(request), self.student_one)
# "as" without permissions
request = RequestFactory().get('/', {'as': self.student_two.username})
request.user = self.student_one
request.course = self.sample_course
self.assertEquals(view.parse_user(request), self.student_one)
# "as" with permissions
request.user = UserFactory(is_staff=True)
request.course = self.sample_course
self.add_as_faculty(request.course, request.user)
self.assertEquals(view.parse_user(request), self.student_two)
def test_self_registration_report(self):
UserProfileFactory(user=self.student_one)
RegistrationProfileFactory(user=self.student_one)
url = reverse('mediathread-self-registration',
args=[self.sample_course.id])
# as student
self.client.login(username=self.student_one.username, password='******')
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
# as instructor
self.client.login(username=self.instructor_one.username,
password='******')
self.switch_course(self.client, self.sample_course)
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
# as superuser
staff = UserFactory(is_staff=True, is_superuser=True)
self.assertTrue(self.client.login(username=staff.username,
password='******'))
set_course_url = '/?set_course=%s&next=/' % \
self.sample_course.group.name
response = self.client.get(set_course_url, follow=True)
self.assertEquals(response.status_code, 200)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
header = ("First Name,Last Name,Email,Title,Institution,"
"Referred_By,User Story,Created")
data = ("Student,One,[email protected],Title,"
"Columbia University,Pablo Picasso,User Story,")
self.assertContains(response, header)
self.assertContains(response, data)
def setUp(self):
self.u = UserFactory(username='******')
self.u.set_password('test')
self.u.save()
login = self.client.login(username='******', password='******')
assert (login is True)
def setUp(self):
self.user = UserFactory()
self.course = CourseFactory()
def setUp(self):
self.setup_sample_course()
self.setup_alternate_course()
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
# Sample Course Image Asset
self.asset1 = AssetFactory.create(course=self.sample_course,
primary_source='image')
self.student_note = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',student_one_selection',
body='student one selection note',
range1=0,
range2=1)
self.student_ga = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',student_one_item',
body='student one item note',
title=None,
range1=None,
range2=None)
self.instructor_note = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_selection,',
body='instructor one selection note',
range1=0,
range2=1)
self.instructor_ga = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_item,',
body='instructor one item note',
title=None,
range1=None,
range2=None)
# Sample Course Projects
self.project_private = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
policy='PrivateEditorsAreOwners')
self.add_citation(self.project_private, self.student_note)
self.add_citation(self.project_private, self.student_ga)
self.project_instructor_shared = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
policy='InstructorShared')
self.add_citation(self.project_instructor_shared, self.student_note)
self.add_citation(self.project_instructor_shared, self.student_ga)
self.project_class_shared = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
policy='CourseProtected')
self.add_citation(self.project_class_shared, self.student_note)
self.add_citation(self.project_class_shared, self.student_ga)
self.assignment = ProjectFactory.create(course=self.sample_course,
author=self.instructor_one,
policy='CourseProtected',
project_type='assignment')
# Alt Course Projects
self.project_private_alt_course = ProjectFactory.create(
course=self.alt_course,
author=self.alt_student,
policy='PrivateEditorsAreOwners')
self.project_public_alt_course = ProjectFactory.create(
course=self.alt_course,
author=self.alt_student,
policy='PrivateEditorsAreOwners')
def setUp(self):
self.setup_sample_course()
self.setup_alternate_course()
# instructor that sees both Sample Course & Alternate Course
self.instructor_three = UserFactory(username='******')
self.add_as_faculty(self.sample_course, self.instructor_three)
self.add_as_faculty(self.alt_course, self.instructor_three)
self.sample_course = Course.objects.get(title='Sample Course')
self.alt_course = Course.objects.get(title="Alternate Course")
self.asset1 = AssetFactory.create(course=self.sample_course,
author=self.instructor_one,
primary_source='image')
self.student_note = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',student_one_selection',
body='student one selection note',
range1=0,
range2=1)
self.student_ga = SherdNoteFactory(asset=self.asset1,
author=self.student_one,
tags=',image, student_one_global,',
body='student one global note',
title=None,
range1=None,
range2=None)
self.instructor_note = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_selection,',
body='instructor one selection note',
range1=1,
range2=2)
self.instructor_ga = SherdNoteFactory(
asset=self.asset1,
author=self.instructor_one,
tags=',image, instructor_one_global,',
body='instructor one global note',
title=None,
range1=None,
range2=None)
self.asset2 = AssetFactory.create(course=self.sample_course,
author=self.instructor_one,
primary_source='video')
self.asset2_instructor_note = SherdNoteFactory(
asset=self.asset2,
author=self.instructor_one,
tags=',video, instructor_one_selection,',
body='instructor one selection note',
range1=0,
range2=1)
self.asset2_instructor_ga = SherdNoteFactory(
asset=self.asset2,
author=self.instructor_one,
tags=',video, instructor_one_global,',
body='instructor one global note',
title=None,
range1=None,
range2=None)
def setUp(self):
self.setup_sample_course()
self.superuser = UserFactory(is_superuser=True, is_staff=True)
def test_user_display_name(self):
user = UserFactory()
self.assertEquals(user_display_name(user), user.username)
user = UserFactory(first_name='John', last_name='Smith')
self.assertEquals(user_display_name(user), 'John Smith')
def test_unicode(self):
user = UserFactory(username='******')
profile = UserProfileFactory(user=user)
self.assertEquals(smart_text(profile), 'johndoe')
def setUp(self):
super(AssetTestsAsNonAuthor, self).setUp()
self.setup_sample_course()
self.add_as_student(self.sample_course, self.u)
self.author = UserFactory()
self.add_as_student(self.sample_course, self.author)
