unit-testing

name	unit-testing
description	Unit testing best practices and patterns
license	MIT
compatibility	opencode
metadata	{"audience":"developers","category":"testing"}

What I do

• Write effective unit tests
• Structure test suites
• Use test doubles (mocks, stubs, fakes)
• Test edge cases and errors
• Achieve good coverage
• Use parameterized tests
• Write readable tests
• Follow testing best practices

When to use me

When writing unit tests or improving test coverage.

Unit Test Structure

import pytest
from unittest.mock import Mock, patch, MagicMock
from dataclasses import dataclass


# Arrange-Act-Assert Pattern
class TestUserService:
    """Unit tests for UserService."""
    
    @pytest.fixture
    def user_repository(self):
        """Create mock user repository."""
        return Mock()
    
    @pytest.fixture
    def email_service(self):
        """Create mock email service."""
        return Mock()
    
    @pytest.fixture
    def service(self, user_repository, email_service):
        """Create service with dependencies."""
        return UserService(
            user_repository=user_repository,
            email_service=email_service,
        )
    
    def test_create_user_saves_and_sends_welcome_email(
        self,
        service: UserService,
        user_repository: Mock,
        email_service: Mock
    ):
        """Test creating a user saves to DB and sends email."""
        # Arrange
        email = "[e-mail]"
        name = "Test User"
        
        user_repository.exists_by_email.return_value = False
        
        # Act
        result = service.create_user(email, name)
        
        # Assert
        # Verify repository calls
        user_repository.exists_by_email.assert_called_once_with(email)
        user_repository.save.assert_called_once()
        
        # Verify email was sent
        email_service.send_welcome_email.assert_called_once_with(
            email=email,
            name=name,
        )
        
        # Verify result
        assert result.email == email
        assert result.name == name
        assert result.id is not None
    
    def test_create_user_raises_error_for_duplicate_email(
        self,
        service: UserService,
        user_repository: Mock
    ):
        """Test that duplicate email raises error."""
        # Arrange
        email = "[e-mail]"
        user_repository.exists_by_email.return_value = True
        
        # Act & Assert
        with pytest.raises(DuplicateEmailError):
            service.create_user(email, "Test")
        
        # Verify save was never called
        user_repository.save.assert_not_called()

Using Mocks Effectively

from unittest.mock import Mock, patch, MagicMock
import pytest


class TestPaymentProcessor:
    """Test payment processor with mocks."""
    
    @patch('app.services.payment_gateway.PaymentGateway')
    def test_process_payment_success(
        self,
        mock_gateway_class
    ):
        """Test successful payment processing."""
        # Arrange
        mock_gateway = MagicMock()
        mock_gateway.process_payment.return_value = {
            "status": "success",
            "transaction_id": "tx_123"
        }
        mock_gateway_class.return_value = mock_gateway
        
        processor = PaymentProcessor(gateway=mock_gateway)
        
        # Act
        result = processor.process(
            amount=100.00,
            currency="USD",
            source="tok_visa"
        )
        
        # Assert
        mock_gateway.process_payment.assert_called_once_with(
            amount=100.00,
            currency="USD",
            source="tok_visa",
        )
        
        assert result.status == "success"
        assert result.transaction_id == "tx_123"
    
    @patch('app.services.payment_gateway.PaymentGateway')
    def test_process_payment_handles_error(
        self,
        mock_gateway_class
    ):
        """Test error handling in payment processing."""
        # Arrange
        mock_gateway = MagicMock()
        mock_gateway.process_payment.side_effect = PaymentError(
            
        )
        mock_gateway_class.return_value = mock_gateway
        
        processor = PaymentProcessor(gateway=mock_gateway)
        
        
         pytest.raises(PaymentProcessingError):
            processor.process(
                amount=,
                currency=,
                source=
            )

Parameterized Tests

import pytest
from hypothesis import given, strategies as st


class TestValidator:
    """Tests for input validator."""
    
    @pytest.mark.parametrize("email,is_valid", [
        ("[e-mail]", True),
        ("[e-mail]", True),
        ("[e-mail]", True),
        ("invalid", False),
        ("@example.com", False),
        ("user@", False),
        ("user@.com", False),
    ])
    def test_email_validation(self, email: str, is_valid: bool):
        """Test email validation with various inputs."""
        validator = EmailValidator()
        
        result = validator.is_valid_email(email)
        
        assert result == is_valid
    
    @pytest.mark.parametrize("password,expected", [
        ("Short1!", False),  # Too short
        ("lowercase1!", False),  # No uppercase
        ("UPPERCASE1!", ),  
        (),  
        (),
    ])
     ():
        
        validator = PasswordValidator()
        
        result = validator.is_strong(password)
        
         result == expected



 :
    
    

     ():
        
         a + b == b + a
    

     ():
        
         a *  == a
    

     ():
        
         (numbers) >= (numbers)
    

     ():
        
         (s[::-]) == (s)

Testing Edge Cases

import pytest
from unittest.mock import Mock, patch


class TestOrderProcessor:
    """Test order processor with edge cases."""
    
    def test_empty_cart_raises_error(self):
        """Test that empty cart raises error."""
        repository = Mock()
        processor = OrderProcessor(repository)
        
        with pytest.raises(EmptyCartError):
            processor.process_order(user_id="123", cart_items=[])
    
    def test_single_item_order(self):
        """Test order with single item."""
        repository = Mock()
        repository.save.return_value = Mock(id="order_123")
        
        processor = OrderProcessor(repository)
        
        result = processor.process_order(
            user_id="123",
            cart_items=[CartItem(product_id="p1", quantity=1)]
        )
        
        assert result.id == "order_123"
        repository.save.assert_called_once()
    
    def test_multiple_items_order(self):
        """Test order with multiple items."""
        repository = Mock()
        repository.save.return_value = Mock(id="order_123")
        
        processor = OrderProcessor(repository)
        
        items = [
            CartItem(product_id="p1", quantity=2),
            CartItem(product_id="p2", quantity=1),
        ]
        
        result = processor.process_order("123", items)
        
        # Verify order was saved
        assert repository.save.called
        
        
        saved_order = repository.save.call_args[][]
         (saved_order.items) == 
    
     ():
        
        repository = Mock()
        repository.save.side_effect = DatabaseConnectionError()
        
        processor = OrderProcessor(repository)
        
         pytest.raises(OrderProcessingError):
            processor.process_order(, [CartItem(, )])
    
     ():
        
        repository = Mock()
        processor = OrderProcessor(repository)
        
        items = [
            CartItem(product_id=, quantity=, price=),
            CartItem(product_id=, quantity=, price=),
        ]
        
        order = processor.process_order(, items)
        
        
         order.total == 
    

     ():
        
        repository = Mock()
        processor = OrderProcessor(repository)
        
         pytest.raises(InvalidQuantityError):
            processor.process_order(
                ,
                [CartItem(, quantity)]
            )

Testing Async Code

import pytest
import asyncio
from unittest.mock import AsyncMock, patch


class TestAsyncUserService:
    """Test async user service."""
    
    @pytest.fixture
    def mock_repository(self):
        """Create async mock repository."""
        return AsyncMock()
    
    @pytest.fixture
    def mock_cache(self):
        """Create async mock cache."""
        return AsyncMock()
    
    @pytest.fixture
    async def service(self, mock_repository, mock_cache):
        """Create async service."""
        return AsyncUserService(
            repository=mock_repository,
            cache=mock_cache,
        )
    
    @pytest.mark.asyncio
    async def test_get_user_caches_result(
        self,
        service: AsyncUserService,
        mock_repository: AsyncMock,
        mock_cache: AsyncMock
    ):
        """Test that get_user caches results."""
        mock_cache.get.return_value = None
        mock_repository.find_by_id.return_value = Mock(
            id="123",
            name="Test User"
        )
        
        # Act
        result = await service.get_user("123")
        
        # Assert
        mock_cache.get.assert_called_once_with("user_123")
        mock_repository.find_by_id.assert_called_once_with()
        mock_cache..assert_called_once()
    

      ():
        
        cached_user = Mock(=, name=)
        mock_cache.get.return_value = cached_user
        
        result =  service.get_user()
        
        
        mock_repository.find_by_id.assert_not_called()
         result == cached_user
    

      ():
        
        mock_repository = AsyncMock()
        mock_repository.find_by_id.return_value = 
        mock_cache = AsyncMock()
        
        service = AsyncUserService(mock_repository, mock_cache)
        
        result =  service.get_user()
        
         result  

Test Fixtures

import pytest
from typing import Generator
from dataclasses import dataclass


@dataclass
class TestUser:
    """Test user fixture."""
    email: str = "[e-mail]"
    name: str = "Test User"
    password: str = "SecurePass123!"


@pytest.fixture
def test_user() -> TestUser:
    """Create test user."""
    return TestUser()


@pytest.fixture
def new_user(test_user) -> dict:
    """Create user data dict."""
    return {
        "email": test_user.email,
        "name": test_user.name,
        "password": test_user.password,
    }


@pytest.fixture
def authenticated_client(client, test_user):
    """Create authenticated API client."""
    token = generate_test_token(test_user.email)
    client.headers["Authorization"] = f"Bearer {token}"
    return client


@pytest.fixture(scope="session")
def database():
    """Create test database (session-scoped)."""
    db = create_test_database()
    yield db
    db.close()


@pytest.fixture
 ():
    
    session = database.new_session()
     session
    session.rollback()
    session.close()



 ():
    
    
    
    db_session.rollback()



 () -> :
    
     [
        {: , : , : },
        {: , : , : },
        {: , : , : },
    ]

Best Practices

1. Test one thing per test
   Each test should have one assertion

2. Use descriptive names
   test_user_creation_success
   test_should_raise_error_for_negative_quantity

3. Follow AAA pattern
   Arrange, Act, Assert

4. Don't test framework code
   Test your business logic

5. Use proper isolation
   Mock external dependencies

6. Test edge cases
   Empty inputs, nulls, boundaries

7. Parameterize repetitive tests
   Use @pytest.mark.parametrize

8. Use property-based testing
   Find edge cases automatically

9. Keep tests fast
   Fast tests run frequently

10. Make tests readable
    Clear intent, good names