Python api.add_course_milestone函数代码示例

    def test_add_course_milestone(self):
        """ Unit Test: test_add_course_milestone """
        with self.assertNumQueries(3):
            api.add_course_milestone(
                self.test_course_key,
                self.relationship_types['REQUIRES'],
                self.test_milestone
            )
        requirer_milestones = api.get_course_milestones(
            self.test_course_key,
            self.relationship_types['REQUIRES']
        )
        self.assertEqual(len(requirer_milestones), 1)

        with self.assertNumQueries(3):
            api.add_course_milestone(
                self.test_prerequisite_course_key,
                self.relationship_types['FULFILLS'],
                self.test_milestone
            )
        fulfiller_milestones = api.get_course_milestones(
            self.test_prerequisite_course_key,
            self.relationship_types['FULFILLS'],
        )
        self.assertEqual(len(fulfiller_milestones), 1)

    def test_add_milestone_inactive_milestone_with_relationships_propagate_false(self):
        """ Unit Test: test_add_milestone_inactive_milestone_with_relationships_propagate_false"""
        milestone_data = {
            'name': 'local_milestone',
            'display_name': 'Local Milestone',
            'namespace': six.text_type(self.test_course_key),
            'description': 'Local Milestone Description'
        }
        milestone = api.add_milestone(milestone_data)
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['REQUIRES'],
            milestone
        )
        api.add_course_content_milestone(
            self.test_course_key,
            self.test_content_key,
            self.relationship_types['FULFILLS'],
            milestone
        )
        api.add_user_milestone(self.serialized_test_user, milestone)
        self.assertGreater(milestone['id'], 0)
        api.remove_milestone(milestone['id'])

        with self.assertNumQueries(3):
            milestone = api.add_milestone(milestone_data, propagate=False)

 def test_get_course_tabs_list_entrance_exam_enabled(self):
     """
     Unit Test: test_get_course_tabs_list_entrance_exam_enabled
     """
     entrance_exam = ItemFactory.create(
         category="chapter", parent_location=self.course.location,
         data="Exam Data", display_name="Entrance Exam"
     )
     entrance_exam.is_entrance_exam = True
     milestone = {
         'name': 'Test Milestone',
         'namespace': '{}.entrance_exams'.format(unicode(self.course.id)),
         'description': 'Testing Courseware Tabs'
     }
     self.course.entrance_exam_enabled = True
     self.course.entrance_exam_id = unicode(entrance_exam.location)
     milestone = milestones_api.add_milestone(milestone)
     milestones_api.add_course_milestone(
         unicode(self.course.id),
         self.relationship_types['REQUIRES'],
         milestone
     )
     milestones_api.add_course_content_milestone(
         unicode(self.course.id),
         unicode(entrance_exam.location),
         self.relationship_types['FULFILLS'],
         milestone
     )
     course_tab_list = get_course_tab_list(self.course, self.user)
     self.assertEqual(len(course_tab_list), 2)
     self.assertEqual(course_tab_list[0]['tab_id'], 'courseware')
     self.assertEqual(course_tab_list[0]['name'], 'Entrance Exam')
     self.assertEqual(course_tab_list[1]['tab_id'], 'instructor')

    def test_remove_content_references(self):
        """ Unit Test: test_remove_content_references """
        # Add a course dependency on the test milestone
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['REQUIRES'],
            self.test_milestone
        )
        self.assertEqual(len(api.get_course_milestones(self.test_course_key)), 1)

        # Add a content fulfillment for the test milestone
        api.add_course_content_milestone(
            self.test_course_key,
            self.test_content_key,
            self.relationship_types['FULFILLS'],
            self.test_milestone
        )
        milestones = api.get_course_content_milestones(self.test_course_key, self.test_content_key)
        self.assertEqual(len(milestones), 1)

        # Remove the content dependency
        with self.assertNumQueries(2):
            api.remove_content_references(self.test_content_key)
        milestones = api.get_course_content_milestones(self.test_course_key, self.test_content_key)
        self.assertEqual(len(milestones), 0)

 def test_add_course_milestone_bogus_course_key(self):
     """ Unit Test: test_add_course_milestone_bogus_course_key """
     with self.assertNumQueries(0):
         with self.assertRaises(exceptions.InvalidCourseKeyException):
             api.add_course_milestone('12345667av', 'whatever', self.test_milestone)
     with self.assertNumQueries(0):
         with self.assertRaises(exceptions.InvalidCourseKeyException):
             api.add_course_milestone(None, 'whatever', self.test_milestone)

 def test_fetch_milestone_courses_no_relationship_type(self):
     """ Unit Test: test_fetch_milestone_courses_no_relationship_type"""
     milestone1 = api.add_milestone({
         'display_name': 'Test Milestone',
         'name': 'test_milestone',
         'namespace': unicode(self.test_course_key),
         'description': 'Test Milestone Description',
     })
     api.add_course_milestone(self.test_course_key, 'fulfills', milestone1)
     self.assertEqual(len(data.fetch_milestone_courses(milestone1)), 1)

def _create_entrance_exam(request, course_key, entrance_exam_minimum_score_pct=None):
    """
    Internal workflow operation to create an entrance exam
    """
    # Provide a default value for the minimum score percent if nothing specified
    if entrance_exam_minimum_score_pct is None:
        entrance_exam_minimum_score_pct = float(settings.ENTRANCE_EXAM_MIN_SCORE_PCT)

    # Confirm the course exists
    course = modulestore().get_course(course_key)
    if course is None:
        return HttpResponse(status=400)

    # Create the entrance exam item (currently it's just a chapter)
    payload = {
        "category": "chapter",
        "display_name": "Entrance Exam",
        "parent_locator": unicode(course.location),
        "is_entrance_exam": True,
        "in_entrance_exam": True,
    }
    factory = RequestFactory()
    internal_request = factory.post("/", json.dumps(payload), content_type="application/json")
    internal_request.user = request.user
    created_item = json.loads(create_item(internal_request).content)

    # Set the entrance exam metadata flags for this course
    # Reload the course so we don't overwrite the new child reference
    course = modulestore().get_course(course_key)
    metadata = {
        "entrance_exam_enabled": True,
        "entrance_exam_minimum_score_pct": entrance_exam_minimum_score_pct / 100,
        "entrance_exam_id": created_item["locator"],
    }
    CourseMetadata.update_from_dict(metadata, course, request.user)

    # Add an entrance exam milestone if one does not already exist
    milestone_namespace = generate_milestone_namespace(NAMESPACE_CHOICES["ENTRANCE_EXAM"], course_key)
    milestones = milestones_api.get_milestones(milestone_namespace)
    if len(milestones):
        milestone = milestones[0]
    else:
        description = "Autogenerated during {} entrance exam creation.".format(unicode(course.id))
        milestone = milestones_api.add_milestone(
            {"name": "Completed Course Entrance Exam", "namespace": milestone_namespace, "description": description}
        )
    relationship_types = milestones_api.get_milestone_relationship_types()
    milestones_api.add_course_milestone(unicode(course.id), relationship_types["REQUIRES"], milestone)
    milestones_api.add_course_content_milestone(
        unicode(course.id), created_item["locator"], relationship_types["FULFILLS"], milestone
    )

    return HttpResponse(status=201)

 def test_add_course_milestone_active_exists(self):
     """ Unit Test: test_add_course_milestone """
     api.add_course_milestone(
         self.test_course_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     with self.assertNumQueries(2):
         api.add_course_milestone(
             self.test_course_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone
         )

 def test_get_course_milestones_with_invalid_relationship_type(self):
     """ Unit Test: test_get_course_milestones_with_invalid_relationship_type """
     api.add_course_milestone(
         self.test_course_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     with self.assertNumQueries(1):
         requirer_milestones = api.get_course_milestones(
             self.test_course_key,
             'INVALID RELATIONSHIP TYPE'
         )
     self.assertEqual(len(requirer_milestones), 0)

 def test_get_course_milestones(self):
     """ Unit Test: test_get_course_milestones """
     api.add_course_milestone(
         self.test_course_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     with self.assertNumQueries(2):
         requirer_milestones = api.get_course_milestones(
             self.test_course_key,
             self.relationship_types['REQUIRES']
         )
     self.assertEqual(len(requirer_milestones), 1)

def add_course_milestone(course_id, relationship, milestone):
    """
    Client API operation adapter/wrapper
    """
    if not settings.FEATURES.get('MILESTONES_APP'):
        return None
    return milestones_api.add_course_milestone(course_id, relationship, milestone)

def add_prerequisite_course(course_key, prerequisite_course_key):
    """
    It would create a milestone, then it would set newly created
    milestones as requirement for course referred by `course_key`
    and it would set newly created milestone as fulfilment
    milestone for course referred by `prerequisite_course_key`.
    """
    if settings.FEATURES.get('MILESTONES_APP', False):
        # create a milestone
        milestone = add_milestone({
            'name': _('Course {} requires {}'.format(unicode(course_key), unicode(prerequisite_course_key))),
            'namespace': unicode(prerequisite_course_key),
            'description': _('System defined milestone'),
        })
        # add requirement course milestone
        add_course_milestone(course_key, 'requires', milestone)

        # add fulfillment course milestone
        add_course_milestone(prerequisite_course_key, 'fulfills', milestone)

    def test_get_courses_milestones_with_invalid_relationship_type(self):
        """ Unit Test: test_get_courses_milestones_with_invalid_relationship_type """
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['REQUIRES'],
            self.test_milestone
        )
        api.add_course_milestone(
            self.test_prerequisite_course_key,
            self.relationship_types['REQUIRES'],
            self.test_milestone
        )
        local_milestone = api.add_milestone({
            'display_name': 'Local Milestone',
            'name': 'local_milestone',
            'namespace': six.text_type(self.test_course_key),
            'description': 'Local Milestone Description'
        })
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['FULFILLS'],
            local_milestone
        )

        with self.assertNumQueries(1):
            requirer_milestones = api.get_courses_milestones(
                [self.test_course_key],
                'INVALID RELATIONSHIP TYPE'
            )
        self.assertEqual(len(requirer_milestones), 0)

    def test_get_courses_milestones(self):
        """ Unit Test: test_get_courses_milestones """
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['REQUIRES'],
            self.test_milestone
        )
        api.add_course_milestone(
            self.test_prerequisite_course_key,
            self.relationship_types['REQUIRES'],
            self.test_milestone
        )
        local_milestone = api.add_milestone({
            'display_name': 'Local Milestone',
            'name': 'local_milestone',
            'namespace': unicode(self.test_course_key),
            'description': 'Local Milestone Description'
        })
        api.add_course_milestone(
            self.test_course_key,
            self.relationship_types['FULFILLS'],
            local_milestone
        )
        with self.assertNumQueries(2):
            requirer_milestones = api.get_courses_milestones(
                [self.test_course_key, self.test_prerequisite_course_key],
                self.relationship_types['REQUIRES']
            )
        self.assertEqual(len(requirer_milestones), 2)

        with self.assertNumQueries(1):
            requirer_milestones = api.get_courses_milestones(
                [self.test_course_key],
            )
        self.assertEqual(len(requirer_milestones), 2)

 def test_fetch_courses_milestones_invalid_milestone_relationship_type(self):
     """ Unit Test: test_fetch_courses_milestones_invalid_milestone_relationship_type"""
     milestone1 = api.add_milestone({
         'display_name': 'Test Milestone',
         'name': 'test_milestone',
         'namespace': unicode(self.test_course_key),
         'description': 'Test Milestone Description',
     })
     api.add_course_milestone(self.test_course_key, self.relationship_types['REQUIRES'], milestone1)
     milestone2 = api.add_milestone({
         'display_name': 'Test Milestone 2',
         'name': 'test_milestone_2',
         'namespace': unicode(self.test_course_key),
         'description': 'Test Milestone Description 2',
     })
     api.add_course_milestone(self.test_course_key, self.relationship_types['FULFILLS'], milestone2)
     with self.assertRaises(exceptions.InvalidMilestoneRelationshipTypeException):
         data.fetch_courses_milestones(
             [self.test_course_key, ],
             'invalid_relationshipppp',
             milestone1
         )