Steps and code to set up Django Rest Framework (DRF) test cases with database mocking.
1. Set up Django and DRF
Install Django and DRF:
```sh
pip install django djangorestframework
```
Create a Django project and app:
```sh
django-admin startproject projectname
cd projectname
python manage.py startapp appname
```
2. Define Models, Serializers, and Views
models.py (appname/models.py):
```python
from django.db import models
class Item(models.Model):
name = models.CharField(max_length=100)
description = models.TextField()
```
serializers.py (appname/serializers.py):
```python
from rest_framework import serializers
from .models import Item
class ItemSerializer(serializers.ModelSerializer):
class Meta:
model = Item
fields = '__all__'
```
views.py (appname/views.py):
```python
from rest_framework import viewsets
from .models import Item
from .serializers import ItemSerializer
class ItemViewSet(viewsets.ModelViewSet):
queryset = Item.objects.all()
serializer_class = ItemSerializer
```
urls.py (appname/urls.py):
```python
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import ItemViewSet
router = DefaultRouter()
router.register(r'items', ItemViewSet)
urlpatterns = [
path('', include(router.urls)),
]
```
projectname/urls.py:
```python
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('appname.urls')),
]
```
3. Migrate Database and Create Superuser
```sh
python manage.py makemigrations appname
python manage.py migrate
python manage.py createsuperuser
python manage.py runserver
```
4. Write Test Cases
tests.py (appname/tests.py):
```python
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITestCase
from .models import Item
from .serializers import ItemSerializer
class ItemTests(APITestCase):
def setUp(self):
self.item1 = Item.objects.create(name='Item 1', description='Description 1')
self.item2 = Item.objects.create(name='Item 2', description='Description 2')
def test_get_items(self):
url = reverse('item-list')
response = self.client.get(url, format='json')
items = Item.objects.all()
serializer = ItemSerializer(items, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def test_create_item(self):
url = reverse('item-list')
data = {'name': 'Item 3', 'description': 'Description 3'}
response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Item.objects.count(), 3)
self.assertEqual(Item.objects.get(id=3).name, 'Item 3')
def test_update_item(self):
url = reverse('item-detail', kwargs={'pk': self.item1.id})
data = {'name': 'Updated Item 1', 'description': 'Updated Description 1'}
response = self.client.put(url, data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.item1.refresh_from_db()
self.assertEqual(self.item1.name, 'Updated Item 1')
def test_delete_item(self):
url = reverse('item-detail', kwargs={'pk': self.item2.id})
response = self.client.delete(url, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Item.objects.count(), 1)
```
5. Run Tests
```sh
python manage.py test
```
This setup provides a basic Django project with DRF and test cases for CRUD operations using the database. The test cases mock the database operations, ensuring isolation and consistency during testing.
Now diving into some more feature tests with Mock, patch etc.
Here are steps and code to write Django Rest Framework (DRF) test cases using mocking and faking features for scenarios like credit card processing.
1. Set up Django and DRF
Install Django and DRF:
```sh
pip install django djangorestframework
```
Create a Django project and app:
```sh
django-admin startproject projectname
cd projectname
python manage.py startapp appname
```
2. Define Models, Serializers, and Views
models.py (appname/models.py):
```python
from django.db import models
class Payment(models.Model):
card_number = models.CharField(max_length=16)
card_holder = models.CharField(max_length=100)
expiration_date = models.CharField(max_length=5)
amount = models.DecimalField(max_digits=10, decimal_places=2)
status = models.CharField(max_length=10)
```
serializers.py (appname/serializers.py):
```python
from rest_framework import serializers
from .models import Payment
class PaymentSerializer(serializers.ModelSerializer):
class Meta:
model = Payment
fields = '__all__'
```
views.py (appname/views.py):
```python
from rest_framework import viewsets
from .models import Payment
from .serializers import PaymentSerializer
class PaymentViewSet(viewsets.ModelViewSet):
queryset = Payment.objects.all()
serializer_class = PaymentSerializer
```
urls.py (appname/urls.py):
```python
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import PaymentViewSet
router = DefaultRouter()
router.register(r'payments', PaymentViewSet)
urlpatterns = [
path('', include(router.urls)),
]
```
projectname/urls.py:
```python
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('api/', include('appname.urls')),
]
```
3. Migrate Database and Create Superuser
```sh
python manage.py makemigrations appname
python manage.py migrate
python manage.py createsuperuser
python manage.py runserver
```
4. Write Test Cases with Mocking and Faking
tests.py (appname/tests.py):
```python
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITestCase
from unittest.mock import patch
from .models import Payment
from .serializers import PaymentSerializer
class PaymentTests(APITestCase):
def setUp(self):
self.payment_data = {
'card_number': '4111111111111111',
'card_holder': 'John Doe',
'expiration_date': '12/25',
'amount': '100.00',
'status': 'Pending'
}
self.payment = Payment.objects.create(**self.payment_data)
@patch('appname.views.PaymentViewSet.create')
def test_create_payment_with_mock(self, mock_create):
mock_create.return_value = self.payment
url = reverse('payment-list')
response = self.client.post(url, self.payment_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['card_number'], self.payment_data['card_number'])
@patch('appname.views.PaymentViewSet.perform_create')
def test_create_payment_fake_response(self, mock_perform_create):
def fake_perform_create(serializer):
serializer.save(status='Success')
mock_perform_create.side_effect = fake_perform_create
url = reverse('payment-list')
response = self.client.post(url, self.payment_data, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['status'], 'Success')
def test_get_payments(self):
url = reverse('payment-list')
response = self.client.get(url, format='json')
payments = Payment.objects.all()
serializer = PaymentSerializer(payments, many=True)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
@patch('appname.views.PaymentViewSet.retrieve')
def test_get_payment_with_mock(self, mock_retrieve):
mock_retrieve.return_value = self.payment
url = reverse('payment-detail', kwargs={'pk': self.payment.id})
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['card_number'], self.payment_data['card_number'])
@patch('appname.views.PaymentViewSet.update')
def test_update_payment_with_mock(self, mock_update):
mock_update.return_value = self.payment
updated_data = self.payment_data.copy()
updated_data['status'] = 'Completed'
url = reverse('payment-detail', kwargs={'pk': self.payment.id})
response = self.client.put(url, updated_data, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['status'], 'Completed')
@patch('appname.views.PaymentViewSet.destroy')
def test_delete_payment_with_mock(self, mock_destroy):
mock_destroy.return_value = None
url = reverse('payment-detail', kwargs={'pk': self.payment.id})
response = self.client.delete(url, format='json')
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Payment.objects.count(), 0)
```
5. Run Tests
```sh
python manage.py test
```
This setup uses `unittest.mock.patch` to mock the behavior of various viewset methods in DRF, allowing you to simulate different responses without hitting the actual database or external services.
Comments