def test_get_user_badges(self):
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
self.BADGE_MOCK_ATTRIBUTES['title'] = 'Badge 2'
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
self.BADGE_MOCK_ATTRIBUTES['title'] = 'Badge 3'
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
self.BADGE_MOCK_ATTRIBUTES['title'] = 'Badge 4'
self.BADGE_MOCK_ATTRIBUTES['author_uri'] = '/uri/user/bob'
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
badges = badge_api.get_user_earned_badges('/uri/autor/badgemaker')
self.assertEqual(len(badges), 3)
badges = badge_api.get_user_earned_badges('/uri/user/bob')
self.assertEqual(len(badges), 1)
badges = badge_api.get_user_earned_badges('/uri/user/auser')
self.assertEqual(len(badges), 0)
def test_get_user_badges(self):
badge = badge_api.create_badge(*self.badge_values)
badge_api.publish_badge(badge['uri'])
badge_values = self.badge_values
badge_values[0] = 'Badge 2'
badge = badge_api.create_badge(*badge_values)
badge_api.publish_badge(badge['uri'])
badge_values[0] = 'Badge 3'
badge = badge_api.create_badge(*badge_values)
badge_api.publish_badge(badge['uri'])
badge_values[0] = 'Badge 4'
badge_values[4] = '/uri/user/bob'
badge = badge_api.create_badge(*badge_values)
badge_api.publish_badge(badge['uri'])
badges = badge_api.get_user_earned_badges('/uri/user/badgemaker')
self.assertEqual(len(badges), 3)
badges = badge_api.get_user_earned_badges('/uri/user/bob')
self.assertEqual(len(badges), 1)
badges = badge_api.get_user_earned_badges('/uri/user/auser')
self.assertEqual(len(badges), 0)
def create( request ):
template_name = 'badge/create.html'
if request.method == 'POST':
form = BadgeForm(request.POST, request.FILES)
else:
form = BadgeForm()
user_uri = request.session['user']['uri']
if form.is_valid():
image = media_api.upload_image(request.FILES['image'], user_uri)
try:
badge = badge_api.create_badge(
form.cleaned_data['title'],
image['uri'],
form.cleaned_data['description'],
form.cleaned_data['requirements'],
user_uri
)
return http.HttpResponseRedirect(
reverse('badge_preview', args=(badge_api.uri2id(badge['uri']),))
)
except badge_api.DuplicateTitleError:
form.errors['title'] = [_('Badge title needs to be unique'),]
return render_to_response(
template_name, {'form': form},
context_instance=RequestContext(request))
def test_award_badge(self):
badge = badge_api.create_badge(*self.badge_values)
self.assertNotIn(badge['author_uri'], badge_api.get_badge_experts(badge['uri']))
badge_api.publish_badge(badge['uri'])
kwargs = {
'badge_uri': badge['uri'],
'user_uri': badge['author_uri'],
'expert_uri': badge['author_uri'],
'evidence_url': 'http://some.evi/dence'
}
# test that the author have the badge
with self.assertRaisesRegexp(Exception, 'already awarded'):
badge_api.award_badge(**kwargs)
# test that non expert cannot award badge
kwargs['user_uri'] = '/uri/user/iwantbadge'
kwargs['expert_uri'] = '/uri/user/igivebadge'
with self.assertRaisesRegexp(Exception, 'Cannot award'):
badge_api.award_badge(**kwargs)
# test that expert can award badge
kwargs['expert_uri'] = badge['author_uri']
badge_api.award_badge(**kwargs)
self.assertIn(kwargs['user_uri'], badge_api.get_badge_experts(badge['uri']))
# test that badge awards triggers notifications
kwargs['user_uri'] = '/uri/user/ialsowantbadge'
with patch('notifications.models.send_notification') as send:
badge_api.award_badge(**kwargs)
self.assertTrue(send.called)
def test_raise_error_on_badge_delete_if_not_owner(self):
# setup
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
# test that method raises error when user is not author of a badge
with self.assertRaises(badge_api.NotTheAuthorError):
badge_api.delete_badge(badge['uri'], '/uri/user/iamnottheowner')
def test_badge_without_projects_was_deleted_by_owner(self):
# setup
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
# test that badge 'deleted' attribute has been set to False
deleted_badge = badge_api.delete_badge(badge['uri'], badge['author_uri'])
self.assertTrue(deleted_badge['deleted'])
def test_project_feedback_cycle(self):
# create badge
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
user = p2pu_user_api.save_user('badgemaker', 'http://placeholdit.com/40x40', '*****@*****.**')
# create project
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
# get feedback - has to be zero, there was not any feedback submitted yet
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
# test that project can be revised - it can not, there has not been feedback given yet
self.assertFalse(project_api.can_revise_project(project['uri']))
# test that error is raised when revision is given - it has to be, there was no feedback given yet
with self.assertRaises(Exception):
project_api.revise_project(project['uri'], 'All better')
# test that project is ready for feedback
self.assertTrue(project_api.ready_for_feedback(project['uri']))
# submit feedback
project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
self.assertIn('good', project_feedback[0])
self.assertIn('bad', project_feedback[0])
self.assertIn('ugly', project_feedback[0])
self.assertIn('expert_uri', project_feedback[0])
# test that multiple feedback cannont be submitted without a revision
#self.assertFalse(project_api.ready_for_feedback(project['uri']))
#with self.assertRaises(Exception):
# project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_api.revise_project(project['uri'], 'everything is better now!!')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 2)
project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_api.revise_project(project['uri'], 'everything is better now, promise!!', work_url='http://mywork.com/new-and-improved')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 4)
self.assertIn('improvement', project_feedback[1])
self.assertIn('date_created', project_feedback[1])
self.assertNotIn('work_url', project_feedback[1])
self.assertIn('improvement', project_feedback[3])
self.assertIn('work_url', project_feedback[3])
def test_update_badge(self):
""" Test that we can update a badge """
badge = badge_api.create_badge(*self.badge_values)
attrs = self.badge_attrs
del attrs[1]
kwargs = dict(zip(self.badge_attrs, [badge['uri']] + self.badge_values))
del kwargs['author_uri']
kwargs['title'] = 'A new title'
badge_api.update_badge(**kwargs)
badge2 = badge_api.get_badge(badge['uri'])
self.assertNotEquals(badge, badge2)
def test_create_and_get_badge(self):
#Test that we can create a badge
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
# test make sure attributes are equal
badge2 = badge_api.get_badge(badge['uri'])
self.assertEqual(badge, badge2)
# test that the badge shows up in drafts
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertEquals(len(badges), 1)
self.assertEquals(badge2, badges[0])
def load_test_data(data_file):
df = open(data_file, 'r')
root = os.path.dirname(os.path.abspath(data_file))
test_data = simplejson.load(df)
for badge in test_data['badges']:
with open(os.path.join(root, badge['image']), 'rb') as image_file:
image = media_api.upload_image(File(image_file), badge['author_uri'])
badge['image_uri'] = image['uri']
del badge['image']
badge = badge_api.create_badge(**badge)
badge_api.publish_badge(badge['uri'])
print(badge)
df.close()
def test_publish_badge(self):
badge = badge_api.create_badge(*self.badge_values)
badges = badge_api.get_published_badges()
self.assertTrue(len(badges) == 0)
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertTrue(len(badges) == 1)
badge_api.publish_badge(badge['uri'])
self.assertRaises(Exception, badge_api.update_badge, [badge['uri']], {'title':'Updated title'})
badges = badge_api.get_published_badges()
self.assertTrue(len(badges) == 1)
badges = badge_api.get_user_draft_badges(badge['uri'])
self.assertTrue(len(badges) == 0)
def test_create_and_get_partner_badge(self):
#Test that we can create a badge
badge_values = self.BADGE_MOCK_ATTRIBUTES.copy()
badge_values['partner_name'] = 'Test partner'
badge = badge_api.create_badge(**badge_values)
# test make sure attributes are equal
badge2 = badge_api.get_badge(badge['uri'])
self.assertEquals(badge, badge2)
self.assertEquals('Test partner', badge['partner_name'])
# test that the badge shows up in drafts
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertEquals(len(badges), 1)
self.assertEquals(badge2, badges[0])
def test_publish_badge(self):
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badges = badge_api.get_published_badges()
self.assertTrue(len(badges) == 0)
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertTrue(len(badges) == 1)
badge_api.publish_badge(badge['uri'])
self.assertRaises(Exception, badge_api.update_badge, [badge['uri']], {'title':'Updated title'})
badges = badge_api.get_published_badges()
self.assertEqual(len(badges), 1)
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertEqual(len(badges), 0)
badges = badge_api.get_user_created_badges(badge['author_uri'])
self.assertEqual(len(badges), 1)
def test_update_badge(self):
badge_attributes = {
'title':'Test Badge',
'image_uri': '/uri/image/1',
'description': 'Short description',
'requirements': 'Requirements are getting listed here',
'author_uri': '/uri/autor/badgemaker',
}
badge = badge_api.create_badge(**badge_attributes)
# author uri has to be taken out since it is not demanded by the method
del badge_attributes['author_uri']
badge_attributes['title'] = 'A new title'
badge_api.update_badge(badge['uri'], **badge_attributes)
badge2 = badge_api.get_badge(badge['uri'])
# Test that we can update a badge
self.assertNotEquals(badge, badge2)
def test_project_feedback_cycle(self):
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
self.assertFalse(project_api.can_revise_project(project['uri']))
with self.assertRaises(Exception):
project_api.revise_project(project['uri'], 'All better')
self.assertTrue(project_api.ready_for_feedback(project['uri']))
project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
self.assertIn('good', project_feedback[0])
self.assertIn('bad', project_feedback[0])
self.assertIn('ugly', project_feedback[0])
self.assertIn('expert_uri', project_feedback[0])
# test that multiple feedback cannont be submitted without a revision
self.assertFalse(project_api.ready_for_feedback(project['uri']))
with self.assertRaises(Exception):
project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_api.revise_project(project['uri'], 'everything is better now!!')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 2)
project_api.submit_feedback(project['uri'], '/uri/user/badgemaker', 'Ugly', 'Bad', 'Good')
project_api.revise_project(project['uri'], 'everything is better now, promise!!', work_url='http://mywork.com/new-and-improved')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 4)
self.assertIn('improvement', project_feedback[1])
self.assertIn('date_created', project_feedback[1])
self.assertNotIn('work_url', project_feedback[1])
self.assertIn('improvement', project_feedback[3])
self.assertIn('work_url', project_feedback[3])
def test_expert_feedback_and_creator_revision(self):
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
with self.assertRaises(Exception):
project_api.submit_feedback(project['uri'], '/uri/user/not_an_expert', 'Ugly', 'Bad', 'Good')
project_api.submit_feedback(project['uri'], badge['author_uri'], 'Ugly', 'Bad', 'Good')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
def test_expert_feedback_and_creator_revision(self):
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
user = p2pu_user_api.save_user('badgemaker', 'http://placeholdit.com/40x40', '*****@*****.**')
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
with self.assertRaises(Exception):
project_api.submit_feedback(project['uri'], '/uri/user/not_an_expert', 'Ugly', 'Bad', 'Good')
project_api.submit_feedback(project['uri'], badge['author_uri'], 'Ugly', 'Bad', 'Good')
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
def test_final_feedback(self):
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
self.assertTrue(project_api.ready_for_feedback(project['uri']))
project_api.submit_feedback(project['uri'], badge['author_uri'], 'Ugly', 'Bad', 'Good', True)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
self.assertFalse(project_api.ready_for_feedback(project['uri']))
self.assertFalse(project_api.can_revise_project(project['uri']))
def create(request):
user_uri = request.session['user']['uri']
user = p2pu_user_api.get_user(user_uri)
user_partner = user['partner']
form = BadgeForm(user_uri=user_uri)
if request.method == 'POST':
form = BadgeForm(request.POST, request.FILES, user_uri=user_uri)
if form.is_valid():
try:
if request.FILES['image_uri'].size > (256 * 1024):
raise media_api.UploadImageError('Image size too large.')
image = media_api.upload_image(
request.FILES['image_uri'],
user_uri,
media_root=settings.MEDIA_ROOT,
delete_original=True)
badge = badge_api.create_badge(
form.cleaned_data['title'],
image['uri'],
form.cleaned_data['description'],
form.cleaned_data['requirements'],
user_uri,
partner_name=form.cleaned_data['partner']
)
return http.HttpResponseRedirect(
reverse('badge_publish', args=(badge_api.uri2id(badge['uri']),))
)
except badge_api.DuplicateTitleError:
form.errors['title'] = [_('Badge title needs to be unique'), ]
except media_api.UploadImageError:
form.errors['title'] = [_('Badge image cannot be uploaded. Possible reasons: format not supported'
'(png, jpeg, jpg, gif), file size too large (up to 256kb).'), ]
return render_to_response(
'badge/badge_info/create.html', {
'form': form,
'user_is_partner': user_partner,
},
context_instance=RequestContext(request))
def test_raise_error_on_badge_if_has_projects(self):
# setup
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
badge_api.publish_badge(badge['uri'])
project = {
'badge_uri': badge['uri'],
'author_uri': '/uri/user/author',
'title': 'Test Project 1',
'image_uri': '/uri/image/1',
'work_url': 'http://example.com',
'description': 'Some description',
'reflection': 'Some other lesions learned',
'tags': 'tags'
}
project_api.create_project(**project)
# test that method raises error when badge has projects attached to it
with self.assertRaises(badge_api.HasProjectsAttachedError):
badge_api.delete_badge(badge['uri'], badge['author_uri'])
def test_final_feedback(self):
badge = badge_api.create_badge(**self.badge_values)
badge_api.publish_badge(badge['uri'])
user = p2pu_user_api.save_user('badgemaker', 'http://placeholdit.com/40x40', '*****@*****.**')
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 0)
self.assertTrue(project_api.ready_for_feedback(project['uri']))
project_api.submit_feedback(project['uri'], badge['author_uri'], 'Ugly', 'Bad', 'Good', True)
project_feedback = project_api.get_project_feedback(project['uri'])
self.assertEqual(len(project_feedback), 1)
self.assertFalse(project_api.ready_for_feedback(project['uri']))
self.assertFalse(project_api.can_revise_project(project['uri']))
def test_get_badge_uri_from_project_under_revision(self):
# create badge
badge = badge_api.create_badge('Title badge 1', '/media/img/1.png', 'desc', 'reqs', '/uri/user/2' )
project = project_api.create_project('/uri/badge/1', '/uri/user/user1', 'Title project 1', '/uri/image/1', 'https://url.com', 'Description', 'Reflection', ['tag1', 'tag2'])
# get badge uri from a project which is unde revision
badge_uri = project_api.get_badge_uri_from_project_under_revision(project['uri'])
# check badge uri
self.assertEquals('/uri/badge/1', badge_uri)
# submit feedback award badge
project_api.submit_feedback(project['uri'], '/uri/user/2', 'good', 'bad', 'ugly', award_badge=True)
# check badge uri
badge_uri = project_api.get_badge_uri_from_project_under_revision(project['uri'])
# check there is no more project after badge was awarded
self.assertEquals(None, badge_uri)
def test_award_partner_badge_as_partne(self):
#create a partner
partner = p2pu_user_api.create_partner('test partner')
# create a parnter badge
badge_values = self.badge_values.copy()
badge_values['partner_name'] = partner['name']
badge =badge_api.create_badge(**badge_values)
badge_api.publish_badge(badge['uri'])
# submit a project for a badge
project_values = self.project_values.copy()
project_values['badge_uri'] = badge['uri']
project = project_api.create_project(**project_values)
# give feedback as a partner
feedback = project_api.submit_feedback(
project['uri'],
self.badge_values['author_uri'],
'Good',
'Bad',
'Ugly',
)
self.assertEquals(feedback, project_api.submit_feedback_result.NOT_AWARDED)
# revise feedback
revision = project_api.revise_project(project['uri'], 'Some improvement')
self.assertEquals('Some improvement', revision['improvement'])
# give feedback and award a badge
feedback = project_api.submit_feedback(
project['uri'],
self.badge_values['author_uri'],
'SecondGood',
'SecondBad',
'SecondUgly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.AWARDED)
def test_create_and_get_badge(self):
""" Test that we can create a badge """
badge = badge_api.create_badge(*self.badge_values)
# test the presence or attributes for a badge
for attr in self.badge_attrs:
self.assertIn(attr, badge)
# test attribute values
attrs = self.badge_attrs
del attrs[0]
del attrs[0]
for key, value in zip(attrs, self.badge_values):
self.assertEquals(badge[key], value)
# test make sure attributes are equal
badge2 = badge_api.get_badge(badge['uri'])
self.assertEqual(badge, badge2)
# test that the badge shows up in drafts
badges = badge_api.get_user_draft_badges(badge['author_uri'])
self.assertEquals(len(badges), 1)
self.assertEquals(badge2, badges[0])
def load_test_data(data_file):
df = open(data_file, 'r')
root = os.path.dirname(os.path.abspath(data_file))
test_data = simplejson.load(df)
for badge in test_data['badges']:
p2pu_user_api.save_user(
p2pu_user_api.uri2username(badge['author_uri']),
'http://placehold.it/150x150',
'*****@*****.**' % p2pu_user_api.uri2username(badge['author_uri']),
)
with open(os.path.join(root, badge['image']), 'rb') as image_file:
image = media_api.upload_image(
File(image_file),
badge['author_uri'],
media_root=settings.MEDIA_ROOT,
delete_original=False)
badge['image_uri'] = image['uri']
del badge['image']
badge = badge_api.create_badge(**badge)
badge_api.publish_badge(badge['uri'])
print(badge)
df.close()
def test_get_badge_uri_from_project_under_revision(self):
# setup
with Stub() as send_badge_creation_notification:
from badge.notification_helpers import send_badge_creation_notification
send_badge_creation_notification(any())
badge = badge_api.create_badge('Title badge 1', '/media/img/1.png', 'desc', 'reqs', '/uri/user/2' )
with Stub() as send_project_creation_notification:
from project.notification_helpers import send_project_creation_notification
send_project_creation_notification(any())
with Stub() as send_project_creation_expert_notification:
from project.notification_helpers import send_project_creation_expert_notification
send_project_creation_expert_notification(any(), any(), any())
project = project_api.create_project('/uri/badge/1', '/uri/user/user1', 'Title project 1', '/uri/image/1', 'https://url.com', 'Description', 'Reflection', ['tag1', 'tag2'])
# run
badge_uri = project_api.get_badge_uri_from_project_under_revision(project['uri'])
# assert
self.assertEquals('/uri/badge/1', badge_uri)
# setup
with Stub() as send_feedback_notification:
from project.notification_helpers import send_feedback_notification
send_feedback_notification(any())
project_api.submit_feedback(project['uri'], '/uri/user/2' ,'good', 'bad', 'ugly', badge_awarded=True)
# run
badge_uri = project_api.get_badge_uri_from_project_under_revision(project['uri'])
# assert
self.assertEquals(None, badge_uri)
def test_unique_title(self):
badge = badge_api.create_badge(*self.badge_values)
self.assertRaises(Exception, badge_api.create_badge, self.badge_values)
def test_badge_create_sends_notification(self):
# Test that we can create a badge
with patch('notifications.models.send_notification') as send:
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
self.assertTrue(send.called)
def test_badge_create_sends_notification(self):
""" Test that we can create a badge """
with patch('notifications.models.send_notification') as send:
badge = badge_api.create_badge(*self.badge_values)
self.assertTrue(send.called)
def test_unique_title(self):
badge = badge_api.create_badge(**self.BADGE_MOCK_ATTRIBUTES)
self.assertRaises(Exception, badge_api.create_badge, **self.BADGE_MOCK_ATTRIBUTES)
