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)