test_validation_tools.py

        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            validation.validate_session_start_rule(
                vctx, location,
                self.get_updated_nrule(**kwargs),

                # Note: can tags include element None?
                self.get_updated_tags(["ts1", None]))

            self.assertEqual(mock_val_func.call_count, 0)

    def test_tag_session_fail(self):
        tag_session = "ts1"
        kwargs = {
            "tag_session": tag_session
        }
        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            with self.assertRaises(ValidationError) as cm:
                validation.validate_session_start_rule(
                    vctx, location,
                    self.get_updated_nrule(**kwargs),
                    self.get_updated_tags(["ts2", "ts3"]))

            self.assertEqual(mock_val_func.call_count, 1)
            self.assertEqual(mock_val_func.call_args[0][2], tag_session)

            # make sure validate_identifier only warn if invalid
            self.assertEqual(mock_val_func.call_args[1]["warning_only"], True)

            expected_error_msg = "invalid tag 'ts1'"
            self.assertIn(expected_error_msg, str(cm.exception))

            # no warnings
            self.assertEqual(vctx.add_warning.call_count, 0)

    def test_default_expiration_mode_success(self):
        mode = "roll_over"
        kwargs = {
            "default_expiration_mode": mode
        }

        validation.validate_session_start_rule(
            vctx, location,
            self.get_updated_nrule(**kwargs),
            self.get_updated_tags())

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_default_expiration_mode_fail(self):
        mode = "unknown"
        kwargs = {
            "default_expiration_mode": mode
        }

        with self.assertRaises(ValidationError) as cm:
            validation.validate_session_start_rule(
                vctx, location,
                self.get_updated_nrule(**kwargs),
                self.get_updated_tags())

        expected_error_msg = (
                f"invalid default expiration mode '{mode}'")
        self.assertIn(expected_error_msg, str(cm.exception))

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)


class ValidateSessionAccessRuleTest(ValidationTestMixin, unittest.TestCase):
    # test validation.validate_session_access_rule

    def get_updated_arule(self, **kwargs):
        rule = {"permissions": ["fp1", "fp2"]}
        rule.update(kwargs)
        return dict_to_struct(rule)

    def get_updated_tags(self, extra=None):
        tags = []

        if extra is not None:
            assert isinstance(extra, list)
        else:
            extra = []

        tags.extend(extra)
        return tags

    def test_success(self):
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp:
            validation.validate_session_access_rule(
                vctx, location, self.get_updated_arule(), self.get_updated_tags())
        self.assertEqual(mock_vfp.call_count, 2)

    def test_if_after(self):
        datespec = "some_time1"
        kwargs = {
            "if_after": datespec
        }

        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        self.assertEqual(mock_vfp.call_count, 2)
        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_if_before(self):
        datespec = "some_time2"
        kwargs = {
            "if_before": datespec
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        self.assertEqual(mock_vfp.call_count, 2)
        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_if_completed_before(self):
        datespec = "some_time3"
        kwargs = {
            "if_completed_before": datespec
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        self.assertEqual(mock_vfp.call_count, 2)
        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_if_has_role(self):
        roles = ["r1", "r2", "r3"]
        kwargs = {
            "if_has_role": roles
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_role") as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        self.assertEqual(mock_val_func.call_count, 3)
        self.assertEqual(mock_vfp.call_count, 2)

    def test_if_has_participation_tags(self):
        ptags = ["t1", "t2", "t3"]
        kwargs1 = {
            "if_has_participation_tags_any": ptags
        }
        kwargs2 = {
            "if_has_participation_tags_all": ptags
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_participationtag"
        ) as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs1),
                self.get_updated_tags())
            self.assertEqual(mock_val_func.call_count, 3)
            mock_val_func.reset_mock()
            self.assertEqual(mock_vfp.call_count, 2)
            mock_vfp.reset_mock()

            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs2),
                self.get_updated_tags())
            self.assertEqual(mock_val_func.call_count, 3)
            self.assertEqual(mock_vfp.call_count, 2)

    def test_if_in_facility(self):
        faclity = "f1"
        kwargs = {
            "if_in_facility": faclity
        }

        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_facility") as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())
            self.assertEqual(mock_val_func.call_count, 1)
            self.assertIn(faclity, mock_val_func.call_args[0])

            self.assertEqual(mock_vfp.call_count, 2)

    def test_if_has_tag_none(self):
        if_has_tag = None
        kwargs = {
            "if_has_tag": if_has_tag
        }

        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

            self.assertEqual(mock_val_func.call_count, 0)

            # no warnings
            self.assertEqual(vctx.add_warning.call_count, 0)

            self.assertEqual(mock_vfp.call_count, 2)

    def test_if_has_tag_success(self):
        if_has_tag = "ts1"
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags(["ts1", "ts2"]))

            self.assertEqual(mock_val_func.call_count, 1)
            self.assertEqual(mock_val_func.call_args[0][2], if_has_tag)

            # make sure validate_identifier only warn if invalid
            self.assertEqual(mock_val_func.call_args[1]["warning_only"], True)

            self.assertEqual(mock_vfp.call_count, 2)

    def test_if_has_tag_success_with_none_in_tags(self):
        # Note: can tags include element None?
        if_has_tag = None
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),

                # Note: can tags include element None?
                self.get_updated_tags(["ts1", None]))

            self.assertEqual(mock_val_func.call_count, 0)

            self.assertEqual(mock_vfp.call_count, 2)

    def test_if_has_tag_fail(self):
        if_has_tag = "ts1"
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            with self.assertRaises(ValidationError) as cm:
                validation.validate_session_access_rule(
                    vctx, location,
                    self.get_updated_arule(**kwargs),
                    self.get_updated_tags(["ts2", "ts3"]))

            self.assertEqual(mock_val_func.call_count, 1)
            self.assertEqual(mock_val_func.call_args[0][2], if_has_tag)

            # make sure validate_identifier only warn if invalid
            self.assertEqual(mock_val_func.call_args[1]["warning_only"], True)

            expected_error_msg = "invalid tag 'ts1'"
            self.assertIn(expected_error_msg, str(cm.exception))

            # no warnings
            self.assertEqual(vctx.add_warning.call_count, 0)

            self.assertEqual(mock_vfp.call_count, 0)

    def test_default_expiration_mode_success(self):
        mode = "roll_over"
        kwargs = {
            "if_expiration_mode": mode
        }
        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

        self.assertEqual(mock_vfp.call_count, 2)

    def test_if_expiration_mode_fail(self):
        mode = "unknown"
        kwargs = {
            "if_expiration_mode": mode
        }

        with mock.patch(
                "course.validation.validate_flow_permission"
        ) as mock_vfp, self.assertRaises(ValidationError) as cm:
            validation.validate_session_access_rule(
                vctx, location,
                self.get_updated_arule(**kwargs),
                self.get_updated_tags())

        expected_error_msg = (
                f"invalid expiration mode '{mode}'")
        self.assertIn(expected_error_msg, str(cm.exception))

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

        self.assertEqual(mock_vfp.call_count, 0)

    def test_if_in_progress_no_warning(self):
        if_in_progress = True
        kwargs = {
            "if_in_progress": if_in_progress,
            "permissions": []
        }
        validation.validate_session_access_rule(
            vctx, location,
            self.get_updated_arule(**kwargs),
            self.get_updated_tags())

        self.assertEqual(vctx.add_warning.call_count, 0)

        if_in_progress = False
        kwargs = {
            "if_in_progress": if_in_progress,
            "permissions": []
        }
        validation.validate_session_access_rule(
            vctx, location,
            self.get_updated_arule(**kwargs),
            self.get_updated_tags())

        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_if_in_progress_warned_ignore(self):
        if_in_progress = False
        kwargs = {
            "if_in_progress": if_in_progress,
            "permissions": [flow_permission.submit_answer]
        }

        expected_warn_msg = (
            "Rule specifies 'submit_answer' or 'end_session' "
            "permissions for non-in-progress flow. These "
            "permissions will be ignored.")
        validation.validate_session_access_rule(
            vctx, location,
            self.get_updated_arule(**kwargs),
            self.get_updated_tags())

        self.assertEqual(vctx.add_warning.call_count, 1)
        self.assertIn(expected_warn_msg, vctx.add_warning.call_args[0])
        vctx.reset_mock()

        kwargs = {
            "if_in_progress": if_in_progress,
            "permissions": [flow_permission.end_session]
        }

        expected_warn_msg = (
            "Rule specifies 'submit_answer' or 'end_session' "
            "permissions for non-in-progress flow. These "
            "permissions will be ignored.")
        validation.validate_session_access_rule(
            vctx, location,
            self.get_updated_arule(**kwargs),
            self.get_updated_tags())

        self.assertEqual(vctx.add_warning.call_count, 1)
        self.assertIn(expected_warn_msg, vctx.add_warning.call_args[0])
        vctx.reset_mock()

        kwargs = {
            "if_in_progress": if_in_progress,
            "permissions": [flow_permission.submit_answer,
                            flow_permission.end_session]
        }

        expected_warn_msg = (
            "Rule specifies 'submit_answer' or 'end_session' "
            "permissions for non-in-progress flow. These "
            "permissions will be ignored.")

        validation.validate_session_access_rule(
            vctx, location,
            self.get_updated_arule(**kwargs),
            self.get_updated_tags())

        self.assertEqual(vctx.add_warning.call_count, 1)
        self.assertIn(expected_warn_msg, vctx.add_warning.call_args[0])


class ValidateSessionGradingRule(ValidationTestMixin, unittest.TestCase):
    # test validation.validate_session_grading_rule

    default_grade_identifier = "my_grade_identifier"

    def get_updated_grule(self, **kwargs):
        rule = {}
        rule.update(kwargs)
        return dict_to_struct(rule)

    def get_updated_tags(self, extra=None):
        tags = []

        if extra is not None:
            assert isinstance(extra, list)
        else:
            extra = []

        tags.extend(extra)
        return tags

    def test_success(self):
        self.assertEqual(validation.validate_session_grading_rule(
            vctx, location, self.get_updated_grule(), self.get_updated_tags(),
            self.default_grade_identifier), False)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_removed_grade_identifier(self):
        kwargs = {
            "grade_identifier": "unknown"
        }

        with self.assertRaises(ValidationError) as cm:
            validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), self.default_grade_identifier)

        expected_error_msg = (
            "'grade_identifier' attribute found. "
            "This attribute is no longer allowed here "
            "and should be moved upward into the 'rules' "
            "block.")

        self.assertIn(expected_error_msg, str(cm.exception))

    def test_removed_grade_aggregation_strategy(self):
        kwargs = {
            "grade_aggregation_strategy": "unknown"
        }

        with self.assertRaises(ValidationError) as cm:
            validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), self.default_grade_identifier)

        expected_error_msg = (
            "'grade_aggregation_strategy' attribute found. "
            "This attribute is no longer allowed here "
            "and should be moved upward into the 'rules' "
            "block.")

        self.assertIn(expected_error_msg, str(cm.exception))

    def test_if_started_before(self):
        datespec = "some_time1"
        kwargs = {
            "if_started_before": datespec
        }
        self.assertEqual(validation.validate_session_grading_rule(
            vctx, location,
            self.get_updated_grule(**kwargs),
            self.get_updated_tags(), self.default_grade_identifier), True)

        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_due(self):
        datespec = "some_time3"
        kwargs = {
            "due": datespec
        }
        self.assertEqual(validation.validate_session_grading_rule(
            vctx, location,
            self.get_updated_grule(**kwargs),
            self.get_updated_tags(), self.default_grade_identifier), False)

        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_if_completed_before(self):
        datespec = "some_time2"
        kwargs = {
            "if_completed_before": datespec
        }
        self.assertEqual(validation.validate_session_grading_rule(
            vctx, location,
            self.get_updated_grule(**kwargs),
            self.get_updated_tags(), self.default_grade_identifier), True)

        self.assertEqual(vctx.encounter_datespec.call_count, 1)
        self.assertIn(datespec, vctx.encounter_datespec.call_args[0])

    def test_if_has_role(self):
        roles = ["r1", "r2", "r3"]
        kwargs = {
            "if_has_role": roles
        }
        with mock.patch("course.validation.validate_role") as mock_val_func:
            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), self.default_grade_identifier), True)
        self.assertEqual(mock_val_func.call_count, 3)

    def test_if_has_participation_tags(self):
        ptags = ["t1", "t2", "t3"]
        kwargs1 = {
            "if_has_participation_tags_any": ptags
        }
        kwargs2 = {
            "if_has_participation_tags_all": ptags
        }
        with mock.patch(
                "course.validation.validate_participationtag") as mock_val_func:
            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs1),
                self.get_updated_tags(), self.default_grade_identifier), True)
            self.assertEqual(mock_val_func.call_count, 3)
            mock_val_func.reset_mock()

            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs2),
                self.get_updated_tags(), self.default_grade_identifier), True)
            self.assertEqual(mock_val_func.call_count, 3)

    def test_if_has_tag_none(self):
        if_has_tag = None
        kwargs = {
            "if_has_tag": if_has_tag
        }

        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), self.default_grade_identifier), True)

            self.assertEqual(mock_val_func.call_count, 0)

            # no warnings
            self.assertEqual(vctx.add_warning.call_count, 0)

    def test_if_has_tag_success(self):
        if_has_tag = "ts1"
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(["ts1", "ts2"]),
                self.default_grade_identifier), True)

            self.assertEqual(mock_val_func.call_count, 1)
            self.assertEqual(mock_val_func.call_args[0][2], if_has_tag)

            # make sure validate_identifier only warn if invalid
            self.assertEqual(mock_val_func.call_args[1]["warning_only"], True)

    def test_if_has_tag_success_with_none_in_tags(self):
        # Note: can tags include element None?
        if_has_tag = None
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            self.assertEqual(validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),

                # Note: can tags include element None?
                self.get_updated_tags(["ts1", None]), self.default_grade_identifier),
                True)

            self.assertEqual(mock_val_func.call_count, 0)

    def test_if_has_tag_fail(self):
        if_has_tag = "ts1"
        kwargs = {
            "if_has_tag": if_has_tag
        }
        with mock.patch(
                "course.validation.validate_identifier") as mock_val_func:
            with self.assertRaises(ValidationError) as cm:
                validation.validate_session_grading_rule(
                    vctx, location,
                    self.get_updated_grule(**kwargs),
                    self.get_updated_tags(["ts2", "ts3"]),
                    self.default_grade_identifier)

            self.assertEqual(mock_val_func.call_count, 1)
            self.assertEqual(mock_val_func.call_args[0][2], if_has_tag)

            # make sure validate_identifier only warn if invalid
            self.assertEqual(mock_val_func.call_args[1]["warning_only"], True)

            expected_error_msg = "invalid tag 'ts1'"
            self.assertIn(expected_error_msg, str(cm.exception))

            # no warnings
            self.assertEqual(vctx.add_warning.call_count, 0)

    def test_generates_grade_and_grade_identifier_is_none(self):
        kwargs = {
            "generates_grade": False
        }

        # success when not generates_grade
        self.assertEqual(validation.validate_session_grading_rule(
            vctx, location,
            self.get_updated_grule(**kwargs),
            self.get_updated_tags(), grade_identifier=None), False)

        expected_error_msg = (
            "'generates_grade' is true, but no 'grade_identifier'"
            "is given.")

        kwargs = {
            "generates_grade": True
        }

        # fail when generates_grade
        with self.assertRaises(ValidationError) as cm:
            validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), grade_identifier=None)
        self.assertIn(expected_error_msg, str(cm.exception))

        kwargs = {}

        # fail when generates_grade not configured
        with self.assertRaises(ValidationError) as cm:
            validation.validate_session_grading_rule(
                vctx, location,
                self.get_updated_grule(**kwargs),
                self.get_updated_tags(), grade_identifier=None)
        self.assertIn(expected_error_msg, str(cm.exception))


class ValidateFlowRules(ValidationTestMixin, unittest.TestCase):
    # test validation.validate_flow_rules

    default_grade_identifier = "my_grade_identifier"

    def get_updated_rule(
            self, no_grade_identifier=False,
            no_grade_aggregation_strategy=False,
            no_grading_rules=False,
            **kwargs):
        rule = {"access": ["access_rule1", "access_rule2"]}

        if not no_grade_identifier:
            rule["grade_identifier"] = self.default_grade_identifier
        if not no_grade_aggregation_strategy:
            rule["grade_aggregation_strategy"] = (
                grade_aggregation_strategy.use_latest)
        if not no_grading_rules:
            rule["grading"] = ["grading_rule1", "grading_rule2",
                               "grading_rule3"]
        rule.update(kwargs)
        return dict_to_struct(rule)

    def test_success(self):
        with mock.patch(
                "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]
            validation.validate_flow_rules(
                vctx, location, self.get_updated_rule())

        self.assertEqual(mock_vi.call_count, 1)
        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vsgr.call_count, 3)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_success_with_grading_identifier_none(self):
        kwargs = {
            "grade_identifier": None
        }
        with mock.patch(
                "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]
            validation.validate_flow_rules(
                vctx, location,
                self.get_updated_rule(
                    no_grading_rules=True,
                    **kwargs))

        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vi.call_count, 0)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_no_grade_identifier_with_no_grading_rules(self):
        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            with self.assertRaises(ValidationError) as cm:
                validation.validate_flow_rules(
                    vctx, location,
                    self.get_updated_rule(
                        no_grade_identifier=True, no_grading_rules=True))

            expected_error_msg = (
                "'rules' block does not have a grade_identifier "
                "attribute.")
            unexpected_error_msg = (
                "This attribute needs to be moved out of "
                "the lower-level 'grading' rules block and into "
                "the 'rules' block itself."
            )
            self.assertIn(expected_error_msg, str(cm.exception))
            self.assertNotIn(unexpected_error_msg, str(cm.exception))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 0)
        self.assertEqual(mock_vsar.call_count, 0)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_no_grade_identifier_with_grading_rules_with_out_grade_identifier(self):
        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            with self.assertRaises(ValidationError) as cm:
                validation.validate_flow_rules(
                    vctx, location,
                    self.get_updated_rule(no_grade_identifier=True))

            expected_error_msg = (
                "'rules' block does not have a grade_identifier "
                "attribute.")
            unexpected_error_msg = (
                "This attribute needs to be moved out of "
                "the lower-level 'grading' rules block and into "
                "the 'rules' block itself."
            )
            self.assertIn(expected_error_msg, str(cm.exception))
            self.assertNotIn(unexpected_error_msg, str(cm.exception))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 0)
        self.assertEqual(mock_vsar.call_count, 0)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_no_grade_identifier_with_grading_rules_with_grade_identifier(self):

        kwargs = {
            "grading": dict_to_struct(
                {"grade_identifier": self.default_grade_identifier})
        }

        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
                "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            with self.assertRaises(ValidationError) as cm:
                validation.validate_flow_rules(
                    vctx, location,
                    self.get_updated_rule(no_grade_identifier=True, **kwargs))

            expected_error_msg = (
                "'rules' block does not have a grade_identifier "
                "attribute. This attribute needs to be moved out of "
                "the lower-level 'grading' rules block and into "
                "the 'rules' block itself.")
            self.assertIn(expected_error_msg, str(cm.exception))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 0)
        self.assertEqual(mock_vsar.call_count, 0)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_tags(self):

        kwargs = {
            "tags": ["tag1", "tag2"]
        }

        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
                "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            validation.validate_flow_rules(
                vctx, location,
                self.get_updated_rule(**kwargs))

        self.assertEqual(mock_vs.call_count, 1)

        # two extra validate_identifier calls for tags
        self.assertEqual(mock_vi.call_count, 3)
        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vsgr.call_count, 3)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_start_rules_validated(self):

        kwargs = {
            "start": ["start_rule1", "start_rule2",
                      "start_rule3", "start_rule4"]
        }

        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_start_rule"
        ) as mock_vssr, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            validation.validate_flow_rules(
                vctx, location,
                self.get_updated_rule(**kwargs))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 1)
        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vssr.call_count, 4)
        self.assertEqual(mock_vsgr.call_count, 3)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_no_grade_aggregation_strategy(self):
        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            with self.assertRaises(ValidationError) as cm:
                validation.validate_flow_rules(
                    vctx, location,
                    self.get_updated_rule(no_grade_aggregation_strategy=True))
            expected_error_msg = (
                "flows that have a grade "
                f"identifier ('{self.default_grade_identifier}') "
                "must have grading rules with a "
                "grade_aggregation_strategy")

            self.assertIn(expected_error_msg, str(cm.exception))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 1)
        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)

    def test_unknown_grade_aggregation_strategy(self):
        g_strategy = "unknown"
        kwargs = {
            "grade_aggregation_strategy": g_strategy
        }
        with mock.patch(
                "course.validation.validate_struct"
        ) as mock_vs, mock.patch(
            "course.validation.validate_identifier"
        ) as mock_vi, mock.patch(
            "course.validation.validate_session_access_rule"
        ) as mock_vsar, mock.patch(
            "course.validation.validate_session_grading_rule"
        ) as mock_vsgr:
            mock_vsgr.side_effect = [True, True, False]

            with self.assertRaises(ValidationError) as cm:
                validation.validate_flow_rules(
                    vctx, location,
                    self.get_updated_rule(**kwargs))

            expected_error_msg = (
                f"invalid grade aggregation strategy: {g_strategy}")

            self.assertIn(expected_error_msg, str(cm.exception))

        self.assertEqual(mock_vs.call_count, 1)
        self.assertEqual(mock_vi.call_count, 1)
        self.assertEqual(mock_vsar.call_count, 2)
        self.assertEqual(mock_vsgr.call_count, 0)

        # no warnings
        self.assertEqual(vctx.add_warning.call_count, 0)