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 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_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_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_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 publish( request, badge_id ):
#TODO check user
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
if request.method == 'POST':
badge_api.publish_badge(badge_api.id2uri(badge_id))
return http.HttpResponseRedirect(reverse(
'badge_view', args=(badge_id,)
))
return render_to_response(
'badge/publish.html',
{ 'badge': badge },
context_instance=RequestContext(request)
)
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_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_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_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 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 publish(request, badge_id):
user = request.session['user']
badge = badge_api.get_badge(badge_api.id2uri(badge_id))
if not user['uri'] == badge['author_uri']:
messages.error(request, _('You cannot publish someone elses badge!'))
return http.HttpResponseRedirect(reverse(
'badge_preview', args=(badge_id,)
))
if request.method == 'POST':
badge_api.publish_badge(badge['uri'])
return http.HttpResponseRedirect(reverse(
'badge_view', args=(badge_id,)
))
return http.HttpResponseRedirect(reverse(
'badge_preview', args=(badge_id,)
))
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_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_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 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_badge_awarded_from_nonpartner_expert(self):
#create a partner
partner = p2pu_user_api.create_partner('Test parnter')
# create partner badge
new_badge_values = self.badge_values.copy()
new_badge_values['partner_name'] = partner['name']
# create a parnter badge
badge = badge_api.create_badge(**new_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)
# award badge as a partner
feedback = project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.AWARDED)
# award badge
# HACK - needs well revision on how to refactor in order to test cycle properly
if project_api.submit_feedback_result.AWARDED:
with patch('badge.models.send_badge_awarded_notification') as mock_notification:
badge_api.award_badge(badge['uri'], project_values['author_uri'], badge['author_uri'], 'http://project.org/url')
self.assertIn(project_values['author_uri'], badge_api.get_badge_experts(badge['uri']))
# submit another project for a badge
another_project_values = {
'badge_uri': badge['uri'],
'author_uri': '/uri/user/anotheruser',
'title': 'Test Second Title',
'image_uri': '/uri/image/2',
'work_url': 'http://project.org/url',
'description': 'Did the test second time',
'reflection': 'Will not do it earlier and more next time',
'tags': ['test', 'tdd', 'bdd'],
}
project = project_api.create_project(**another_project_values)
# award badge as a non partner
feedback = project_api.submit_feedback(
project['uri'],
'/uri/user/testuser',
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.REQUIRES_APPROVAL)
# award badge as partner
feedback = project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
self.assertEquals(feedback, project_api.submit_feedback_result.AWARDED)
# test that feedback can not be given anymore
with self.assertRaises(Exception):
project_api.submit_feedback(
project['uri'],
badge['author_uri'],
'Good',
'Bad',
'Ugly',
award_badge=True
)
# test that revision can not be given any longer either
with self.assertRaises(Exception):
project_api.revise_project(project['uri'], 'Some improvement')
