Metadata-Version: 2.1
Name: smart-data
Version: 0.2.0
Summary: Smart comparing data for tests
Home-page: https://github.com/pkoscielny/smart_data
Author: Pawel Koscielny
License: UNKNOWN
Project-URL: Bug Tracker, https://github.com/pkoscielny/smart_data/issues
Description: # SMART DATA
        
        SMART DATA is a package to make your live easier. For example you want to test many JSON (or any other) results from some API in Python.
        There are plenty of great Python packages to find a differences between two complex structres but sometimes you need omit some their parts.
        This package help you to write this kind of code easier.
        
        ## Requirements
        
        No package dependecy.
        
        ## Installation
        
        ```
        pip install smart_data
        ```
        
        ## Functions
        
        ### list_diff = include(got, expected) 
        * got       - structure to check
        * expected  - structure that is required in 'got' structure. Any difference will be in returned list.
        * list_diff - list with differences, e.g. 
          `['/attributes/temperature/<20.1 vs 22.2>']`
        
        Try to check if 'expected' structure includes 'got' structure. Any additional keys from 'got' will be igroned.
        This situation can be expected if you don't want to check some parts of complex structure (e.g. in tests).
        
        The structures should contain dictionaries, lists, objects, simple types or any comparable structures (`__str__` and `__eq__` implementation).
        Additionally 'expected' can be or can contains compiled regular expression (re package) to check e.g. if you don't want mocking datetime objects.
        
        ## Example of usage
        
        So let's try test some endpoint:
        ```
        import re
        re_datetime = re.compile(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d$")
        
        def test_add_new(self, client):
            with client:
                res = client.post(
                    '/air_state',
                    json = {
                        'data': {
                            'type': 'air_state',
                            'attributes': {
                                'temperature': 20.1,
                                'humidity': 51.2,
                                'location': 'kitchen',
                                'device': 'dev1_esp',
                            },
                        },
                    },
                    content_type = 'application/vnd.api+json',
                )
                assert 201 == res.status_code
                res_json = res.get_json()
                
                assert res_json['data']['type'] == 'air_state'
                assert res_json['data']['id'] == '1'
                assert res_json['data']['attributes']['temperature'] == '20.1'
                assert res_json['data']['attributes']['humidity'] == '51.2'
                assert res_json['data']['attributes']['location'] == 'kitchen'
                assert res_json['data']['attributes']['device'] == 'dev1_esp'
                assert re_datetime.search(res_json['data']['attributes']['created'])
        
        ```
        You need write buch of asserts for many items in result structure. Many lines of code. If bigger structure then more code.
        
        Now you can write it in another way using smart_data package:
        ```
        from smart_data import include
        from re import compile
        
        def test_add_new(self, client):
        
            payload = {
                'type': 'air_state',
                'attributes': {
                    'temperature': 20.1,
                    'humidity': 51.2,
                    'location': 'kitchen',
                    'device': 'dev1_esp',
                },
            }
        
            with client:
                res = client.post(
                    '/air_state',
                    json = { 'data': payload },
                    content_type = 'application/vnd.api+json',
                )
                assert 201 == res.status_code
        
                payload['attributes']['id'] = 1
                payload['attributes']['created'] = compile(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d$")
                res_json = res.get_json()
                assert include(got=res_json['data'], expected=payload) == []
        ```
        This is simple example with really small amount of data to test. For more complex structure the benefit is higher. 
        
        Next benefit is readable output from broken assert during tests. For example:
        ```
            def test_foo():
                expected = {
                    'foo': 1.1,
                    'bar': [42, {'baz': 22}],
                    'zoo': None,
                    'zar': [[1, 3], [5, 8]],
                }
                got = {
                    'foo': 1.1,
                    'bar': [42, {'baz': 2}],
                    'zoo': None,
                    'zar': [[1, 3], [5, 8]],
                }
        >       assert include(got, expected) == []
        E       AssertionError: assert ['/bar/1/baz/<2 vs 22>'] == []
        E         Left contains one more item: '/bar/1/baz/<2 vs 22>'
        E         Full diff:
        E         - []
        E         + ['/bar/1/baz/<2 vs 22>']
        
        tests/test_include.py:38: AssertionError
        ```
        
        
        
Platform: UNKNOWN
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.6.9
Description-Content-Type: text/markdown
