# To install pytest:
# pip install pytest

# --- my_module.py ---
# This is the module we will test.

def add(a: int, b: int) -> int:
    """Adds two numbers."""
    return a + b

def subtract(a: int, b: int) -> int:
    """Subtracts two numbers."""
    return a - b

# --- test_my_module.py ---
# This is our first pytest test file.

# A basic test function. Pytest discovers functions starting with 'test_'.
def test_add_positive_numbers():
    """Verifies correct addition of positive integers."""
    result = add(5, 3)
    assert result == 8, f"Expected 8, but got {result}"

# Another test case for subtraction.
def test_subtract_numbers():
    """Verifies correct subtraction of integers."""
    result = subtract(10, 4)
    assert result == 6, f"Expected 6, but got {result}"

# To run these tests from your terminal:
# pytest
# or for more verbose output:
# pytest -v

# --- user_service.py ---
# A simplified service to manage user data.

class User:
    def __init__(self, user_id: int, name: str, email: str):
        self.user_id = user_id
        self.name = name
        self.email = email

    def is_valid_email(self) -> bool:
        """Checks if the user's email is valid (simple validation)."""
        return "@" in self.email and "." in self.email

    def get_full_info(self) -> str:
        """Returns a formatted string of user information."""
        return f"ID: {self.user_id}, Name: {self.name}, Email: {self.email}"

# --- test_user_service.py ---
import pytest
from user_service import User

# Fixture: A reusable setup for tests.
# This 'user_data' fixture provides a common User object for tests.
@pytest.fixture
def sample_user() -> User:
    """Provides a sample User object for testing."""
    return User(1, "Alice", "alice@example.com")

# Test a method's logic in isolation.
def test_user_is_valid_email_valid(sample_user):
    """Verifies that is_valid_email returns True for a valid email."""
    assert sample_user.is_valid_email() is True

def test_user_is_valid_email_invalid():
    """Verifies that is_valid_email returns False for an invalid email."""
    user = User(2, "Bob", "bob.example.com") # Missing '@'
    assert user.is_valid_email() is False

def test_user_get_full_info(sample_user):
    """Verifies the correct formatting of user information."""
    expected_info = "ID: 1, Name: Alice, Email: alice@example.com"
    assert sample_user.get_full_info() == expected_info

# Parameterized test using @pytest.mark.parametrize
@pytest.mark.parametrize(
    "email, expected",
    [ ("test@domain.com", True),
      ("invalid-email.com", False),
      ("user@sub.domain.co", True),
      ("user@.com", False)
    ]
)
def test_is_valid_email_parameterized(email, expected):
    """Tests email validation with various inputs using parametrization."""
    user = User(99, "Tester", email)
    assert user.is_valid_email() == expected

# To run these tests:
# pytest test_user_service.py

# --- database_connector.py ---
# A simulated database connector.

class DatabaseConnector:
    def __init__(self, db_name: str):
        self.db_name = db_name
        self.connected = False
        print(f"[DB] Initializing {db_name} connector...")

    def connect(self) -> bool:
        # Simulate a connection attempt
        self.connected = True
        print(f"[DB] Connected to {self.db_name}")
        return True

    def disconnect(self):
        # Simulate disconnection
        self.connected = False
        print(f"[DB] Disconnected from {self.db_name}")

    def fetch_data(self, query: str) -> list:
        if not self.connected:
            raise ConnectionError("Not connected to database.")
        # Simulate fetching data
        print(f"[DB] Fetching data for query: {query}")
        if "users" in query:
            return [{"id": 1, "name": "Alice"}, {"id": 2, "name": "Bob"}]
        return []

# --- application_service.py ---
# A service that uses the database connector.

from database_connector import DatabaseConnector

class ApplicationService:
    def __init__(self, db_connector: DatabaseConnector):
        self.db = db_connector

    def get_all_users(self) -> list:
        if not self.db.connected:
            self.db.connect()
        data = self.db.fetch_data("SELECT * FROM users")
        self.db.disconnect() # Disconnect after operation
        return data

# --- test_integration.py ---
import pytest
from unittest.mock import MagicMock, patch
from database_connector import DatabaseConnector
from application_service import ApplicationService

# Fixture for a real (but simplified) DB connector
@pytest.fixture(scope="module") # Use 'module' scope for resources expensive to setup
def real_db_connector():
    """Provides a real database connector for integration tests."""
    connector = DatabaseConnector("test_db")
    # In a real scenario, this would set up a temporary test database.
    connector.connect()
    yield connector # The test runs here
    connector.disconnect()
    # In a real scenario, this would clean up the test database.

# Test the interaction between ApplicationService and DatabaseConnector
def test_application_service_get_all_users_real_db(real_db_connector):
    """Tests ApplicationService with a 'real' (simulated) database connector."""
    service = ApplicationService(real_db_connector)
    users = service.get_all_users()
    assert len(users) == 2
    assert users[0]["name"] == "Alice"
    assert real_db_connector.connected is False # Verify disconnection

# Fixture for a mocked DB connector
@pytest.fixture
def mock_db_connector():
    """Provides a mocked database connector to isolate ApplicationService further."""
    mock = MagicMock(spec=DatabaseConnector) # Ensure mock has same interface as real object
    mock.connected = False
    mock.connect.return_value = True
    mock.fetch_data.return_value = [{"id": 10, "name": "Charlie"}]
    mock.disconnect.return_value = None
    return mock

# Test with a mocked database for scenarios where you don't need a real DB interaction.
# This is borderline unit/integration depending on definition, useful for validating service logic.
def test_application_service_get_all_users_mock_db(mock_db_connector):
    """Tests ApplicationService with a mocked database connector."""
    service = ApplicationService(mock_db_connector)
    users = service.get_all_users()

    assert len(users) == 1
    assert users[0]["name"] == "Charlie"
    mock_db_connector.connect.assert_called_once() # Verify connect was called
    mock_db_connector.fetch_data.assert_called_once_with("SELECT * FROM users")
    mock_db_connector.disconnect.assert_called_once()

# To run these tests:
# pytest test_integration.py

# --- advanced_features.py ---

import pytest

# Custom marker example
@pytest.mark.slow
def test_long_running_computation():
    """Simulates a test that takes a long time."""
    import time
    time.sleep(2) # Simulate heavy computation
    assert True

# Another custom marker
@pytest.mark.network
def test_external_api_call():
    """Simulates a test that requires network access."""
    # Imagine actual network call here
    assert True

# To run only 'slow' tests:
# pytest -m slow

# To run tests that are NOT 'slow':
# pytest -m "not slow"

# To run 'network' tests:
# pytest -m network

# You can also register markers in pytest.ini for better visibility and avoiding warnings:
# [pytest]
# markers =
#     slow: marks tests as slow to run
#     network: marks tests that require network access

# --- conftest.py ---
# This file is automatically discovered by pytest and contains fixtures and hooks.
# It allows for sharing fixtures across multiple test files.

import pytest

@pytest.fixture(scope="session")
def app_config():
    """Provides application configuration available across all tests in a session."""
    # Simulate loading configuration from a file or environment variables
    config = {
        "DATABASE_URL": "sqlite:///test.db",
        "API_KEY": "mock_api_key_123"
    }
    print("\n[SETUP] Application configuration loaded.")
    yield config
    print("\n[TEARDOWN] Application configuration cleaned up (if any).")

# Example of using a fixture from conftest.py in a test file (e.g., test_settings.py)
# Assuming test_settings.py is in the same directory as conftest.py

# --- test_settings.py ---

# from conftest import app_config # Not needed, pytest finds it automatically

def test_database_url_is_present(app_config):
    """Verifies that the database URL is correctly configured."""
    assert "DATABASE_URL" in app_config
    assert app_config["DATABASE_URL"] == "sqlite:///test.db"

def test_api_key_is_set(app_config):
    """Verifies that the API key is correctly configured."""
    assert "API_KEY" in app_config
    assert app_config["API_KEY"] == "mock_api_key_123"

# To run these tests:
# pytest