Integration Test Generator

import pytest
from myapp.services import ServiceA, ServiceB

class TestServiceIntegration:
    """Test integration between ServiceA and ServiceB."""

    @pytest.fixture
    def service_a(self):
        """Setup ServiceA with test configuration."""
        return ServiceA(config={"mode": "test"})

    @pytest.fixture
    def service_b(self, service_a):
        """Setup ServiceB that depends on ServiceA."""
        return ServiceB(service_a=service_a)

    def test_services_communicate_correctly(self, service_a, service_b):
        """Test that ServiceB correctly uses ServiceA."""
        # Arrange
        test_data = {"key": "value"}

        # Act
        service_a.store(test_data)
        result = service_b.process()

        # Assert
        assert result["key"] == "value"
        assert result["processed"] is True

@pytest.fixture(scope="function")
def db_session():
    """Create a fresh database for each test."""
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()

    yield session  # Test runs here

    session.close()

@pytest.fixture
def test_user(db_session):
    """Create a test user and clean up after test."""
    user = User(username="testuser", email="test@example.com")
    db_session.add(user)
    db_session.commit()

    yield user

    db_session.delete(user)
    db_session.commit()

def test_create_user_then_create_order(test_client):
    # Create user
    user_response = test_client.post("/api/users", json={"username": "test"})
    user_id = user_response.json()["id"]

    # Create order for user
    order_response = test_client.post(
        "/api/orders",
        json={"user_id": user_id, "items": [...]}
    )

    # Verify integration
    assert order_response.status_code == 201
    assert order_response.json()["user_id"] == user_id

def test_user_order_relationship(db_session, user_repo, order_repo):
    # Create user
    user = user_repo.create(username="test")
    db_session.commit()

    # Create orders
    order1 = order_repo.create(user_id=user.id, total=50.00)
    order2 = order_repo.create(user_id=user.id, total=75.00)
    db_session.commit()

    # Verify relationship
    retrieved_user = user_repo.get_by_id(user.id)
    assert len(retrieved_user.orders) == 2

import responses

@responses.activate
def test_payment_integration():
    # Mock external payment API
    responses.add(
        responses.POST,
        "https://api.payment.com/charge",
        json={"transaction_id": "txn_123", "status": "success"},
        status=200
    )

    # Test integration
    payment_service = PaymentService()
    result = payment_service.charge(amount=99.99, card_token="tok_test")

    assert result["status"] == "success"
    assert len(responses.calls) == 1

@pytest.fixture(scope="function")  # New instance per test
def db_session():
    # Fresh database for each test
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    # ...

@pytest.fixture
def test_resource():
    # Setup
    resource = create_resource()

    yield resource

    # Teardown - always runs even if test fails
    delete_resource(resource)

def make_user(username="test", **kwargs):
    defaults = {"email": f"{username}@example.com", "is_active": True}
    return User(**{**defaults, **kwargs, "username": username})

# Usage
admin = make_user("admin", role="admin")
inactive = make_user("inactive", is_active=False)

def test_complete_checkout_workflow(test_client, db_session):
    # 1. Create user
    user = create_test_user()

    # 2. Add items to cart
    add_to_cart(user.id, product_id=1, quantity=2)

    # 3. Checkout
    order = checkout(user.id, payment_method="credit_card")

    # 4. Verify all integrations
    assert order.status == "confirmed"
    assert order.user_id == user.id
    assert len(order.items) == 1
    assert get_cart(user.id).items == []  # Cart emptied

from unittest.mock import Mock, patch

def test_with_mocked_email_service():
    with patch('myapp.services.EmailService') as mock_email:
        mock_email.send.return_value = {"message_id": "123"}

        # Test code that uses email service
        result = send_confirmation_email("user@example.com")

        # Verify mock was called correctly
        mock_email.send.assert_called_once()
        assert result["message_id"] == "123"

# Run all integration tests
pytest tests/integration/

# Run specific test file
pytest tests/integration/test_user_order.py

# Run tests matching pattern
pytest -k "test_integration"

# Run with verbose output
pytest -v tests/integration/

# Run with coverage
pytest --cov=myapp tests/integration/

# Database session
@pytest.fixture(scope="function")
def db_session():
    """Fresh database for each test."""

# Test client for API testing
@pytest.fixture
def test_client():
    """Test client for FastAPI/Flask app."""
    with TestClient(app) as client:
        yield client

# Mock external service
@pytest.fixture
def mock_payment_gateway():
    with patch('myapp.services.PaymentGateway') as mock:
        yield mock

# Verify status codes
assert response.status_code == 201

# Verify data structure
assert "id" in response.json()
assert len(response.json()["items"]) == 2

# Verify relationships
assert order.user_id == user.id
assert user.orders[0].id == order.id

# Verify side effects
assert email_service.send.called
assert db_session.query(Order).count() == 1