JsonSchemaException is not right.

When I ran unittest case test_nonExistProject with fastjsonschema in master branch of this repo

The output is AssertionError: False is not true : data.Code must match pattern MissingParameter

response: {‘RequestId’: ‘', ‘HostId’: '’, ‘Code’: ‘InvalidProject.NotFound’, ‘Message’: ‘Specified project is not found.’}

schema: {‘id’: ‘http://localhost:8000/’, ‘$ref’: ‘http://localhost:8000/definitions.json#/NotFoundDefinition’}

AssertionError suggests that I used the MissingParameter related jsonschema, but the debug info I add in is_data_validate function suggests that current error was from Invalid.NotFound related jsonschema. Why they are not the same?

def is_data_validate(response, name):
    schema = SCHEMAS[name]
    validator = fastjsonschema.compile(schema)
    try:
        validator(response)
    except fastjsonschema.JsonSchemaException as e:
        msg = e.message + "\n\nresponse: %s\n\nschema: %s" % (response, schema)
        return False, msg
    else:
        return True, "validate %s pass" % name

class RestTestCase(unittest.TestCase):
    def do_request_and_check_response(self, schema_name):
        self.response = myclient.do_action_with_exception(self.request)
        result, msg = is_data_validate(self.response, schema_name)
        self.assertTrue(result, msg)


class TestCreateTagSet(client.RestTestCase):
#here is the test case that ran with unexpected result.
    def test_nonExistProject(self):
        schema_project_list = [('MissingParameter', ""), ('Invalid.NotFound', "non-exists")]
        for schema_name, project in schema_project_list:
            self.request.set_Project(project)
            self.do_request_and_check_response(schema_name)

here is the json file for reference,

[
    {
        "name": "MissingParameter",
        "schema": {
            "id": "http://localhost:8000/",
            "type": "object",
            "allOf": [
                {"$ref": "definitions.json#/HostRequestDefinition"},
                {
                    "properties": {
                        "Code": {"type": "string", "pattern": "MissingParameter"},
                        "Message": {"type": "string", "pattern": "The parameter is missing."}
                    },
                    "required": ["Code", "Message"]
                }
            ]
        }
    },
    {
        "name": "Invalid.NotFound",
        "schema": {
            "id": "http://localhost:8000/",
            "$ref": "definitions.json#/NotFoundDefinition"
        }
    }
]

file: definitions.json

{
    "NotFoundDefinition": {
        "type": "object",
        "allOf": [
            {"$ref": "#/HostRequestDefinition"},
            {
                "properties": {
                    "Code": {"type": "string", "pattern": "Invalid(Set|Project).NotFound"},
                    "Message": {"type": "string", "pattern": "Specified (set|project) is not found."}
                },
                "required:": ["Code", "Message"]
            }
        ]
    }
}

[ThreeO]

you should have for the exception class

  def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)

with no need for the message member variable. Then doing

raise JsonSchemaException(message)

will ensure that the str() of the exception is the message, which is the behavior of the base Exception class. Your way requires special treatment and will not get printed correctly by the default handler, for instance.

test case:

raise fastjsonschema.JsonSchemaException("test")

will print

JsonSchemaException:

instead of

JsonSchemaException: test

[ThreeO]

If you want to keep the message compatibility I would suggest to go with something like the following

class JsonSchemaException(ValueError):
    """
    Exception raised by validation function. Contains ``message`` with
    information what is wrong.
    """

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    @property
    def message(self):
      return str(self)

It’s somewhat more efficient and achieves the same result 😃