def test_create_from_request(self):
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(self.annotation_data['text'], note.text)
self.assertEqual(self.annotation_data['quote'], note.quote)
self.assertEqual(self.annotation_data['uri'], note.uri)
self.assert_('ranges' in note.extra_data)
self.assertEqual(self.annotation_data['ranges'][0]['start'],
note.extra_data['ranges'][0]['start'])
self.assert_('permissions' in note.extra_data)
# create from request with user specified
user = get_user_model().objects.get(username='******')
self.mockrequest.user = user
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(user, note.user)
def test_create_from_request(self):
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(self.annotation_data['text'], note.text)
self.assertEqual(self.annotation_data['quote'], note.quote)
self.assertEqual(self.annotation_data['uri'], note.uri)
self.assert_('ranges' in note.extra_data)
self.assertEqual(self.annotation_data['ranges'][0]['start'],
note.extra_data['ranges'][0]['start'])
self.assert_('permissions' in note.extra_data)
# create from request with user specified
user = get_user_model().objects.get(username='******')
self.mockrequest.user = user
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(user, note.user)
def test_permissions_dict(self):
note = Annotation.create_from_request(self.mockrequest)
note.save()
# get some users and groups to work with
user = get_user_model().objects.get(username='******')
group1 = AnnotationGroup.objects.create(name='foo')
group2 = AnnotationGroup.objects.create(name='foobar')
perms = {
'read':
[user.username, group1.annotation_id, group2.annotation_id],
'update': [user.username, group1.annotation_id],
'delete': [user.username],
'admin': []
}
# test round-trip: convert to db permissions and then back
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
perms = {
'read': [user.username, group1.annotation_id],
'update': [user.username],
'delete': [],
'admin': []
}
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
perms = {'read': [], 'update': [], 'delete': [], 'admin': []}
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
def test_user_permissions(self):
# annotation user/owner automatically gets permissions
user = get_user_model().objects.get(username='******')
note = Annotation.create_from_request(self.mockrequest)
note.user = user
note.save()
user_perms = note.user_permissions()
self.assertEqual(4, user_perms.count())
self.assert_(
user_perms.filter(user=user,
permission__codename='view_annotation').exists())
self.assert_(
user_perms.filter(
user=user, permission__codename='change_annotation').exists())
self.assert_(
user_perms.filter(
user=user, permission__codename='delete_annotation').exists())
self.assert_(
user_perms.filter(
user=user, permission__codename='admin_annotation').exists())
note.save()
# saving again shouldn't duplicate the permissions
self.assertEqual(4, note.user_permissions().count())
def test_user_permissions(self):
# annotation user/owner automatically gets permissions
user = get_user_model().objects.get(username='******')
note = Annotation.create_from_request(self.mockrequest)
note.user = user
note.save()
user_perms = note.user_permissions()
self.assertEqual(4, user_perms.count())
self.assert_(user_perms.filter(user=user,
permission__codename='view_annotation')
.exists())
self.assert_(user_perms.filter(user=user,
permission__codename='change_annotation')
.exists())
self.assert_(user_perms.filter(user=user,
permission__codename='delete_annotation')
.exists())
self.assert_(user_perms.filter(user=user,
permission__codename='admin_annotation')
.exists())
note.save()
# saving again shouldn't duplicate the permissions
self.assertEqual(4, note.user_permissions().count())
def last_updated_time(self):
Annotation.objects.all().delete() # delete fixture annotations
self.assertEqual(None, Annotation.objects.all().last_updated_time())
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
self.assertEqual(note.updated,
Annotation.objects.all().last_updated_time())
def last_updated_time(self):
Annotation.objects.all().delete() # delete fixture annotations
self.assertEqual(None, Annotation.objects.all().last_updated_time())
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
self.assertEqual(note.updated,
Annotation.objects.all().last_updated_time())
def test_last_created_time(self):
# test custom queryset methods
Annotation.objects.all().delete() # delete fixture annotations
self.assertEqual(None, Annotation.objects.all().last_created_time())
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
self.assertEqual(note.created,
Annotation.objects.all().last_created_time())
def test_last_created_time(self):
# test custom queryset methods
Annotation.objects.all().delete() # delete fixture annotations
self.assertEqual(None, Annotation.objects.all().last_created_time())
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
self.assertEqual(note.created,
Annotation.objects.all().last_created_time())
def test_related_pages(self):
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(len(self.annotation_data['related_pages']),
len(note.related_pages))
for idx in range(len(self.annotation_data['related_pages'])):
self.assertEqual(self.annotation_data['related_pages'][idx],
note.related_pages[idx])
self.assertEqual(self.annotation_data['related_pages'][idx],
note.extra_data['related_pages'][idx])
note = Annotation()
self.assertEqual(None, note.related_pages)
def test_related_pages(self):
note = Annotation.create_from_request(self.mockrequest)
self.assertEqual(len(self.annotation_data['related_pages']),
len(note.related_pages))
for idx in range(len(self.annotation_data['related_pages'])):
self.assertEqual(self.annotation_data['related_pages'][idx],
note.related_pages[idx])
self.assertEqual(self.annotation_data['related_pages'][idx],
note.extra_data['related_pages'][idx])
note = Annotation()
self.assertEqual(None, note.related_pages)
def post(self, request):
'Create a new annotation via AJAX.'
# for now, only support creation via ajax
if request.is_ajax():
note = Annotation.create_from_request(request)
note.save()
# annotator store documentation says to return 303
# not sure why this isn't a 201 Created...
return HttpResponseSeeOtherRedirect(note.get_absolute_url())
else:
return HttpResponseBadRequest(non_ajax_error_msg)
def test_info(self):
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
info = note.info()
fields = ['id', 'annotator_schema_version', 'created', 'updated',
'text', 'quote', 'uri', 'user', 'ranges', 'permissions']
# test that expected fields are present
for f in fields:
self.assert_(f in info)
# test that dates are in isoformat
self.assertEqual(info['created'], note.created.isoformat())
self.assertEqual(info['updated'], note.updated.isoformat())
# associate note with a user
user = get_user_model().objects.get(username='******')
note.user = user
info = note.info()
self.assertEqual(user.username, info['user'])
def test_info(self):
note = Annotation.create_from_request(self.mockrequest)
note.save() # save so created/updated will get set
info = note.info()
fields = [
'id', 'annotator_schema_version', 'created', 'updated', 'text',
'quote', 'uri', 'user', 'ranges', 'permissions'
]
# test that expected fields are present
for f in fields:
self.assert_(f in info)
# test that dates are in isoformat
self.assertEqual(info['created'], note.created.isoformat())
self.assertEqual(info['updated'], note.updated.isoformat())
# associate note with a user
user = get_user_model().objects.get(username='******')
note.user = user
info = note.info()
self.assertEqual(user.username, info['user'])
def test_permissions_dict(self):
note = Annotation.create_from_request(self.mockrequest)
note.save()
# get some users and groups to work with
user = get_user_model().objects.get(username='******')
group1 = AnnotationGroup.objects.create(name='foo')
group2 = AnnotationGroup.objects.create(name='foobar')
perms = {
'read': [user.username, group1.annotation_id,
group2.annotation_id],
'update': [user.username, group1.annotation_id],
'delete': [user.username],
'admin': []
}
# test round-trip: convert to db permissions and then back
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
perms = {
'read': [user.username, group1.annotation_id],
'update': [user.username],
'delete': [],
'admin': []
}
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
perms = {
'read': [],
'update': [],
'delete': [],
'admin': []
}
note.db_permissions(perms)
self.assertEqual(perms, note.permissions_dict())
def test_db_permissions(self):
note = Annotation.create_from_request(self.mockrequest)
note.save()
# get some users and groups to work with
user = get_user_model().objects.get(username='******')
group1 = AnnotationGroup.objects.create(name='foo')
group2 = AnnotationGroup.objects.create(name='foobar')
note.db_permissions({
'read':
[user.username, group1.annotation_id, group2.annotation_id],
'update': [user.username, group1.annotation_id],
'delete': [user.username]
})
# inspect the db permissions created
# should be two total user permissions, one to view and one to change
user_perms = note.user_permissions()
self.assertEqual(3, user_perms.count())
self.assert_(
user_perms.filter(user=user,
permission__codename='view_annotation').exists())
self.assert_(
user_perms.filter(
user=user, permission__codename='change_annotation').exists())
self.assert_(
user_perms.filter(
user=user, permission__codename='delete_annotation').exists())
# should be three total group permissions
group_perms = note.group_permissions()
self.assertEqual(3, group_perms.count())
self.assert_(
group_perms.filter(
group=group1, permission__codename='view_annotation').exists())
self.assert_(
group_perms.filter(
group=group1,
permission__codename='change_annotation').exists())
self.assert_(
group_perms.filter(
group=group2, permission__codename='view_annotation').exists())
# updating the permissions for the same note should
# remove permissions that no longer apply
note.db_permissions({
'read': [user.username, group1.annotation_id],
'update': [user.username],
'delete': []
})
# counts should reflect the changes
user_perms = note.user_permissions()
self.assertEqual(2, user_perms.count())
group_perms = note.group_permissions()
self.assertEqual(1, group_perms.count())
# permissions created before should be gone
self.assertFalse(
user_perms.filter(
user=user, permission__codename='delete_annotation').exists())
self.assertFalse(
group_perms.filter(
group=group1,
permission__codename='change_annotation').exists())
self.assertFalse(
group_perms.filter(
group=group2, permission__codename='view_annotation').exists())
# invalid group/user should not error
note.db_permissions({
'read': ['bogus', 'group:666', 'group:foo'],
'update': ['group:__world__'],
'delete': []
})
self.assertEqual(0, note.user_permissions().count())
self.assertEqual(0, note.group_permissions().count())
def test_db_permissions(self):
note = Annotation.create_from_request(self.mockrequest)
note.save()
# get some users and groups to work with
user = get_user_model().objects.get(username='******')
group1 = AnnotationGroup.objects.create(name='foo')
group2 = AnnotationGroup.objects.create(name='foobar')
note.db_permissions({
'read': [user.username, group1.annotation_id,
group2.annotation_id],
'update': [user.username, group1.annotation_id],
'delete': [user.username]
})
# inspect the db permissions created
# should be two total user permissions, one to view and one to change
user_perms = note.user_permissions()
self.assertEqual(3, user_perms.count())
self.assert_(user_perms.filter(user=user,
permission__codename='view_annotation')
.exists())
self.assert_(user_perms.filter(user=user,
permission__codename='change_annotation')
.exists())
self.assert_(user_perms.filter(user=user,
permission__codename='delete_annotation')
.exists())
# should be three total group permissions
group_perms = note.group_permissions()
self.assertEqual(3, group_perms.count())
self.assert_(group_perms.filter(group=group1,
permission__codename='view_annotation')
.exists())
self.assert_(group_perms.filter(group=group1,
permission__codename='change_annotation')
.exists())
self.assert_(group_perms.filter(group=group2,
permission__codename='view_annotation')
.exists())
# updating the permissions for the same note should
# remove permissions that no longer apply
note.db_permissions({
'read': [user.username, group1.annotation_id],
'update': [user.username],
'delete': []
})
# counts should reflect the changes
user_perms = note.user_permissions()
self.assertEqual(2, user_perms.count())
group_perms = note.group_permissions()
self.assertEqual(1, group_perms.count())
# permissions created before should be gone
self.assertFalse(user_perms.filter(user=user,
permission__codename='delete_annotation')
.exists())
self.assertFalse(group_perms.filter(group=group1,
permission__codename='change_annotation')
.exists())
self.assertFalse(group_perms.filter(group=group2,
permission__codename='view_annotation')
.exists())
# invalid group/user should not error
note.db_permissions({
'read': ['bogus', 'group:666', 'group:foo'],
'update': ['group:__world__'],
'delete': []
})
self.assertEqual(0, note.user_permissions().count())
self.assertEqual(0, note.group_permissions().count())