I am trying to decide whether I should use Django's Client
or RequestFactory
to test my views.
I am creating my server using DjangoRESTFramework and it's really simple, so far:
class SimpleModelList(generics.ListCreateAPIView): """ Retrieve list of all route_areas or create a new one. """ queryset = SimpleModel.objects.all() serializer_class = SimpleModelSerializer filter_backends = (IsOwnerFilterBackend,) def perform_create(self, serializer): serializer.save(owner=self.request.user)
What are the differences between testing with Django's Client
and RequestFactory
and which approach is more suited for testing a REST server (if there is any difference besides liking one better)?
Should I create tests with both so as to provide a better coverage for my system?
The test client is a Python class that acts as a dummy web browser, allowing you to test your views and interact with your Django-powered application programmatically.
The request factory The RequestFactory shares the same API as the test client. However, instead of behaving like a browser, the RequestFactory provides a way to generate a request instance that can be used as the first argument to any view.
With Django's Test Runner. If you're using manage.py test , you need to change the way you run it. You need to wrap it with three coverage commands like so: $ coverage erase # Remove any coverage data from previous runs $ coverage run manage.py test # Run the full test suite Creating test database for alias 'default'.. ...
RequestFactory
and Client
have some very different use-cases. To put it in a single sentence: RequestFactory
returns a request
, while Client
returns a response
.
The RequestFactory
does what it says - it's a factory to create request
objects. Nothing more, nothing less.
The Client
is used to fake a complete request-response cycle. It will create a request
object, which it then passes through a WSGI handler. This handler resolves the url, calls the appropriate middleware, and runs the view. It then returns the response object. It has the added benefit that it gathers a lot of extra data on the response
object that is extremely useful for testing.
The RequestFactory
doesn't actually touch any of your code, but the request
object can be used to test parts of your code that require a valid request
. The Client
runs your views, so in order to test your views, you need to use the Client
and inspect the response. Be sure to check out the documentation on the Client
.
When using Django REST framework request factory would be helpfull to test the permissions.
EX:
Class TestPermission(TestCase): def test_admin_permisiion(self): admin_user = User.objects.create(email='[email protected]',password='admin997',is_staff=True) factory = RequestFactory() request = factory.get('/') request.user = admin_user permission = IsAdminUser() has_permission = permission.has_permission(request, None) self.assertTrue(has_permission)
what we have done hear is we created a admin user by setting is_staff=True , then we created a request and assigned the admin as user of the request. request factory helps us do so. then we checked the IsAdminUser() permission from DRF against the request. the test will pass .
Client is to be used when you need to test the response returned by an Api.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With