def test_assertions_for_user(self):
"""
Verify that grabbing all assertions for a user behaves as expected.
This function uses object IDs because for some reason Jenkins trips up
on its assertCountEqual check here despite the items being equal.
"""
user = UserFactory()
assertions = [
BadgeAssertionFactory.create(user=user).id for _i in range(3)
]
course = CourseFactory.create()
course_key = course.location.course_key
course_badges = [
RandomBadgeClassFactory(course_id=course_key) for _i in range(3)
]
course_assertions = [
BadgeAssertionFactory.create(user=user, badge_class=badge_class).id
for badge_class in course_badges
]
assertions.extend(course_assertions)
assertions.sort()
assertions_for_user = [
badge.id for badge in BadgeAssertion.assertions_for_user(user)
]
assertions_for_user.sort()
assert assertions_for_user == assertions
course_scoped_assertions = [
badge.id for badge in BadgeAssertion.assertions_for_user(
user, course_id=course_key)
]
course_scoped_assertions.sort()
assert course_scoped_assertions == course_assertions
def test_get_assertions(self):
"""
Verify we can get all of a user's badge assertions.
"""
for dummy in range(3):
BadgeAssertionFactory(user=self.user)
# Add in a course scoped badge-- these should not be excluded from the full listing.
BadgeAssertionFactory(user=self.user, badge_class=BadgeClassFactory(course_id=self.course.location.course_key))
# Should not be included.
for dummy in range(3):
self.create_badge_class(False)
response = self.get_json(self.url())
self.assertEqual(len(response['results']), 4)
def test_clear_badge(self, issue_badges, xqueue):
"""
Given that I have a user with a badge
If I run regeneration for a user
Then certificate generation will be requested
And the badge will be deleted if badge issuing is enabled
"""
key = self.course.location.course_key
self._create_cert(key, self.user, CertificateStatuses.downloadable)
badge_class = get_completion_badge(key, self.user)
BadgeAssertionFactory(badge_class=badge_class, user=self.user)
assert BadgeAssertion.objects.filter(user=self.user,
badge_class=badge_class)
self.course.issue_badges = issue_badges
self.store.update_item(self.course, None)
args = '-u {} -c {}'.format(self.user.email, str(key))
call_command(self.command, *args.split(' '))
assert xqueue.return_value.regen_cert.call_args.args == (
self.user,
key,
)
regen_cert_call_kwargs = xqueue.return_value.regen_cert.call_args.kwargs
assert regen_cert_call_kwargs.pop(
'course').location == self.course.location
assert regen_cert_call_kwargs == {
'forced_grade': None,
'template_file': None,
'generate_pdf': True,
}
assert bool(
BadgeAssertion.objects.filter(
user=self.user, badge_class=badge_class)) == (not issue_badges)
def test_clear_badge(self, issue_badges, xqueue):
"""
Given that I have a user with a badge
If I run regeneration for a user
Then certificate generation will be requested
And the badge will be deleted if badge issuing is enabled
"""
key = self.course.location.course_key
self._create_cert(key, self.user, CertificateStatuses.downloadable)
badge_class = get_completion_badge(key, self.user)
BadgeAssertionFactory(badge_class=badge_class, user=self.user)
self.assertTrue(
BadgeAssertion.objects.filter(user=self.user,
badge_class=badge_class))
self.course.issue_badges = issue_badges
self.store.update_item(self.course, None)
args = u'-u {} -c {}'.format(self.user.email, text_type(key))
call_command(self.command, *args.split(' '))
xqueue.return_value.regen_cert.assert_called_with(self.user,
key,
course=self.course,
forced_grade=None,
template_file=None,
generate_pdf=True)
self.assertEqual(
bool(
BadgeAssertion.objects.filter(user=self.user,
badge_class=badge_class)),
not issue_badges)
def test_assertion_structure(self):
"""
Verify the badge assertion structure is as expected when a course is involved.
"""
course_key = self.course.location.course_key
badge_class = BadgeClassFactory.create(course_id=course_key)
assertion = BadgeAssertionFactory.create(badge_class=badge_class, user=self.user)
response = self.get_json(self.url())
self.check_assertion_structure(assertion, response['results'][0])
def test_get_for_user(self):
"""
Make sure we can get an assertion for a user if there is one.
"""
user = UserFactory.create()
badge_class = BadgeClassFactory.create()
assert not badge_class.get_for_user(user)
assertion = BadgeAssertionFactory.create(badge_class=badge_class, user=user)
assert list(badge_class.get_for_user(user)) == [assertion]
def test_get_for_user(self):
"""
Make sure we can get an assertion for a user if there is one.
"""
user = UserFactory.create()
badge_class = BadgeClassFactory.create()
self.assertFalse(badge_class.get_for_user(user))
assertion = BadgeAssertionFactory.create(badge_class=badge_class, user=user)
self.assertEqual(list(badge_class.get_for_user(user)), [assertion])
def check_badge_class_assertion(self, check_course, wildcard, badge_class):
"""
Given a badge class, create an assertion for the current user and fetch it, checking the structure.
"""
assertion = BadgeAssertionFactory.create(badge_class=badge_class, user=self.user)
response = self.get_json(
self.url(),
data=self.get_qs_args(check_course, wildcard, badge_class),
)
self.check_assertion_structure(assertion, response['results'][0])
def test_get_assertions(self, check_course, wildcard):
"""
Verify we can get assertions via the badge class and username.
"""
badge_class = self.create_badge_class(check_course)
for dummy in range(3):
BadgeAssertionFactory.create(user=self.user,
badge_class=badge_class)
if badge_class.course_id:
# Also create a version of this badge under a different course.
alt_class = BadgeClassFactory.create(
slug=badge_class.slug,
issuing_component=badge_class.issuing_component,
course_id=CourseFactory.create().location.course_key)
BadgeAssertionFactory.create(user=self.user, badge_class=alt_class)
# Same badge class, but different user. Should not show up in the list.
for dummy in range(5):
BadgeAssertionFactory.create(badge_class=badge_class)
# Different badge class AND different user. Certainly shouldn't show up in the list!
for dummy in range(6):
BadgeAssertionFactory.create()
response = self.get_json(
self.url(),
data=self.get_qs_args(check_course, wildcard, badge_class),
)
if wildcard:
expected_length = 4
else:
expected_length = 3
self.assertEqual(len(response['results']), expected_length)
unused_class = self.create_badge_class(
check_course,
slug='unused_slug',
issuing_component='unused_component')
response = self.get_json(
self.url(),
data=self.get_qs_args(check_course, wildcard, unused_class),
)
self.assertEqual(len(response['results']), 0)
def test_get_assertions(self):
"""
Verify we can get assertions via the course_id and username.
"""
course_key = self.course.location.course_key
badge_class = BadgeClassFactory.create(course_id=course_key)
for dummy in range(3):
BadgeAssertionFactory.create(user=self.user, badge_class=badge_class)
# Should not be included, as they don't share the target badge class.
for dummy in range(3):
BadgeAssertionFactory.create(user=self.user)
# Also should not be included, as they don't share the same user.
for dummy in range(6):
BadgeAssertionFactory.create(badge_class=badge_class)
response = self.get_json(self.url(), data={'course_id': str(course_key)})
self.assertEqual(len(response['results']), 3)
unused_course = CourseFactory.create()
response = self.get_json(self.url(), data={'course_id': str(unused_course.location.course_key)})
self.assertEqual(len(response['results']), 0)
def award(self, badge_class, user, evidence_url=None):
return BadgeAssertionFactory(badge_class=badge_class, user=user)
def test_assertion_structure(self):
badge_class = self.create_badge_class(False)
assertion = BadgeAssertionFactory.create(user=self.user, badge_class=badge_class)
response = self.get_json(self.url())
self.check_assertion_structure(assertion, response['results'][0])
