test(ip-recognizer): add ::1 loopback and mixed :: / ::1 test cases (#1940)

* test(ip-recognizer): add ::1 loopback and mixed :: / ::1 test cases

After #1941 added IPv6_loopback pattern, these tests verify:
- ::1 (loopback) is detected at 0.6 score, not confused with bare ::
- bare :: and ::1 coexisting in one string each match independently

* test(ip-recognizer): normalize result ordering in assertions

Signed-off-by: Extra Small <littleshuai.bot@gmail.com>

---------

Signed-off-by: Extra Small <littleshuai.bot@gmail.com>
Co-authored-by: extrasmall0 <extrasmall0@users.noreply.github.com>
Co-authored-by: Sharon Hart <sharonh.dev@gmail.com>

Author: extrasmall0

presidio-analyzer/tests/test_ip_recognizer.py

@@ -14,6 +14,24 @@ def entities():
     return ["IP_ADDRESS"]
 
 
+def assert_results_match(
+    results,
+    expected_positions,
+    expected_score_ranges,
+    entities,
+    max_score,
+):
+    ordered_results = sorted(results, key=lambda result: (result.start, result.end))
+    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
+        ordered_results, expected_positions, expected_score_ranges
+    ):
+        if fn_score == "max":
+            fn_score = max_score
+        assert_result_within_score_range(
+            res, entities[0], st_pos, fn_pos, st_score, fn_score
+        )
+
+
 @pytest.mark.parametrize(
     "text, expected_len, expected_positions, expected_score_ranges",
     [
@@ -29,6 +47,11 @@ def entities():
         ("2345:0425:2CA1::0567:5673:23b5", 1, (), (),),
         ("2400:c401::5054:ff:fe1b:b031", 1, (), (),),
         ("Use local ipv6 ::", 1, ((15, 17),), ((0.05, 0.15),),),
+        # IPv6 loopback (::1) should match at high confidence
+        ("my ip: ::1", 1, ((7, 10),), ((0.6, 0.81),),),
+        ("connecting from ::1", 1, ((16, 19),), ((0.6, 0.81),),),
+        # bare :: and ::1 in same string should each match once
+        ("src=:: dst=::1", 2, ((4, 6), (11, 14)), ((0.05, 0.15), (0.6, 0.81)),),
         # fmt: on
     ],
 )
@@ -43,14 +66,9 @@ def test_when_all_ips_then_succeed(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -77,14 +95,9 @@ def test_when_ipv6_compression_then_succeed(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -112,14 +125,9 @@ def test_when_ipv6_in_context_then_succeed(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -162,14 +170,9 @@ def test_when_ipv4_mapped_then_full_span_redacted(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -205,14 +208,9 @@ def test_when_ipv4_embedded_then_full_span_redacted(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -237,14 +235,9 @@ def test_when_multiple_ips_then_all_found(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -278,14 +271,9 @@ def test_when_non_ip_pattern_then_no_match(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -321,14 +309,9 @@ def test_when_ip_at_boundary_then_correct_span(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -364,14 +347,9 @@ def test_when_invalid_ip_then_no_match(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -403,14 +381,9 @@ def test_when_special_ip_variants_then_succeed(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )
 
 
 @pytest.mark.parametrize(
@@ -457,11 +430,6 @@ def test_when_cidr_notation_then_largest_span_redacted(
 ):
     results = recognizer.analyze(text, entities)
     assert len(results) == expected_len
-    for res, (st_pos, fn_pos), (st_score, fn_score) in zip(
-        results, expected_positions, expected_score_ranges
-    ):
-        if fn_score == "max":
-            fn_score = max_score
-        assert_result_within_score_range(
-            res, entities[0], st_pos, fn_pos, st_score, fn_score
-        )
+    assert_results_match(
+        results, expected_positions, expected_score_ranges, entities, max_score
+    )