# Example of a basic Python function to be tested
# my_module.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# Example of a basic pytest test file
# test_my_module.py

import pytest
from my_module import add, subtract

def test_add_function():
    # Assert that 1 + 2 equals 3
    assert add(1, 2) == 3
    # Assert with negative numbers
    assert add(-1, 1) == 0
    # Assert with zero
    assert add(0, 0) == 0

def test_subtract_function():
    # Assert that 5 - 3 equals 2
    assert subtract(5, 3) == 2
    # Assert with negative results
    assert subtract(3, 5) == -2
    # Assert with zero
    assert subtract(0, 0) == 0

# To run these tests locally, ensure pytest is installed:
# pip install pytest
# Navigate to the directory containing these files and run:
# pytest

# my_application/logic.py
def calculate_discount(price, discount_percentage):
    if not isinstance(price, (int, float)) or price < 0:
        raise ValueError("Price must be a non-negative number.")
    if not isinstance(discount_percentage, (int, float)) or not (0 <= discount_percentage <= 100):
        raise ValueError("Discount percentage must be between 0 and 100.")
    
    discount_amount = price * (discount_percentage / 100)
    return price - discount_amount

def get_product_details(product_id):
    # Simulate database or API call
    products = {
        "P101": {"name": "Laptop", "price": 1200},
        "P102": {"name": "Mouse", "price": 25}
    }
    return products.get(product_id)


# tests/test_logic.py
import pytest
from my_application.logic import calculate_discount, get_product_details

# --- Unit Tests ---

def test_calculate_discount_valid_inputs():
    assert calculate_discount(100, 10) == 90.0
    assert calculate_discount(200, 0) == 200.0
    assert calculate_discount(50, 100) == 0.0
    assert calculate_discount(99.99, 25) == 74.9925

def test_calculate_discount_invalid_price():
    with pytest.raises(ValueError, match="Price must be a non-negative number."):
        calculate_discount(-10, 10)
    with pytest.raises(ValueError, match="Price must be a non-negative number."):
        calculate_discount("abc", 10)

def test_calculate_discount_invalid_percentage():
    with pytest.raises(ValueError, match="Discount percentage must be between 0 and 100."):
        calculate_discount(100, -5)
    with pytest.raises(ValueError, match="Discount percentage must be between 0 and 100."):
        calculate_discount(100, 105)
    with pytest.raises(ValueError, match="Discount percentage must be between 0 and 100."):
        calculate_discount(100, "twenty")

# --- Integration Tests ---
# For get_product_details, we might mock actual database calls in a real scenario.
# For this example, we'll test its direct behavior based on predefined data.

def test_get_product_details_valid_id():
    details = get_product_details("P101")
    assert details is not None
    assert details["name"] == "Laptop"
    assert details["price"] == 1200

def test_get_product_details_invalid_id():
    details = get_product_details("P999")
    assert details is None

# --- Fixture Example (in tests/conftest.py) ---
# This file would be named 'conftest.py' and placed in the 'tests' directory

# import pytest

# @pytest.fixture
# def setup_test_data():
#     """Provides common test data for multiple tests."""
#     user_data = {"id": 1, "name": "Alice", "email": "alice@example.com"}
#     yield user_data
#     # Teardown logic can go here if needed after tests run

# Example usage in a test:
# def test_user_creation(setup_test_data):
#     # Use setup_test_data here
#     assert setup_test_data["name"] == "Alice"

# To run these tests:
# 1. Create directory structure: my_application/logic.py, tests/test_logic.py
# 2. (Optional) Create tests/conftest.py for fixtures.
# 3. From the project root (above my_application and tests), run 'pytest'.

# .github/workflows/python-ci.yml
# This YAML file defines a GitHub Actions workflow for Python CI.

name: Python CI Pipeline

on:
  push:
    branches:
      - main
      - develop
  pull_request:
    branches:
      - main
      - develop

jobs:
  build-and-test:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Python environment
      uses: actions/setup-python@v5
      with:
        python-version: '3.9' # Specify your target Python version
        cache: 'pip' # Cache pip dependencies for faster builds

    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install pytest # Add other dependencies like flake8, coverage, etc., here
        # Example for installing project-specific dependencies from requirements.txt:
        # pip install -r requirements.txt

    - name: Run Pytest tests
      run: |
        pytest # Execute all tests found by pytest

    # Example of linting (requires flake8 to be installed in 'Install dependencies')
    # - name: Run Flake8 linting
    #   run: |
    #     pip install flake8
    #     flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
    #     flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
    #     # The second flake8 command runs with exit-zero to not fail the build for warnings,
    #     # but still show statistics. Adjust as per your team's policy.

    # Example of code coverage (requires pytest-cov to be installed)
    # - name: Generate coverage report
    #   run: |
    #     pip install pytest-cov
    #     pytest --cov=./my_application --cov-report=xml --cov-report=term-missing
    #     # The --cov=./my_application specifies the directory to measure coverage for.
    #     # --cov-report=xml is useful for integrating with SonarQube or other tools.

# To use this example:
# 1. Create a directory '.github/workflows' in your project root.
# 2. Save the content above as 'python-ci.yml' inside that directory.
# 3. Ensure your Python code and tests are structured correctly (e.g., `my_application` and `tests` folders as in previous examples).
# 4. Push this file to your GitHub repository.

# .github/workflows/python-ci.yml (Enhanced section for coverage and linting)
# This builds upon the previous python-ci.yml example.

name: Python CI Pipeline

on:
  push:
    branches:
      - main
      - develop
  pull_request:
    branches:
      - main
      - develop

jobs:
  build-test-lint-coverage:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v4

    - name: Set up Python environment
      uses: actions/setup-python@v5
      with:
        python-version: '3.9'
        cache: 'pip'

    - name: Install dependencies (including testing, linting, and coverage tools)
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt # Ensure your project dependencies are listed here
        pip install pytest pytest-cov flake8 black # Install testing, coverage, and linting tools

    - name: Run Black formatter check (optional, but good for style consistency)
      run: |
        black --check . --diff
        # Use 'black .' to apply formatting automatically, but --check is better for CI

    - name: Run Flake8 linting
      run: |
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # This runs critical error checks. For style warnings, you might use --exit-zero
        # flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

    - name: Run Pytest tests and generate coverage report
      run: |
        # --cov=./src (or your main application directory) to specify coverage scope
        # --cov-report=xml generates a Cobertura XML report, useful for SonarQube, Codecov.io
        # --cov-report=term-missing displays missing lines in the console
        pytest --cov=./my_application --cov-report=xml --cov-report=term-missing

    # Example: Upload coverage report to Codecov.io (requires Codecov token or public repo)
    # - name: Upload coverage to Codecov
    #   uses: codecov/codecov-action@v3
    #   with:
    #     token: ${{ secrets.CODECOV_TOKEN }} # Use a secret for private repos
    #     # files: ./coverage.xml # Specify the path to your coverage report
    #     # verbose: true # Optional: enable verbose output for debugging

# To use this enhanced example:
# 1. Update your '.github/workflows/python-ci.yml' with these steps.
# 2. Ensure 'requirements.txt' contains your project's runtime dependencies.
# 3. Adjust '--cov=./my_application' to point to your actual application source directory.
# 4. (Optional) Set up Codecov.io integration for visual coverage reporting and historique.

# Example of how to structure a requirements.txt for a project
# requirements.txt

# Production dependencies
requests==2.28.1
Flask==2.2.2
SQLAlchemy==1.4.45

# Development and testing dependencies (often installed in a dev/test environment or CI)
# Using 'pip install -r requirements.txt -r requirements-dev.txt' is a common pattern
pytest==7.2.0
pytest-cov==4.0.0
flake8==6.0.0
black==22.10.0
# Other development tools like ipython, debuggers etc.

# .gitignore example to prevent committing generated files or virtual environments
# .gitignore

# Python bytecode
__pycache__/
*.pyc
*.pyd
*.pyo

# Virtual environment
venv/
.venv/
ENV/
env/

# IDE-specific files
.vscode/
.idea/

# Test results, coverage reports, build artifacts
.pytest_cache/
.coverage
htmlcov/
*.egg-info/
dist/
build/

# Local settings (often with sensitive data)
*.env
.env.local
*.ini

# Always keep your .gitignore comprehensive to maintain a clean repository.