15. Testing & Quality Assurance

import pytest
from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)

def test_bulk_upload_csv():
    """Test CSV file upload."""
    csv_content = b"amount,currency,mode\n1000,INR,greedy\n2500,USD,balanced"
    
    files = {"file": ("test.csv", csv_content, "text/csv")}
    response = client.post("/api/v1/bulk/upload", files=files)
    
    assert response.status_code == 200
    data = response.json()
    assert data["total_rows"] == 2
    assert data["successful_rows"] == 2

def test_ocr_image():
    """Test image OCR processing."""
    with open("test_image.jpg", "rb") as f:
        files = {"file": ("test.jpg", f, "image/jpeg")}
        response = client.post("/api/v1/ocr/process", files=files)
    
    assert response.status_code == 200
    data = response.json()
    assert "extracted_text" in data
    assert len(data["detected_amounts"]) > 0

def test_calculate_endpoint():
    """Test single calculation endpoint."""
    payload = {
        "amount": 1850.50,
        "currency": "INR",
        "mode": "greedy"
    }
    
    response = client.post("/api/v1/calculate", json=payload)
    
    assert response.status_code == 200
    data = response.json()
    assert data["amount"] == 1850.50
    assert data["currency"] == "INR"
    assert len(data["breakdown"]) > 0
    assert data["summary"]["total_pieces"] > 0

def test_invalid_amount():
    """Test validation for invalid amount."""
    payload = {
        "amount": -100,  # Negative amount
        "currency": "INR",
        "mode": "greedy"
    }
    
    response = client.post("/api/v1/calculate", json=payload)
    
    assert response.status_code == 400
    assert "error" in response.json()

def test_invalid_currency():
    """Test validation for invalid currency."""
    payload = {
        "amount": 1000,
        "currency": "INVALID",
        "mode": "greedy"
    }
    
    response = client.post("/api/v1/calculate", json=payload)
    
    assert response.status_code == 400

def test_history_pagination():
    """Test history endpoint pagination."""
    response = client.get("/api/v1/history?page=1&per_page=10")
    
    assert response.status_code == 200
    data = response.json()
    assert "items" in data
    assert "total" in data
    assert "page" in data
    assert "pages" in data

import unittest
from decimal import Decimal
from engine import DenominationEngine

class TestDenominationEngine(unittest.TestCase):
    
    def setUp(self):
        """Set up test fixtures."""
        self.engine = DenominationEngine()
    
    def test_greedy_algorithm_basic(self):
        """Test greedy algorithm with basic amount."""
        result = self.engine.calculate(
            amount=Decimal("1850.50"),
            currency="INR",
            mode="greedy"
        )
        
        self.assertEqual(result["amount"], 1850.50)
        self.assertEqual(result["currency"], "INR")
        self.assertIsInstance(result["breakdown"], list)
        self.assertGreater(len(result["breakdown"]), 0)
    
    def test_all_modes(self):
        """Test all calculation modes."""
        amount = Decimal("3000")
        modes = ["greedy", "balanced", "minimize_large", "minimize_small"]
        
        for mode in modes:
            result = self.engine.calculate(amount, "INR", mode)
            self.assertEqual(result["mode"], mode)
            self.assertIsNotNone(result["breakdown"])
    
    def test_all_currencies(self):
        """Test all supported currencies."""
        currencies = ["INR", "USD", "EUR", "GBP"]
        
        for currency in currencies:
            result = self.engine.calculate(
                Decimal("100"),
                currency,
                "greedy"
            )
            self.assertEqual(result["currency"], currency)
    
    def test_edge_case_small_amount(self):
        """Test with smallest denomination."""
        result = self.engine.calculate(
            Decimal("0.01"),
            "INR",
            "greedy"
        )
        
        self.assertEqual(len(result["breakdown"]), 1)
    
    def test_edge_case_large_amount(self):
        """Test with very large amount."""
        result = self.engine.calculate(
            Decimal("999999999"),
            "INR",
            "greedy"
        )
        
        self.assertIsNotNone(result["breakdown"])
        self.assertGreater(result["summary"]["total_pieces"], 0)
    
    def test_summary_calculation(self):
        """Test summary statistics."""
        result = self.engine.calculate(
            Decimal("1850"),
            "INR",
            "greedy"
        )
        
        summary = result["summary"]
        self.assertIn("total_pieces", summary)
        self.assertIn("total_notes", summary)
        self.assertIn("total_coins", summary)
        self.assertIn("total_denominations", summary)
        
        # Verify math
        total_from_breakdown = sum(
            item["count"] for item in result["breakdown"]
        )
        self.assertEqual(summary["total_pieces"], total_from_breakdown)

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

Backend API Tests

cd packages/local-backend
python -m pytest test_ocr_api.py -v

Core Engine Tests

cd packages/core-engine
python -m pytest test_engine.py -v

Run All Tests

# From project root
python -m pytest --tb=short -v

With Coverage

python -m pytest --cov=app --cov-report=html

Backend (Python)

Module	Statements	Missing	Coverage
engine.py	150	8	95%
api/calculate.py	80	10	88%
api/bulk.py	120	18	85%
services/ocr_processor.py	200	35	83%
models.py	60	12	80%

Overall: 87% (Target: 90%)

Purpose: Test individual functions and methods in isolation

Examples

• Test greedy algorithm with specific amount
• Test currency validation function
• Test denomination sorting
• Test summary calculation

Coverage

Should cover all calculation modes, edge cases, and error conditions

Purpose: Test interaction between multiple components

Examples

• API endpoint → Engine → Database
• File upload → OCR → Parsing → Calculation
• Settings update → Database → API response

Test Cases

def test_end_to_end_calculation():
    """Test complete flow from API to database."""
    # 1. Make calculation request
    response = client.post("/api/v1/calculate", json={
        "amount": 1850,
        "currency": "INR",
        "mode": "greedy"
    })
    
    # 2. Verify response
    assert response.status_code == 200
    calculation_id = response.json()["calculation_id"]
    
    # 3. Verify saved to database
    history = client.get(f"/api/v1/history/{calculation_id}")
    assert history.status_code == 200
    assert history.json()["amount"] == 1850

Purpose: Test all API endpoints with various inputs

Test Matrix

Endpoint	Valid Input	Invalid Input	Edge Cases
/calculate	✓	✓	✓
/bulk/upload	✓	✓	✓
/history	✓	✓	✓
/settings	✓	✓	✓

Purpose: Verify system meets performance requirements

Test Script

import time

def test_single_calculation_performance():
    """Single calculation should complete in < 1ms."""
    start = time.perf_counter()
    
    result = engine.calculate(
        Decimal("1850"),
        "INR",
        "greedy"
    )
    
    end = time.perf_counter()
    duration_ms = (end - start) * 1000
    
    assert duration_ms < 1.0, f"Took {duration_ms}ms (limit: 1ms)"

def test_bulk_calculation_performance():
    """100 calculations should complete in < 100ms."""
    start = time.perf_counter()
    
    for i in range(100):
        engine.calculate(
            Decimal(str(1000 + i)),
            "INR",
            "greedy"
        )
    
    end = time.perf_counter()
    duration_ms = (end - start) * 1000
    
    assert duration_ms < 100, f"Took {duration_ms}ms (limit: 100ms)"

Benchmarks

Operation	Requirement	Current	Status
Single calculation	< 1ms	~0.3ms	✓ Pass
100 calculations	< 100ms	~35ms	✓ Pass
OCR processing	< 3s/page	~2.8s	✓ Pass
History query	< 100ms	~25ms	✓ Pass

Purpose: Test OCR accuracy with various image qualities

Test Images

• High quality (300+ DPI): Expected 95%+ accuracy
• Medium quality (150-300 DPI): Expected 85%+ accuracy
• Low quality (<150 DPI): Expected 70%+ accuracy
• Skewed images: Test rotation correction
• Noisy images: Test noise reduction

Format Tests

Format	Test Cases	Success Rate
CSV format	20	98%
Labeled format	20	96%
Number only	20	99%
Mixed format	20	92%
Symbol detection	15	94%

Calculation Features

• ☑ Single calculation works for all currencies
• ☑ All 4 modes produce different results
• ☑ Breakdown sums to correct total
• ☑ Summary statistics are accurate
• ☑ Results saved to history automatically
• ☑ Export to CSV works correctly

Bulk Upload

• ☑ CSV files process correctly
• ☑ PDF files process (text + OCR)
• ☑ Word documents process correctly
• ☑ Images process with OCR
• ☑ Error rows reported accurately
• ☑ Progress indicator works

History Management

• ☑ Pagination works correctly
• ☑ Filter by currency works
• ☑ Delete single entry works
• ☑ Clear all history works
• ☑ Date range filter works

• ☑ All pages load without errors
• ☑ Navigation works smoothly
• ☑ Dark mode toggle works
• ☑ Language switcher works (all 5 languages)
• ☑ Responsive on mobile (768px)
• ☑ Responsive on tablet (1024px)
• ☑ Responsive on desktop (1920px)
• ☑ Loading states show correctly
• ☑ Error messages display properly
• ☑ Success messages display properly

• ☑ Invalid amount shows error
• ☑ Negative amount rejected
• ☑ Zero amount rejected
• ☑ Invalid currency rejected
• ☑ Unsupported file type rejected
• ☑ File too large rejected (>10MB)
• ☑ Network errors handled gracefully
• ☑ Backend offline shows error

• ☑ SQL injection prevented
• ☑ XSS attacks prevented
• ☑ CSRF protection enabled
• ☑ File upload validation works
• ☑ Input sanitization works
• ☑ Rate limiting works

Steps

1. Open application
2. Enter amount: 1850.50
3. Select currency: INR
4. Select mode: Greedy
5. Click "Calculate"

Expected Result

• Breakdown displays in <100ms
• Shows: 3×₹500, 1×₹200, 1×₹100, 1×₹50, 1×₹0.50
• Summary: 7 total pieces
• Result saved to history

Steps

1. Navigate to Bulk Upload page
2. Click "Choose File"
3. Select test.csv (100 rows)
4. Click "Upload & Process"
5. Wait for processing

Expected Result

• File name displays prominently
• Progress bar shows completion
• Processing completes in <500ms
• Results table shows all rows
• Success/failure count accurate
• Export button available

Steps

1. Navigate to Bulk Upload
2. Select image file (JPG/PNG)
3. Upload file
4. Wait for OCR processing

Expected Result

• OCR processes in <3s per page
• Extracted text shown
• Amounts detected correctly
• Currency detected (if present)
• Smart defaults applied if missing
• Results display in table