test_order_reader.py

#!/usr/bin/env python3
"""
Unit tests for SmartOrderReader.

This test suite validates the order data extraction functionality.
"""

import unittest
import sys
import os
from pathlib import Path

# Add parent directory to path to import order_reader
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from order_reader import OrderDataExtractor, format_output


class TestOrderNumberExtraction(unittest.TestCase):
    """Test order number extraction patterns."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.extractor = OrderDataExtractor()
    
    def test_extract_basic_order_number(self):
        """Test basic order number extraction."""
        text = "Order #: ABC12345\nTotal: $100.00"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "ABC12345")
    
    def test_extract_order_no(self):
        """Test order no. format."""
        text = "Order No.: XYZ-9876\nCustomer: John Doe"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "XYZ-9876")
    
    def test_extract_invoice_number(self):
        """Test invoice number extraction."""
        text = "Invoice #: INV-2024-001\nDate: 12/25/2023"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "INV-2024-001")
    
    def test_extract_order_id(self):
        """Test order ID extraction."""
        text = "Order ID: ORD123456\nShipping: Express"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "ORD123456")
    
    def test_extract_po_number(self):
        """Test PO number extraction."""
        text = "PO #: PO-2024-567\nVendor: ACME Corp"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "PO-2024-567")
    
    def test_extract_reference_number(self):
        """Test reference number extraction."""
        text = "Reference #: REF-ABC123\nAmount: $250.00"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "REF-ABC123")
    
    def test_order_number_not_found(self):
        """Test when no order number is present."""
        text = "Total: $100.00\nThank you for your order!"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "Not Found")
    
    def test_order_number_case_insensitive(self):
        """Test case insensitive matching."""
        text = "ORDER NUMBER: TEST123\nDate: Today"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "TEST123")
    
    def test_order_number_with_colon(self):
        """Test order number with colon separator."""
        text = "Order: ABC-DEF-123\nCustomer Name: Test"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "ABC-DEF-123")
    
    def test_order_number_mixed_case(self):
        """Test order number with mixed case is preserved."""
        text = "Order #: Ord123abc\nDate: 01/01/2024"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "Ord123abc")
    
    def test_order_number_with_special_chars(self):
        """Test order number with underscores, dots, and slashes."""
        text = "Invoice Number: INV_2024.001/A\nTotal: $100"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "INV_2024.001/A")


class TestOrderDateExtraction(unittest.TestCase):
    """Test order date extraction patterns."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.extractor = OrderDataExtractor()
    
    def test_extract_order_date_slash_format(self):
        """Test order date in MM/DD/YYYY format."""
        text = "Order Date: 12/25/2023\nOrder #: ABC123"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "12/25/2023")
    
    def test_extract_invoice_date(self):
        """Test invoice date extraction."""
        text = "Invoice Date: 01-15-2024\nTotal: $500"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "01-15-2024")
    
    def test_extract_date_iso_format(self):
        """Test date in ISO format (YYYY-MM-DD)."""
        text = "Date: 2024-03-20\nCustomer: John"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "2024-03-20")
    
    def test_extract_date_with_month_name(self):
        """Test date with month name."""
        text = "Order Date: January 15, 2024\nOrder ID: XYZ"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "January 15, 2024")
    
    def test_extract_created_on_date(self):
        """Test 'Created On' label."""
        text = "Created On: 11/30/2023\nStatus: Shipped"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "11/30/2023")
    
    def test_extract_issue_date(self):
        """Test 'Issue Date' label."""
        text = "Issue Date: 2024-01-01\nReference: REF123"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "2024-01-01")
    
    def test_extract_transaction_date(self):
        """Test 'Transaction Date' label."""
        text = "Transaction Date: 03/15/2024\nAmount: $100"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "03/15/2024")
    
    def test_date_not_found(self):
        """Test when no date is present."""
        text = "Order #: ABC123\nThank you!"
        result = self.extractor.extract_order_date(text)
        self.assertEqual(result, "Not Found")
    
    def test_date_prioritization(self):
        """Test that order date is prioritized over other dates."""
        text = "Created: 01/01/2024\nOrder Date: 01/15/2024\nShipped: 01/20/2024"
        result = self.extractor.extract_order_date(text)
        # Should extract the first matching pattern
        self.assertEqual(result, "01/15/2024")


class TestFormatOutput(unittest.TestCase):
    """Test output formatting."""
    
    def test_format_output_with_results(self):
        """Test formatting with valid results."""
        results = [
            {
                'Image File Name': 'invoice1.jpg',
                'Order Number': 'ABC123',
                'Order Date': '12/25/2023'
            },
            {
                'Image File Name': 'invoice2.png',
                'Order Number': 'XYZ789',
                'Order Date': '01/15/2024'
            }
        ]
        
        output = format_output(results)
        
        # Check that output contains expected sections
        self.assertIn("EXTRACTED ORDER DATA", output)
        self.assertIn("CSV FORMAT", output)
        self.assertIn("SUMMARY", output)
        self.assertIn("Total images processed: 2", output)
        self.assertIn("invoice1.jpg", output)
        self.assertIn("ABC123", output)
    
    def test_format_output_with_missing_data(self):
        """Test formatting with missing data."""
        results = [
            {
                'Image File Name': 'invoice.jpg',
                'Order Number': 'Not Found',
                'Order Date': 'Not Found'
            }
        ]
        
        output = format_output(results)
        
        # Check that summary shows missing fields
        self.assertIn("Images with missing Order Number: 1", output)
        self.assertIn("Images with missing Order Date: 1", output)
    
    def test_format_output_csv_structure(self):
        """Test that CSV output has correct structure."""
        results = [
            {
                'Image File Name': 'test.jpg',
                'Order Number': 'TEST123',
                'Order Date': '01/01/2024'
            }
        ]
        
        output = format_output(results)
        
        # Check CSV header
        self.assertIn("Image File Name,Order Number,Order Date", output)
        self.assertIn("test.jpg,TEST123,01/01/2024", output)


class TestExtractorInitialization(unittest.TestCase):
    """Test extractor initialization."""
    
    def test_default_language(self):
        """Test default language is English."""
        extractor = OrderDataExtractor()
        self.assertEqual(extractor.lang, 'eng')
    
    def test_custom_language(self):
        """Test custom language setting."""
        extractor = OrderDataExtractor(lang='eng+urd')
        self.assertEqual(extractor.lang, 'eng+urd')


class TestEdgeCases(unittest.TestCase):
    """Test edge cases and error handling."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.extractor = OrderDataExtractor()
    
    def test_empty_text(self):
        """Test with empty text."""
        result_order = self.extractor.extract_order_number("")
        result_date = self.extractor.extract_order_date("")
        self.assertEqual(result_order, "Not Found")
        self.assertEqual(result_date, "Not Found")
    
    def test_whitespace_only(self):
        """Test with whitespace only."""
        text = "   \n  \t  \n  "
        result_order = self.extractor.extract_order_number(text)
        result_date = self.extractor.extract_order_date(text)
        self.assertEqual(result_order, "Not Found")
        self.assertEqual(result_date, "Not Found")
    
    def test_special_characters_in_order_number(self):
        """Test order numbers with special characters."""
        text = "Order #: ABC-123-XYZ\nDate: 01/01/2024"
        result = self.extractor.extract_order_number(text)
        self.assertEqual(result, "ABC-123-XYZ")
    
    def test_multiple_order_numbers(self):
        """Test when multiple order numbers are present."""
        text = "Order #: FIRST123\nReference #: SECOND456"
        result = self.extractor.extract_order_number(text)
        # Should return the first match
        self.assertEqual(result, "FIRST123")
    
    def test_multiline_text(self):
        """Test with multiline text."""
        text = """
        INVOICE
        
        Order Number: ORD-2024-001
        Order Date: January 1, 2024
        
        Customer: John Doe
        Total: $100.00
        """
        result_order = self.extractor.extract_order_number(text)
        result_date = self.extractor.extract_order_date(text)
        self.assertEqual(result_order, "ORD-2024-001")
        self.assertEqual(result_date, "January 1, 2024")


if __name__ == '__main__':
    # Run tests with verbose output
    unittest.main(verbosity=2)