Metadata-Version: 1.1
Name: django-mock-queries
Version: 2.1.4
Summary: A django library for mocking queryset functions in memory for testing
Home-page: https://github.com/stphivos/django-mock-queries
Author: Phivos Stylianides
Author-email: stphivos@gmail.com
License: MIT
Description: |Latest Version| |Build Status| |Code Coverage| |Code Climate|
        
        Django Mock Queries
        ===================
        
        A library for mocking Django queryset functions in memory for testing
        
        Features
        --------
        
        -  QuerySet style support for method chaining
        -  Filtering with Q objects
        -  Aggregates generation
        -  CRUD functions
        -  Field lookups
        -  django-rest-framework serializer asserts
        
        Examples
        --------
        
        .. code:: python
        
            from django.db.models import Avg, Q
            from django_mock_queries.query import MockSet, MockModel
        
            qs = MockSet(
                MockModel(mock_name='john', email='john@gmail.com'),
                MockModel(mock_name='jeff', email='jeff@hotmail.com'),
                MockModel(mock_name='bill', email='bill@gmail.com'),
            )
        
            print [x for x in qs.all().filter(email__icontains='gmail.com').select_related('address')]
            # Outputs: [john, bill]
        
            qs = MockSet(
                MockModel(mock_name='model s', msrp=70000),
                MockModel(mock_name='model x', msrp=80000),
                MockModel(mock_name='model 3', msrp=35000),
            )
        
            print qs.all().aggregate(Avg('msrp'))
            # Outputs: {'msrp__avg': 61666}
        
            qs = MockSet(
                MockModel(mock_name='model x', make='tesla', country='usa'),
                MockModel(mock_name='s-class', make='mercedes', country='germany'),
                MockModel(mock_name='s90', make='volvo', country='sweden'),
            )
        
            print [x for x in qs.all().filter(Q(make__iexact='tesla') | Q(country__iexact='germany'))]
            # Outputs: [model x, s-class]
        
            qs = MockSet(cls=MockModel)
            print qs.create(mock_name='my_object', foo='1', bar='a')
            # Outputs: my_object
        
            print [x for x in qs]
            # Outputs: [my_object]
        
        Test function that uses Django QuerySet:
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        .. code:: python
        
            """
            Function that queries active users
            """
            def active_users(self):
                return User.objects.filter(is_active=True).all()
        
            """
            Test function applies expected filters by patching Django's user model Manager or Queryset with a MockSet
            """
            from django_mock_queries.query import MockSet, MockModel
        
        
            class TestApi(TestCase):
                users = MockSet()
                user_objects = patch('django.contrib.auth.models.User.objects', users)
        
                @user_objects
                def test_api_active_users_filters_by_is_active_true(self):
                    self.users.add(
                        MockModel(mock_name='active user', is_active=True),
                        MockModel(mock_name='inactive user', is_active=False)
                    )
        
                    for x in self.api.active_users():
                        assert x.is_active
        
        Test django-rest-framework model serializer:
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        .. code:: python
        
            """
            Car model serializer that includes a nested serializer and a method field
            """
            class CarSerializer(serializers.ModelSerializer):
                make = ManufacturerSerializer()
                speed = serializers.SerializerMethodField()
        
                def get_speed(self, obj):
                    return obj.format_speed()
        
                class Meta:
                    model = Car
                    fields = ('id', 'make', 'model', 'speed',)
        
            """
            Test serializer returns fields with expected values and mock the result of nested serializer for field make
            """
            def test_car_serializer_fields(self):
                car = Car(id=1, make=Manufacturer(id=1, name='vw'), model='golf', speed=300)
        
                values = {
                    'id': car.id,
                    'model': car.model,
                    'speed': car.formatted_speed(),
                }
        
                assert_serializer(CarSerializer) \
                    .instance(car) \
                    .returns('id', 'make', 'model', 'speed') \
                    .values(**values) \
                    .mocks('make') \
                    .run()
        
        Full Example
        ~~~~~~~~~~~~
        
        There is a full Django application in the ``examples/users`` folder. It
        shows how to configure ``django_mock_queries`` in your tests and run
        them with or without setting up a Django database. Running the mock
        tests without a database can be much faster when your Django application
        has a lot of database migrations.
        
        To run your Django tests without a database, add a new settings file,
        and call ``monkey_patch_test_db()``. Use a wildcard import to get all
        the regular settings as well.
        
        .. code:: python
        
            # settings_mocked.py
            from django_mock_queries.mocks import monkey_patch_test_db
        
            from users.settings import *
        
            monkey_patch_test_db()
        
        Then run your Django tests with the new settings file:
        
        ::
        
            ./manage.py test --settings=users.settings_mocked
        
        Here’s the pytest equivalent:
        
        ::
        
            pytest --ds=users.settings_mocked
        
        That will run your tests without setting up a test database. All of your
        tests that use Django mock queries should run fine, but what about the
        tests that really need a database?
        
        ::
        
            ERROR: test_create (examples.users.analytics.tests.TestApi)
            ----------------------------------------------------------------------
            Traceback (most recent call last):
              File "/.../examples/users/analytics/tests.py", line 28, in test_create
                start_count = User.objects.count()
              [...]
            NotSupportedError: Mock database tried to execute SQL for User model.
        
        If you want to run your tests without a database, you need to tell
        Django to skip the tests that need a database. You can do that by
        putting a skip decorator on the test classes or test methods that need a
        database.
        
        .. code:: python
        
            @skipIfDBFeature('is_mocked')
            class TestApi(TestCase):
                def test_create(self):
                    start_count = User.objects.count()
        
                    User.objects.create(username='bob')
                    final_count = User.objects.count()
        
                    self.assertEqual(start_count + 1, final_count)
        
        Installation
        ------------
        
        .. code:: bash
        
            $ pip install django_mock_queries
        
        Contributing
        ------------
        
        Anything missing or not functioning correctly? PRs are always welcome!
        Otherwise, you can create an issue so someone else does it when time
        allows.
        
        You can follow these guidelines:
        
        -  Fork the repo from this page
        -  Clone your fork:
        
        .. code:: bash
        
            $ git clone https://github.com/{your-username}/django-mock-queries.git
            $ cd django-mock-queries
            $ git checkout -b feature/your_cool_feature
        
        -  Implement feature/fix
        -  Add/modify relevant tests
        -  Run tox to verify all tests and flake8 quality checks pass
        
        .. code:: bash
        
            $ tox
        
        -  Commit and push local branch to your origin
        
        .. code:: bash
        
            $ git commit . -m "New cool feature does this"
            $ git push -u origin HEAD
        
        -  Create pull request
        
        TODO
        ----
        
        -  Add docs as a service like readthedocs with examples for every
           feature
        -  Add support for missing QuerySet methods/Field lookups/Aggregation
           functions:
        
           -  Methods that return new QuerySets: annotate, reverse, none, extra,
              raw
        
           -  Methods that do not return QuerySets: bulk_create, in_bulk,
              as_manager
        
           -  Field lookups: search
        
           -  Aggregation functions: StdDev, Variance
        
        .. |Latest Version| image:: https://img.shields.io/pypi/v/django_mock_queries.svg
           :target: https://pypi.python.org/pypi/django_mock_queries
        .. |Build Status| image:: https://travis-ci.org/stphivos/django-mock-queries.svg?branch=master
           :target: https://travis-ci.org/stphivos/django-mock-queries
        .. |Code Coverage| image:: https://codecov.io/github/stphivos/django-mock-queries/coverage.svg?branch=master
           :target: https://codecov.io/github/stphivos/django-mock-queries?branch=master
        .. |Code Climate| image:: https://codeclimate.com/github/stphivos/django-mock-queries/badges/gpa.svg
           :target: https://codeclimate.com/github/stphivos/django-mock-queries
        
Keywords: django orm mocking unit-testing tdd
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Testing
Classifier: Topic :: Software Development :: Testing :: Mocking
Classifier: Topic :: Software Development :: Testing :: Unit
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
