copilot-instructions: Instructions file for GitHub Copilot

Unit and Integration Tests Instructions

Overview

This instruction file defines testing standards using pytest for Python projects.

Test Organization

tests/
├── unit/
│   ├── domain/
│   │   └── test_order.py
│   └── application/
│       └── test_use_cases.py
├── integration/
│   ├── test_repositories.py
│   └── test_api.py
├── e2e/
│   └── test_order_flow.py
├── conftest.py
└── fixtures/
    └── factories.py

Unit Tests

Test individual components in isolation without external dependencies.

import pytest
from uuid import uuid4
from domain.order import Order, OrderItem, Money

class TestOrder:
    """Test domain logic without dependencies"""

    def test_add_item_to_pending_order(self):
        # Arrange
        order = Order(id=uuid4(), customer_id=uuid4())
        price = Money(10.0, "USD")

        # Act
        order.add_item("product-1", quantity=2, price=price)

        # Assert
        assert len(order.items) == 1
        assert order.items[0].quantity == 2

    def test_cannot_add_item_to_confirmed_order(self):
        # Arrange
        order = Order(id=uuid4(), customer_id=uuid4(), status="CONFIRMED")
        price = Money(10.0, "USD")

        # Act & Assert
        with pytest.raises(ValueError, match="Cannot modify confirmed order"):
            order.add_item("product-1", quantity=1, price=price)

    def test_calculate_total_with_multiple_items(self):
        # Arrange
        order = Order(id=uuid4(), customer_id=uuid4())
        order.add_item("p1", 2, Money(10.0, "USD"))
        order.add_item("p2", 1, Money(15.0, "USD"))

        # Act
        total = order.calculate_total()

        # Assert
        assert total.amount == 35.0
        assert total.currency == "USD"

Integration Tests

Test interactions between components with real or in-memory infrastructure.

import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, Session
from infrastructure.repositories.order_repository import SqlAlchemyOrderRepository
from domain.order import Order

@pytest.fixture
def db_session():
    """In-memory database for testing"""
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    SessionLocal = sessionmaker(bind=engine)
    session = SessionLocal()

    yield session

    session.close()

class TestOrderRepository:
    """Test repository with real database"""

    def test_save_and_retrieve_order(self, db_session: Session):
        # Arrange
        repository = SqlAlchemyOrderRepository(db_session)
        order = Order(id=uuid4(), customer_id=uuid4())
        order.add_item("product-1", 1, Money(10.0, "USD"))

        # Act
        repository.save(order)
        retrieved = repository.get_by_id(order.id)

        # Assert
        assert retrieved is not None
        assert retrieved.id == order.id
        assert len(retrieved.items) == 1