Bài 20: Testing Basics

Why Testing?

Testing đảm bảo code hoạt động đúng và tránh regressions khi thay đổi code.

# Without tests:# - Fear of changing code# - Manual testing time-consuming# - Bugs in production# - No confidence in refactoring # With tests:# - Automatic verification# - Fast feedback# - Catch bugs early# - Safe refactoring# - Documentation of behavior # Test-Driven Development (TDD):# 1. Write failing test# 2. Write code to pass test# 3. Refactor# 4. Repeat

Django Testing Framework

# Django uses Python's unittest moduleimport unittestfrom django.test import TestCase, Clientfrom django.urls import reverse # Test structure# - Test files: tests.py or tests/ directory# - Test classes: Inherit from TestCase# - Test methods: Start with test_# - Assertions: self.assertEqual, self.assertTrue, etc. # Django provides:# - TestCase: Test database, fixtures, assertions# - Client: Simulate requests# - Test runner: python manage.py test

Django TestCase

Basic TestCase

# blog/tests.pyfrom django.test import TestCasefrom django.contrib.auth.models import Userfrom .models import Post class PostTestCase(TestCase):    """Test Post model"""        def setUp(self):        """Run before each test method"""        self.user = User.objects.create_user(            username='testuser',            password='testpass123'        )                self.post = Post.objects.create(            title='Test Post',            content='Test content',            author=self.user        )        def tearDown(self):        """Run after each test method (optional)"""        pass        def test_post_creation(self):        """Test post is created correctly"""        self.assertEqual(self.post.title, 'Test Post')        self.assertEqual(self.post.author, self.user)        self.assertIsNotNone(self.post.created)        def test_post_str(self):        """Test post __str__ method"""        self.assertEqual(str(self.post), 'Test Post') # Run: python manage.py test# Run specific test: python manage.py test blog.tests.PostTestCase.test_post_creation

TestCase Features

from django.test import TestCase class MyTestCase(TestCase):    """Django TestCase features"""        # Test database    # - Fresh database for each test    # - Automatic rollback after test    # - No impact on actual database        # Fixtures    fixtures = ['users.json', 'posts.json']        # setUpTestData (class method - runs once)    @classmethod    def setUpTestData(cls):        """Create data once for all test methods"""        cls.user = User.objects.create_user(username='test')        # More efficient than setUp for read-only data        # setUp (instance method - runs before each test)    def setUp(self):        """Run before each test method"""        self.client = Client()        # Test methods    def test_example(self):        """Test method - must start with 'test_'"""        self.assertTrue(True)

Assertions

from django.test import TestCase class AssertionTestCase(TestCase):    """Common assertions"""        def test_assertions(self):        # Equality        self.assertEqual(1 + 1, 2)        self.assertNotEqual(1, 2)                # Boolean        self.assertTrue(True)        self.assertFalse(False)                # None        self.assertIsNone(None)        self.assertIsNotNone('value')                # Membership        self.assertIn('a', ['a', 'b', 'c'])        self.assertNotIn('d', ['a', 'b', 'c'])                # Exceptions        with self.assertRaises(ValueError):            int('invalid')                # Django-specific assertions        self.assertQuerysetEqual(            Post.objects.all(),            ['<Post: Title>']        )                self.assertContains(response, 'text')        self.assertRedirects(response, '/success/')        self.assertTemplateUsed(response, 'template.html')

Testing Models

Basic Model Tests

from django.test import TestCasefrom django.core.exceptions import ValidationErrorfrom .models import Post, Category class PostModelTest(TestCase):    """Test Post model"""        @classmethod    def setUpTestData(cls):        cls.user = User.objects.create_user(username='test')        cls.category = Category.objects.create(name='Tech')        def test_create_post(self):        """Test creating a post"""        post = Post.objects.create(            title='Test Post',            content='Content',            author=self.user,            category=self.category        )                self.assertEqual(Post.objects.count(), 1)        self.assertEqual(post.title, 'Test Post')        self.assertEqual(post.author, self.user)        def test_post_str(self):        """Test __str__ method"""        post = Post(title='My Post')        self.assertEqual(str(post), 'My Post')        def test_post_get_absolute_url(self):        """Test get_absolute_url method"""        post = Post.objects.create(            title='Test',            slug='test',            author=self.user        )        self.assertEqual(            post.get_absolute_url(),            f'/post/{post.slug}/'        )        def test_post_ordering(self):        """Test default ordering"""        post1 = Post.objects.create(            title='Post 1',            author=self.user        )        post2 = Post.objects.create(            title='Post 2',            author=self.user        )                posts = Post.objects.all()        self.assertEqual(posts[0], post2)  # Newest first        self.assertEqual(posts[1], post1)

Testing Model Methods

class PostMethodTest(TestCase):    """Test Post model methods"""        def setUp(self):        self.user = User.objects.create_user(username='test')        self.post = Post.objects.create(            title='Test Post',            content='A' * 200,  # Long content            author=self.user        )        def test_get_excerpt(self):        """Test excerpt generation"""        excerpt = self.post.get_excerpt(length=50)        self.assertEqual(len(excerpt), 53)  # 50 + '...'        self.assertTrue(excerpt.endswith('...'))        def test_is_published(self):        """Test published status"""        self.post.published = False        self.assertFalse(self.post.is_published())                self.post.published = True        self.post.publish_date = timezone.now() - timedelta(days=1)        self.assertTrue(self.post.is_published())        def test_get_reading_time(self):        """Test reading time calculation"""        self.post.content = 'word ' * 300  # 300 words        reading_time = self.post.get_reading_time()        self.assertEqual(reading_time, 2)  # 300/200 = 1.5, rounded up

Testing Model Validation

class PostValidationTest(TestCase):    """Test Post model validation"""        def setUp(self):        self.user = User.objects.create_user(username='test')        def test_title_required(self):        """Test title is required"""        post = Post(content='Content', author=self.user)                with self.assertRaises(ValidationError):            post.full_clean()        def test_title_max_length(self):        """Test title max length"""        post = Post(            title='x' * 201,  # Exceeds 200 char limit            author=self.user        )                with self.assertRaises(ValidationError):            post.full_clean()        def test_slug_unique(self):        """Test slug uniqueness"""        Post.objects.create(            title='Test',            slug='test-slug',            author=self.user        )                post2 = Post(            title='Test 2',            slug='test-slug',  # Duplicate            author=self.user        )                with self.assertRaises(ValidationError):            post2.full_clean()

Testing Views

Testing Function-Based Views

from django.test import TestCase, Clientfrom django.urls import reverse class PostListViewTest(TestCase):    """Test post list view"""        @classmethod    def setUpTestData(cls):        cls.user = User.objects.create_user(username='test')                # Create test posts        for i in range(15):            Post.objects.create(                title=f'Post {i}',                content=f'Content {i}',                author=cls.user,                published=True            )        def test_view_url_exists(self):        """Test URL exists"""        response = self.client.get('/posts/')        self.assertEqual(response.status_code, 200)        def test_view_url_by_name(self):        """Test URL accessible by name"""        response = self.client.get(reverse('post_list'))        self.assertEqual(response.status_code, 200)        def test_view_uses_correct_template(self):        """Test correct template used"""        response = self.client.get(reverse('post_list'))        self.assertTemplateUsed(response, 'blog/post_list.html')        def test_pagination(self):        """Test pagination works"""        response = self.client.get(reverse('post_list'))        self.assertTrue('is_paginated' in response.context)        self.assertTrue(response.context['is_paginated'])        self.assertEqual(len(response.context['posts']), 10)        def test_lists_all_posts(self):        """Test all posts shown across pages"""        response = self.client.get(reverse('post_list') + '?page=2')        self.assertEqual(len(response.context['posts']), 5)

Testing Class-Based Views

class PostDetailViewTest(TestCase):    """Test post detail view"""        def setUp(self):        self.user = User.objects.create_user(username='test')        self.post = Post.objects.create(            title='Test Post',            slug='test-post',            content='Content',            author=self.user,            published=True        )        def test_view_displays_post(self):        """Test view displays post correctly"""        response = self.client.get(            reverse('post_detail', kwargs={'slug': self.post.slug})        )                self.assertEqual(response.status_code, 200)        self.assertContains(response, 'Test Post')        self.assertContains(response, 'Content')        def test_view_404_for_invalid_post(self):        """Test 404 for non-existent post"""        response = self.client.get(            reverse('post_detail', kwargs={'slug': 'invalid'})        )        self.assertEqual(response.status_code, 404)

Testing Forms in Views

class PostCreateViewTest(TestCase):    """Test post create view"""        def setUp(self):        self.user = User.objects.create_user(            username='test',            password='testpass123'        )        self.client.login(username='test', password='testpass123')        def test_redirect_if_not_logged_in(self):        """Test redirect to login if not authenticated"""        self.client.logout()        response = self.client.get(reverse('post_create'))        self.assertRedirects(            response,            f'/login/?next={reverse("post_create")}'        )        def test_view_form_displayed(self):        """Test form is displayed"""        response = self.client.get(reverse('post_create'))        self.assertEqual(response.status_code, 200)        self.assertContains(response, '<form')        self.assertContains(response, 'csrf')        def test_create_post_valid_data(self):        """Test creating post with valid data"""        data = {            'title': 'New Post',            'content': 'New content',            'category': self.category.id,        }                response = self.client.post(reverse('post_create'), data)                self.assertEqual(Post.objects.count(), 1)        post = Post.objects.first()        self.assertEqual(post.title, 'New Post')        self.assertEqual(post.author, self.user)        self.assertRedirects(response, post.get_absolute_url())        def test_create_post_invalid_data(self):        """Test creating post with invalid data"""        data = {            'title': '',  # Required field empty            'content': 'Content',        }                response = self.client.post(reverse('post_create'), data)                self.assertEqual(Post.objects.count(), 0)        self.assertEqual(response.status_code, 200)        self.assertFormError(response, 'form', 'title', 'This field is required.')

Test Client

Basic Client Usage

from django.test import TestCase, Client class ClientTest(TestCase):    """Test Django test client"""        def setUp(self):        self.client = Client()        def test_get_request(self):        """Test GET request"""        response = self.client.get('/posts/')                self.assertEqual(response.status_code, 200)        self.assertIn('posts', response.context)        def test_post_request(self):        """Test POST request"""        data = {'title': 'Test', 'content': 'Content'}        response = self.client.post('/posts/create/', data)                self.assertEqual(response.status_code, 302)  # Redirect        def test_with_query_params(self):        """Test with query parameters"""        response = self.client.get('/posts/', {'page': 2, 'q': 'search'})        self.assertEqual(response.status_code, 200)

Authentication with Client

class AuthClientTest(TestCase):    """Test client with authentication"""        def setUp(self):        self.user = User.objects.create_user(            username='test',            password='testpass123',            email='test@example.com'        )        def test_login(self):        """Test client login"""        logged_in = self.client.login(            username='test',            password='testpass123'        )        self.assertTrue(logged_in)                # Now authenticated        response = self.client.get('/profile/')        self.assertEqual(response.status_code, 200)        def test_force_login(self):        """Test force login (bypass password)"""        self.client.force_login(self.user)                response = self.client.get('/profile/')        self.assertEqual(response.status_code, 200)        def test_logout(self):        """Test logout"""        self.client.login(username='test', password='testpass123')        self.client.logout()                response = self.client.get('/profile/')        self.assertEqual(response.status_code, 302)  # Redirect to login

Testing AJAX Requests

class AjaxTest(TestCase):    """Test AJAX requests"""        def test_ajax_request(self):        """Test AJAX request"""        response = self.client.get(            '/api/posts/',            HTTP_X_REQUESTED_WITH='XMLHttpRequest'        )                self.assertEqual(response.status_code, 200)        self.assertEqual(response['Content-Type'], 'application/json')        def test_json_response(self):        """Test JSON response"""        import json                response = self.client.get('/api/posts/')        data = json.loads(response.content)                self.assertIsInstance(data, list)        self.assertIn('title', data[0])

Running Tests

Command Line

# Run all testspython manage.py test # Run specific app testspython manage.py test blog # Run specific test casepython manage.py test blog.tests.PostTestCase # Run specific test methodpython manage.py test blog.tests.PostTestCase.test_post_creation # Run with verbose outputpython manage.py test --verbosity=2 # Keep test databasepython manage.py test --keepdb # Run tests in parallelpython manage.py test --parallel # Run failed tests onlypython manage.py test --failed

Test Configuration

# settings.py # Test databaseDATABASES = {    'default': {        'ENGINE': 'django.db.backends.postgresql',        'NAME': 'mydb',        'TEST': {            'NAME': 'test_mydb',  # Test database name        }    }} # Speed up tests with faster password hasherif 'test' in sys.argv:    PASSWORD_HASHERS = [        'django.contrib.auth.hashers.MD5PasswordHasher',    ] # Disable migrations in tests (faster)class DisableMigrations:    def __contains__(self, item):        return True        def __getitem__(self, item):        return None if 'test' in sys.argv:    MIGRATION_MODULES = DisableMigrations()

Test Coverage

# Install coveragepip install coverage # Run tests with coveragecoverage run --source='.' manage.py test # Generate coverage reportcoverage report # Generate HTML coverage reportcoverage html# Open htmlcov/index.html # Example output:# Name                      Stmts   Miss  Cover# ---------------------------------------------# blog/models.py              45      3    93%# blog/views.py               68      5    93%# blog/forms.py               25      0   100%# ---------------------------------------------# TOTAL                      138      8    94%

Best Practices

# 1. Test namingclass PostModelTest(TestCase):    """Clear test class name"""        def test_create_post_with_valid_data(self):        """Descriptive test method name"""        pass # 2. One assertion per test (preferred)def test_post_title(self):    """Test post title is set correctly"""    self.assertEqual(self.post.title, 'Test Post') def test_post_author(self):    """Test post author is set correctly"""    self.assertEqual(self.post.author, self.user) # 3. Use setUpTestData for read-only data@classmethoddef setUpTestData(cls):    """Create data once for all tests"""    cls.user = User.objects.create_user(username='test') # 4. Test edge casesdef test_empty_title(self):    """Test validation with empty title"""    post = Post(title='', author=self.user)    with self.assertRaises(ValidationError):        post.full_clean() # 5. Test error conditionsdef test_404_for_invalid_post(self):    """Test 404 response for non-existent post"""    response = self.client.get('/post/999/')    self.assertEqual(response.status_code, 404) # 6. DRY - Don't Repeat Yourselfdef create_post(self, **kwargs):    """Helper method to create post"""    defaults = {        'title': 'Test Post',        'content': 'Content',        'author': self.user,    }    defaults.update(kwargs)    return Post.objects.create(**defaults) def test_example(self):    post = self.create_post(title='Custom Title')

Bài Tập

Bài 1: Model Testing

Task: Write comprehensive tests for Blog models:

# Models: Post, Category, Comment, Tag# Test:# 1. Model creation and fields# 2. __str__ methods# 3. get_absolute_url methods# 4. Custom model methods (get_excerpt, is_published, etc.)# 5. Model validation (required fields, max_length, unique constraints)# 6. Relationships (ForeignKey, ManyToMany)# 7. Default values and auto-generated fields (slug, created, etc.)# 8. Ordering# 9. Model managers and custom querysets # Achieve 100% coverage for models

Bài 2: View Testing

Task: Test all blog views:

# Views: List, Detail, Create, Update, Delete# Test:# 1. URL accessibility and reverse lookup# 2. Correct templates used# 3. Context data# 4. Pagination# 5. Authentication required# 6. Permissions (only author can edit/delete)# 7. Form display and submission# 8. Valid/invalid form data# 9. Success/error messages# 10. Redirects # Test both authenticated and anonymous users

Bài 3: Integration Testing

Task: Test complete user workflows:

# Workflow 1: User Registration and Login# 1. Register new user# 2. Verify email sent# 3. Activate account# 4. Login# 5. Update profile # Workflow 2: Create and Publish Post# 1. Login# 2. Create draft post# 3. Add tags and category# 4. Upload image# 5. Preview post# 6. Publish post# 7. Verify post visible in list # Workflow 3: Comment System# 1. View post# 2. Add comment# 3. Reply to comment# 4. Edit own comment# 5. Delete own comment# 6. Report comment (if not author)

Bài 4: Test Coverage

Task: Achieve high test coverage:

# Requirements:# 1. Install coverage: pip install coverage# 2. Run tests with coverage: coverage run manage.py test# 3. Generate report: coverage report# 4. Generate HTML report: coverage html# 5. Achieve minimum 90% coverage for:#    - Models: 95%+#    - Views: 90%+#    - Forms: 95%+#    - Utilities: 90%+# 6. Identify untested code# 7. Write tests for uncovered code# 8. Document any intentionally untested code

Tài Liệu Tham Khảo

Previous: Bài 19: Generic Views | Next: Bài 21: Model Relationships

#testcase

Django Testing Basics