TestCase and SimpleTestCase in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

Difference in database usage between TestCase and SimpleTestCase

What happens when you run a test method inside a Django SimpleTestCase that tries to access the database?

Django

from django.test import SimpleTestCase
from myapp.models import MyModel

class MySimpleTest(SimpleTestCase):
    def test_db_access(self):
        count = MyModel.objects.count()
        self.assertEqual(count, 0)

A The test raises an error because SimpleTestCase does not set up the test database.

B The test silently ignores the database call and passes.

C The test runs successfully and counts the objects in the database.

D The test runs but always returns zero regardless of database content.

💡 Hint

Think about which test class sets up the test database.

SimpleTestCase does not set up or use the test database. Any database access inside it will raise an error.

Only TestCase sets up a test database and allows database queries.

❓ state_output

intermediate

Effect of TestCase on database state between tests

Given this Django TestCase class, what will be the count of MyModel objects in the second test method?

Django

from django.test import TestCase
from myapp.models import MyModel

class MyTest(TestCase):
    def test_create(self):
        MyModel.objects.create(name='test')
        self.assertEqual(MyModel.objects.count(), 1)

    def test_count(self):
        count = MyModel.objects.count()
        print(count)

A 2

B 0

C Raises an error because the database is not available.

D 1

💡 Hint

Remember how TestCase resets the database between tests.

Django's TestCase resets the test database after each test method, so the second test sees an empty database.

📝 Syntax

advanced

Correct way to write a Django TestCase with setup

Which option correctly defines a Django TestCase with a setup method that creates a model instance before each test?

A

class MyTest(TestCase):
    def setUp(self):
        MyModel.objects.create(name='setup')

    def test_example(self):
        self.assertEqual(MyModel.objects.count(), 1)

B

class MyTest(TestCase):
    def setup(self):
        MyModel.objects.create(name='setup')

    def test_example(self):
        self.assertEqual(MyModel.objects.count(), 1)

C

class MyTest(TestCase):
    def SetUp(self):
        MyModel.objects.create(name='setup')

    def test_example(self):
        self.assertEqual(MyModel.objects.count(), 1)

D

class MyTest(TestCase):
    def set_up(self):
        MyModel.objects.create(name='setup')

    def test_example(self):
        self.assertEqual(MyModel.objects.count(), 1)

💡 Hint

Check the exact method name Django expects for setup.

Django expects the setup method to be named exactly setUp with camel case.

Other variations like setup, SetUp, or set_up are ignored.

🔧 Debug

advanced

Why does this SimpleTestCase test fail with AttributeError?

Consider this test code. Why does it raise AttributeError: 'Client' object has no attribute 'login'?

Django

from django.test import SimpleTestCase

class MySimpleTest(SimpleTestCase):
    def test_login(self):
        logged_in = self.client.login(username='user', password='pass')
        self.assertTrue(logged_in)

A SimpleTestCase does not provide a full test client with login support.

B The test is missing a call to super().setUp() to initialize the client.

C The client attribute is missing in SimpleTestCase.

D The login method requires a database, which SimpleTestCase does not set up.

💡 Hint

Think about what login requires internally.

The login method requires database access to check user credentials.

SimpleTestCase does not set up the database, so login fails with AttributeError.

🧠 Conceptual

expert

Why choose SimpleTestCase over TestCase for some tests?

Which reason best explains why you might use SimpleTestCase instead of TestCase in Django testing?

A SimpleTestCase automatically mocks all external APIs, making tests more isolated.

B SimpleTestCase supports testing with a real database, unlike TestCase which uses a mock database.

C SimpleTestCase runs faster because it skips database setup, ideal for tests that don't need the database.

D SimpleTestCase allows testing asynchronous views, which TestCase does not support.

💡 Hint

Consider the cost of database setup in tests.

SimpleTestCase is faster because it does not set up or use the test database.

It is suitable for tests that do not require database access.