def setUp(self):
     """
     Create a course and user to test with.
     """
     super(BadgrBackendTestCase, self).setUp()
     # Need key to be deterministic to test slugs.
     self.course = CourseFactory.create(org='edX',
                                        course='course_test',
                                        run='test_run',
                                        display_name='Badged',
                                        start=datetime(year=2015,
                                                       month=5,
                                                       day=19),
                                        end=datetime(year=2015,
                                                     month=5,
                                                     day=20))
     self.user = UserFactory.create(email='*****@*****.**')
     CourseEnrollmentFactory.create(
         user=self.user,
         course_id=self.course.location.course_key,
         mode='honor')
     # Need to empty this on each run.
     BadgrBackend.badges = []
     self.badge_class = BadgeClassFactory.create(
         course_id=self.course.location.course_key)
     self.legacy_badge_class = BadgeClassFactory.create(
         course_id=self.course.location.course_key, issuing_component='')
     self.no_course_badge_class = BadgeClassFactory.create()
Exemple #2
0
 def create_badge_class(self, check_course, **kwargs):
     """
     Create a badge class, using a course id if it's relevant to the URL pattern.
     """
     if check_course:
         mode = str(
             random()
         )  # need a random mode for uniqueness constraints on course id + mode
         return BadgeClassFactory.create(
             course_id=self.course.location.course_key, **kwargs)
     return BadgeClassFactory.create(**kwargs)
Exemple #3
0
 def setUp(self):
     super(CourseEnrollmentBadgeTest, self).setUp()
     self.badge_classes = [
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
     ]
     nums = ['3', '5', '8']
     entries = [
         ','.join(pair)
         for pair in zip(nums, [badge.slug for badge in self.badge_classes])
     ]
     enrollment_config = '\r'.join(entries)
     self.config = CourseEventBadgesConfigurationFactory(
         courses_enrolled=enrollment_config)
Exemple #4
0
    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 assertItemsEqual 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 = [
            BadgeClassFactory(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()
        self.assertEqual(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()
        self.assertEqual(course_scoped_assertions, course_assertions)
Exemple #5
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
        # pylint: disable=no-member
        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))
        # pylint: disable=no-member
        self.assertEqual(len(response["results"]), 0)
Exemple #6
0
 def setUp(self, **kwargs):
     super(CourseCompletionBadgeTest, self).setUp()
     self.badge_classes = [
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
     ]
     nums = ['2', '6', '9']
     entries = [
         ','.join(pair)
         for pair in zip(nums, [badge.slug for badge in self.badge_classes])
     ]
     completed_config = '\r'.join(entries)
     self.config = CourseEventBadgesConfigurationFactory.create(
         courses_completed=completed_config)
     self.config.clean_fields()
Exemple #7
0
 def test_award(self, mock_award):
     """
     Verify that the award command calls the award function on the backend with the right parameters.
     """
     user = UserFactory.create()
     badge_class = BadgeClassFactory.create()
     badge_class.award(user, evidence_url='http://example.com/evidence')
     self.assertTrue(mock_award.called)
     mock_award.assert_called_with(badge_class, user, evidence_url='http://example.com/evidence')
Exemple #8
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()
     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])
Exemple #9
0
 def test_award(self, mock_award):
     """
     Verify that the award command calls the award function on the backend with the right parameters.
     """
     user = UserFactory.create()
     badge_class = BadgeClassFactory.create()
     badge_class.award(user, evidence_url='http://example.com/evidence')
     self.assertTrue(mock_award.called)
     mock_award.assert_called_with(badge_class, user, evidence_url='http://example.com/evidence')
Exemple #10
0
 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])
Exemple #11
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()
     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])
Exemple #12
0
 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 setUp(self):
     """
     Create a course and user to test with.
     """
     super(BadgrBackendTestCase, self).setUp()
     # Need key to be deterministic to test slugs.
     self.course = CourseFactory.create(
         org='edX', course='course_test', run='test_run', display_name='Badged',
         start=datetime(year=2015, month=5, day=19),
         end=datetime(year=2015, month=5, day=20)
     )
     self.user = UserFactory.create(email='*****@*****.**')
     CourseEnrollmentFactory.create(user=self.user, course_id=self.course.location.course_key, mode='honor')
     # Need to empty this on each run.
     BadgrBackend.badges = []
     self.badge_class = BadgeClassFactory.create(course_id=self.course.location.course_key)
     self.legacy_badge_class = BadgeClassFactory.create(
         course_id=self.course.location.course_key, issuing_component=''
     )
     self.no_course_badge_class = BadgeClassFactory.create()
Exemple #14
0
 def setUp(self):
     super(CourseGroupBadgeTest, self).setUp()
     self.badge_classes = [
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
         BadgeClassFactory(issuing_component='openedx__course'),
     ]
     self.courses = []
     for _badge_class in self.badge_classes:
         # pylint: disable=no-member
         self.courses.append(
             [CourseFactory().location.course_key for _i in range(3)])
     lines = [
         badge_class.slug + ',' +
         ','.join([unicode(course_key) for course_key in keys])
         for badge_class, keys in zip(self.badge_classes, self.courses)
     ]
     config = '\r'.join(lines)
     self.config = CourseEventBadgesConfigurationFactory(
         course_groups=config)
     self.config_map = dict(zip(self.badge_classes, self.courses))
Exemple #15
0
 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)
Exemple #16
0
 def test_get_badge_class_preexisting(self):
     """
     Verify fetching a badge first grabs existing badges.
     """
     premade_badge_class = BadgeClassFactory.create()
     # Ignore additional parameters. This class already exists.
     badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good')
     )
     # These defaults are set on the factory.
     self.assertEqual(badge_class.criteria, 'https://example.com/syllabus')
     self.assertEqual(badge_class.display_name, 'Test Badge')
     self.assertEqual(badge_class.description, "Yay! It's a test badge.")
     # File name won't always be the same.
     self.assertEqual(badge_class.image.path, premade_badge_class.image.path)
 def test_get_badge_class(self):
     runtime = self.create_runtime()
     badge_service = runtime.service(self.mock_block, 'badging')
     premade_badge_class = BadgeClassFactory.create()
     # Ignore additional parameters. This class already exists.
     # We should get back the first class we created, rather than a new one.
     badge_class = badge_service.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good')
     )
     # These defaults are set on the factory.
     self.assertEqual(badge_class.criteria, 'https://example.com/syllabus')
     self.assertEqual(badge_class.display_name, 'Test Badge')
     self.assertEqual(badge_class.description, "Yay! It's a test badge.")
     # File name won't always be the same.
     self.assertEqual(badge_class.image.path, premade_badge_class.image.path)
Exemple #18
0
 def test_get_badge_class_preexisting(self):
     """
     Verify fetching a badge first grabs existing badges.
     """
     premade_badge_class = BadgeClassFactory.create()
     # Ignore additional parameters. This class already exists.
     badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good')
     )
     # These defaults are set on the factory.
     self.assertEqual(badge_class.criteria, 'https://example.com/syllabus')
     self.assertEqual(badge_class.display_name, 'Test Badge')
     self.assertEqual(badge_class.description, "Yay! It's a test badge.")
     # File name won't always be the same.
     self.assertEqual(badge_class.image.path, premade_badge_class.image.path)
Exemple #19
0
 def test_unique_for_course(self):
     """
     Verify that the course_id is used in fetching existing badges or creating new ones.
     """
     course_key = CourseFactory.create().location.course_key
     premade_badge_class = BadgeClassFactory.create(course_id=course_key)
     badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good')
     )
     course_badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good'),
         course_id=course_key,
     )
     self.assertNotEqual(badge_class.id, course_badge_class.id)
     self.assertEqual(course_badge_class.id, premade_badge_class.id)
Exemple #20
0
 def test_unique_for_course(self):
     """
     Verify that the course_id is used in fetching existing badges or creating new ones.
     """
     course_key = CourseFactory.create().location.course_key
     premade_badge_class = BadgeClassFactory.create(course_id=course_key)
     badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good')
     )
     course_badge_class = BadgeClass.get_badge_class(
         slug='test_slug', issuing_component='test_component', description='Attempted override',
         criteria='test', display_name='Testola', image_file_handle=get_image('good'),
         course_id=course_key,
     )
     self.assertNotEqual(badge_class.id, course_badge_class.id)
     self.assertEqual(course_badge_class.id, premade_badge_class.id)
Exemple #21
0
 def test_unique_by_course_id_plus_mode(self):
     """
     Verify that validation error is triggered when creating a BadgeClass w/ same course_id and mode as existing.
     """
     course_key = CourseFactory.create().location.course_key
     badge_class = BadgeClassFactory.create(course_id=course_key,
                                            mode='honor')
     self.assertRaises(
         ValidationError,
         BadgeClass(
             course_id=course_key,
             mode='honor',
             slug='test',
             issuing_component='test2',
             criteria='test3',
             description='test4',
             image=get_image('unbalanced'),
         ).full_clean)
Exemple #22
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': course_key})
     self.assertEqual(len(response['results']), 3)
     unused_course = CourseFactory.create()
     response = self.get_json(self.url(), data={'course_id': unused_course.location.course_key})
     self.assertEqual(len(response['results']), 0)
Exemple #23
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': course_key})
     self.assertEqual(len(response['results']), 3)
     unused_course = CourseFactory.create()
     response = self.get_json(self.url(), data={'course_id': unused_course.location.course_key})
     self.assertEqual(len(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
        # pylint: disable=no-member
        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),
        )
        # pylint: disable=no-member
        self.assertEqual(len(response['results']), 0)