AI-Powered Development Tools

# You type:
# Function to validate email addresses using regex

# Copilot suggests:
import re

def validate_email(email):
    """
    Validate email address format.

    Args:
        email: Email address to validate

    Returns:
        bool: True if valid email format, False otherwise
    """
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))


# Result: Complete, working function from a single comment!

# You type:
class User:
    def __init__(self, name, email):

# Copilot suggests:
        self.name = name
        self.email = email
        self.created_at = datetime.now()
        self.id = str(uuid.uuid4())

    def __repr__(self):
        return f"User(name={self.name}, email={self.email})"

    def to_dict(self):
        return {
            "id": self.id,
            "name": self.name,
            "email": self.email,
            "created_at": self.created_at.isoformat()
        }


# Copilot often suggests standard methods and patterns

# You have this function:
def calculate_discount(price, discount_percent):
    """Calculate final price after discount."""
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Discount must be between 0 and 100")
    return price * (1 - discount_percent / 100)


# You type:
def test_calculate_discount():

# Copilot suggests complete test:
    # Test normal discount
    assert calculate_discount(100, 20) == 80
    assert calculate_discount(50, 10) == 45

    # Test edge cases
    assert calculate_discount(100, 0) == 100
    assert calculate_discount(100, 100) == 0

    # Test invalid input
    with pytest.raises(ValueError):
        calculate_discount(100, -10)

    with pytest.raises(ValueError):
        calculate_discount(100, 150)


# Copilot often generates comprehensive tests from function signature

# Step 1: Plan manually (AI can't understand your requirements)
"""
Requirements:
- Track requests per user
- Limit: 100 requests per 60 seconds
- Return 429 status when limit exceeded
- Store in Redis (fast, distributed)
- Reset counter after window expires
"""


# Step 2: Write comment for implementation
# AI-powered rate limiter using Redis
# - Track requests per user in Redis
# - Sliding window: count requests in last 60 seconds
# - Return True if allowed, False if rate limited
# - Handle Redis connection errors gracefully


# Step 3: Let Copilot suggest implementation
import redis
import time
from typing import Tuple

def check_rate_limit(user_id: str, redis_client: redis.Redis) -> Tuple[bool, int]:
    """
    Check if user has exceeded rate limit.

    Args:
        user_id: Unique user identifier
        redis_client: Redis connection

    Returns:
        Tuple of (allowed: bool, remaining: int)
    """
    # Copilot suggests:
    key = f"rate_limit:{user_id}"
    current_time = time.time()
    window = 60  # seconds
    limit = 100

    try:
        # Remove old entries outside the window
        redis_client.zremrangebyscore(key, 0, current_time - window)

        # Count current requests in window
        current_count = redis_client.zcard(key)

        if current_count < limit:
            # Add this request
            redis_client.zadd(key, {str(current_time): current_time})
            redis_client.expire(key, window)
            return True, limit - current_count - 1
        else:
            return False, 0

    except redis.RedisError as e:
        # Log error, but allow request (fail open)
        print(f"Redis error: {e}")
        return True, -1


# Step 4: Review the suggestion
# ✅ Good: Uses Redis sorted sets (efficient)
# ✅ Good: Cleans up old entries
# ✅ Good: Handles Redis errors
# ✅ Good: Returns remaining count
# ⚠️  Issue: Doesn't handle atomic operations properly
# ⚠️  Issue: Race condition between check and add


# Step 5: Improve with AI's help
# Prompt: "This has a race condition. Use Redis pipeline for atomic operations"

def check_rate_limit_improved(user_id: str, redis_client: redis.Redis) -> Tuple[bool, int]:
    """Rate limit with atomic operations."""
    key = f"rate_limit:{user_id}"
    current_time = time.time()
    window = 60
    limit = 100

    try:
        # Use pipeline for atomic operations
        pipe = redis_client.pipeline()

        # Remove old entries
        pipe.zremrangebyscore(key, 0, current_time - window)

        # Add current request
        pipe.zadd(key, {str(current_time): current_time})

        # Set expiry
        pipe.expire(key, window)

        # Count requests
        pipe.zcard(key)

        # Execute atomically
        results = pipe.execute()
        current_count = results[-1]  # Last result is the count

        if current_count <= limit:
            return True, limit - current_count
        else:
            # Remove the request we just added
            redis_client.zrem(key, str(current_time))
            return False, 0

    except redis.RedisError as e:
        print(f"Redis error: {e}")
        return True, -1  # Fail open


# Step 6: Generate tests with AI
# Prompt: "Generate pytest tests for check_rate_limit_improved"

import pytest
from unittest.mock import Mock, patch
import time

def test_rate_limit_allows_under_limit():
    """Test requests are allowed when under limit."""
    mock_redis = Mock()
    mock_redis.pipeline.return_value.execute.return_value = [None, None, None, 50]

    allowed, remaining = check_rate_limit_improved("user123", mock_redis)

    assert allowed is True
    assert remaining == 50

def test_rate_limit_blocks_over_limit():
    """Test requests are blocked when over limit."""
    mock_redis = Mock()
    mock_redis.pipeline.return_value.execute.return_value = [None, None, None, 101]

    allowed, remaining = check_rate_limit_improved("user123", mock_redis)

    assert allowed is False
    assert remaining == 0

def test_rate_limit_handles_redis_error():
    """Test graceful handling of Redis errors."""
    mock_redis = Mock()
    mock_redis.pipeline.side_effect = redis.RedisError("Connection failed")

    allowed, remaining = check_rate_limit_improved("user123", mock_redis)

    # Should fail open
    assert allowed is True
    assert remaining == -1


# Step 7: Manual review and add domain-specific tests
def test_rate_limit_sliding_window():
    """Test sliding window properly expires old requests."""
    # This test requires actual Redis or more complex mocking
    # Add based on your specific needs
    pass


# Step 8: Add integration into API (manual)
from flask import Flask, jsonify, request

app = Flask(__name__)
redis_client = redis.Redis(host='localhost', port=6379)

@app.before_request
def rate_limit_middleware():
    user_id = request.headers.get('X-User-ID')
    if not user_id:
        return jsonify({"error": "Missing user ID"}), 400

    allowed, remaining = check_rate_limit_improved(user_id, redis_client)

    if not allowed:
        return jsonify({
            "error": "Rate limit exceeded",
            "retry_after": 60
        }), 429

    # Add headers for client
    request.rate_limit_remaining = remaining


# Result: Complete, tested, production-ready rate limiter
# - AI helped with implementation and tests
# - You reviewed for correctness and security
# - Manual integration and business logic