/website/addons/badges/tests/test_views.py

https://gitlab.com/doublebits/osf.io · Python · 335 lines · 284 code · 51 blank · 0 comment · 5 complexity · 76b982b1eb92eb0d4bc70df40dca255d MD5 · raw file

  1. import mock
  2. import random
  3. import string
  4. from nose.tools import *
  5. import website.app
  6. from webtest_plus import TestApp
  7. from website.util import api_url_for, web_url_for
  8. from website.addons.base.testing import AddonTestCase
  9. from tests.factories import AuthUserFactory
  10. from utils import create_mock_badger, create_badge_dict, get_garbage
  11. class TestBadgesViews(AddonTestCase):
  12. ADDON_SHORT_NAME = 'badges'
  13. def setUp(self):
  14. super(TestBadgesViews, self).setUp()
  15. def set_node_settings(self, settings):
  16. return settings
  17. def set_user_settings(self, settings):
  18. return create_mock_badger(settings)
  19. def create_app(self):
  20. return TestApp(app)
  21. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  22. def test_create_badge(self, img_proc):
  23. img_proc.return_value = 'temp.png'
  24. badge = create_badge_dict()
  25. ret = self.app.post_json(api_url_for('create_badge'), badge, auth=self.user.auth)
  26. self.user_settings.reload()
  27. assert_equals(ret.status_int, 201)
  28. assert_equals(ret.content_type, 'application/json')
  29. assert_true(ret.json['badgeid'] in [badge._id for badge in self.user_settings.badges])
  30. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  31. def test_create_badge_no_data(self, img_proc):
  32. url = api_url_for('create_badge')
  33. badge = {}
  34. ret = self.app.post_json(url, badge, auth=self.user.auth, expect_errors=True)
  35. assert_equals(ret.status_int, 400)
  36. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  37. def test_create_badge_some_data(self, img_proc):
  38. img_proc.return_value = 'temp.png'
  39. url = api_url_for('create_badge')
  40. badge = {
  41. 'badgeName': ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(4)),
  42. 'description': 'Just doesn\'t '.join(random.choice(string.ascii_letters + string.digits) for _ in range(6))
  43. }
  44. ret = self.app.post_json(url, badge, auth=self.user.auth, expect_errors=True)
  45. assert_equals(ret.status_int, 400)
  46. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  47. def test_create_badge_empty_data(self, img_proc):
  48. img_proc.return_value = 'temp.png'
  49. url = api_url_for('create_badge')
  50. badge = create_badge_dict()
  51. badge['imageurl'] = ''
  52. ret = self.app.post_json(url, badge, auth=self.user.auth, expect_errors=True)
  53. assert_equals(ret.status_int, 400)
  54. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  55. def test_create_badge_cant_issue(self, img_proc):
  56. img_proc.return_value = 'temp.png'
  57. self.user.delete_addon('badges')
  58. url = api_url_for('create_badge')
  59. badge = create_badge_dict()
  60. ret = self.app.post_json(url, badge, auth=self.user.auth, expect_errors=True)
  61. assert_equals(ret.status_int, 400)
  62. def test_award_badge(self):
  63. badgeid = self.user_settings.badges[0]._id
  64. initnum = len(self.project.badgeassertion__awarded)
  65. assert_true(self.user_settings.can_award)
  66. url = api_url_for('award_badge', pid=self.project._id)
  67. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  68. self.project.reload()
  69. assert_equals(ret.status_int, 200)
  70. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  71. def test_award_badge_bad_badge_id(self):
  72. badgeid = 'badid67'
  73. assert_true(self.user_settings.can_award)
  74. url = api_url_for('award_badge', pid=self.project._id)
  75. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth, expect_errors=True)
  76. assert_equals(ret.status_int, 400)
  77. def test_award_badge_empty_badge_id(self):
  78. assert_true(self.user_settings.can_award)
  79. url = api_url_for('award_badge', pid=self.project._id)
  80. ret = self.app.post_json(url, {'badgeid': ''}, auth=self.user.auth, expect_errors=True)
  81. assert_equals(ret.status_int, 400)
  82. def test_award_badge_no_badge_id(self):
  83. assert_true(self.user_settings.can_award)
  84. url = api_url_for('award_badge', pid=self.project._id)
  85. ret = self.app.post_json(url, {}, auth=self.user.auth, expect_errors=True)
  86. assert_equals(ret.status_int, 400)
  87. @mock.patch('website.addons.badges.model.badges.acquire_badge_image')
  88. def test_badge_html(self, img_proc):
  89. img_proc.return_value = 'temp.png'
  90. badge = {
  91. 'badgeName': get_garbage(),
  92. 'description': get_garbage(),
  93. 'imageurl': get_garbage(),
  94. 'criteria': get_garbage()
  95. }
  96. ret = self.app.post_json(api_url_for('create_badge'), badge, auth=self.user.auth)
  97. self.user_settings.reload()
  98. assert_equals(ret.status_int, 201)
  99. assert_equals(ret.content_type, 'application/json')
  100. assert_true(ret.json['badgeid'] in [badge._id for badge in self.user_settings.badges])
  101. with self.app.app.test_request_context():
  102. bstr = str(self.user_settings.badges[0].to_openbadge())
  103. assert_false('>' in bstr)
  104. assert_false('<' in bstr)
  105. def test_revoke_badge(self):
  106. badgeid = self.user_settings.badges[0]._id
  107. initnum = len(self.project.badgeassertion__awarded)
  108. assert_true(self.user_settings.can_award)
  109. url = api_url_for('award_badge', pid=self.project._id)
  110. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  111. self.project.reload()
  112. assert_equals(ret.status_int, 200)
  113. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  114. assertion = self.project.badgeassertion__awarded[0]
  115. revoke = api_url_for('revoke_badge', pid=self.project._id)
  116. ret = self.app.post_json(revoke,
  117. {
  118. 'id': assertion._id,
  119. 'reason': ''
  120. }, auth=self.user.auth)
  121. self.project.reload()
  122. self.user_settings.reload()
  123. assertion.reload()
  124. assert_equals(ret.status_int, 200)
  125. assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
  126. assert_true(assertion.revoked)
  127. assert_true(assertion._id in self.user_settings.revocation_list)
  128. assert_equals(len(self.user_settings.revocation_list), 1)
  129. def test_revoke_badge_reason(self):
  130. badgeid = self.user_settings.badges[0]._id
  131. initnum = len(self.project.badgeassertion__awarded)
  132. assert_true(self.user_settings.can_award)
  133. url = api_url_for('award_badge', pid=self.project._id)
  134. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  135. self.project.reload()
  136. assert_equals(ret.status_int, 200)
  137. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  138. assertion = self.project.badgeassertion__awarded[0]
  139. revoke = api_url_for('revoke_badge', pid=self.project._id)
  140. ret = self.app.post_json(revoke,
  141. {
  142. 'id': assertion._id,
  143. 'reason': 'Is a loser'
  144. }, auth=self.user.auth)
  145. self.project.reload()
  146. self.user_settings.reload()
  147. assertion.reload()
  148. assert_equals(ret.status_int, 200)
  149. assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
  150. assert_true(assertion._id in self.user_settings.revocation_list)
  151. assert_equals(len(self.user_settings.revocation_list), 1)
  152. assert_true(assertion.revoked)
  153. assert_equals(self.user_settings.revocation_list[assertion._id], 'Is a loser')
  154. def test_revoke_badge_no_addon(self):
  155. badgeid = self.user_settings.badges[0]._id
  156. initnum = len(self.project.badgeassertion__awarded)
  157. assert_true(self.user_settings.can_award)
  158. url = api_url_for('award_badge', pid=self.project._id)
  159. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  160. self.project.reload()
  161. assert_equals(ret.status_int, 200)
  162. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  163. assertion = self.project.badgeassertion__awarded[0]
  164. revoke = api_url_for('revoke_badge', pid=self.project._id)
  165. self.user.delete_addon('badges')
  166. self.user.save()
  167. self.user.reload()
  168. ret = self.app.post_json(revoke,
  169. {
  170. 'id': assertion._id,
  171. 'reason': ''
  172. }, auth=self.user.auth, expect_errors=True)
  173. self.project.reload()
  174. self.user_settings.reload()
  175. assertion.reload()
  176. assert_equals(ret.status_int, 400)
  177. assert_false(assertion.revoked)
  178. assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
  179. assert_false(assertion._id in self.user_settings.revocation_list)
  180. def test_revoke_didnt_award(self):
  181. badgeid = self.user_settings.badges[0]._id
  182. initnum = len(self.project.badgeassertion__awarded)
  183. assert_true(self.user_settings.can_award)
  184. url = api_url_for('award_badge', pid=self.project._id)
  185. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  186. self.project.reload()
  187. assert_equals(ret.status_int, 200)
  188. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  189. assertion = self.project.badgeassertion__awarded[0]
  190. revoke = api_url_for('revoke_badge', pid=self.project._id)
  191. user2 = AuthUserFactory()
  192. user2.add_addon('badges', override=True)
  193. user2.save()
  194. user2.reload()
  195. ret = self.app.post_json(revoke,
  196. {
  197. 'id': assertion._id,
  198. 'reason': ''
  199. }, auth=user2.auth, expect_errors=True)
  200. self.project.reload()
  201. self.user_settings.reload()
  202. assertion.reload()
  203. assert_equals(ret.status_int, 400)
  204. assert_false(assertion.revoked)
  205. assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
  206. assert_false(assertion._id in self.user_settings.revocation_list)
  207. def test_issuer_html(self):
  208. pass
  209. def test_revoke_bad_aid(self):
  210. badgeid = self.user_settings.badges[0]._id
  211. initnum = len(self.project.badgeassertion__awarded)
  212. assert_true(self.user_settings.can_award)
  213. url = api_url_for('award_badge', pid=self.project._id)
  214. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  215. self.project.reload()
  216. assert_equals(ret.status_int, 200)
  217. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  218. assertion = self.project.badgeassertion__awarded[0]
  219. revoke = api_url_for('revoke_badge', pid=self.project._id)
  220. ret = self.app.post_json(revoke,
  221. {
  222. 'id': 'Im a bad id :D',
  223. 'reason': ''
  224. }, auth=self.user.auth, expect_errors=True)
  225. self.project.reload()
  226. self.user_settings.reload()
  227. assertion.reload()
  228. assert_equals(ret.status_int, 400)
  229. assert_false(assertion.revoked)
  230. assert_true(self.project.badgeassertion__awarded[0]._id, assertion._id)
  231. assert_false(assertion._id in self.user_settings.revocation_list)
  232. def test_system_badge_awarder(self):
  233. badgeid = self.user_settings.badges[0]._id
  234. self.user_settings.badges[0].make_system_badge()
  235. initnum = len(self.project.badgeassertion__awarded)
  236. assert_true(self.user_settings.can_award)
  237. url = api_url_for('award_badge', pid=self.project._id)
  238. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  239. self.project.reload()
  240. assert_equals(ret.status_int, 200)
  241. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  242. assertion = self.project.badgeassertion__awarded[0]
  243. assert_equals(assertion.awarder._id, self.user_settings._id)
  244. def test_badge_awarder(self):
  245. badgeid = self.user_settings.badges[0]._id
  246. initnum = len(self.project.badgeassertion__awarded)
  247. assert_true(self.user_settings.can_award)
  248. url = api_url_for('award_badge', pid=self.project._id)
  249. ret = self.app.post_json(url, {'badgeid': badgeid}, auth=self.user.auth)
  250. self.project.reload()
  251. assert_equals(ret.status_int, 200)
  252. assert_equals(initnum + 1, len(self.project.badgeassertion__awarded))
  253. assertion = self.project.badgeassertion__awarded[0]
  254. assert_equals(assertion.awarder._id, self.user_settings._id)
  255. def test_award_times(self):
  256. badge = self.user_settings.badges[0]
  257. assert_true(self.user_settings.can_award)
  258. url = api_url_for('award_badge', pid=self.project._id)
  259. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  260. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  261. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  262. self.project.reload()
  263. assert_equals(ret.status_int, 200)
  264. badge.reload()
  265. assert_equals(badge.awarded_count, 3)
  266. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  267. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  268. badge.reload()
  269. assert_equals(badge.awarded_count, 5)
  270. def test_unique_awards(self):
  271. badge = self.user_settings.badges[0]
  272. assert_true(self.user_settings.can_award)
  273. url = api_url_for('award_badge', pid=self.project._id)
  274. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  275. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  276. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  277. self.project.reload()
  278. assert_equals(ret.status_int, 200)
  279. badge.reload()
  280. assert_equals(badge.unique_awards_count, 1)
  281. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  282. ret = self.app.post_json(url, {'badgeid': badge._id}, auth=self.user.auth)
  283. badge.reload()
  284. assert_equals(badge.unique_awards_count, 1)