def test_add_course_content_milestone_inactive_to_active_update_requirements(self):
     """ Unit Test: test_add_course_content_milestone_inactive_to_active_update_requirement """
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone,
         {'min_score': 60}
     )
     api.remove_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.test_milestone
     )
     with self.assertNumQueries(3):
         api.add_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone,
             {'min_score': 80}
         )
     milestone = api.get_course_content_milestones(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES']
     )
     for m in milestone:
         self.assertEqual(m['requirements'], {'min_score': 80})

 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_add_course_content_milestone(self):
     """ Unit Test: test_add_course_content_milestone """
     with self.assertNumQueries(3):
         api.add_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone
         )
     requirer_milestones = api.get_course_content_milestones(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES']
     )
     self.assertEqual(len(requirer_milestones), 1)
     with self.assertNumQueries(3):
         api.add_course_content_milestone(
             self.test_prerequisite_course_key,
             self.test_content_key,
             self.relationship_types['FULFILLS'],
             self.test_milestone,
             {'min_score': 80}
         )
     fulfiller_milestones = api.get_course_content_milestones(
         self.test_prerequisite_course_key,
         self.test_content_key,
         self.relationship_types['FULFILLS']
     )
     self.assertEqual(len(fulfiller_milestones), 1)

    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_remove_course_content_milestone(self):
     """ Unit Test: test_remove_course_content_milestone """
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     requirer_milestones = api.get_course_content_milestones(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES']
     )
     self.assertEqual(len(requirer_milestones), 1)
     with self.assertNumQueries(2):
         api.remove_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.test_milestone
         )
     requirer_milestones = api.get_course_content_milestones(
         self.test_course_key,
         self.test_content_key
     )
     self.assertEqual(len(requirer_milestones), 0)

    def test_is_gate_fulfilled(self, min_score, min_completion, learner_score, learner_completion, is_gate_fulfilled):
        """
        Test if prereq section has any unfulfilled milestones
        """
        student = UserFactory(is_staff=False)
        gating_api.add_prerequisite(self.course.id, self.seq1.location)
        gating_api.set_required_content(
            self.course.id, self.seq2.location, self.seq1.location, min_score, min_completion
        )
        milestone = milestones_api.add_milestone(self.generic_milestone)
        milestones_api.add_course_content_milestone(self.course.id, self.seq1.location, 'fulfills', milestone)

        self.assertFalse(gating_api.is_gate_fulfilled(self.course.id, self.seq1.location, student.id))

        # complete the prerequisite to unlock the gated content
        # this call triggers reevaluation of prerequisites fulfilled by the gating block.
        with patch.object(gating_api, 'get_subsection_completion_percentage') as mock_grade:
            mock_grade.return_value = learner_completion
            lms_gating_api.evaluate_prerequisite(
                self.course,
                Mock(location=self.seq1.location, percent_graded=learner_score / 100.0),
                student,
            )
            self.assertEqual(
                gating_api.is_gate_fulfilled(self.course.id, self.seq1.location, student.id), is_gate_fulfilled
            )

    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 set_required_content(course_key, gated_content_key, prereq_content_key, min_score):
    """
    Adds a `requires` milestone relationship for the given gated_content_key if a prerequisite
    prereq_content_key is provided. If prereq_content_key is None, removes the `requires`
    milestone relationship.

    Arguments:
        course_key (str|CourseKey): The course key
        gated_content_key (str|UsageKey): The gated content usage key
        prereq_content_key (str|UsageKey): The prerequisite content usage key
        min_score (str|int): The minimum score

    Returns:
        None
    """
    milestone = None
    for gating_milestone in find_gating_milestones(course_key, gated_content_key, 'requires'):
        if not prereq_content_key or prereq_content_key not in gating_milestone.get('namespace'):
            milestones_api.remove_course_content_milestone(course_key, gated_content_key, gating_milestone)
        else:
            milestone = gating_milestone

    if prereq_content_key:
        _validate_min_score(min_score)
        requirements = {'min_score': min_score}
        if not milestone:
            milestone = _get_prerequisite_milestone(prereq_content_key)
        milestones_api.add_course_content_milestone(course_key, gated_content_key, 'requires', milestone, requirements)

    def test_fetch_course_content_milestones_null_keys(self):
        """ Unit Test: test_fetch_course_content_milestones_null_keys"""
        namespace = '{}.entrance_exams'.format(unicode(self.test_course_key))
        milestone1 = api.add_milestone({
            'display_name': 'Test Milestone',
            'name': 'test_milestone',
            'namespace': namespace,
            'description': 'Test Milestone Description',
        })
        api.add_course_content_milestone(
            self.test_course_key,
            self.test_content_key,
            self.relationship_types['REQUIRES'],
            milestone1
        )
        milestones = data.fetch_milestones(milestone={'namespace': namespace})
        self.assertEqual(len(milestones), 1)

        ccms = data.fetch_course_content_milestones(
            content_key=self.test_content_key,
            course_key=None,
            relationship=None
        )
        self.assertEqual(len(ccms), 1)

        ccms = data.fetch_course_content_milestones(
            content_key=None,
            course_key=self.test_course_key,
            relationship=None
        )
        self.assertEqual(len(ccms), 1)

 def test_fetch_course_content_milestones_invalid_milestone_relationship_type(self):
     """ Unit Test: test_fetch_course_content_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_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         milestone1
     )
     milestone2 = api.add_milestone({
         'display_name': 'Test Milestone 2',
         'name': 'test_milestone2',
         'namespace': unicode(self.test_course_key),
         'description': 'Test Milestone Description 2',
     })
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['FULFILLS'],
         milestone2
     )
     with self.assertRaises(exceptions.InvalidMilestoneRelationshipTypeException):
         data.fetch_course_content_milestones(
             self.test_course_key,
             self.test_content_key,
             'invalid_relationshipppp'
         )

 def test_add_course_content_milestone_invalid_requirements(self):
     """ Unit Test: test_add_course_content_milestone_invalid_requirements """
     with self.assertRaises(exceptions.InvalidCourseContentMilestoneRequirementsException):
         api.add_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone,
             set()  # Not JSON serializable
         )

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_find_gating_milestones(self):
        """ Test test_find_gating_milestones """

        gating_api.add_prerequisite(self.course.id, self.seq1.location)
        gating_api.set_required_content(self.course.id, self.seq2.location, self.seq1.location, 100)
        milestone = milestones_api.add_milestone(self.generic_milestone)
        milestones_api.add_course_content_milestone(self.course.id, self.seq1.location, 'fulfills', milestone)

        self.assertEqual(len(gating_api.find_gating_milestones(self.course.id, self.seq1.location, 'fulfills')), 1)
        self.assertEqual(len(gating_api.find_gating_milestones(self.course.id, self.seq1.location, 'requires')), 0)
        self.assertEqual(len(gating_api.find_gating_milestones(self.course.id, self.seq2.location, 'fulfills')), 0)
        self.assertEqual(len(gating_api.find_gating_milestones(self.course.id, self.seq2.location, 'requires')), 1)

 def test_fetch_milestone_course_content_no_relationship_type(self):
     """ Unit Test: test_fetch_milestone_course_content_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_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['FULFILLS'],
         milestone1
     )
     self.assertEqual(len(data.fetch_milestone_course_content(milestone1)), 1)

 def test_add_course_content_milestone_active_exists(self):
     """ Unit Test: test_add_course_content_milestone_active_exists """
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     with self.assertNumQueries(2):
         api.add_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone
         )

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

 def test_get_course_content_milestones_with_unfulfilled_user_milestones(self):
     """ Unit Test: test_get_course_content_milestones_with_unfulfilled_user_milestones """
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     with self.assertNumQueries(2):
         requirer_milestones = api.get_course_content_milestones(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             {'id': self.test_user.id}
         )
     self.assertEqual(len(requirer_milestones), 1)

 def test_add_course_content_milestone_bogus_milestone_relationship_type(self):
     """ Unit Test: test_add_course_content_milestone_bogus_milestone_relationship_type """
     with self.assertNumQueries(1):
         with self.assertRaises(exceptions.InvalidMilestoneRelationshipTypeException):
             api.add_course_content_milestone(
                 self.test_course_key,
                 self.test_content_key,
                 'whatever',
                 self.test_milestone
             )
     with self.assertNumQueries(1):
         with self.assertRaises(exceptions.InvalidMilestoneRelationshipTypeException):
             api.add_course_content_milestone(
                 self.test_course_key,
                 self.test_content_key,
                 None,
                 self.test_milestone
             )

 def test_add_course_content_milestone_bogus_content_key(self):
     """ Unit Test: test_add_course_content_milestone_bogus_content_key """
     with self.assertNumQueries(0):
         with self.assertRaises(exceptions.InvalidContentKeyException):
             api.add_course_content_milestone(
                 self.test_course_key,
                 '234290jweovsu',
                 'whatever',
                 self.test_milestone
             )
     with self.assertNumQueries(0):
         with self.assertRaises(exceptions.InvalidContentKeyException):
             api.add_course_content_milestone(
                 self.test_course_key,
                 None,
                 'whatever',
                 self.test_milestone
             )

 def test_add_course_content_milestone_inactive_to_active(self):
     """ Unit Test: test_add_course_content_milestone_inactive_to_active """
     api.add_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.relationship_types['REQUIRES'],
         self.test_milestone
     )
     api.remove_course_content_milestone(
         self.test_course_key,
         self.test_content_key,
         self.test_milestone
     )
     with self.assertNumQueries(3):
         api.add_course_content_milestone(
             self.test_course_key,
             self.test_content_key,
             self.relationship_types['REQUIRES'],
             self.test_milestone
         )