Re-structure the project.

tests/utils/test_advanced_utils.py

@@ -0,0 +1,399 @@
+"""
+Tests for advanced utility modules:
+- FuzzyMatcher
+- OCRCorrections
+- ContextExtractor
+"""
+
+import pytest
+from src.utils.fuzzy_matcher import FuzzyMatcher, FuzzyMatchResult
+from src.utils.ocr_corrections import OCRCorrections, correct_ocr_digits, generate_ocr_variants
+from src.utils.context_extractor import ContextExtractor, extract_field_with_context
+
+
+class TestFuzzyMatcher:
+    """Tests for FuzzyMatcher class."""
+
+    def test_levenshtein_distance_identical(self):
+        """Test distance for identical strings."""
+        assert FuzzyMatcher.levenshtein_distance("hello", "hello") == 0
+
+    def test_levenshtein_distance_one_char(self):
+        """Test distance for one character difference."""
+        assert FuzzyMatcher.levenshtein_distance("hello", "hallo") == 1
+        assert FuzzyMatcher.levenshtein_distance("hello", "hell") == 1
+        assert FuzzyMatcher.levenshtein_distance("hello", "helloo") == 1
+
+    def test_levenshtein_distance_multiple(self):
+        """Test distance for multiple differences."""
+        assert FuzzyMatcher.levenshtein_distance("hello", "world") == 4
+        assert FuzzyMatcher.levenshtein_distance("", "hello") == 5
+
+    def test_similarity_ratio_identical(self):
+        """Test similarity for identical strings."""
+        assert FuzzyMatcher.similarity_ratio("hello", "hello") == 1.0
+
+    def test_similarity_ratio_similar(self):
+        """Test similarity for similar strings."""
+        ratio = FuzzyMatcher.similarity_ratio("hello", "hallo")
+        assert 0.8 <= ratio <= 0.9  # One char different in 5-char string
+
+    def test_similarity_ratio_different(self):
+        """Test similarity for different strings."""
+        ratio = FuzzyMatcher.similarity_ratio("hello", "world")
+        assert ratio < 0.5
+
+    def test_ocr_aware_similarity_exact(self):
+        """Test OCR-aware similarity for exact match."""
+        assert FuzzyMatcher.ocr_aware_similarity("12345", "12345") == 1.0
+
+    def test_ocr_aware_similarity_ocr_error(self):
+        """Test OCR-aware similarity with OCR error."""
+        # O instead of 0
+        score = FuzzyMatcher.ocr_aware_similarity("1234O", "12340")
+        assert score >= 0.9  # Should be high due to OCR correction
+
+    def test_ocr_aware_similarity_multiple_errors(self):
+        """Test OCR-aware similarity with multiple OCR errors."""
+        # l instead of 1, O instead of 0
+        score = FuzzyMatcher.ocr_aware_similarity("l234O", "12340")
+        assert score >= 0.85
+
+    def test_match_digits_exact(self):
+        """Test digit matching for exact match."""
+        result = FuzzyMatcher.match_digits("12345", "12345")
+        assert result.matched is True
+        assert result.score == 1.0
+        assert result.match_type == 'exact'
+
+    def test_match_digits_with_separators(self):
+        """Test digit matching ignoring separators."""
+        result = FuzzyMatcher.match_digits("123-4567", "1234567")
+        assert result.matched is True
+        assert result.normalized_ocr == "1234567"
+
+    def test_match_digits_ocr_error(self):
+        """Test digit matching with OCR error."""
+        result = FuzzyMatcher.match_digits("556O234567", "5560234567")
+        assert result.matched is True
+        assert result.score >= 0.9
+
+    def test_match_amount_exact(self):
+        """Test amount matching for exact values."""
+        result = FuzzyMatcher.match_amount("1234.56", "1234.56")
+        assert result.matched is True
+        assert result.score == 1.0
+
+    def test_match_amount_different_formats(self):
+        """Test amount matching with different formats."""
+        # Swedish vs US format
+        result = FuzzyMatcher.match_amount("1234,56", "1234.56")
+        assert result.matched is True
+        assert result.score >= 0.99
+
+    def test_match_amount_with_spaces(self):
+        """Test amount matching with thousand separators."""
+        result = FuzzyMatcher.match_amount("1 234,56", "1234.56")
+        assert result.matched is True
+
+    def test_match_date_same_date_different_format(self):
+        """Test date matching with different formats."""
+        result = FuzzyMatcher.match_date("2024-12-29", "29.12.2024")
+        assert result.matched is True
+        assert result.score >= 0.9
+
+    def test_match_date_different_dates(self):
+        """Test date matching with different dates."""
+        result = FuzzyMatcher.match_date("2024-12-29", "2024-12-30")
+        assert result.matched is False
+
+    def test_match_string_exact(self):
+        """Test string matching for exact match."""
+        result = FuzzyMatcher.match_string("Hello World", "Hello World")
+        assert result.matched is True
+        assert result.match_type == 'exact'
+
+    def test_match_string_case_insensitive(self):
+        """Test string matching case insensitivity."""
+        result = FuzzyMatcher.match_string("HELLO", "hello")
+        assert result.matched is True
+        assert result.match_type == 'normalized'
+
+    def test_match_string_ocr_corrected(self):
+        """Test string matching with OCR corrections."""
+        result = FuzzyMatcher.match_string("5561234567", "556l234567")
+        assert result.matched is True
+
+    def test_match_field_routes_correctly(self):
+        """Test that match_field routes to correct matcher."""
+        # Amount field
+        result = FuzzyMatcher.match_field("Amount", "1234.56", "1234,56")
+        assert result.matched is True
+
+        # Date field
+        result = FuzzyMatcher.match_field("InvoiceDate", "2024-12-29", "29.12.2024")
+        assert result.matched is True
+
+    def test_find_best_match(self):
+        """Test finding best match from candidates."""
+        candidates = ["12345", "12346", "99999"]
+        result = FuzzyMatcher.find_best_match("12345", candidates, "InvoiceNumber")
+
+        assert result is not None
+        assert result[0] == "12345"
+        assert result[1].score == 1.0
+
+    def test_find_best_match_no_match(self):
+        """Test finding best match when none above threshold."""
+        candidates = ["99999", "88888", "77777"]
+        result = FuzzyMatcher.find_best_match("12345", candidates, "InvoiceNumber")
+
+        assert result is None
+
+
+class TestOCRCorrections:
+    """Tests for OCRCorrections class."""
+
+    def test_correct_digits_simple(self):
+        """Test simple digit correction."""
+        result = OCRCorrections.correct_digits("556O23", aggressive=False)
+        assert result.corrected == "556023"
+        assert len(result.corrections_applied) == 1
+
+    def test_correct_digits_multiple(self):
+        """Test multiple digit corrections."""
+        result = OCRCorrections.correct_digits("5S6l23", aggressive=False)
+        assert result.corrected == "556123"
+        assert len(result.corrections_applied) == 2
+
+    def test_correct_digits_aggressive(self):
+        """Test aggressive mode corrects all potential errors."""
+        result = OCRCorrections.correct_digits("AB123", aggressive=True)
+        # A -> 4, B -> 8
+        assert result.corrected == "48123"
+
+    def test_correct_digits_non_aggressive(self):
+        """Test non-aggressive mode only corrects adjacent."""
+        result = OCRCorrections.correct_digits("AB 123", aggressive=False)
+        # A and B are adjacent to each other and both in CHAR_TO_DIGIT,
+        # so they may be corrected. The key is digits are not affected.
+        assert "123" in result.corrected
+
+    def test_generate_digit_variants(self):
+        """Test generating OCR variants."""
+        variants = OCRCorrections.generate_digit_variants("10")
+        # Should include original and variants like "1O", "I0", "IO", "l0", etc.
+        assert "10" in variants
+        assert "1O" in variants or "l0" in variants
+
+    def test_generate_digit_variants_limits(self):
+        """Test that variant generation is limited."""
+        variants = OCRCorrections.generate_digit_variants("1234567890")
+        # Should be limited to prevent explosion (limit is ~100, but may slightly exceed)
+        assert len(variants) <= 150
+
+    def test_is_likely_ocr_error(self):
+        """Test OCR error detection."""
+        assert OCRCorrections.is_likely_ocr_error('0', 'O') is True
+        assert OCRCorrections.is_likely_ocr_error('O', '0') is True
+        assert OCRCorrections.is_likely_ocr_error('1', 'l') is True
+        assert OCRCorrections.is_likely_ocr_error('5', 'S') is True
+        assert OCRCorrections.is_likely_ocr_error('A', 'Z') is False
+
+    def test_count_potential_ocr_errors(self):
+        """Test counting OCR errors vs other errors."""
+        ocr_errors, other_errors = OCRCorrections.count_potential_ocr_errors("1O3", "103")
+        assert ocr_errors == 1  # O vs 0
+        assert other_errors == 0
+
+        ocr_errors, other_errors = OCRCorrections.count_potential_ocr_errors("1X3", "103")
+        assert ocr_errors == 0
+        assert other_errors == 1  # X vs 0, not a known pair
+
+    def test_suggest_corrections(self):
+        """Test correction suggestions."""
+        suggestions = OCRCorrections.suggest_corrections("556O23", expected_type='digit')
+        assert len(suggestions) > 0
+        # First suggestion should be the corrected version
+        assert suggestions[0][0] == "556023"
+
+    def test_convenience_function_correct(self):
+        """Test convenience function."""
+        assert correct_ocr_digits("556O23") == "556023"
+
+    def test_convenience_function_variants(self):
+        """Test convenience function for variants."""
+        variants = generate_ocr_variants("10")
+        assert "10" in variants
+
+
+class TestContextExtractor:
+    """Tests for ContextExtractor class."""
+
+    def test_extract_invoice_number_with_label(self):
+        """Test extracting invoice number after label."""
+        text = "Fakturanummer: 12345678"
+        candidates = ContextExtractor.extract_with_label(text, "InvoiceNumber")
+
+        assert len(candidates) > 0
+        assert candidates[0].value == "12345678"
+        assert candidates[0].extraction_method == 'label'
+
+    def test_extract_invoice_number_swedish(self):
+        """Test extracting with Swedish label."""
+        text = "Faktura nr: A12345"
+        candidates = ContextExtractor.extract_with_label(text, "InvoiceNumber")
+
+        assert len(candidates) > 0
+        # Should extract A12345 or 12345
+
+    def test_extract_amount_with_label(self):
+        """Test extracting amount after label."""
+        text = "Att betala: 1 234,56"
+        candidates = ContextExtractor.extract_with_label(text, "Amount")
+
+        assert len(candidates) > 0
+
+    def test_extract_amount_total(self):
+        """Test extracting with total label."""
+        text = "Total: 5678,90 kr"
+        candidates = ContextExtractor.extract_with_label(text, "Amount")
+
+        assert len(candidates) > 0
+
+    def test_extract_date_with_label(self):
+        """Test extracting date after label."""
+        text = "Fakturadatum: 2024-12-29"
+        candidates = ContextExtractor.extract_with_label(text, "InvoiceDate")
+
+        assert len(candidates) > 0
+        assert "2024-12-29" in candidates[0].value
+
+    def test_extract_due_date(self):
+        """Test extracting due date."""
+        text = "Förfallodatum: 2025-01-15"
+        candidates = ContextExtractor.extract_with_label(text, "InvoiceDueDate")
+
+        assert len(candidates) > 0
+
+    def test_extract_bankgiro(self):
+        """Test extracting Bankgiro."""
+        text = "Bankgiro: 1234-5678"
+        candidates = ContextExtractor.extract_with_label(text, "Bankgiro")
+
+        assert len(candidates) > 0
+        assert "1234-5678" in candidates[0].value or "12345678" in candidates[0].value
+
+    def test_extract_plusgiro(self):
+        """Test extracting Plusgiro."""
+        text = "Plusgiro: 1234567-8"
+        candidates = ContextExtractor.extract_with_label(text, "Plusgiro")
+
+        assert len(candidates) > 0
+
+    def test_extract_ocr(self):
+        """Test extracting OCR number."""
+        text = "OCR: 12345678901234"
+        candidates = ContextExtractor.extract_with_label(text, "OCR")
+
+        assert len(candidates) > 0
+        assert candidates[0].value == "12345678901234"
+
+    def test_extract_org_number(self):
+        """Test extracting organization number."""
+        text = "Org.nr: 556123-4567"
+        candidates = ContextExtractor.extract_with_label(text, "supplier_organisation_number")
+
+        assert len(candidates) > 0
+
+    def test_extract_customer_number(self):
+        """Test extracting customer number."""
+        text = "Kundnummer: EMM 256-6"
+        candidates = ContextExtractor.extract_with_label(text, "customer_number")
+
+        assert len(candidates) > 0
+
+    def test_extract_field_returns_sorted(self):
+        """Test that extract_field returns sorted by confidence."""
+        text = "Fakturanummer: 12345 Invoice number: 67890"
+        candidates = ContextExtractor.extract_field(text, "InvoiceNumber")
+
+        if len(candidates) > 1:
+            # Should be sorted by confidence (descending)
+            assert candidates[0].confidence >= candidates[1].confidence
+
+    def test_extract_best(self):
+        """Test extract_best returns single best candidate."""
+        text = "Fakturanummer: 12345678"
+        best = ContextExtractor.extract_best(text, "InvoiceNumber")
+
+        assert best is not None
+        assert best.value == "12345678"
+
+    def test_extract_best_no_match(self):
+        """Test extract_best returns None when no match."""
+        text = "No invoice information here"
+        best = ContextExtractor.extract_best(text, "InvoiceNumber", validate=True)
+
+        # May or may not find something depending on validation
+
+    def test_extract_all_fields(self):
+        """Test extracting all fields from text."""
+        text = """
+        Fakturanummer: 12345
+        Datum: 2024-12-29
+        Belopp: 1234,56
+        Bankgiro: 1234-5678
+        """
+        results = ContextExtractor.extract_all_fields(text)
+
+        # Should find at least some fields
+        assert len(results) > 0
+
+    def test_identify_field_type(self):
+        """Test identifying field type from context."""
+        text = "Fakturanummer: 12345"
+        field_type = ContextExtractor.identify_field_type(text, "12345")
+
+        assert field_type == "InvoiceNumber"
+
+    def test_convenience_function_extract(self):
+        """Test convenience function."""
+        text = "Fakturanummer: 12345678"
+        value = extract_field_with_context(text, "InvoiceNumber")
+
+        assert value == "12345678"
+
+
+class TestIntegration:
+    """Integration tests combining multiple modules."""
+
+    def test_fuzzy_match_with_ocr_correction(self):
+        """Test fuzzy matching with OCR correction."""
+        # Simulate OCR error: 0 -> O
+        ocr_text = "556O234567"
+        expected = "5560234567"
+
+        # First correct
+        corrected = correct_ocr_digits(ocr_text)
+        assert corrected == expected
+
+        # Then match
+        result = FuzzyMatcher.match_digits(ocr_text, expected)
+        assert result.matched is True
+
+    def test_context_extraction_with_fuzzy_match(self):
+        """Test extracting value and fuzzy matching."""
+        text = "Fakturanummer: 1234S678"  # S is OCR error for 5
+
+        # Extract
+        candidate = ContextExtractor.extract_best(text, "InvoiceNumber", validate=False)
+        assert candidate is not None
+
+        # Fuzzy match against expected
+        result = FuzzyMatcher.match_string(candidate.value, "12345678")
+        # Might match depending on threshold
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/utils/test_utils.py

@@ -0,0 +1,235 @@
+"""
+Tests for shared utility modules.
+"""
+
+import pytest
+from src.utils.text_cleaner import TextCleaner
+from src.utils.format_variants import FormatVariants
+from src.utils.validators import FieldValidators
+
+
+class TestTextCleaner:
+    """Tests for TextCleaner class."""
+
+    def test_clean_unicode_dashes(self):
+        """Test normalization of various dash types."""
+        # en-dash
+        assert TextCleaner.clean_unicode("556123–4567") == "556123-4567"
+        # em-dash
+        assert TextCleaner.clean_unicode("556123—4567") == "556123-4567"
+        # minus sign
+        assert TextCleaner.clean_unicode("556123−4567") == "556123-4567"
+
+    def test_clean_unicode_spaces(self):
+        """Test normalization of various space types."""
+        # non-breaking space
+        assert TextCleaner.clean_unicode("1\xa0234") == "1 234"
+        # zero-width space removed
+        assert TextCleaner.clean_unicode("123\u200b456") == "123456"
+
+    def test_ocr_digit_corrections(self):
+        """Test OCR error corrections for digit fields."""
+        # O -> 0
+        assert TextCleaner.apply_ocr_digit_corrections("556O23") == "556023"
+        # l -> 1
+        assert TextCleaner.apply_ocr_digit_corrections("556l23") == "556123"
+        # S -> 5
+        assert TextCleaner.apply_ocr_digit_corrections("5S6123") == "556123"
+        # Mixed
+        assert TextCleaner.apply_ocr_digit_corrections("S56l23-4S67") == "556123-4567"
+
+    def test_extract_digits(self):
+        """Test digit extraction with OCR correction."""
+        assert TextCleaner.extract_digits("556123-4567") == "5561234567"
+        assert TextCleaner.extract_digits("556O23-4567", apply_ocr_correction=True) == "5560234567"
+        # Without OCR correction, only extracts actual digits
+        assert TextCleaner.extract_digits("ABC 123 DEF", apply_ocr_correction=False) == "123"
+        # With OCR correction, standalone letters are not converted
+        # (they need to be adjacent to digits to be corrected)
+        assert TextCleaner.extract_digits("A 123 B", apply_ocr_correction=True) == "123"
+
+    def test_normalize_amount_text(self):
+        """Test amount text normalization."""
+        assert TextCleaner.normalize_amount_text("1 234,56 kr") == "1234,56"
+        assert TextCleaner.normalize_amount_text("SEK 1234.56") == "1234.56"
+        assert TextCleaner.normalize_amount_text("1 234 567,89 kronor") == "1234567,89"
+
+
+class TestFormatVariants:
+    """Tests for FormatVariants class."""
+
+    def test_organisation_number_variants(self):
+        """Test organisation number variant generation."""
+        variants = FormatVariants.organisation_number_variants("5561234567")
+
+        assert "5561234567" in variants        # 纯数字
+        assert "556123-4567" in variants       # 带横线
+        assert "SE556123456701" in variants    # VAT格式
+
+    def test_organisation_number_from_vat(self):
+        """Test extracting org number from VAT format."""
+        variants = FormatVariants.organisation_number_variants("SE556123456701")
+
+        assert "5561234567" in variants
+        assert "556123-4567" in variants
+
+    def test_bankgiro_variants(self):
+        """Test Bankgiro variant generation."""
+        # 8 digits
+        variants = FormatVariants.bankgiro_variants("53939484")
+        assert "53939484" in variants
+        assert "5393-9484" in variants
+
+        # 7 digits
+        variants = FormatVariants.bankgiro_variants("1234567")
+        assert "1234567" in variants
+        assert "123-4567" in variants
+
+    def test_plusgiro_variants(self):
+        """Test Plusgiro variant generation."""
+        variants = FormatVariants.plusgiro_variants("12345678")
+        assert "12345678" in variants
+        assert "1234567-8" in variants
+
+    def test_amount_variants(self):
+        """Test amount variant generation."""
+        variants = FormatVariants.amount_variants("1234.56")
+
+        assert "1234.56" in variants
+        assert "1234,56" in variants
+        assert "1 234,56" in variants or "1234,56" in variants  # Swedish format
+
+    def test_date_variants(self):
+        """Test date variant generation."""
+        variants = FormatVariants.date_variants("2024-12-29")
+
+        assert "2024-12-29" in variants        # ISO
+        assert "29.12.2024" in variants        # European
+        assert "29/12/2024" in variants        # European slash
+        assert "20241229" in variants          # Compact
+        assert "29 december 2024" in variants  # Swedish text
+
+    def test_invoice_number_variants(self):
+        """Test invoice number variant generation."""
+        variants = FormatVariants.invoice_number_variants("INV-2024-001")
+
+        assert "INV-2024-001" in variants
+        assert "INV2024001" in variants        # No separators
+        assert "inv-2024-001" in variants      # Lowercase
+
+    def test_get_variants_dispatch(self):
+        """Test get_variants dispatches to correct method."""
+        # Organisation number
+        org_variants = FormatVariants.get_variants("supplier_organisation_number", "5561234567")
+        assert "556123-4567" in org_variants
+
+        # Bankgiro
+        bg_variants = FormatVariants.get_variants("Bankgiro", "53939484")
+        assert "5393-9484" in bg_variants
+
+        # Amount
+        amount_variants = FormatVariants.get_variants("Amount", "1234.56")
+        assert "1234,56" in amount_variants
+
+
+class TestFieldValidators:
+    """Tests for FieldValidators class."""
+
+    def test_luhn_checksum_valid(self):
+        """Test Luhn validation with valid numbers."""
+        # Valid Bankgiro numbers (with correct check digit)
+        assert FieldValidators.luhn_checksum("53939484") is True
+        # Valid OCR numbers
+        assert FieldValidators.luhn_checksum("1234567897") is True  # check digit 7
+
+    def test_luhn_checksum_invalid(self):
+        """Test Luhn validation with invalid numbers."""
+        assert FieldValidators.luhn_checksum("53939485") is False  # wrong check digit
+        assert FieldValidators.luhn_checksum("1234567890") is False
+
+    def test_calculate_luhn_check_digit(self):
+        """Test Luhn check digit calculation."""
+        # For "123456789", the check digit should make it valid
+        check = FieldValidators.calculate_luhn_check_digit("123456789")
+        full_number = "123456789" + str(check)
+        assert FieldValidators.luhn_checksum(full_number) is True
+
+    def test_is_valid_organisation_number(self):
+        """Test organisation number validation."""
+        # Valid (with correct Luhn checksum)
+        # Note: Need actual valid org numbers for this test
+        # Using a well-known one: 5565006245 (placeholder)
+        pass  # Skip without real test data
+
+    def test_is_valid_bankgiro(self):
+        """Test Bankgiro validation."""
+        # Valid 8-digit Bankgiro with Luhn
+        assert FieldValidators.is_valid_bankgiro("53939484") is True
+        # Invalid (wrong length)
+        assert FieldValidators.is_valid_bankgiro("123") is False
+        assert FieldValidators.is_valid_bankgiro("123456789") is False  # 9 digits
+
+    def test_format_bankgiro(self):
+        """Test Bankgiro formatting."""
+        assert FieldValidators.format_bankgiro("53939484") == "5393-9484"
+        assert FieldValidators.format_bankgiro("1234567") == "123-4567"
+        assert FieldValidators.format_bankgiro("123") is None
+
+    def test_is_valid_plusgiro(self):
+        """Test Plusgiro validation."""
+        # Valid Plusgiro (2-8 digits with Luhn)
+        assert FieldValidators.is_valid_plusgiro("18") is True  # minimal
+        # Invalid (wrong length)
+        assert FieldValidators.is_valid_plusgiro("1") is False
+
+    def test_format_plusgiro(self):
+        """Test Plusgiro formatting."""
+        assert FieldValidators.format_plusgiro("12345678") == "1234567-8"
+        assert FieldValidators.format_plusgiro("123456") == "12345-6"
+
+    def test_is_valid_amount(self):
+        """Test amount validation."""
+        assert FieldValidators.is_valid_amount("1234.56") is True
+        assert FieldValidators.is_valid_amount("1 234,56") is True
+        assert FieldValidators.is_valid_amount("abc") is False
+        assert FieldValidators.is_valid_amount("-100") is False  # below min
+        assert FieldValidators.is_valid_amount("100000000") is False  # above max
+
+    def test_parse_amount(self):
+        """Test amount parsing."""
+        assert FieldValidators.parse_amount("1234.56") == 1234.56
+        assert FieldValidators.parse_amount("1 234,56") == 1234.56
+        assert FieldValidators.parse_amount("1.234,56") == 1234.56  # German
+        assert FieldValidators.parse_amount("1,234.56") == 1234.56  # US
+
+    def test_is_valid_date(self):
+        """Test date validation."""
+        assert FieldValidators.is_valid_date("2024-12-29") is True
+        assert FieldValidators.is_valid_date("29.12.2024") is True
+        assert FieldValidators.is_valid_date("29/12/2024") is True
+        assert FieldValidators.is_valid_date("not a date") is False
+        assert FieldValidators.is_valid_date("1900-01-01") is False  # out of range
+
+    def test_format_date_iso(self):
+        """Test date ISO formatting."""
+        assert FieldValidators.format_date_iso("29.12.2024") == "2024-12-29"
+        assert FieldValidators.format_date_iso("29/12/2024") == "2024-12-29"
+        assert FieldValidators.format_date_iso("2024-12-29") == "2024-12-29"
+
+    def test_validate_field_dispatch(self):
+        """Test validate_field dispatches correctly."""
+        # Organisation number
+        is_valid, error = FieldValidators.validate_field("supplier_organisation_number", "")
+        assert is_valid is False
+
+        # Amount
+        is_valid, error = FieldValidators.validate_field("Amount", "1234.56")
+        assert is_valid is True
+
+        # Date
+        is_valid, error = FieldValidators.validate_field("InvoiceDate", "2024-12-29")
+        assert is_valid is True
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])