How to Skip a Unit Test in Django

Django has an excellent built-in testing framework that allows us to test various parts of our application, including models, views, forms, and more.

"Wait, aren't we supposed to run all our tests?" well, usually yes, however, there are times when we may want to skip a specific test temporarily because some tests take more time to finish reducing our productivity, rely on an external service, or need to be skipped under certain conditions. Django provides several ways to skip tests.

In this article, we will explore different approaches to skip unit tests in Django.

Skipping Unit Tests in Django

So, why would we ever want to skip a test? Well, imagine we're working on a big project, and we've got this one test that's giving us trouble. Maybe, it's failing because of some weird edge case, or perhaps it's testing a feature that is still under development. In situations like these, it can be super helpful to temporarily skip that test so we can focus on other parts of our code without constant interruptions.

Django, being the awesome framework it is, gives us some handy tools to skip tests when we need to. It's like having a "not now" button for our tests. Pretty neat, right?

Using @skip and @skipIf Decorators to skip tests in Django

Django provides us with two main ways to skip tests: the @skip decorator and the @skipIf decorator. Let's break these down:

1. @skip: This decorator is used to skip test unconditionally. All, the test decorated using skip will be skipped.
2. @skipIf: This decorator is used to skip test conditionally. It lets us specify a condition. If that condition is true, the test gets skipped. If it's false, the test runs as normal. It's like having a bouncer for our tests!

tests.py

from django.test import TestCase
from unittest import skip, skipIf
import os


class MyAwesomeTests(TestCase):

    @skip("This test is giving me a headache")
    def test_complicated_feature(self):
        # This test won't run because we've skipped it
        pass

    @skipIf(os.environ.get('SKIP_SLOW_TESTS') == 'true',
            "Skipping slow tests")
    def test_time_consuming_operation(self):
        # This test will only be skipped if the SKIP_SLOW_TESTS
        # environment variable is set to 'true'
        pass

Output:

Explanation:

• The 's' represents the skipped test (test_complicated_feature)
• The '.' represents the test that ran (test_time_consuming_operation)

Now let's understand, in this example, we've got two tests.

• The first one, test_complicated_feature, is always skipped because we've used the @skip decorator. Maybe it's a test we're still working on, or one that's temporarily broken.
• The second test, test_time_consuming_operation, uses the @skipIf decorator. This test will only be skipped if we've set an environment variable called SKIP_SLOW_TESTS to 'true'.

This could be super useful if we want to run quick tests during development but still have the option to run all tests, including slow ones, in our CI/CD pipeline.

Example: More Advanced Usage

Let's look at a slightly more complex example where we're testing a weather app feature:

from django.test import TestCase
from unittest import skip, skipIf
from django.conf import settings
from .models import WeatherData


class WeatherAppTests(TestCase):

    @skipIf(not settings.WEATHER_API_KEY, "No API key set")
    def test_fetch_weather_data(self):
        # This test will be skipped if the WEATHER_API_KEY setting isn't configured
        city = "New York"
        weather_data = WeatherData.fetch_for_city(city)
        self.assertIsNotNone(weather_data)
        self.assertEqual(weather_data.city, city)

    @skip("Feature not implemented yet")
    def test_weather_alerts(self):
        # This test is skipped because we haven't implemented weather alerts yet
        pass

    def test_temperature_conversion(self):
        # This test always runs because it doesn't depend on external services
        celsius = 0
        fahrenheit = WeatherData.celsius_to_fahrenheit(celsius)
        self.assertEqual(fahrenheit, 32)

Output:

In this output:

• The first 's' represents test_fetch_weather_data being skipped
• The second 's' represents test_weather_alerts being skipped
• The '.' represents test_temperature_conversion running successfully
  

If we run the program with

python manage.py test -v 2

We'd see more details in the output in terminal:

Explanation:

The verbose output will show us exactly which tests were skipped and why, and which tests were passed.

Now let us understand, in this example, we're testing different aspects of a weather app. The test_fetch_weather_data method is skipped if we haven't set up an API key in our Django settings. This is super handy when we're developing locally and don't want to set up API keys for every developer's machine.

The test_weather_alerts method is skipped entirely because we haven't implemented that feature yet. But by writing the test and skipping it, we're leaving ourselves a reminder to implement and test this feature later.

Finally, the test_temperature_conversion method always runs because it's a simple unit test that doesn't depend on any external services or unfinished features.

Using --exclude-tag to Skip Tests in Django

Django allow us to use tag() decorator that we can use to add specific tag to each test. This tag will help us find specific test and when running tests we can determine which test to run which not.

Here's how we can use tags and the --exclude-tag option to skip tests.

from django.test import TestCase, tag


class MyProjectTests(TestCase):

    @tag('slow')
    def test_time_consuming_operation(self):
        # This is a slow test
        pass

    @tag('api')
    def test_api_interaction(self):
        # This test interacts with an external API
        pass

    def test_simple_math(self):
        # This is a quick, simple test
        self.assertEqual(1 + 1, 2)

In this example, we have tagged one test as 'slow' and another as 'api'. Now, when we run our tests, we can exclude these tagged tests using the --exclude-tag option:

python manage.py test --exclude-tag=slow

This command will run all tests except the ones tagged as 'slow'.

If we run the command:

python manage.py test --exclude-tag=slow --exclude-tag=api

Both the tests with tags 'slow' and 'api' will be excluded from running.

Conclusion

And there we have it! Skipping tests in Django is pretty much straightforward once we know about these decorators. Remember, though, skipping tests should be a temporary solution. If we find ourself skipping tests all the time, it might be a sign that we need to revisit our testing strategy or refactor some code.

Use these tools wisely, and they can help us stay productive even when we hit bumps in the road. They're especially useful when dealing with external dependencies, features in progress, or tests that might not always be relevant. Happy testing, and remember - a skipped test is better than a failing test that we ignore!