Metadata-Version: 1.2
Name: json-checker
Version: 1.1.5
Summary: Simple data validation library
Home-page: https://github.com/DKorytkin/json_checker
Author: Denis Korytkin
Author-email: dkorytkin@gmail.com
License: UNKNOWN
Description: json_checker
        ===============================================================================
        
        .. image:: https://travis-ci.org/DKorytkin/json_checker.svg?branch=master
            :target: https://travis-ci.org/DKorytkin/json_checker
        
        .. image:: https://codecov.io/gh/DKorytkin/Checker/branch/master/graph/badge.svg
            :target: https://codecov.io/gh/DKorytkin/Checker
        
        .. image:: https://img.shields.io/badge/python-2.7%2C%203.3%2C%203.4%2C%203.5%2C%203.6-blue.svg
            :target: https://pypi.python.org/pypi/json_checker
        
        .. image:: https://img.shields.io/badge/version-1.1.5-lightgrey.svg
            :target: https://github.com/DKorytkin/json_checker.__version__
        
        **json_checker** is a library for validating Python data structures,
        such as those obtained from JSON (or something else) to Python data-types.
        json_checker has a parameter (soft=True) that allows you validate all json and
        raise all errors after validation done, it`s very profitable from API testing:
        
        .. code:: python
        
            >>> import requests
            >>>
            >>> from json_checker import Checker
            >>>
            >>>
            >>> def test_api():
            >>>     res = requests.get(API_URL).json()
            >>>     assert Checker(EXPECTED_RESPONSE, soft=True).validate(res) == res
        
        
        Installation
        -------------------------------------------------------------------------------
        
        .. code-block:: sh
        
            $ pip install json_checker
        
        
        Example
        ----------------------------------------------------------------------------
        
        Here is a quick example to get a feeling of **json_checker**,
        validating a list of entries with personal information:
        
        .. code:: python
        
            >>> from json_checker import Checker
        
            >>> current_data = {'first_key': 1, 'second_key': '2'}
            >>> expected_data = {'first_key': int, 'second_key': str}
        
        
            >>> checker = Checker(expected_data)
            >>> result = checker.validate(current_data)
        
        
            >>> assert result == current_data
        
        
        If data is valid, ``Checker.validate`` will return the validated data
        
        If data is invalid, ``Checker`` will raise ``CheckerError``.
        
        
        How ``json_checker`` validates data
        -------------------------------------------------------------------------------
        
        Types
        ~~~~~
        
        If ``Checker(...)`` encounters a type (such as ``int``, ``str``),
        it will check if the corresponding piece of data is an instance of that type,
        otherwise it will raise ``CheckerError``.
        
        .. code:: python
        
            >>> from json_checker import Checker
        
            >>> Checker(int).validate(123)
            123
        
            >>> Checker(int).validate('123')
            Traceback (most recent call last):
            ...
            checker_exceptions.TypeCheckerError:
            current value "123" is not int
        
        
        Lists, similar containers
        ~~~~~~~~~~~~~~~~~~~~~~~~~
        
        If ``Checker(...)`` encounters an instance of ``list``, ``tuple``, ``set`` or
        ``frozenset``, it will validate contents of corresponding data container
        against schemas listed inside that container:
        if param ``soft`` is True validate all data,
        and if have not valid data raise exception after validation
        
        .. code:: python
        
            >>> Checker([int]).validate([1, 1, 0, 1])
            [1, 1, 0, 1]
        
            >>> Checker([str], soft=True).validate((1, 2, 3))
            Traceback (most recent call last):
            ...
            checker_exceptions.CheckerError:
            ListCheckerErrors:
            current value 1 is not str
            current value 2 is not str
            current value 3 is not str
        
            >>> Checker([str]).validate((1, 2, 3))
            Traceback (most recent call last):
            ...
            checker_exceptions.ListCheckerError:
            current value 1 is not str
        
        Dictionaries
        ~~~~~~~~~~~~
        
        If ``Checker(...)`` encounters an instance of ``dict``, it will validate data
        key-value pairs:
        
        .. code:: python
        
            >>> current_dict = {'first_key': 1, 'second_key': '2'}
            >>> checker = Checker({'first_key': int, 'second_key': int})
            >>> checker.validate(current_dict)
        
            Traceback (most recent call last):
            ...
            checker_exceptions.DictCheckerError:
            From key="second_key"
                current value "2" is not int
        
        
        Operators Or, And, OptionalKey
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        If you needed validate data from some conditions, use And operator
        for example current data must be int instance and greater than 0 and less 99
        try it:
        
        .. code:: python
        
            >>> from json_checker import Checker, And
        
            >>> checker = Checker(And(int, lambda x: 0 < x < 99))
            >>> checker.validate(12)
            12
        
            >>> checker.validate(100)
            Traceback (most recent call last):
            ...
            checker_exceptions.CheckerError:
                Not valid data And('int', '<lambda>')
        
        
        If you need validation not required data value, use Or operator
        for example current data must be int or None
        try it:
        
        .. code:: python
        
            >>> from json_checker import Checker, Or
        
            >>> checker = Checker(Or(int, None))
            >>> checker.validate(122)
            122
        
            >>> checker.validate('666')
            Traceback (most recent call last):
            ...
            checker_exceptions.CheckerError:
            Not valid data Or('int', None)
                current value "122" is not int
                current value "122" is not None
        
        If you need validate no required dict key, use OptionalKey
        
        .. code:: python
        
            >>> from json_checker import Checker, OptionalKey
        
            >>> expected_dict = {'key1': str, OptionalKey('key2'): int}
            >>> Checker(expected_dict).validate({'key1': 'value'})
            {'key1': 'value'}
        
            >>> Checker(expected_dict).validate({'key1': 'value', 'key2': 'value2'})
            Traceback (most recent call last):
            ...
            checker_exceptions.DictCheckerError:
            From key="OptionalKey(key2)"
                current value "value2" is not int
        
        
        
Keywords: Json checker from auto tests api
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Requires-Python: >=2.7
