Python Regression Test Generator

# Old version
def calculate_total(items):
    return sum(item.price for item in items)

# New version
def calculate_total(items, tax_rate=0.0):
    subtotal = sum(item.price for item in items)
    return subtotal * (1 + tax_rate)

def test_calculate_total():
    items = [Item(price=10), Item(price=20)]
    assert calculate_total(items) == 30

def test_calculate_total_no_tax():
    """Regression: ensure backward compatibility with no tax"""
    items = [Item(price=10), Item(price=20)]
    assert calculate_total(items) == 30  # Uses default tax_rate=0.0

def test_calculate_total_with_tax():
    """New: test tax calculation functionality"""
    items = [Item(price=10), Item(price=20)]
    assert calculate_total(items, tax_rate=0.1) == 33.0

def test_calculate_total_zero_tax():
    """Test explicit zero tax rate"""
    items = [Item(price=100)]
    assert calculate_total(items, tax_rate=0.0) == 100

def test_calculate_total_high_tax():
    """Test high tax rate"""
    items = [Item(price=100)]
    assert calculate_total(items, tax_rate=0.5) == 150

def test_calculate_total_empty_items():
    """Edge case: empty items list"""
    assert calculate_total([], tax_rate=0.1) == 0

def test_calculate_total_negative_tax():
    """Edge case: negative tax (discount)"""
    items = [Item(price=100)]
    assert calculate_total(items, tax_rate=-0.1) == 90

def send_notification(user_id, message):
    user = database.get_user(user_id)
    email_service.send_email(
        to=user.email,
        subject='Notification',
        body=message
    )
    return True

from unittest.mock import Mock, patch

def test_send_notification():
    """Test notification sending with mocked dependencies"""
    # Mock database
    mock_db = Mock()
    mock_user = Mock()
    mock_user.email = 'user@example.com'
    mock_db.get_user.return_value = mock_user

    # Mock email service
    with patch('myapp.email_service.send_email') as mock_send:
        mock_send.return_value = True

        with patch('myapp.database', mock_db):
            result = send_notification(user_id=123, message="Hello")

            assert result is True
            mock_db.get_user.assert_called_once_with(123)
            mock_send.assert_called_once_with(
                to='user@example.com',
                subject='Notification',
                body='Hello'
            )

class TestCalculateTotal(unittest.TestCase):
    def setUp(self):
        """Run before each test"""
        self.items = [
            Item(price=10),
            Item(price=20),
            Item(price=30)
        ]

    def test_no_tax(self):
        result = calculate_total(self.items)
        self.assertEqual(result, 60)

    def test_with_tax(self):
        result = calculate_total(self.items, tax_rate=0.1)
        self.assertAlmostEqual(result, 66.0)

@pytest.fixture
def items():
    """Fixture providing test items"""
    return [
        Item(price=10),
        Item(price=20),
        Item(price=30)
    ]

def test_no_tax(items):
    result = calculate_total(items)
    assert result == 60

def test_with_tax(items):
    result = calculate_total(items, tax_rate=0.1)
    assert result == pytest.approx(66.0)

class Calculator:
    def calculate_total(self, items):
        """Calculate total price of items"""
        return sum(item.price for item in items)

import unittest
from calculator import Calculator
from models import Item

class TestCalculator(unittest.TestCase):
    def test_calculate_total(self):
        calc = Calculator()
        items = [Item(price=10), Item(price=20)]
        result = calc.calculate_total(items)
        self.assertEqual(result, 30)

class Calculator:
    def calculate_total(self, items, tax_rate=0.0, discount=0.0):
        """Calculate total price with tax and discount"""
        if tax_rate < 0 or tax_rate > 1:
            raise ValueError("Tax rate must be between 0 and 1")
        if discount < 0 or discount > 1:
            raise ValueError("Discount must be between 0 and 1")

        subtotal = sum(item.price for item in items)
        after_discount = subtotal * (1 - discount)
        total = after_discount * (1 + tax_rate)
        return round(total, 2)

import unittest
from unittest.mock import Mock
from calculator import Calculator
from models import Item

class TestCalculator(unittest.TestCase):
    def setUp(self):
        """Set up test fixtures"""
        self.calc = Calculator()
        self.items = [Item(price=10), Item(price=20)]

    def test_calculate_total_backward_compatibility(self):
        """Regression: ensure old behavior still works"""
        result = self.calc.calculate_total(self.items)
        self.assertEqual(result, 30)

    def test_calculate_total_with_tax(self):
        """New: test tax calculation"""
        result = self.calc.calculate_total(self.items, tax_rate=0.1)
        self.assertAlmostEqual(result, 33.0)

    def test_calculate_total_with_discount(self):
        """New: test discount calculation"""
        result = self.calc.calculate_total(self.items, discount=0.2)
        self.assertAlmostEqual(result, 24.0)

    def test_calculate_total_with_tax_and_discount(self):
        """New: test combined tax and discount"""
        result = self.calc.calculate_total(
            self.items,
            tax_rate=0.1,
            discount=0.2
        )
        self.assertAlmostEqual(result, 26.4)

    def test_calculate_total_empty_items(self):
        """Edge case: empty items list"""
        result = self.calc.calculate_total([])
        self.assertEqual(result, 0)

    def test_calculate_total_invalid_tax_rate_negative(self):
        """Error case: negative tax rate"""
        with self.assertRaises(ValueError) as context:
            self.calc.calculate_total(self.items, tax_rate=-0.1)
        self.assertIn("Tax rate must be between 0 and 1", str(context.exception))

    def test_calculate_total_invalid_tax_rate_too_high(self):
        """Error case: tax rate > 1"""
        with self.assertRaises(ValueError):
            self.calc.calculate_total(self.items, tax_rate=1.5)

    def test_calculate_total_invalid_discount_negative(self):
        """Error case: negative discount"""
        with self.assertRaises(ValueError):
            self.calc.calculate_total(self.items, discount=-0.1)

    def test_calculate_total_invalid_discount_too_high(self):
        """Error case: discount > 1"""
        with self.assertRaises(ValueError):
            self.calc.calculate_total(self.items, discount=1.5)

if __name__ == '__main__':
    unittest.main()

def fetch_user_data(user_id):
    response = requests.get(f'https://api.example.com/users/{user_id}')
    return response.json()

def test_fetch_user_data():
    with patch('requests.get') as mock_get:
        mock_get.return_value.json.return_value = {'id': 1, 'name': 'Alice'}
        result = fetch_user_data(1)
        assert result['name'] == 'Alice'

async def fetch_user_data(user_id, include_posts=False):
    async with aiohttp.ClientSession() as session:
        url = f'https://api.example.com/users/{user_id}'
        if include_posts:
            url += '?include=posts'
        async with session.get(url) as response:
            return await response.json()

import pytest
from unittest.mock import AsyncMock, patch

@pytest.mark.asyncio
async def test_fetch_user_data_backward_compatibility():
    """Regression: basic user fetch still works"""
    with patch('aiohttp.ClientSession') as mock_session:
        mock_response = AsyncMock()
        mock_response.json.return_value = {'id': 1, 'name': 'Alice'}
        mock_session.return_value.__aenter__.return_value.get.return_value.__aenter__.return_value = mock_response

        result = await fetch_user_data(1)
        assert result['name'] == 'Alice'

@pytest.mark.asyncio
async def test_fetch_user_data_with_posts():
    """New: test include_posts parameter"""
    with patch('aiohttp.ClientSession') as mock_session:
        mock_response = AsyncMock()
        mock_response.json.return_value = {
            'id': 1,
            'name': 'Alice',
            'posts': [{'id': 1, 'title': 'Post 1'}]
        }
        mock_session.return_value.__aenter__.return_value.get.return_value.__aenter__.return_value = mock_response

        result = await fetch_user_data(1, include_posts=True)
        assert 'posts' in result
        assert len(result['posts']) == 1

@pytest.mark.asyncio
@pytest.mark.parametrize("user_id,include_posts", [
    (1, False),
    (1, True),
    (999, False),
])
async def test_fetch_user_data_parametrized(user_id, include_posts):
    """Parametrized test for various inputs"""
    with patch('aiohttp.ClientSession') as mock_session:
        mock_response = AsyncMock()
        mock_response.json.return_value = {'id': user_id, 'name': 'User'}
        mock_session.return_value.__aenter__.return_value.get.return_value.__aenter__.return_value = mock_response

        result = await fetch_user_data(user_id, include_posts=include_posts)
        assert result['id'] == user_id