def setUp(self):
        self.mock_runtime = Mock()
        self.block = SchoolYourselfReviewXBlock(
            self.mock_runtime, DictFieldData({}),
            ScopeIds("foo", "bar", "baz", "x"))

        # This is a fake shared key and a manually computed signature for use
        # in this test.
        self.block.shared_key = "key"
        self.canned_signature = "f0cc345470c322e0c6f41d541fe2b736"
  def setUp(self):
    self.mock_runtime = Mock()
    self.block = SchoolYourselfReviewXBlock(self.mock_runtime,
                                            DictFieldData({}),
                                            ScopeIds("foo", "bar", "baz", "x"))

    # This is a fake shared key and a manually computed signature for use
    # in this test.
    self.block.shared_key = "key"
    self.canned_signature = "f0cc345470c322e0c6f41d541fe2b736"
class SchoolYourselfReviewXBlockTest(unittest.TestCase):
  def setUp(self):
    self.mock_runtime = Mock()
    self.block = SchoolYourselfReviewXBlock(self.mock_runtime,
                                            DictFieldData({}),
                                            ScopeIds("foo", "bar", "baz", "x"))

    # This is a fake shared key and a manually computed signature for use
    # in this test.
    self.block.shared_key = "key"
    self.canned_signature = "f0cc345470c322e0c6f41d541fe2b736"


  def test_default_params(self):
    self.assertFalse(SchoolYourselfReviewXBlock.has_children)
    self.assertTrue(SchoolYourselfReviewXBlock.has_score)
    self.assertAlmostEqual(SchoolYourselfReviewXBlock.weight, 1.0)


  def test_display_name(self):
    """
    Make sure we are correctly overriding the get_display_name() of
    the base class.
    """
    self.assertEqual(self.block.get_display_name("blah"), "Review: blah")


  def test_student_id(self):
    self.assertEqual(self.block.get_student_id(), "debug")
    self.block.xmodule_runtime = FakeXModuleRuntime("abc123")
    self.assertEqual(self.block.get_student_id(), "abc123")


  def test_handle_grade_malformed_input(self):
    self.block.module_id = "algebra/multiplication"

    self.assertEqual(self.block.handle_grade_json("foo"), "bad_request")
    self.assertEqual(self.block.handle_grade_json(["foo"]), "bad_request")
    self.assertEqual(self.block.handle_grade_json({}), "forbidden")
    self.assertEqual(self.block.handle_grade_json(
        {"mastery": {"invalid_module_id": 1.0},
         "user_id": "foo",
         "signature": "asdf"}), "bad_request")

    # Make sure we never publish any grades for situations like this.
    self.assertEqual(len(self.mock_runtime.publish.method_calls), 0)


  def test_handle_grade_malformed_signed_input(self):
    """
    This is a test for an unlikely situation where the input is malformed
    but the signature is somehow correct. We should at least not start
    throwing errors.
    """
    self.block.module_id = "algebra/multiplication"

    self.assertEqual(self.block.handle_grade_json(
        {"mastery": {"algebra/multiplication": "hello"},  # A non-number!
         "user_id": "foo",
         "signature": self.canned_signature}), "bad_request")


  def test_handle_grade(self):
    self.block.module_id = "algebra/multiplication"

    self.assertEqual(self.block.handle_grade_json(
        {"mastery": {"algebra/multiplication": 0.7},
         "user_id": "foo",
         "signature": "asdf"}), "invalid_signature")

    # Invalid signatures should never publish grades.
    self.assertEqual(len(self.mock_runtime.publish.method_calls), 0)

    self.assertEqual(self.block.handle_grade_json(
        {"mastery": {"algebra/multiplication": 0.7},
         "user_id": "foo",
         "signature": self.canned_signature}), 1.0)

    self.mock_runtime.publish.assert_called_with(self.block, "grade",
                                                 { "value": 1.0,
                                                   "max_value": 1.0 })


  def test_get_partner_url_params(self):
    # These are the defaults:
    self.assertEqual(self.block.get_partner_url_params(),
                     { "partner": "edx",
                       "partner_user_id": "debug" })

    self.block.partner_id = "foo"
    self.block.xmodule_runtime = FakeXModuleRuntime("abc123")

    self.assertEqual(self.block.get_partner_url_params(),
                     { "partner": "foo",
                       "partner_user_id": "abc123" })
class SchoolYourselfReviewXBlockTest(unittest.TestCase):
    def setUp(self):
        self.mock_runtime = Mock()
        self.block = SchoolYourselfReviewXBlock(
            self.mock_runtime, DictFieldData({}),
            ScopeIds("foo", "bar", "baz", "x"))

        # This is a fake shared key and a manually computed signature for use
        # in this test.
        self.block.shared_key = "key"
        self.canned_signature = "f0cc345470c322e0c6f41d541fe2b736"

    def test_default_params(self):
        self.assertFalse(SchoolYourselfReviewXBlock.has_children)
        self.assertTrue(SchoolYourselfReviewXBlock.has_score)
        self.assertAlmostEqual(SchoolYourselfReviewXBlock.weight, 1.0)

    def test_display_name(self):
        """
    Make sure we are correctly overriding the get_display_name() of
    the base class.
    """
        self.assertEqual(self.block.get_display_name("blah"), "Review: blah")

    def test_student_id(self):
        self.assertEqual(self.block.get_student_id(), "debug")
        self.block.xmodule_runtime = FakeXModuleRuntime("abc123")
        self.assertEqual(self.block.get_student_id(), "abc123")

    def test_handle_grade_malformed_input(self):
        self.block.module_id = "algebra/multiplication"

        self.assertEqual(self.block.handle_grade_json("foo"), "bad_request")
        self.assertEqual(self.block.handle_grade_json(["foo"]), "bad_request")
        self.assertEqual(self.block.handle_grade_json({}), "forbidden")
        self.assertEqual(
            self.block.handle_grade_json({
                "mastery": {
                    "invalid_module_id": 1.0
                },
                "user_id": "foo",
                "signature": "asdf"
            }), "bad_request")

        # Make sure we never publish any grades for situations like this.
        self.assertEqual(len(self.mock_runtime.publish.method_calls), 0)

    def test_handle_grade_malformed_signed_input(self):
        """
    This is a test for an unlikely situation where the input is malformed
    but the signature is somehow correct. We should at least not start
    throwing errors.
    """
        self.block.module_id = "algebra/multiplication"

        self.assertEqual(
            self.block.handle_grade_json({
                "mastery": {
                    "algebra/multiplication": "hello"
                },  # A non-number!
                "user_id": "foo",
                "signature": self.canned_signature
            }),
            "bad_request")

    def test_handle_grade(self):
        self.block.module_id = "algebra/multiplication"

        self.assertEqual(
            self.block.handle_grade_json({
                "mastery": {
                    "algebra/multiplication": 0.7
                },
                "user_id": "foo",
                "signature": "asdf"
            }), "invalid_signature")

        # Invalid signatures should never publish grades.
        self.assertEqual(len(self.mock_runtime.publish.method_calls), 0)

        self.assertEqual(
            self.block.handle_grade_json({
                "mastery": {
                    "algebra/multiplication": 0.7
                },
                "user_id": "foo",
                "signature": self.canned_signature
            }), 1.0)

        self.mock_runtime.publish.assert_called_with(self.block, "grade", {
            "value": 1.0,
            "max_value": 1.0
        })

    def test_get_partner_url_params(self):
        # These are the defaults:
        self.assertEqual(self.block.get_partner_url_params(), {
            "partner": "edx",
            "partner_user_id": "debug"
        })

        self.block.partner_id = "foo"
        self.block.xmodule_runtime = FakeXModuleRuntime("abc123")

        self.assertEqual(self.block.get_partner_url_params(), {
            "partner": "foo",
            "partner_user_id": "abc123"
        })