Monday

Pytest with Django

 


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.

No comments: