def test_update_reference_in_string(self):
old_asset = AssetFactory(course=self.sample_course, author=self.student_one)
old_note = SherdNoteFactory(asset=old_asset, author=self.student_one, title="Selection", range1=43, range2=75)
alt_note = SherdNoteFactory(
asset=old_asset, author=self.student_one, title="Alt Selection", range1=43, range2=75
)
new_asset = AssetFactory(course=self.sample_course, author=self.student_one)
new_note = SherdNoteFactory(asset=new_asset, author=self.student_one, title="Selection", range1=43, range2=75)
text = (
'<p><a href="/asset/%s/annotations/%s/">Selection</a>'
'</p><p><a href="/asset/%s/annotations/%s/">Selection</a>'
'</p><p><a href="/asset/%s/annotations/%s/">Alt Selection</a>'
'</p><a href="/asset/%s/">Global</a></p>'
% (old_asset.id, old_note.id, old_asset.id, old_note.id, old_asset.id, alt_note.id, old_asset.id)
)
new_text = new_note.update_references_in_string(text, old_note)
citations = SherdNote.objects.references_in_string(new_text, old_note.author)
self.assertEquals(len(citations), 4)
self.assertEquals(citations[0].id, new_note.id)
self.assertEquals(citations[0].asset.id, new_note.asset.id)
self.assertEquals(citations[1].id, new_note.id)
self.assertEquals(citations[1].asset.id, new_note.asset.id)
self.assertEquals(citations[2].id, alt_note.id)
self.assertEquals(citations[2].asset.id, old_asset.id)
gann = old_asset.global_annotation(self.student_one, auto_create=False)
self.assertEquals(citations[3].id, gann.id)
self.assertEquals(citations[3].asset.id, old_asset.id)
def setUp(self):
self.setup_sample_course()
self.assignment = ProjectFactory.create(
course=self.sample_course, author=self.instructor_one,
policy=PUBLISH_WHOLE_CLASS[0],
project_type='selection-assignment')
self.asset = AssetFactory.create(course=self.sample_course,
primary_source='image')
self.assets = Asset.objects.filter(id=self.asset.id)
AssignmentItemFactory.create(project=self.assignment, asset=self.asset)
self.response_one = ProjectFactory.create(
course=self.sample_course, author=self.student_one,
policy='PrivateEditorsAreOwners', parent=self.assignment)
self.note_one = SherdNoteFactory(
asset=self.asset, author=self.student_one,
body='student one selection note', range1=0, range2=1)
ProjectNoteFactory(project=self.response_one, annotation=self.note_one)
self.response_two = ProjectFactory.create(
course=self.sample_course, author=self.student_two,
policy='PrivateEditorsAreOwners', parent=self.assignment)
self.note_two = SherdNoteFactory(
asset=self.asset, author=self.student_one,
body='student one selection note', range1=0, range2=1)
ProjectNoteFactory(project=self.response_two, annotation=self.note_two)
self.mixin = RestrictedMaterialsMixin()
self.mixin.request = RequestFactory().get('/')
self.mixin.request.course = self.sample_course
def test_get_selection(self):
asset = AssetFactory.create(course=self.sample_course,
primary_source='image',
author=self.instructor_one)
gann = SherdNoteFactory(asset=asset,
author=self.instructor_one,
title=None,
range1=None,
range2=None)
note = SherdNoteFactory(asset=asset,
author=self.instructor_one,
title='Selection')
view = AssetEmbedListView()
keys = ['foo-1234']
self.assertIsNone(view.get_selection(keys, self.instructor_one))
with self.assertRaises(Http404):
keys = ['item-666']
view.get_selection(keys, self.instructor_one)
with self.assertRaises(Http404):
keys = ['selection-666']
view.get_selection(keys, self.instructor_one)
keys = ['item-%s' % asset.id]
view = AssetEmbedListView()
self.assertEquals(view.get_selection(keys, self.instructor_one), gann)
keys = ['selection-%s' % note.id]
view = AssetEmbedListView()
self.assertEquals(view.get_selection(keys, self.instructor_one), note)
def setUp(self):
self.setup_sample_course()
self.assignment1 = ProjectFactory.create(
title='Alpha', course=self.sample_course,
author=self.instructor_one, policy='CourseProtected',
project_type='assignment')
self.response1 = ProjectFactory.create(
title="Response 1",
course=self.sample_course, author=self.student_one,
policy='InstructorShared', parent=self.assignment1)
self.asset = AssetFactory(course=self.sample_course)
SherdNote.objects.global_annotation(
self.asset, self.student_one, auto_create=True)
self.student_one_selection1 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_selection',
title="Selection", range1=116.25, range2=6.75)
self.student_one_selection2 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
title="Selection", range1=116.25, range2=6.75)
self.student_two_selection = SherdNoteFactory(
asset=self.asset, author=self.student_two,
title="Selection", range1=16.25, range2=2.75)
self.add_citation(self.response1, self.student_one_selection1)
self.add_citation(self.response1, self.student_two_selection)
def test_create_with_track_elements_with_large_decimals(self):
course = CourseFactory()
note = SherdNoteFactory()
note2 = SherdNoteFactory()
project = ProjectFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': note.pk,
'project': project.pk,
'media_elements': [
{
'media': note2.pk,
'start_time': Decimal('0.9999999999992222'),
'end_time': Decimal('10.15955395959359395'),
}
],
'text_elements': [
{
'text': 'My text',
'start_time': Decimal('0.19898591249142984912849218'),
'end_time': Decimal('10.853598923859285928598958392'),
},
{
'text': 'My text 2',
'start_time': Decimal('11'),
'end_time': Decimal('148744.835739573575'),
},
]
}, format='json')
self.assertEqual(r.status_code, 201)
sa = SequenceAsset.objects.first()
self.assertEqual(sa.course, sa.course)
self.assertEqual(sa.author, self.u)
self.assertEqual(sa.spine, note)
self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
psa = ProjectSequenceAsset.objects.first()
self.assertEqual(psa.sequence_asset, sa)
self.assertEqual(psa.project, project)
self.assertEqual(SequenceTextElement.objects.count(), 2)
e0 = SequenceTextElement.objects.first()
e1 = SequenceTextElement.objects.last()
self.assertEqual(e0.text, 'My text')
self.assertEqual(e0.start_time, Decimal('0.19899'))
self.assertEqual(e0.end_time, Decimal('10.85360'))
self.assertEqual(e1.text, 'My text 2')
self.assertEqual(e1.start_time, Decimal('11'))
self.assertEqual(e1.end_time, Decimal('148744.83574'))
self.assertEqual(SequenceMediaElement.objects.count(), 1)
e0 = SequenceMediaElement.objects.first()
self.assertEqual(e0.media, note2)
self.assertEqual(e0.start_time, Decimal('1.00000'))
self.assertEqual(e0.end_time, Decimal('10.15955'))
def setUp(self):
self.setup_sample_course()
self.asset1 = AssetFactory(course=self.sample_course)
global_annotation, created = SherdNote.objects.global_annotation(
self.asset1, self.student_three, auto_create=True
)
self.assertTrue(global_annotation.is_global_annotation())
whole_item_annotation = SherdNoteFactory(
asset=self.asset1, author=self.student_three, title="Whole Item Selection", range1=0, range2=0
)
self.assertFalse(whole_item_annotation.is_global_annotation())
real_annotation = SherdNoteFactory(
asset=self.asset1, author=self.student_three, title="Selection", range1=116.25, range2=6.75
)
self.assertFalse(real_annotation.is_global_annotation())
self.assignment1 = ProjectFactory.create(
title="Alpha",
course=self.sample_course,
author=self.instructor_one,
policy="CourseProtected",
project_type="assignment",
)
self.response1 = ProjectFactory.create(
title="Response 1",
course=self.sample_course,
author=self.student_one,
policy="InstructorShared",
parent=self.assignment1,
)
self.response2 = ProjectFactory.create(
title="Response 2",
date_submitted=datetime.now(),
course=self.sample_course,
author=self.student_two,
policy="InstructorShared",
parent=self.assignment1,
)
self.assignment2 = ProjectFactory.create(
title="Beta",
course=self.sample_course,
author=self.instructor_one,
policy="CourseProtected",
project_type="assignment",
)
self.project = ProjectFactory(
title="Gamma", course=self.sample_course, author=self.instructor_one, policy="CourseProtected"
)
self.add_citation(self.project, global_annotation)
self.add_citation(self.project, whole_item_annotation)
self.add_citation(self.project, real_annotation)
def setUp(self):
self.setup_sample_course()
self.setup_alternate_course()
taxonomy = {
'Shapes': ['Square', 'Triangle'],
'Colors': ['Red', 'Blue', 'Green']
}
self.create_vocabularies(self.sample_course, taxonomy)
taxonomy = {'Materials': ['Paper', 'Wood', 'Stone']}
self.create_vocabularies(self.alt_course, taxonomy)
asset = AssetFactory(course=self.sample_course,
author=self.student_one,
title="Asset One")
# instructor_one in Sample Course
note = SherdNoteFactory(asset=asset,
author=self.student_three,
title="Nice Tie",
tags=',student_three_selection',
body='student three selection note',
range1=0,
range2=1)
term = Term.objects.get(name="square")
self.create_term_relationship(note, term)
note = SherdNoteFactory(asset=asset,
author=self.instructor_one,
title="Left Corner",
tags=',instructor_one_selection',
body='instructor one selection note',
range1=0,
range2=1)
term = Term.objects.get(name="square")
self.create_term_relationship(note, term)
term = Term.objects.get(name="red")
self.create_term_relationship(note, term)
# alt_student in Alternate Course
asset = AssetFactory(course=self.alt_course,
author=self.alt_student,
title="Asset Two")
note = SherdNoteFactory(asset=asset,
author=self.student_two,
title="Whole Item Selection",
tags=',alt_student_selection',
body='alt student selection note',
range1=0,
range2=1)
term = Term.objects.get(name="paper")
self.create_term_relationship(note, term)
def setUp(self):
self.setup_sample_course()
self.assignment = ProjectFactory.create(
course=self.sample_course,
author=self.instructor_one,
policy='CourseProtected',
project_type='selection-assignment')
self.asset = AssetFactory.create(course=self.sample_course,
primary_source='image')
AssignmentItemFactory.create(project=self.assignment, asset=self.asset)
self.response_one = ProjectFactory.create(
course=self.sample_course,
author=self.student_one,
title="Student One Response",
policy='PrivateEditorsAreOwners',
parent=self.assignment)
self.note_one = SherdNoteFactory(asset=self.asset,
author=self.student_one,
body='student one selection note',
range1=0,
range2=1)
ProjectNoteFactory(project=self.response_one, annotation=self.note_one)
self.response_two = ProjectFactory.create(
course=self.sample_course,
author=self.student_two,
policy='PrivateEditorsAreOwners',
parent=self.assignment)
self.note_two = SherdNoteFactory(asset=self.asset,
author=self.student_two,
title="Student One Response",
body='student two selection note',
range1=0,
range2=1)
ProjectNoteFactory(project=self.response_two, annotation=self.note_two)
ProjectFactory.create(course=self.sample_course,
author=self.student_three,
policy='CourseProtected',
parent=self.assignment,
date_submitted=datetime.now())
url = reverse('project-item-view',
args=[self.assignment.id, self.asset.id])
self.view = ProjectItemView()
self.view.request = RequestFactory().get(url)
self.view.request.course = self.sample_course
def test_is_global_annotation(self):
asset = AssetFactory(course=self.sample_course)
global_annotation, created = SherdNote.objects.global_annotation(
asset, self.student_three, auto_create=True)
self.assertTrue(global_annotation.is_global_annotation())
whole_item_annotation = SherdNoteFactory(
asset=asset, author=self.student_three,
title="Whole Item Selection", range1=0, range2=0)
self.assertFalse(whole_item_annotation.is_global_annotation())
real_annotation = SherdNoteFactory(
asset=asset, author=self.student_three,
title="Selection", range1=116.25, range2=6.75)
self.assertFalse(real_annotation.is_global_annotation())
def test_create_without_spine_with_track_elements(self):
course = CourseFactory()
project = ProjectFactory()
note = SherdNoteFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': '',
'project': project.pk,
'media_elements': [
{
'media': note.pk,
'start_time': Decimal('0'),
'end_time': Decimal('10'),
}
],
'text_elements': [
{
'text': 'My text',
'start_time': Decimal('0'),
'end_time': Decimal('10'),
}
]
}, format='json')
self.assertEqual(
r.status_code, 400,
'Attempting to create a SequenceAsset without a spine but '
'with track elements should be invalid.')
def test_copy_annotation(self):
asset = AssetFactory(course=self.sample_course, primary_source='image')
self.assertIsNone(asset.global_annotation(self.student_two, False))
note = SherdNoteFactory(asset=asset,
author=self.student_one,
title='Sample Note',
annotation_data='{1:2}',
body='student one notes',
tags=',student_one_selection',
range1=0,
range2=1)
params = {'asset_id': asset.id, 'annotation_id': note.id}
url = reverse('annotation-copy-view', args=[asset.id, note.id])
self.client.login(username=self.student_two.username, password='******')
response = self.client.post(url,
params,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
the_json = loads(response.content)
self.assertEquals(the_json['asset']['id'], asset.id)
self.assertNotEquals(the_json['annotation']['id'], note.id)
self.assertEquals(response.status_code, 200)
note = SherdNote.objects.get(author=self.student_two,
title=note.title,
range1=note.range1,
range2=note.range2,
annotation_data=note.annotation_data)
self.assertEquals(note.tags, '')
self.assertIsNone(note.body)
self.assertIsNotNone(asset.global_annotation(self.student_two, False))
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 test_asset_title_save_as_author_global_annotation(self):
asset1 = AssetFactory.create(course=self.sample_course,
primary_source='image',
title="Item Title",
author=self.instructor_one)
gann = SherdNoteFactory(asset=asset1,
author=self.instructor_one,
title=None,
range1=None,
range2=None)
self.assert_(
self.client.login(username=self.instructor_one.username,
password="******"))
self.switch_course(self.client, self.sample_course)
# Update passing in a non-global annotation. This should fail
post_data = {'asset-title': "Updated Item Title"}
url = "/asset/save/%s/annotations/%s/" % (asset1.id, gann.id)
response = self.client.post(url,
post_data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
asset = Asset.objects.get(id=asset1.id)
self.assertEquals(asset.title, "Updated Item Title")
def test_create(self):
course = CourseFactory()
note = SherdNoteFactory()
project = ProjectFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': note.pk,
'project': project.pk,
'media_elements': [],
'text_elements': [],
}, format='json')
self.assertEqual(r.status_code, 201)
sa = SequenceAsset.objects.first()
self.assertEqual(sa.course, sa.course)
self.assertEqual(sa.author, self.u)
self.assertEqual(sa.spine, note)
self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
psa = ProjectSequenceAsset.objects.first()
self.assertEqual(psa.sequence_asset, sa)
self.assertEqual(psa.project, project)
def setUp(self):
super(self.__class__, self).setUp()
self.asset = AssetFactory(course=self.sample_course,
author=self.student_one)
self.ga1 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_item', title=None, range1=None, range2=None)
self.assertTrue(self.ga1.is_global_annotation())
self.note1 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_selection', range1=0, range2=1)
self.ga2 = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_item', title=None, range1=None, range2=None)
self.note2 = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_selection', range1=0, range2=1)
self.ga3 = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',instructor_one_item', title=None, range1=None, range2=None)
self.note3 = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',image,instructor_one_selection,', range1=0, range2=1)
def setUp(self):
self.setup_sample_course()
self.asset = AssetFactory(course=self.sample_course,
author=self.student_one,
primary_source='image',)
self.student_one_ga = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_item', title=None, range1=None, range2=None)
self.assertTrue(self.student_one_ga.is_global_annotation())
self.student_one_note = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_selection', range1=0, range2=1)
self.student_two_ga = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_item', title=None, range1=None, range2=None)
self.student_two_note = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_selection', range1=0, range2=1)
self.instructor_one_ga = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',instructor_one_item', title=None, range1=None, range2=None)
self.instructor_one_note = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',image,instructor_one_selection,', range1=0, range2=1)
def setUp(self):
self.setup_sample_course()
asset = AssetFactory(author=self.student_one,
primary_source='image',
course=self.sample_course)
self.note1 = SherdNoteFactory(asset=asset,
author=self.student_one,
title='one',
range1=116.25,
range2=6.75)
self.note2 = SherdNoteFactory(asset=asset,
author=self.student_one,
title='two',
range1=116.25,
range2=6.75)
def test_update_reference_in_string(self):
old_asset = AssetFactory(course=self.sample_course,
author=self.student_one)
old_note = SherdNoteFactory(asset=old_asset,
author=self.student_one,
title="Selection",
range1=43,
range2=75)
alt_note = SherdNoteFactory(asset=old_asset,
author=self.student_one,
title="Alt Selection",
range1=43,
range2=75)
new_asset = AssetFactory(course=self.sample_course,
author=self.student_one)
new_note = SherdNoteFactory(asset=new_asset,
author=self.student_one,
title="Selection",
range1=43,
range2=75)
text = ('<p><a href="/asset/%s/annotations/%s/">Selection</a>'
'</p><p><a href="/asset/%s/annotations/%s/">Selection</a>'
'</p><p><a href="/asset/%s/annotations/%s/">Alt Selection</a>'
'</p><a href="/asset/%s/">Global</a></p>' %
(old_asset.id, old_note.id, old_asset.id, old_note.id,
old_asset.id, alt_note.id, old_asset.id))
new_text = new_note.update_references_in_string(text, old_note)
citations = SherdNote.objects.references_in_string(
new_text, old_note.author)
self.assertEquals(len(citations), 4)
self.assertEquals(citations[0].id, new_note.id)
self.assertEquals(citations[0].asset.id, new_note.asset.id)
self.assertEquals(citations[1].id, new_note.id)
self.assertEquals(citations[1].asset.id, new_note.asset.id)
self.assertEquals(citations[2].id, alt_note.id)
self.assertEquals(citations[2].asset.id, old_asset.id)
gann = old_asset.global_annotation(self.student_one, auto_create=False)
self.assertEquals(citations[3].id, gann.id)
self.assertEquals(citations[3].asset.id, old_asset.id)
def test_create_duplicate(self):
course = CourseFactory()
note = SherdNoteFactory()
project = ProjectFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': note.pk,
'project': project.pk,
'media_elements': [
],
'text_elements': [
{
'text': 'My text',
'start_time': Decimal('0'),
'end_time': Decimal('10'),
}
]
}, format='json')
self.assertEqual(r.status_code, 201)
sa = SequenceAsset.objects.first()
self.assertEqual(sa.course, sa.course)
self.assertEqual(sa.author, self.u)
self.assertEqual(sa.spine, note)
self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
psa = ProjectSequenceAsset.objects.first()
self.assertEqual(psa.sequence_asset, sa)
self.assertEqual(psa.project, project)
self.assertEqual(SequenceTextElement.objects.count(), 1)
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': note.pk,
'project': project.pk,
'media_elements': [
],
'text_elements': [
{
'text': 'My text',
'start_time': Decimal('0'),
'end_time': Decimal('10'),
}
]
}, format='json')
self.assertEqual(
r.status_code, 400,
'Creating two SequenceAssets for the same combination '
'of author / project should be invalid.')
self.assertEqual(SequenceAsset.objects.count(), 1)
def test_get(self):
asset = AssetFactory(course=self.sample_course, primary_source='image')
SherdNoteFactory(asset=asset,
author=self.student_one,
tags=',student_one_selection',
range1=0,
range2=1)
SherdNoteFactory(asset=asset,
author=self.student_one,
tags=',student_one_item',
title=None,
range1=None,
range2=None)
url = reverse('asset-references', args=[asset.id])
# anonymous
response = self.client.get(url)
self.assertEquals(response.status_code, 302)
self.client.login(username=self.student_one, password='******')
# non-ajax
response = self.client.get(url)
self.assertEquals(response.status_code, 405)
# ajax
response = self.client.get(url, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
the_json = loads(response.content)
self.assertTrue('tags' in the_json)
self.assertTrue('vocabulary' in the_json)
self.assertTrue('references' in the_json)
# invalid asset
url = reverse('asset-references', args=[1234])
response = self.client.get(url, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
the_json = loads(response.content)
self.assertFalse('tags' in the_json)
self.assertFalse('vocabulary' in the_json)
self.assertFalse('references' in the_json)
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_get_related_assets(self):
asset2 = AssetFactory(course=self.sample_course,
author=self.student_one)
note2 = SherdNoteFactory(asset=asset2, author=self.student_one)
ids = [self.student_one_ga.id, self.student_one_note.id, note2.id]
notes = SherdNote.objects.filter(id__in=ids)
assets = notes.get_related_assets()
self.assertEquals(assets.count(), 2)
self.assertTrue(self.asset in assets)
self.assertTrue(asset2 in assets)
def test_asset_delete(self):
self.assertTrue(
self.client.login(username=self.instructor_one.username,
password='******'))
self.switch_course(self.client, self.sample_course)
asset1 = AssetFactory.create(course=self.sample_course,
author=self.instructor_one,
primary_source='image')
self.student_note = SherdNoteFactory(asset=asset1,
author=self.student_one)
self.instructor_note = SherdNoteFactory(asset=asset1,
author=self.instructor_one)
response = self.client.get('/asset/delete/%s/' % asset1.id, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
notes = asset1.sherdnote_set.filter(author=self.instructor_one)
self.assertEquals(notes.count(), 0)
notes = asset1.sherdnote_set.filter(author=self.student_one)
self.assertEquals(notes.count(), 1)
def test_user_analysis_count(self):
SherdNoteFactory(asset=self.asset1,
author=self.student_two,
tags=',student_two_item',
title=None,
range1=None,
range2=None)
# global notes y/n + global tag count + annotation count
self.assertEqual(0,
self.asset1.user_analysis_count(self.instructor_two))
self.assertEqual(1, self.asset1.user_analysis_count(self.student_two))
self.assertEqual(4,
self.asset1.user_analysis_count(self.instructor_one))
def setUp(self):
self.setup_sample_course()
self.project = ProjectFactory.create(course=self.sample_course,
author=self.student_one,
policy='CourseProtected')
self.collaboration = self.project.get_collaboration()
self.asset = AssetFactory.create(course=self.sample_course,
primary_source='image')
self.asset2 = AssetFactory.create(course=self.sample_course,
primary_source='image')
self.note = SherdNoteFactory(asset=self.asset,
author=self.student_one,
tags=',student_one_selection',
body='student one selection note',
range1=0,
range2=1)
self.note2 = SherdNoteFactory(asset=self.asset2,
author=self.student_one,
title='note2')
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_create_with_track_elements_with_no_start_time(self):
course = CourseFactory()
note = SherdNoteFactory()
note2 = SherdNoteFactory()
project = ProjectFactory()
r = self.client.post(
reverse('sequenceasset-list'),
{
'course': course.pk,
'spine': note.pk,
'project': project.pk,
'media_elements': [
{
'media': note2.pk,
'start_time': None,
'end_time': Decimal('0.9999'),
}
],
'text_elements': [
{
'text': 'My text',
'start_time': None,
'end_time': Decimal('0.198985'),
},
{
'text': 'My text 2',
'start_time': Decimal('11'),
'end_time': Decimal('14'),
},
]
}, format='json')
self.assertEqual(
r.status_code, 400,
'Attempting to create track elements with no start time should '
'be invalid.')
def test_get(self):
asset = AssetFactory(course=self.sample_course, primary_source='image')
self.client.login(username=self.student_one.username, password='******')
SherdNoteFactory(asset=asset,
author=self.student_one,
tags=',student_one_selection',
range1=0,
range2=1)
SherdNoteFactory(asset=asset,
author=self.student_one,
tags=',student_one_item',
title=None,
range1=None,
range2=None)
response = self.client.get(self.url, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEquals(response.status_code, 200)
the_json = loads(response.content)
self.assertTrue('tags' in the_json)
self.assertEquals(len(the_json['tags']), 2)
self.assertEquals(the_json['tags'][0]['name'], 'student_one_item')
self.assertEquals(the_json['tags'][1]['name'], 'student_one_selection')
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_edit_annotation(self):
note = SherdNoteFactory(
asset=self.asset, author=self.student_one,
title='Selection', range1=116.25, range2=6.75)
data = {'annotation-range1': -4.5,
'annotation-tags': 'foo,bar', 'next': 'foo'}
request = RequestFactory().post('/', data)
request.user = self.student_two
with self.assertRaises(Http404):
edit_annotation(request, 123)
response = edit_annotation(request, note.id)
self.assertEquals(response.status_code, 403)
# via post
request.user = self.student_one
response = edit_annotation(request, note.id)
self.assertEquals(response.status_code, 302)
note.refresh_from_db()
self.assertEquals(note.range1, -4.5)
self.assertEquals(note.tags, 'foo,bar')
# via ajax
data = {'annotation-range2': 7}
request = RequestFactory().post('/', data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
request.user = self.student_one
response = edit_annotation(request, note.id)
self.assertEquals(response.status_code, 200)
the_json = loads(response.content)
self.assertEquals(the_json['asset']['id'], self.asset.id)
self.assertEquals(the_json['annotation']['id'], note.id)
note.refresh_from_db()
self.assertEquals(note.range2, 7)
def test_filter_by_today(self):
note = SherdNoteFactory()
# today
notes = SherdNote.objects.filter_by_date('today')
self.assertEquals(notes.count(), 1)
self.assertEquals(notes[0].title, note.title)
# yesterday
notes = SherdNote.objects.filter_by_date('yesterday')
self.assertEquals(notes.count(), 0)
# in the last week
notes = SherdNote.objects.filter_by_date('lastweek')
self.assertEquals(notes.count(), 1)
self.assertEquals(notes[0].title, note.title)
def setUp(self):
self.setup_sample_course()
self.factory = RequestFactory()
taxonomy = {
'Shapes': ['Square', 'Triangle', 'Circle'],
'Colors': ['Red', 'Blue', 'Green']
}
self.create_vocabularies(self.sample_course, taxonomy)
self.asset = AssetFactory(course=self.sample_course)
self.note = SherdNoteFactory(asset=self.asset,
author=self.student_one,
title="Whole Item Selection",
range1=116.25,
range2=6.75)
def test_retrieve_with_text_elements(self):
note = SherdNoteFactory()
asset = SequenceAssetFactory(author=self.u, spine=note)
e1 = SequenceTextElementFactory(sequence_asset=asset)
e2 = SequenceTextElementFactory(sequence_asset=asset)
e3 = SequenceTextElementFactory(sequence_asset=asset)
r = self.client.get(
reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
)
self.assertEqual(r.status_code, 200)
the_json = loads(r.content)
self.assertEqual(the_json['spine']['id'], note.pk)
textelements = the_json['text_elements']
self.assertEqual(textelements[0]['text'], e1.text)
self.assertEqual(textelements[1]['text'], e2.text)
self.assertEqual(textelements[2]['text'], e3.text)
def test_retrieve(self):
asset = SequenceAssetFactory()
r = self.client.get(
reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
)
self.assertEqual(r.status_code, 200)
self.assertIsNone(r.data.get('spine'))
self.assertEqual(r.data.get('id'), asset.pk)
note = SherdNoteFactory()
asset = SequenceAssetFactory(spine=note)
r = self.client.get(
reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
)
self.assertEqual(r.status_code, 200)
self.assertEqual(r.data.get('spine')['id'], note.pk)
def test_range_as_timecode(self):
asset = AssetFactory(course=self.sample_course)
global_annotation, created = SherdNote.objects.global_annotation(
asset, self.student_three, auto_create=True)
self.assertEquals(global_annotation.range_as_timecode(), "")
whole_item_annotation = SherdNoteFactory(asset=asset,
author=self.student_three)
self.assertEquals(whole_item_annotation.range_as_timecode(), "")
real_annotation = SherdNoteFactory(asset=asset,
author=self.student_three,
range1=28,
range2=39)
self.assertEquals(real_annotation.range_as_timecode(), "0:28 - 0:39")
real_annotation = SherdNoteFactory(asset=asset,
author=self.student_three,
range1=43,
range2=75)
self.assertEquals(real_annotation.range_as_timecode(), "0:43 - 01:15")
def test_annotation_delete(self):
asset = AssetFactory(course=self.sample_course, primary_source='image')
note = SherdNoteFactory(asset=asset,
author=self.student_one,
tags=',student_one_selection',
range1=0,
range2=1)
request = RequestFactory().post('/')
request.user = self.student_one
request.course = self.sample_course
response = annotation_delete(request, asset.id, note.id)
self.assertEquals(response.status_code, 302)
response = annotation_delete(request, asset.id, note.id)
self.assertEquals(response.status_code, 404)
def test_range_as_timecode(self):
asset = AssetFactory(course=self.sample_course)
global_annotation, created = SherdNote.objects.global_annotation(asset, self.student_three, auto_create=True)
self.assertEquals(global_annotation.range_as_timecode(), "")
whole_item_annotation = SherdNoteFactory(asset=asset, author=self.student_three)
self.assertEquals(whole_item_annotation.range_as_timecode(), "")
real_annotation = SherdNoteFactory(asset=asset, author=self.student_three, range1=28, range2=39)
self.assertEquals(real_annotation.range_as_timecode(), "0:28 - 0:39")
real_annotation = SherdNoteFactory(asset=asset, author=self.student_three, range1=43, range2=75)
self.assertEquals(real_annotation.range_as_timecode(), "0:43 - 01:15")
class SherdNoteFilterTest(MediathreadTestMixin, TestCase):
def setUp(self):
self.setup_sample_course()
self.asset = AssetFactory(course=self.sample_course,
author=self.student_one,
primary_source='image',)
self.student_one_ga = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_item', title=None, range1=None, range2=None)
self.assertTrue(self.student_one_ga.is_global_annotation())
self.student_one_note = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_selection', range1=0, range2=1)
self.student_two_ga = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_item', title=None, range1=None, range2=None)
self.student_two_note = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_selection', range1=0, range2=1)
self.instructor_one_ga = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',instructor_one_item', title=None, range1=None, range2=None)
self.instructor_one_note = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',image,instructor_one_selection,', range1=0, range2=1)
def test_filter_by_record_owner(self):
qs = Asset.objects.filter(id=self.asset.id)
author = User.objects.get(username='******')
names = ['instructor_one', 'instructor_two', 'student_one']
users = User.objects.filter(username__in=names).values_list('id')
visible_authors = users.values_list('id', flat=True)
notes = SherdNote.objects.get_related_notes(qs,
author,
visible_authors,
True)
self.assertEquals(notes.count(), 2)
self.assertEquals(notes[0], self.student_one_ga)
self.assertEquals(notes[1], self.student_one_note)
def test_filter_no_authors(self):
qs = Asset.objects.filter(id=self.asset.id)
notes = SherdNote.objects.get_related_notes(qs, None, [], True)
self.assertEquals(notes.count(), 6)
self.assertEquals(notes[0], self.student_one_ga)
self.assertEquals(notes[1], self.student_one_note)
self.assertEquals(notes[2], self.student_two_ga)
self.assertEquals(notes[3], self.student_two_note)
self.assertEquals(notes[4], self.instructor_one_ga)
self.assertEquals(notes[5], self.instructor_one_note)
def test_filter_by_visible_authors(self):
qs = Asset.objects.filter(id=self.asset.id)
names = ['instructor_one', 'instructor_two', 'student_one']
users = User.objects.filter(username__in=names).values_list('id')
visible_authors = users.values_list('id', flat=True)
notes = SherdNote.objects.get_related_notes(qs,
None,
visible_authors,
True)
self.assertEquals(notes.count(), 5)
self.assertEquals(notes[0], self.student_one_ga)
self.assertEquals(notes[1], self.student_one_note)
self.assertEquals(notes[2], self.student_two_ga)
self.assertEquals(notes[3], self.instructor_one_ga)
self.assertEquals(notes[4], self.instructor_one_note)
def test_filter_by_all_items_are_visible(self):
qs = Asset.objects.filter(id=self.asset.id)
names = ['instructor_one', 'instructor_two', 'student_one']
users = User.objects.filter(username__in=names).values_list('id')
visible_authors = users.values_list('id', flat=True)
notes = SherdNote.objects.get_related_notes(qs,
None,
visible_authors,
False)
self.assertEquals(notes.count(), 4)
self.assertEquals(notes[0], self.student_one_ga)
self.assertEquals(notes[1], self.student_one_note)
self.assertEquals(notes[2], self.instructor_one_ga)
self.assertEquals(notes[3], self.instructor_one_note)
def test_filter_by_tags(self):
notes = SherdNote.objects.filter_by_tags('student_one_selection')
self.assertEquals(notes.count(), 1)
self.assertEquals(notes[0], self.student_one_note)
notes = SherdNote.objects.filter(asset=self.asset)
self.assertEquals(notes.count(), 6)
notes = notes.filter_by_tags(
'student_two_selection,image').order_by('id')
self.assertEquals(notes.count(), 2)
self.assertEquals(notes[0], self.student_two_note)
self.assertEquals(notes[1], self.instructor_one_note)
def test_get_related_assets(self):
asset2 = AssetFactory(course=self.sample_course,
author=self.student_one)
note2 = SherdNoteFactory(asset=asset2, author=self.student_one)
ids = [self.student_one_ga.id, self.student_one_note.id, note2.id]
notes = SherdNote.objects.filter(id__in=ids)
assets = notes.get_related_assets()
self.assertEquals(assets.count(), 2)
self.assertTrue(self.asset in assets)
self.assertTrue(asset2 in assets)
def test_exclude_primary_types(self):
asset2 = AssetFactory(course=self.sample_course,
author=self.student_one,
primary_source='youtube',)
youtube_note = SherdNoteFactory(
asset=asset2, author=self.student_one,
tags=',student_one_selection', range1=0, range2=1)
qs = SherdNote.objects.filter(author=self.student_one)
self.assertEquals(qs.count(), 3)
notes = qs.exclude_primary_types(['youtube'])
self.assertEquals(notes.count(), 2)
self.assertTrue(self.student_one_ga in notes)
self.assertTrue(self.student_one_note in notes)
notes = qs.exclude_primary_types(['image'])
self.assertEquals(notes.count(), 1)
self.assertEquals(notes[0], youtube_note)
class SherdNoteFilterTest(MediathreadTestCase):
def setUp(self):
super(self.__class__, self).setUp()
self.asset = AssetFactory(course=self.sample_course,
author=self.student_one)
self.ga1 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_item', title=None, range1=None, range2=None)
self.assertTrue(self.ga1.is_global_annotation())
self.note1 = SherdNoteFactory(
asset=self.asset, author=self.student_one,
tags=',student_one_selection', range1=0, range2=1)
self.ga2 = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_item', title=None, range1=None, range2=None)
self.note2 = SherdNoteFactory(
asset=self.asset, author=self.student_two,
tags=',student_two_selection', range1=0, range2=1)
self.ga3 = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',instructor_one_item', title=None, range1=None, range2=None)
self.note3 = SherdNoteFactory(
asset=self.asset, author=self.instructor_one,
tags=',image,instructor_one_selection,', range1=0, range2=1)
def test_filter_by_record_owner(self):
qs = Asset.objects.filter(id=self.asset.id)
author = User.objects.get(username='******')
names = ['instructor_one', 'instructor_two', 'student_one']
users = User.objects.filter(username__in=names).values_list('id')
visible_authors = users.values_list('id', flat=True)
notes = SherdNote.objects.get_related_notes(qs,
author,
visible_authors)
self.assertEquals(notes.count(), 2)
self.assertEquals(notes[0], self.ga1)
self.assertEquals(notes[1], self.note1)
def test_filter_no_authors(self):
qs = Asset.objects.filter(id=self.asset.id)
notes = SherdNote.objects.get_related_notes(qs, None, [])
self.assertEquals(notes.count(), 6)
self.assertEquals(notes[0], self.ga1)
self.assertEquals(notes[1], self.note1)
self.assertEquals(notes[2], self.ga2)
self.assertEquals(notes[3], self.note2)
self.assertEquals(notes[4], self.ga3)
self.assertEquals(notes[5], self.note3)
def test_filter_by_visible_authors(self):
qs = Asset.objects.filter(id=self.asset.id)
names = ['instructor_one', 'instructor_two', 'student_one']
users = User.objects.filter(username__in=names).values_list('id')
visible_authors = users.values_list('id', flat=True)
notes = SherdNote.objects.get_related_notes(qs,
None,
visible_authors)
self.assertEquals(notes.count(), 4)
self.assertEquals(notes[0], self.ga1)
self.assertEquals(notes[1], self.note1)
self.assertEquals(notes[2], self.ga3)
self.assertEquals(notes[3], self.note3)
def test_filter_by_tags(self):
notes = SherdNote.objects.filter_by_tags('student_one_selection')
self.assertEquals(notes.count(), 1)
self.assertEquals(notes[0], self.note1)
notes = SherdNote.objects.filter(asset=self.asset)
self.assertEquals(notes.count(), 6)
notes = notes.filter_by_tags(
'student_two_selection,image').order_by('id')
self.assertEquals(notes.count(), 2)
self.assertEquals(notes[0], self.note2)
self.assertEquals(notes[1], self.note3)
