Testing and Debugging in Python

1import unittest
2
3# Example demonstrating different types of tests
4
5def add(a, b):
6    """Simple function to demonstrate testing"""
7    return a + b
8
9def divide(a, b):
10    """Function that can raise exceptions"""
11    if b == 0:
12        raise ValueError("Cannot divide by zero")
13    return a / b
14
15class Calculator:
16    """Class to demonstrate object testing"""
17    def __init__(self):
18        self.history = []
19
20    def calculate(self, operation, a, b):
21        if operation == "add":
22            result = add(a, b)
23        elif operation == "divide":
24            result = divide(a, b)
25        else:
26            raise ValueError("Unsupported operation")
27
28        self.history.append((operation, a, b, result))
29        return result
30
31# Unit Tests - Test individual functions
32class TestMathFunctions(unittest.TestCase):
33
34    def test_add_positive_numbers(self):
35        """Test adding positive numbers"""
36        self.assertEqual(add(2, 3), 5)
37        self.assertEqual(add(10, 20), 30)
38
39    def test_add_negative_numbers(self):
40        """Test adding negative numbers"""
41        self.assertEqual(add(-5, -3), -8)
42        self.assertEqual(add(-10, 5), -5)
43
44    def test_divide_valid_numbers(self):
45        """Test valid division"""
46        self.assertEqual(divide(10, 2), 5)
47        self.assertAlmostEqual(divide(7, 3), 2.333333, places=5)
48
49    def test_divide_by_zero(self):
50        """Test division by zero raises exception"""
51        with self.assertRaises(ValueError) as context:
52            divide(10, 0)
53        self.assertIn("Cannot divide by zero", str(context.exception))
54
55# Integration Tests - Test component interactions
56class TestCalculator(unittest.TestCase):
57
58    def setUp(self):
59        """Set up test fixtures before each test"""
60        self.calculator = Calculator()
61
62    def test_calculator_operations(self):
63        """Test calculator with various operations"""
64        # Test addition
65        result = self.calculator.calculate("add", 5, 3)
66        self.assertEqual(result, 8)
67
68        # Test division
69        result = self.calculator.calculate("divide", 15, 3)
70        self.assertEqual(result, 5)
71
72        # Check history tracking
73        self.assertEqual(len(self.calculator.history), 2)
74
75    def test_calculator_invalid_operation(self):
76        """Test calculator with invalid operation"""
77        with self.assertRaises(ValueError):
78            self.calculator.calculate("multiply", 5, 3)

1# TDD Example: Building a BankAccount class
2
3# STEP 1: Write failing test
4class TestBankAccount(unittest.TestCase):
5    def test_initial_balance(self):
6        account = BankAccount(100)
7        self.assertEqual(account.balance, 100)
8
9# STEP 2: Write minimal code to pass
10class BankAccount:
11    def __init__(self, initial_balance):
12        self.balance = initial_balance
13
14# STEP 3: Add more tests and refactor
15class TestBankAccountExpanded(unittest.TestCase):
16    def setUp(self):
17        self.account = BankAccount(1000)
18
19    def test_deposit(self):
20        self.account.deposit(200)
21        self.assertEqual(self.account.balance, 1200)
22
23    def test_withdraw_sufficient_funds(self):
24        self.account.withdraw(300)
25        self.assertEqual(self.account.balance, 700)
26
27    def test_withdraw_insufficient_funds(self):
28        with self.assertRaises(ValueError):
29            self.account.withdraw(1500)
30
31# Expanded implementation
32class BankAccount:
33    def __init__(self, initial_balance):
34        if initial_balance < 0:
35            raise ValueError("Initial balance cannot be negative")
36        self.balance = initial_balance
37
38    def deposit(self, amount):
39        if amount <= 0:
40            raise ValueError("Deposit amount must be positive")
41        self.balance += amount
42
43    def withdraw(self, amount):
44        if amount <= 0:
45            raise ValueError("Withdrawal amount must be positive")
46        if amount > self.balance:
47            raise ValueError("Insufficient funds")
48        self.balance -= amount

1import unittest
2from unittest.mock import Mock, patch, MagicMock
3import tempfile
4import os
5
6class TestUnittestFeatures(unittest.TestCase):
7    """Comprehensive demonstration of unittest features"""
8
9    @classmethod
10    def setUpClass(cls):
11        """Called once before all tests in the class"""
12        print("Setting up class-level resources")
13        cls.shared_resource = "Shared data"
14
15    @classmethod
16    def tearDownClass(cls):
17        """Called once after all tests in the class"""
18        print("Cleaning up class-level resources")
19
20    def setUp(self):
21        """Called before each test method"""
22        self.test_data = [1, 2, 3, 4, 5]
23        self.temp_file = tempfile.NamedTemporaryFile(delete=False)
24
25    def tearDown(self):
26        """Called after each test method"""
27        if os.path.exists(self.temp_file.name):
28            os.unlink(self.temp_file.name)
29
30    # Assertion Methods
31    def test_equality_assertions(self):
32        """Test various equality assertions"""
33        self.assertEqual(2 + 2, 4)
34        self.assertNotEqual(2 + 2, 5)
35        self.assertAlmostEqual(0.1 + 0.2, 0.3, places=7)
36
37    def test_boolean_assertions(self):
38        """Test boolean assertions"""
39        self.assertTrue(True)
40        self.assertFalse(False)
41        self.assertIs(None, None)
42        self.assertIsNot([], [])
43
44    def test_container_assertions(self):
45        """Test container-related assertions"""
46        self.assertIn(3, self.test_data)
47        self.assertNotIn(10, self.test_data)
48        self.assertListEqual([1, 2, 3], [1, 2, 3])
49        self.assertCountEqual([1, 2, 3], [3, 2, 1])  # Order doesn't matter
50
51    def test_exception_assertions(self):
52        """Test exception handling"""
53        with self.assertRaises(ZeroDivisionError):
54            1 / 0
55
56        with self.assertRaises(ValueError) as context:
57            int("not a number")
58
59        self.assertIn("invalid literal", str(context.exception))
60
61    def test_regex_assertions(self):
62        """Test regular expression assertions"""
63        text = "Hello, World!"
64        self.assertRegex(text, r"Hello.*World")
65        self.assertNotRegex(text, r"d+")  # No digits
66
67    def test_type_assertions(self):
68        """Test type-related assertions"""
69        self.assertIsInstance("hello", str)
70        self.assertNotIsInstance(123, str)
71
72    def test_custom_assertion_messages(self):
73        """Test custom assertion messages"""
74        value = 42
75        self.assertEqual(value, 42, f"Expected 42, but got {value}")
76
77    # Skip and Expected Failure
78    @unittest.skip("Demonstrating skipping")
79    def test_skipped(self):
80        """This test will be skipped"""
81        self.fail("This should not run")
82
83    @unittest.skipIf(os.name == "nt", "Not supported on Windows")
84    def test_skip_conditional(self):
85        """Skip based on condition"""
86        self.assertTrue(True)
87
88    @unittest.expectedFailure
89    def test_expected_failure(self):
90        """This test is expected to fail"""
91        self.assertEqual(1, 2)  # Will fail, but expected
92
93    # Subtests for parameterized testing
94    def test_subtests(self):
95        """Demonstrate subtests for parameterized testing"""
96        test_cases = [
97            (2, 3, 5),
98            (1, 1, 2),
99            (0, 5, 5),
100            (-1, 1, 0)
101        ]
102
103        for a, b, expected in test_cases:
104            with self.subTest(a=a, b=b, expected=expected):
105                self.assertEqual(a + b, expected)
106
107class TestMockingExamples(unittest.TestCase):
108    """Examples of mocking in tests"""
109
110    def test_simple_mock(self):
111        """Basic mock usage"""
112        # Create a mock object
113        mock_obj = Mock()
114
115        # Configure mock behavior
116        mock_obj.method.return_value = "mocked result"
117        mock_obj.property = "mocked property"
118
119        # Use the mock
120        result = mock_obj.method()
121        self.assertEqual(result, "mocked result")
122
123        # Verify mock was called
124        mock_obj.method.assert_called_once()
125
126    def test_mock_with_side_effects(self):
127        """Mock with side effects"""
128        mock_obj = Mock()
129
130        # Side effect that raises exception
131        mock_obj.risky_method.side_effect = ValueError("Mocked error")
132
133        with self.assertRaises(ValueError):
134            mock_obj.risky_method()
135
136        # Side effect with sequence of values
137        mock_obj.counter.side_effect = [1, 2, 3]
138
139        self.assertEqual(mock_obj.counter(), 1)
140        self.assertEqual(mock_obj.counter(), 2)
141        self.assertEqual(mock_obj.counter(), 3)
142
143    @patch('builtins.open', new_callable=unittest.mock.mock_open, read_data="file content")
144    def test_patch_decorator(self, mock_file):
145        """Using patch decorator"""
146        # The open function is mocked
147        with open("fake_file.txt", "r") as f:
148            content = f.read()
149
150        self.assertEqual(content, "file content")
151        mock_file.assert_called_once_with("fake_file.txt", "r")
152
153    def test_patch_context_manager(self):
154        """Using patch as context manager"""
155        with patch('os.path.exists') as mock_exists:
156            mock_exists.return_value = True
157
158            # Now os.path.exists always returns True
159            self.assertTrue(os.path.exists("any_path"))
160            mock_exists.assert_called_with("any_path")
161
162    def test_spec_mocking(self):
163        """Mock with spec to ensure interface compliance"""
164        # Mock that enforces the interface of a list
165        mock_list = Mock(spec=list)
166
167        # These will work (list has these methods)
168        mock_list.append("item")
169        mock_list.pop()
170
171        # This would raise AttributeError if uncommented
172        # mock_list.nonexistent_method()
173
174class FileProcessor:
175    """Example class for testing"""
176
177    def __init__(self, file_path):
178        self.file_path = file_path
179
180    def process_file(self):
181        """Process a file (example with external dependency)"""
182        if not os.path.exists(self.file_path):
183            raise FileNotFoundError(f"File {self.file_path} not found")
184
185        with open(self.file_path, 'r') as f:
186            content = f.read()
187
188        return content.upper()
189
190class TestFileProcessor(unittest.TestCase):
191    """Test FileProcessor with mocking"""
192
193    @patch('os.path.exists')
194    @patch('builtins.open', new_callable=unittest.mock.mock_open, read_data="hello world")
195    def test_process_file_success(self, mock_open, mock_exists):
196        """Test successful file processing"""
197        mock_exists.return_value = True
198
199        processor = FileProcessor("test.txt")
200        result = processor.process_file()
201
202        self.assertEqual(result, "HELLO WORLD")
203        mock_exists.assert_called_once_with("test.txt")
204        mock_open.assert_called_once_with("test.txt", 'r')
205
206    @patch('os.path.exists')
207    def test_process_file_not_found(self, mock_exists):
208        """Test file not found scenario"""
209        mock_exists.return_value = False
210
211        processor = FileProcessor("missing.txt")
212
213        with self.assertRaises(FileNotFoundError):
214            processor.process_file()

1# Test Suite Creation
2def create_test_suite():
3    """Create a custom test suite"""
4    suite = unittest.TestSuite()
5
6    # Add specific test cases
7    suite.addTest(TestUnittestFeatures('test_equality_assertions'))
8    suite.addTest(TestMockingExamples('test_simple_mock'))
9
10    # Add entire test classes
11    suite.addTests(unittest.TestLoader().loadTestsFromTestCase(TestFileProcessor))
12
13    return suite
14
15# Running tests programmatically
16if __name__ == '__main__':
17    # Run all tests in current module
18    unittest.main()
19
20    # Or run specific test suite
21    runner = unittest.TextTestRunner(verbosity=2)
22    suite = create_test_suite()
23    runner.run(suite)

1import pdb
2
3def buggy_function(numbers):
4    """Function with potential bugs for debugging demonstration"""
5    total = 0
6    for i, num in enumerate(numbers):
7        # Set breakpoint for debugging
8        pdb.set_trace()  # Execution will pause here
9
10        if i % 2 == 0:
11            total += num * 2
12        else:
13            total += num
14
15    return total
16
17# Alternative debugging approaches
18def debug_with_post_mortem():
19    """Demonstrate post-mortem debugging"""
20    try:
21        result = 10 / 0  # This will cause an error
22    except:
23        pdb.post_mortem()  # Drop into debugger at exception point
24
25# Using pdb in scripts
26if __name__ == "__main__":
27    # Start script in debugger
28    pdb.run('buggy_function([1, 2, 3, 4, 5])')
29
30# Common pdb commands:
31# n (next line)
32# s (step into function)
33# c (continue)
34# l (list current code)
35# p <variable> (print variable)
36# pp <variable> (pretty print)
37# w (where - show stack trace)
38# q (quit)

1import logging
2from functools import wraps
3
4# Configure logging
5logging.basicConfig(
6    level=logging.DEBUG,
7    format='%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
8    handlers=[
9        logging.FileHandler('debug.log'),
10        logging.StreamHandler()
11    ]
12)
13
14logger = logging.getLogger(__name__)
15
16def debug_decorator(func):
17    """Decorator to add debug logging to functions"""
18    @wraps(func)
19    def wrapper(*args, **kwargs):
20        logger.debug(f"Calling {func.__name__} with args={args}, kwargs={kwargs}")
21
22        try:
23            result = func(*args, **kwargs)
24            logger.debug(f"{func.__name__} returned: {result}")
25            return result
26        except Exception as e:
27            logger.error(f"{func.__name__} raised {type(e).__name__}: {e}")
28            raise
29
30    return wrapper
31
32class DatabaseConnection:
33    """Example class with comprehensive logging"""
34
35    def __init__(self, host, port):
36        self.host = host
37        self.port = port
38        self.connected = False
39        logger.info(f"DatabaseConnection created for {host}:{port}")
40
41    @debug_decorator
42    def connect(self):
43        """Simulate database connection"""
44        logger.debug(f"Attempting to connect to {self.host}:{self.port}")
45
46        # Simulate connection logic
47        if self.host == "localhost" and self.port == 5432:
48            self.connected = True
49            logger.info("Successfully connected to database")
50            return True
51        else:
52            logger.warning(f"Failed to connect to {self.host}:{self.port}")
53            return False
54
55    @debug_decorator
56    def execute_query(self, query):
57        """Execute database query with logging"""
58        if not self.connected:
59            logger.error("Cannot execute query: not connected")
60            raise ConnectionError("Database not connected")
61
62        logger.info(f"Executing query: {query[:50]}...")  # Log first 50 chars
63
64        # Simulate query execution
65        if "SELECT" in query.upper():
66            result = [(1, "John"), (2, "Jane")]
67            logger.debug(f"Query returned {len(result)} rows")
68            return result
69        else:
70            logger.warning(f"Unsupported query type: {query}")
71            return None
72
73# Usage example
74def demonstrate_logging():
75    db = DatabaseConnection("localhost", 5432)
76    db.connect()
77    db.execute_query("SELECT * FROM users")

1import sys
2import traceback
3import inspect
4from contextlib import contextmanager
5
6class DebugContext:
7    """Context manager for detailed debugging information"""
8
9    def __init__(self, name):
10        self.name = name
11        self.start_time = None
12
13    def __enter__(self):
14        import time
15        self.start_time = time.time()
16        print(f"[DEBUG] Entering {self.name}")
17
18        # Print current stack frame info
19        frame = inspect.currentframe().f_back
20        print(f"[DEBUG] Called from {frame.f_code.co_filename}:{frame.f_lineno}")
21        print(f"[DEBUG] Local variables: {list(frame.f_locals.keys())}")
22
23        return self
24
25    def __exit__(self, exc_type, exc_val, exc_tb):
26        import time
27        duration = time.time() - self.start_time
28
29        if exc_type:
30            print(f"[DEBUG] {self.name} failed after {duration:.4f}s")
31            print(f"[DEBUG] Exception: {exc_type.__name__}: {exc_val}")
32            self.print_detailed_traceback(exc_tb)
33        else:
34            print(f"[DEBUG] {self.name} completed successfully in {duration:.4f}s")
35
36    def print_detailed_traceback(self, tb):
37        """Print detailed traceback information"""
38        print("[DEBUG] Detailed traceback:")
39        for filename, lineno, name, line in traceback.extract_tb(tb):
40            print(f"[DEBUG]   File {filename}, line {lineno}, in {name}")
41            print(f"[DEBUG]     {line}")
42
43def debug_variable_state(*variables):
44    """Print detailed information about variables"""
45    frame = inspect.currentframe().f_back
46
47    for var_name in variables:
48        if var_name in frame.f_locals:
49            value = frame.f_locals[var_name]
50            print(f"[DEBUG] {var_name} = {repr(value)} (type: {type(value).__name__})")
51
52            # Additional info for collections
53            if hasattr(value, '__len__') and not isinstance(value, str):
54                print(f"[DEBUG]   Length: {len(value)}")
55
56            if hasattr(value, '__dict__'):
57                print(f"[DEBUG]   Attributes: {list(value.__dict__.keys())}")
58        else:
59            print(f"[DEBUG] {var_name} is not defined in local scope")
60
61class SmartAssert:
62    """Enhanced assertions with debugging information"""
63
64    @staticmethod
65    def assert_equal(actual, expected, message=""):
66        if actual != expected:
67            frame = inspect.currentframe().f_back
68            filename = frame.f_code.co_filename
69            lineno = frame.f_lineno
70
71            error_msg = f"""
72Assertion failed at {filename}:{lineno}
73Expected: {expected!r} (type: {type(expected).__name__})
74Actual:   {actual!r} (type: {type(actual).__name__})
75Message:  {message}
76
77Local variables:
78"""
79
80            for name, value in frame.f_locals.items():
81                if not name.startswith('_'):
82                    error_msg += f"  {name} = {repr(value)}
83"
84
85            raise AssertionError(error_msg)
86
87# Example usage of advanced debugging
88def complex_calculation(data):
89    """Function demonstrating advanced debugging techniques"""
90    with DebugContext("complex_calculation"):
91        debug_variable_state('data')
92
93        # Processing steps with debugging
94        filtered_data = [x for x in data if x > 0]
95        debug_variable_state('filtered_data')
96
97        if not filtered_data:
98            logger.warning("No positive numbers found in data")
99            return 0
100
101        # Calculate result
102        result = sum(filtered_data) / len(filtered_data)
103        debug_variable_state('result')
104
105        # Validate result
106        SmartAssert.assert_equal(type(result), float, "Result should be float")
107
108        return result
109
110# Memory debugging
111def debug_memory_usage():
112    """Monitor memory usage for debugging"""
113    import psutil
114    import os
115
116    process = psutil.Process(os.getpid())
117
118    def print_memory_info(label):
119        memory_info = process.memory_info()
120        print(f"[MEMORY] {label}: {memory_info.rss / 1024 / 1024:.2f} MB")
121
122    print_memory_info("Before operation")
123
124    # Simulate memory-intensive operation
125    large_list = [i for i in range(1000000)]
126
127    print_memory_info("After creating large list")
128
129    del large_list
130
131    print_memory_info("After deleting large list")
132
133# Exception debugging utilities
134def enhanced_exception_handler(exc_type, exc_value, exc_traceback):
135    """Enhanced exception handler for debugging"""
136    if issubclass(exc_type, KeyboardInterrupt):
137        sys.__excepthook__(exc_type, exc_value, exc_traceback)
138        return
139
140    print("
141" + "="*60)
142    print("UNHANDLED EXCEPTION DETECTED")
143    print("="*60)
144
145    print(f"Exception Type: {exc_type.__name__}")
146    print(f"Exception Message: {exc_value}")
147
148    print("
149Detailed Traceback:")
150    traceback.print_exception(exc_type, exc_value, exc_traceback)
151
152    print("
153Local Variables at Exception Point:")
154    frame = exc_traceback.tb_frame
155    for name, value in frame.f_locals.items():
156        try:
157            print(f"  {name} = {repr(value)}")
158        except:
159            print(f"  {name} = <could not represent>")
160
161    print("="*60)
162
163# Install the enhanced exception handler
164# sys.excepthook = enhanced_exception_handler

1# Example using coverage.py (would need to be installed)
2# Command line: pip install coverage
3# Usage: coverage run --source=. test_module.py
4#        coverage report
5#        coverage html
6
7import unittest
8from unittest.mock import patch
9
10class ShoppingCart:
11    """Example class for coverage analysis"""
12
13    def __init__(self):
14        self.items = []
15        self.discount_rate = 0.0
16
17    def add_item(self, name, price, quantity=1):
18        """Add item to cart"""
19        if price < 0:
20            raise ValueError("Price cannot be negative")
21        if quantity <= 0:
22            raise ValueError("Quantity must be positive")
23
24        item = {
25            'name': name,
26            'price': price,
27            'quantity': quantity,
28            'total': price * quantity
29        }
30        self.items.append(item)
31        return item
32
33    def remove_item(self, name):
34        """Remove item from cart"""
35        for i, item in enumerate(self.items):
36            if item['name'] == name:
37                return self.items.pop(i)
38        return None
39
40    def apply_discount(self, rate):
41        """Apply discount to entire cart"""
42        if not 0 <= rate <= 1:
43            raise ValueError("Discount rate must be between 0 and 1")
44        self.discount_rate = rate
45
46    def get_total(self):
47        """Calculate total cart value"""
48        subtotal = sum(item['total'] for item in self.items)
49        discount_amount = subtotal * self.discount_rate
50        return subtotal - discount_amount
51
52    def get_item_count(self):
53        """Get total number of items"""
54        return sum(item['quantity'] for item in self.items)
55
56    def is_empty(self):
57        """Check if cart is empty"""
58        return len(self.items) == 0
59
60    def clear(self):
61        """Clear all items from cart"""
62        self.items.clear()
63        self.discount_rate = 0.0
64
65    def apply_bulk_discount(self):
66        """Apply bulk discount for large orders"""
67        total_items = self.get_item_count()
68
69        if total_items >= 100:  # This line might not be covered
70            self.apply_discount(0.15)  # 15% discount
71        elif total_items >= 50:
72            self.apply_discount(0.10)  # 10% discount
73        elif total_items >= 20:
74            self.apply_discount(0.05)  # 5% discount
75        # No discount for less than 20 items
76
77class TestShoppingCartCoverage(unittest.TestCase):
78    """Test suite demonstrating different levels of coverage"""
79
80    def setUp(self):
81        self.cart = ShoppingCart()
82
83    def test_add_item_valid(self):
84        """Test adding valid items"""
85        item = self.cart.add_item("Apple", 1.50, 3)
86
87        self.assertEqual(item['name'], "Apple")
88        self.assertEqual(item['price'], 1.50)
89        self.assertEqual(item['quantity'], 3)
90        self.assertEqual(item['total'], 4.50)
91        self.assertEqual(len(self.cart.items), 1)
92
93    def test_add_item_invalid_price(self):
94        """Test adding item with negative price"""
95        with self.assertRaises(ValueError):
96            self.cart.add_item("Invalid", -1.0)
97
98    def test_add_item_invalid_quantity(self):
99        """Test adding item with invalid quantity"""
100        with self.assertRaises(ValueError):
101            self.cart.add_item("Invalid", 1.0, 0)
102
103        with self.assertRaises(ValueError):
104            self.cart.add_item("Invalid", 1.0, -1)
105
106    def test_remove_existing_item(self):
107        """Test removing existing item"""
108        self.cart.add_item("Apple", 1.50, 2)
109        removed_item = self.cart.remove_item("Apple")
110
111        self.assertIsNotNone(removed_item)
112        self.assertEqual(removed_item['name'], "Apple")
113        self.assertTrue(self.cart.is_empty())
114
115    def test_remove_nonexistent_item(self):
116        """Test removing non-existent item"""
117        self.cart.add_item("Apple", 1.50, 2)
118        removed_item = self.cart.remove_item("Orange")
119
120        self.assertIsNone(removed_item)
121        self.assertFalse(self.cart.is_empty())
122
123    def test_apply_valid_discount(self):
124        """Test applying valid discount"""
125        self.cart.add_item("Apple", 10.0, 1)
126        self.cart.apply_discount(0.1)  # 10% discount
127
128        self.assertEqual(self.cart.get_total(), 9.0)
129
130    def test_apply_invalid_discount(self):
131        """Test applying invalid discount rates"""
132        with self.assertRaises(ValueError):
133            self.cart.apply_discount(-0.1)  # Negative discount
134
135        with self.assertRaises(ValueError):
136            self.cart.apply_discount(1.5)  # > 100% discount
137
138    def test_get_total_empty_cart(self):
139        """Test total calculation for empty cart"""
140        self.assertEqual(self.cart.get_total(), 0.0)
141
142    def test_get_total_with_items(self):
143        """Test total calculation with items"""
144        self.cart.add_item("Apple", 1.50, 2)  # 3.00
145        self.cart.add_item("Orange", 2.00, 1)  # 2.00
146
147        self.assertEqual(self.cart.get_total(), 5.0)
148
149    def test_bulk_discount_small_order(self):
150        """Test bulk discount for small orders"""
151        # Add 10 items (less than 20)
152        for i in range(10):
153            self.cart.add_item(f"Item{i}", 1.0, 1)
154
155        self.cart.apply_bulk_discount()
156        self.assertEqual(self.cart.discount_rate, 0.0)  # No discount
157
158    def test_bulk_discount_medium_order(self):
159        """Test bulk discount for medium orders"""
160        # Add 25 items (>= 20, < 50)
161        for i in range(25):
162            self.cart.add_item(f"Item{i}", 1.0, 1)
163
164        self.cart.apply_bulk_discount()
165        self.assertEqual(self.cart.discount_rate, 0.05)  # 5% discount
166
167    def test_bulk_discount_large_order(self):
168        """Test bulk discount for large orders"""
169        # Add 60 items (>= 50, < 100)
170        for i in range(60):
171            self.cart.add_item(f"Item{i}", 1.0, 1)
172
173        self.cart.apply_bulk_discount()
174        self.assertEqual(self.cart.discount_rate, 0.10)  # 10% discount
175
176    # Note: The >= 100 items case is not tested, so that branch won't be covered
177
178    def test_clear_cart(self):
179        """Test clearing cart"""
180        self.cart.add_item("Apple", 1.50, 2)
181        self.cart.apply_discount(0.1)
182
183        self.cart.clear()
184
185        self.assertTrue(self.cart.is_empty())
186        self.assertEqual(self.cart.discount_rate, 0.0)
187        self.assertEqual(self.cart.get_total(), 0.0)
188
189# Coverage reporting utility
190class CoverageReporter:
191    """Utility to analyze test coverage"""
192
193    def __init__(self, source_files):
194        self.source_files = source_files
195        self.covered_lines = set()
196        self.total_lines = set()
197
198    def analyze_coverage(self, test_results):
199        """Analyze coverage from test results"""
200        # This is a simplified example
201        # Real coverage tools use more sophisticated techniques
202
203        coverage_data = {
204            'lines_covered': len(self.covered_lines),
205            'lines_total': len(self.total_lines),
206            'coverage_percentage': (len(self.covered_lines) / len(self.total_lines)) * 100
207        }
208
209        return coverage_data
210
211    def generate_coverage_report(self):
212        """Generate coverage report"""
213        print("Coverage Report")
214        print("=" * 50)
215
216        for file in self.source_files:
217            print(f"File: {file}")
218            # Analyze each file's coverage
219            # This would involve parsing the source and tracking execution
220            print(f"  Lines: 45/50 (90%)")
221            print(f"  Missing: 12, 18, 25")

1# Example of code quality analysis
2
3import ast
4import inspect
5from typing import List, Dict, Any
6
7class CodeQualityAnalyzer:
8    """Analyze code quality metrics"""
9
10    def __init__(self):
11        self.metrics = {}
12
13    def analyze_function_complexity(self, func):
14        """Analyze cyclomatic complexity of a function"""
15        source = inspect.getsource(func)
16        tree = ast.parse(source)
17
18        complexity = 1  # Base complexity
19
20        for node in ast.walk(tree):
21            # Count decision points
22            if isinstance(node, (ast.If, ast.While, ast.For, ast.Try,
23                               ast.With, ast.Assert, ast.Raise,
24                               ast.BoolOp, ast.Compare)):
25                complexity += 1
26
27        return {
28            'cyclomatic_complexity': complexity,
29            'function_name': func.__name__,
30            'lines_of_code': len(source.split('
31')),
32            'complexity_rating': self._get_complexity_rating(complexity)
33        }
34
35    def _get_complexity_rating(self, complexity):
36        """Rate complexity level"""
37        if complexity <= 5:
38            return "Low (Good)"
39        elif complexity <= 10:
40            return "Moderate"
41        elif complexity <= 15:
42            return "High (Review needed)"
43        else:
44            return "Very High (Refactor recommended)"
45
46    def analyze_class_design(self, cls):
47        """Analyze class design metrics"""
48        methods = [method for method in dir(cls)
49                  if callable(getattr(cls, method)) and not method.startswith('_')]
50
51        return {
52            'class_name': cls.__name__,
53            'public_methods': len(methods),
54            'total_attributes': len([attr for attr in dir(cls) if not attr.startswith('_')]),
55            'inheritance_depth': len(cls.__mro__) - 1,
56            'design_rating': self._get_design_rating(len(methods))
57        }
58
59    def _get_design_rating(self, method_count):
60        """Rate class design"""
61        if method_count <= 7:
62            return "Good (Focused responsibility)"
63        elif method_count <= 15:
64            return "Acceptable"
65        else:
66            return "Consider splitting (Too many responsibilities)"
67
68    def check_naming_conventions(self, obj):
69        """Check if naming follows Python conventions"""
70        name = obj.__name__
71        obj_type = type(obj).__name__
72
73        issues = []
74
75        if obj_type == 'function':
76            if not name.islower() or '_' not in name:
77                if len(name.split('_')) < 2 and len(name) > 3:
78                    issues.append("Function names should use snake_case")
79
80        elif obj_type == 'type':  # Class
81            if not name[0].isupper() or '_' in name:
82                issues.append("Class names should use PascalCase")
83
84        return {
85            'object_name': name,
86            'object_type': obj_type,
87            'naming_issues': issues,
88            'follows_convention': len(issues) == 0
89        }
90
91# Quality gates and continuous integration
92class QualityGate:
93    """Define quality gates for CI/CD"""
94
95    def __init__(self):
96        self.criteria = {
97            'test_coverage_minimum': 80.0,
98            'max_complexity_per_function': 10,
99            'max_methods_per_class': 15,
100            'max_line_length': 88,
101            'require_docstrings': True
102        }
103        self.results = []
104
105    def check_coverage_gate(self, coverage_percentage):
106        """Check if coverage meets minimum requirement"""
107        passed = coverage_percentage >= self.criteria['test_coverage_minimum']
108
109        result = {
110            'gate': 'test_coverage',
111            'passed': passed,
112            'actual': coverage_percentage,
113            'required': self.criteria['test_coverage_minimum'],
114            'message': f"Coverage: {coverage_percentage:.1f}% (required: {self.criteria['test_coverage_minimum']}%)"
115        }
116
117        self.results.append(result)
118        return passed
119
120    def check_complexity_gate(self, functions_complexity):
121        """Check if all functions meet complexity requirements"""
122        violations = []
123
124        for func_data in functions_complexity:
125            if func_data['cyclomatic_complexity'] > self.criteria['max_complexity_per_function']:
126                violations.append(func_data)
127
128        passed = len(violations) == 0
129
130        result = {
131            'gate': 'complexity',
132            'passed': passed,
133            'violations': violations,
134            'message': f"Complexity violations: {len(violations)} functions exceed limit of {self.criteria['max_complexity_per_function']}"
135        }
136
137        self.results.append(result)
138        return passed
139
140    def generate_quality_report(self):
141        """Generate comprehensive quality report"""
142        print("
143Code Quality Report")
144        print("=" * 50)
145
146        passed_gates = sum(1 for result in self.results if result['passed'])
147        total_gates = len(self.results)
148
149        print(f"Quality Gates: {passed_gates}/{total_gates} passed")
150        print()
151
152        for result in self.results:
153            status = "✓ PASS" if result['passed'] else "✗ FAIL"
154            print(f"{status} {result['gate'].upper()}: {result['message']}")
155
156            if 'violations' in result and result['violations']:
157                for violation in result['violations']:
158                    print(f"    - {violation['function_name']}: complexity {violation['cyclomatic_complexity']}")
159
160        overall_passed = passed_gates == total_gates
161        print(f"
162Overall Status: {'PASS' if overall_passed else 'FAIL'}")
163
164        return overall_passed
165
166# Example usage
167def example_quality_analysis():
168    """Demonstrate quality analysis"""
169    analyzer = CodeQualityAnalyzer()
170
171    # Analyze the ShoppingCart class
172    class_metrics = analyzer.analyze_class_design(ShoppingCart)
173    print(f"Class Analysis: {class_metrics}")
174
175    # Analyze a specific function
176    func_metrics = analyzer.analyze_function_complexity(ShoppingCart.apply_bulk_discount)
177    print(f"Function Analysis: {func_metrics}")
178
179    # Check naming conventions
180    naming_check = analyzer.check_naming_conventions(ShoppingCart)
181    print(f"Naming Check: {naming_check}")
182
183    # Quality gate example
184    gate = QualityGate()
185    gate.check_coverage_gate(85.5)  # Pass
186    gate.check_complexity_gate([func_metrics])  # May pass or fail
187    gate.generate_quality_report()