@adaptic/maestro 1.0.0

package/scripts/test-email-thread-dedup.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""Tests for email-thread-dedup.py — thread-level email deduplication.
+
+Run: python3 scripts/test-email-thread-dedup.py
+"""
+import json
+import os
+import sys
+import time
+
+# Add scripts dir to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from email_thread_dedup import (
+    _normalize_subject,
+    _normalize_recipient,
+    _thread_key,
+    check_thread_lock,
+    acquire_thread_lock,
+    confirm_thread_lock,
+    release_thread_lock,
+    clean_expired_locks,
+    LOCK_DIR,
+    TTL_SECONDS,
+    _lock_path,
+)
+
+PASS = 0
+FAIL = 0
+
+
+def assert_eq(label, actual, expected):
+    global PASS, FAIL
+    if actual == expected:
+        PASS += 1
+        print(f"  PASS: {label}")
+    else:
+        FAIL += 1
+        print(f"  FAIL: {label}")
+        print(f"    expected: {expected!r}")
+        print(f"    actual:   {actual!r}")
+
+
+def assert_true(label, value):
+    assert_eq(label, bool(value), True)
+
+
+def assert_false(label, value):
+    assert_eq(label, bool(value), False)
+
+
+# --- Test subject normalization ---
+
+print("\n=== Subject normalization ===")
+assert_eq("strips Re:", _normalize_subject("Re: Hello"), "Hello")
+assert_eq("strips RE:", _normalize_subject("RE: Hello"), "Hello")
+assert_eq("strips Fwd:", _normalize_subject("Fwd: Hello"), "Hello")
+assert_eq("strips FW:", _normalize_subject("FW: Hello"), "Hello")
+assert_eq("strips nested Re: Re:", _normalize_subject("Re: Re: Hello"), "Hello")
+assert_eq("strips mixed Re: Fwd:", _normalize_subject("Re: Fwd: Hello"), "Hello")
+assert_eq("normalizes whitespace", _normalize_subject("  Re:  Hello   World  "), "Hello World")
+assert_eq("preserves clean subject", _normalize_subject("Hello World"), "Hello World")
+
+# --- Test recipient normalization ---
+
+print("\n=== Recipient normalization ===")
+assert_eq("lowercases", _normalize_recipient("John@Example.COM"), "john@example.com")
+assert_eq("strips display name", _normalize_recipient("John Doe <john@example.com>"), "john@example.com")
+assert_eq("takes first of multiple", _normalize_recipient("john@a.com, jane@b.com"), "john@a.com")
+assert_eq("strips whitespace", _normalize_recipient("  john@example.com  "), "john@example.com")
+
+# --- Test thread key consistency ---
+
+print("\n=== Thread key consistency ===")
+key1 = _thread_key("john@example.com", "Re: Hello World")
+key2 = _thread_key("john@example.com", "Hello World")
+key3 = _thread_key("john@example.com", "RE: Fwd: Hello World")
+key4 = _thread_key("JOHN@EXAMPLE.COM", "Re: Hello World")
+key5 = _thread_key("john@example.com", "Different Subject")
+
+assert_eq("Re: stripped matches base", key1, key2)
+assert_eq("RE: Fwd: stripped matches base", key3, key2)
+assert_eq("case-insensitive recipient", key4, key1)
+assert_true("different subject = different key", key5 != key1)
+
+# --- Test lock lifecycle ---
+
+print("\n=== Lock lifecycle ===")
+
+# Use unique test subjects to avoid interference
+TEST_TO = "test-dedup@example.com"
+TEST_SUBJECT = f"Test Subject {time.time()}"
+
+# Clean start
+release_thread_lock(TEST_TO, TEST_SUBJECT)
+
+# 1. Check — should be available
+result = check_thread_lock(TEST_TO, TEST_SUBJECT)
+assert_false("initially unlocked", result["locked"])
+
+# 2. Acquire — should succeed
+acq = acquire_thread_lock(TEST_TO, TEST_SUBJECT, session_id="test-session-1", preview="Hello this is a test")
+assert_true("first acquire succeeds", acq["acquired"])
+assert_true("thread key returned", len(acq["thread_key"]) > 0)
+
+# 3. Check again — should now be locked
+result = check_thread_lock(TEST_TO, TEST_SUBJECT)
+assert_true("now locked", result["locked"])
+assert_eq("locked by correct session", result["lock_data"]["session_id"], "test-session-1")
+
+# 4. Second acquire — should be BLOCKED
+acq2 = acquire_thread_lock(TEST_TO, TEST_SUBJECT, session_id="test-session-2", preview="Different wording")
+assert_false("second acquire blocked", acq2["acquired"])
+assert_true("existing lock returned", acq2["existing_lock"] is not None)
+assert_eq("existing lock session", acq2["existing_lock"]["session_id"], "test-session-1")
+
+# 5. Confirm — should update status
+confirm_thread_lock(TEST_TO, TEST_SUBJECT, preview="Confirmed preview text")
+result = check_thread_lock(TEST_TO, TEST_SUBJECT)
+assert_true("still locked after confirm", result["locked"])
+assert_eq("status is confirmed", result["lock_data"]["status"], "confirmed")
+
+# 6. Release — should unlock
+release_thread_lock(TEST_TO, TEST_SUBJECT)
+result = check_thread_lock(TEST_TO, TEST_SUBJECT)
+assert_false("unlocked after release", result["locked"])
+
+# --- Test expired lock handling ---
+
+print("\n=== Expired lock handling ===")
+TEST_SUBJECT_EXP = f"Expired Subject {time.time()}"
+
+# Create a lock with a timestamp in the past (>24h ago)
+key = _thread_key(TEST_TO, TEST_SUBJECT_EXP)
+path = _lock_path(key)
+os.makedirs(LOCK_DIR, exist_ok=True)
+expired_data = {
+    "thread_key": key,
+    "timestamp": "2026-01-01T00:00:00Z",
+    "timestamp_epoch": time.time() - (TTL_SECONDS + 3600),  # 25 hours ago
+    "session_id": "old-session",
+    "subject_normalized": "Expired Subject",
+    "recipient_normalized": TEST_TO,
+    "preview": "old message",
+    "status": "confirmed",
+}
+with open(path, "w") as f:
+    json.dump(expired_data, f)
+
+# Check — expired lock should NOT block
+result = check_thread_lock(TEST_TO, TEST_SUBJECT_EXP)
+assert_false("expired lock does not block", result["locked"])
+
+# Acquire over expired lock — should succeed
+acq = acquire_thread_lock(TEST_TO, TEST_SUBJECT_EXP, session_id="new-session")
+assert_true("acquire over expired lock succeeds", acq["acquired"])
+
+# Clean up
+release_thread_lock(TEST_TO, TEST_SUBJECT_EXP)
+
+# --- Test Re:/Fwd: variant blocking ---
+
+print("\n=== Subject variant blocking ===")
+TEST_SUBJECT_VAR = f"Important Meeting Notes {time.time()}"
+release_thread_lock(TEST_TO, TEST_SUBJECT_VAR)  # clean start
+
+# Acquire with base subject
+acq = acquire_thread_lock(TEST_TO, TEST_SUBJECT_VAR, session_id="session-a")
+assert_true("acquire base subject", acq["acquired"])
+
+# Attempt with Re: variant — should be blocked (same thread)
+acq2 = acquire_thread_lock(TEST_TO, f"Re: {TEST_SUBJECT_VAR}", session_id="session-b")
+assert_false("Re: variant blocked", acq2["acquired"])
+
+# Attempt with RE: Fwd: variant — should also be blocked
+acq3 = acquire_thread_lock(TEST_TO, f"RE: Fwd: {TEST_SUBJECT_VAR}", session_id="session-c")
+assert_false("RE: Fwd: variant blocked", acq3["acquired"])
+
+# Clean up
+release_thread_lock(TEST_TO, TEST_SUBJECT_VAR)
+
+# --- Test clean_expired_locks ---
+
+print("\n=== Cleanup function ===")
+TEST_SUBJECT_CLN = f"Cleanup Test {time.time()}"
+
+# Create an expired lock
+key = _thread_key(TEST_TO, TEST_SUBJECT_CLN)
+path = _lock_path(key)
+expired_data = {
+    "thread_key": key,
+    "timestamp": "2026-01-01T00:00:00Z",
+    "timestamp_epoch": time.time() - (TTL_SECONDS + 3600),
+    "session_id": "cleanup-test",
+    "subject_normalized": "Cleanup Test",
+    "recipient_normalized": TEST_TO,
+    "status": "confirmed",
+}
+with open(path, "w") as f:
+    json.dump(expired_data, f)
+
+assert_true("expired lock file exists before clean", os.path.exists(path))
+removed = clean_expired_locks()
+assert_true("cleanup removed at least 1", removed >= 1)
+assert_false("expired lock file gone after clean", os.path.exists(path))
+
+# --- Test lock file contents ---
+
+print("\n=== Lock file contents ===")
+TEST_SUBJECT_META = f"Metadata Check {time.time()}"
+release_thread_lock(TEST_TO, TEST_SUBJECT_META)
+
+acquire_thread_lock(TEST_TO, TEST_SUBJECT_META, session_id="meta-session", preview="Hello, I wanted to follow up on our conversation")
+key = _thread_key(TEST_TO, TEST_SUBJECT_META)
+path = _lock_path(key)
+
+with open(path, "r") as f:
+    data = json.load(f)
+
+assert_eq("has thread_key", data.get("thread_key"), key)
+assert_true("has timestamp", "timestamp" in data)
+assert_true("has timestamp_epoch", "timestamp_epoch" in data)
+assert_eq("has session_id", data.get("session_id"), "meta-session")
+assert_true("has subject_normalized", "subject_normalized" in data)
+assert_true("has recipient_normalized", "recipient_normalized" in data)
+assert_true("has preview", len(data.get("preview", "")) > 0)
+assert_eq("status is acquired", data.get("status"), "acquired")
+
+release_thread_lock(TEST_TO, TEST_SUBJECT_META)
+
+# --- Summary ---
+
+print(f"\n{'='*50}")
+print(f"Results: {PASS} passed, {FAIL} failed, {PASS + FAIL} total")
+if FAIL > 0:
+    print("SOME TESTS FAILED")
+    sys.exit(1)
+else:
+    print("ALL TESTS PASSED")
+    sys.exit(0)