# Run all tests
pytest

# Run with coverage
pytest --cov=app --cov-report=html

# Run specific test file
pytest tests/test_models.py

# Run with verbose output
pytest -v

# pytest.ini
[tool:pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts = 
    --cov=app
    --cov-report=term-missing
    --cov-report=html:htmlcov
    --strict-markers
    --disable-warnings
markers =
    unit: Unit tests
    integration: Integration tests
    slow: Slow running tests
    auth: Authentication tests

# tests/conftest.py
import pytest
import tempfile
import os
from app import create_app
from app.extensions import db
from app.models import User, Post, Category
from flask_login import login_user

@pytest.fixture(scope='session')
def app():
    """Create test application."""
    # Create temporary database
    db_fd, db_path = tempfile.mkstemp()
    
    app = create_app({
        'TESTING': True,
        'SQLALCHEMY_DATABASE_URI': f'sqlite:///{db_path}',
        'WTF_CSRF_ENABLED': False,
        'SECRET_KEY': 'test-secret-key'
    })
    
    with app.app_context():
        db.create_all()
        yield app
        
    # Cleanup
    os.close(db_fd)
    os.unlink(db_path)

@pytest.fixture
def client(app):
    """Create test client."""
    return app.test_client()

@pytest.fixture
def runner(app):
    """Create test CLI runner."""
    return app.test_cli_runner()

@pytest.fixture
def db_session(app):
    """Create database session for testing."""
    with app.app_context():
        connection = db.engine.connect()
        transaction = connection.begin()
        
        # Configure session to use the connection
        db.session.configure(bind=connection)
        
        yield db.session
        
        # Rollback transaction
        transaction.rollback()
        connection.close()
        db.session.remove()

@pytest.fixture
def user(db_session):
    """Create test user."""
    user = User(
        username='testuser',
        email='test@example.com',
        first_name='Test',
        last_name='User'
    )
    user.set_password('testpass123')
    user.save()
    return user

@pytest.fixture
def admin_user(db_session):
    """Create admin user."""
    admin = User(
        username='admin',
        email='admin@example.com',
        first_name='Admin',
        last_name='User',
        is_admin=True
    )
    admin.set_password('adminpass123')
    admin.save()
    return admin

@pytest.fixture
def category(db_session):
    """Create test category."""
    category = Category(
        name='Test Category',
        description='A test category'
    )
    category.save()
    return category

@pytest.fixture
def post(db_session, user, category):
    """Create test post."""
    post = Post(
        title='Test Post',
        content='This is a test post content.',
        slug='test-post',
        status='published',
        user_id=user.id,
        category_id=category.id
    )
    post.save()
    return post

@pytest.fixture
def auth_headers(user):
    """Create authentication headers."""
    # For API testing
    token = user.generate_auth_token()
    return {'Authorization': f'Bearer {token}'}

# tests/test_models.py
import pytest
from datetime import datetime
from app.models import User, Post, Category
from werkzeug.security import check_password_hash

class TestUser:
    """Test User model."""
    
    def test_user_creation(self, db_session):
        """Test user creation."""
        user = User(
            username='newuser',
            email='new@example.com',
            first_name='New',
            last_name='User'
        )
        user.set_password('password123')
        user.save()
        
        assert user.id is not None
        assert user.username == 'newuser'
        assert user.email == 'new@example.com'
        assert user.full_name == 'New User'
        assert user.is_active is True
        assert user.is_admin is False
        assert user.created_at is not None
    
    def test_password_hashing(self, user):
        """Test password hashing."""
        user.set_password('newpassword')
        assert user.password_hash != 'newpassword'
        assert check_password_hash(user.password_hash, 'newpassword')
        assert user.check_password('newpassword')
        assert not user.check_password('wrongpassword')
    
    def test_user_repr(self, user):
        """Test user string representation."""
        assert repr(user) == '<User testuser>'
    
    def test_user_to_dict(self, user):
        """Test user dictionary conversion."""
        user_dict = user.to_dict()
        assert 'username' in user_dict
        assert 'email' in user_dict
        assert 'password_hash' not in user_dict  # Should be excluded
    
    def test_user_relationsh