13.13. Creating a Django Project: Automated Tests

Página 71

When creating a Django project, a crucial component that cannot be overlooked is automated tests. Automated testing is an essential part of software development as it helps ensure that code works as expected and that future changes do not break existing functionality.

Django provides a robust testing framework that makes it easy to write tests for your code. Let's explore how you can use this framework to write tests for your Django project.

Why Automated Testing?

Automated testing is important for several reasons. First, they help ensure that your code is working correctly. This is especially important when you're working on a development team, where multiple people might be modifying the same code. Testing helps ensure that changes made by one person don't break someone else's code.

Second, tests provide documentation. They demonstrate how the code should be used and what it is expected to do. This can be extremely useful for other developers who need to understand your code.

Lastly, tests facilitate refactoring. If you have a comprehensive test suite, you can make changes to your code with confidence, knowing that if you break something, the tests will alert you.

Tests in Django

Django comes with a built-in testing framework that makes it easy to write tests for your code. It provides a number of tools and classes that you can use to test your application.

Django supports two types of tests: unit tests and functional tests. Unit tests are used to test a small part of your code in isolation. For example, you can write a unit test for a specific function or method.

Functional tests, on the other hand, are used to test the functionality of your site as a whole. They simulate the user's interaction with the website, verifying that the website behaves as expected.

Writing Tests

To write a test in Django, you create a subclass of django.test.TestCase and define methods in that class that represent individual tests. Each test method must begin with the word "test".

Here is an example of how a test might be structured:

from django.test import TestCase
from .models import MyModel

class MyModelTest(TestCase):
    def test_saving_and_retrieving_items(self):
        first_item = MyModel()
        first_item.text = 'The first (ever) list item'
        first_item.save()

        second_item = MyModel()
        second_item.text = 'Item the second'
        second_item.save()

        saved_items = MyModel.objects.all()
        self.assertEqual(saved_items.count(), 2)

        first_saved_item = saved_items[0]
        second_saved_item = saved_items[1]
        self.assertEqual(first_saved_item.text, 'The first (ever) list item')
        self.assertEqual(second_saved_item.text, 'Item the second')

This test verifies that you can save items to a template and retrieve them later.

Running Tests

To run your tests, you use the "test" command from the Django manager:

python manage.py test

This will run all the tests for your project and print the results to the screen.

Conclusion

Automated testing is a crucial part of software development. They help ensure your code is working correctly, provide documentation, and make refactoring easier. Django provides a robust testing framework that makes it easy to write and run tests for your project.

Next page of the Free Ebook:

7213.14. Creating a Django Project: Deploying a Django Application