Skip to content

~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.

test: remove 14 shadow files in tests/news/ (6,788 lines) (#4125)

LearningCircuitef7d7e80b522
diff --git a/tests/news/test_base_preference_logic_behavior.py b/tests/news/test_base_preference_logic_behavior.py
deleted file mode 100644
index b4a21f1667..0000000000
--- a/tests/news/test_base_preference_logic_behavior.py
+++ /dev/null
@@ -1,470 +0,0 @@
-"""
-Deep behavioral tests for base_preference.py pure logic.
-Tests default preferences, interest management, topic registry,
-and source boosting patterns.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- Default preferences structure ---
-
-
-class TestDefaultPreferencesStructure:
- """Tests for get_default_preferences structure."""
-
- def _get_default_preferences(self):
- return {
- "liked_categories": [],
- "disliked_categories": [],
- "liked_topics": [],
- "disliked_topics": [],
- "interests": {},
- "source_weights": {},
- "impact_threshold": 5,
- "focus_preferences": {
- "surprising": False,
- "breaking": True,
- "positive": False,
- "local": False,
- },
- "custom_search_terms": "",
- "search_strategy": "news_aggregation",
- "created_at": "2025-06-15T10:00:00+00:00",
- "preferences_updated_at": "2025-06-15T10:00:00+00:00",
- }
-
- def test_has_liked_categories(self):
- prefs = self._get_default_preferences()
- assert "liked_categories" in prefs
- assert prefs["liked_categories"] == []
-
- def test_has_disliked_categories(self):
- prefs = self._get_default_preferences()
- assert "disliked_categories" in prefs
- assert prefs["disliked_categories"] == []
-
- def test_has_liked_topics(self):
- prefs = self._get_default_preferences()
- assert "liked_topics" in prefs
-
- def test_has_disliked_topics(self):
- prefs = self._get_default_preferences()
- assert "disliked_topics" in prefs
-
- def test_has_interests(self):
- prefs = self._get_default_preferences()
- assert "interests" in prefs
- assert prefs["interests"] == {}
-
- def test_has_source_weights(self):
- prefs = self._get_default_preferences()
- assert "source_weights" in prefs
- assert prefs["source_weights"] == {}
-
- def test_default_impact_threshold(self):
- prefs = self._get_default_preferences()
- assert prefs["impact_threshold"] == 5
-
- def test_has_focus_preferences(self):
- prefs = self._get_default_preferences()
- assert "focus_preferences" in prefs
-
- def test_default_search_strategy(self):
- prefs = self._get_default_preferences()
- assert prefs["search_strategy"] == "news_aggregation"
-
-
-# --- Focus preferences structure ---
-
-
-class TestFocusPreferencesStructure:
- """Tests for focus_preferences defaults."""
-
- def _get_default_focus(self):
- return {
- "surprising": False,
- "breaking": True,
- "positive": False,
- "local": False,
- }
-
- def test_surprising_default_false(self):
- focus = self._get_default_focus()
- assert focus["surprising"] is False
-
- def test_breaking_default_true(self):
- focus = self._get_default_focus()
- assert focus["breaking"] is True
-
- def test_positive_default_false(self):
- focus = self._get_default_focus()
- assert focus["positive"] is False
-
- def test_local_default_false(self):
- focus = self._get_default_focus()
- assert focus["local"] is False
-
-
-# --- Add interest logic ---
-
-
-class TestAddInterestLogic:
- """Tests for add_interest method logic."""
-
- def _add_interest(self, prefs, interest, weight=1.0):
- if "interests" not in prefs:
- prefs["interests"] = {}
- prefs["interests"][interest] = weight
- prefs["interests_updated_at"] = "2025-06-15T10:00:00+00:00"
- return prefs
-
- def test_adds_interest(self):
- prefs = {}
- result = self._add_interest(prefs, "AI")
- assert "AI" in result["interests"]
-
- def test_default_weight_1(self):
- prefs = {}
- result = self._add_interest(prefs, "AI")
- assert result["interests"]["AI"] == 1.0
-
- def test_custom_weight(self):
- prefs = {}
- result = self._add_interest(prefs, "AI", 2.0)
- assert result["interests"]["AI"] == 2.0
-
- def test_updates_timestamp(self):
- prefs = {}
- result = self._add_interest(prefs, "AI")
- assert "interests_updated_at" in result
-
- def test_creates_interests_dict(self):
- prefs = {}
- result = self._add_interest(prefs, "AI")
- assert "interests" in result
-
-
-# --- Remove interest logic ---
-
-
-class TestRemoveInterestLogic:
- """Tests for remove_interest method logic."""
-
- def _remove_interest(self, prefs, interest):
- if "interests" in prefs and interest in prefs["interests"]:
- del prefs["interests"][interest]
- prefs["interests_updated_at"] = "2025-06-15T10:00:00+00:00"
- return prefs
-
- def test_removes_interest(self):
- prefs = {"interests": {"AI": 1.0, "ML": 1.0}}
- result = self._remove_interest(prefs, "AI")
- assert "AI" not in result["interests"]
- assert "ML" in result["interests"]
-
- def test_no_error_if_not_exists(self):
- prefs = {"interests": {}}
- result = self._remove_interest(prefs, "AI")
- assert result == {"interests": {}}
-
- def test_no_error_if_no_interests_key(self):
- prefs = {}
- result = self._remove_interest(prefs, "AI")
- assert result == {}
-
-
-# --- Ignore topic logic ---
-
-
-class TestIgnoreTopicLogic:
- """Tests for ignore_topic method logic."""
-
- def _ignore_topic(self, prefs, topic):
- if "disliked_topics" not in prefs:
- prefs["disliked_topics"] = []
- if topic not in prefs["disliked_topics"]:
- prefs["disliked_topics"].append(topic)
- prefs["preferences_updated_at"] = "2025-06-15T10:00:00+00:00"
- return prefs
-
- def test_adds_topic(self):
- prefs = {}
- result = self._ignore_topic(prefs, "Politics")
- assert "Politics" in result["disliked_topics"]
-
- def test_no_duplicate(self):
- prefs = {"disliked_topics": ["Politics"]}
- result = self._ignore_topic(prefs, "Politics")
- assert result["disliked_topics"].count("Politics") == 1
-
- def test_creates_disliked_topics_list(self):
- prefs = {}
- result = self._ignore_topic(prefs, "Sports")
- assert "disliked_topics" in result
-
- def test_updates_timestamp_only_on_add(self):
- prefs = {"disliked_topics": ["Politics"]}
- result = self._ignore_topic(prefs, "Politics")
- assert "preferences_updated_at" not in result
-
-
-# --- Boost source logic ---
-
-
-class TestBoostSourceLogic:
- """Tests for boost_source method logic."""
-
- def _boost_source(self, prefs, source, weight=1.5):
- if "source_weights" not in prefs:
- prefs["source_weights"] = {}
- prefs["source_weights"][source] = weight
- prefs["preferences_updated_at"] = "2025-06-15T10:00:00+00:00"
- return prefs
-
- def test_adds_source(self):
- prefs = {}
- result = self._boost_source(prefs, "bbc.com")
- assert "bbc.com" in result["source_weights"]
-
- def test_default_weight_1_5(self):
- prefs = {}
- result = self._boost_source(prefs, "bbc.com")
- assert result["source_weights"]["bbc.com"] == 1.5
-
- def test_custom_weight(self):
- prefs = {}
- result = self._boost_source(prefs, "bbc.com", 2.0)
- assert result["source_weights"]["bbc.com"] == 2.0
-
- def test_overwrites_existing(self):
- prefs = {"source_weights": {"bbc.com": 1.0}}
- result = self._boost_source(prefs, "bbc.com", 2.0)
- assert result["source_weights"]["bbc.com"] == 2.0
-
-
-# --- Topic Registry ---
-
-
-class TestTopicRegistryStructure:
- """Tests for TopicRegistry topic data structure."""
-
- def _create_topic_entry(self, now):
- return {
- "first_seen": now,
- "count": 0,
- "last_seen": now,
- }
-
- def test_has_first_seen(self):
- now = datetime.now(timezone.utc)
- entry = self._create_topic_entry(now)
- assert entry["first_seen"] == now
-
- def test_has_count(self):
- now = datetime.now(timezone.utc)
- entry = self._create_topic_entry(now)
- assert entry["count"] == 0
-
- def test_has_last_seen(self):
- now = datetime.now(timezone.utc)
- entry = self._create_topic_entry(now)
- assert entry["last_seen"] == now
-
-
-# --- Topic registration ---
-
-
-class TestTopicRegistration:
- """Tests for register_topic logic."""
-
- def _register_topic(self, topics, topic, now):
- if topic not in topics:
- topics[topic] = {
- "first_seen": now,
- "count": 0,
- "last_seen": now,
- }
- topics[topic]["count"] += 1
- topics[topic]["last_seen"] = now
- return topics
-
- def test_new_topic(self):
- topics = {}
- now = datetime.now(timezone.utc)
- result = self._register_topic(topics, "AI", now)
- assert "AI" in result
- assert result["AI"]["count"] == 1
-
- def test_existing_topic_increments(self):
- now = datetime.now(timezone.utc)
- topics = {"AI": {"first_seen": now, "count": 5, "last_seen": now}}
- result = self._register_topic(topics, "AI", now)
- assert result["AI"]["count"] == 6
-
- def test_updates_last_seen(self):
- old_time = datetime(2025, 1, 1, tzinfo=timezone.utc)
- new_time = datetime(2025, 6, 15, tzinfo=timezone.utc)
- topics = {
- "AI": {"first_seen": old_time, "count": 1, "last_seen": old_time}
- }
- result = self._register_topic(topics, "AI", new_time)
- assert result["AI"]["last_seen"] == new_time
-
- def test_preserves_first_seen(self):
- old_time = datetime(2025, 1, 1, tzinfo=timezone.utc)
- new_time = datetime(2025, 6, 15, tzinfo=timezone.utc)
- topics = {
- "AI": {"first_seen": old_time, "count": 1, "last_seen": old_time}
- }
- result = self._register_topic(topics, "AI", new_time)
- assert result["AI"]["first_seen"] == old_time
-
-
-# --- Get trending topics ---
-
-
-class TestGetTrendingTopics:
- """Tests for get_trending_topics logic."""
-
- def _get_trending(self, topics, cutoff_time, limit):
- recent = [
- (topic, data)
- for topic, data in topics.items()
- if data["last_seen"] >= cutoff_time
- ]
- recent.sort(key=lambda x: x[1]["count"], reverse=True)
- return [topic for topic, _ in recent[:limit]]
-
- def test_filters_old_topics(self):
- cutoff = datetime(2025, 6, 1, tzinfo=timezone.utc)
- topics = {
- "AI": {
- "last_seen": datetime(2025, 6, 15, tzinfo=timezone.utc),
- "count": 10,
- },
- "Old": {
- "last_seen": datetime(2025, 1, 1, tzinfo=timezone.utc),
- "count": 5,
- },
- }
- result = self._get_trending(topics, cutoff, 10)
- assert "AI" in result
- assert "Old" not in result
-
- def test_sorts_by_count(self):
- cutoff = datetime(2025, 6, 1, tzinfo=timezone.utc)
- recent = datetime(2025, 6, 15, tzinfo=timezone.utc)
- topics = {
- "A": {"last_seen": recent, "count": 5},
- "B": {"last_seen": recent, "count": 10},
- "C": {"last_seen": recent, "count": 3},
- }
- result = self._get_trending(topics, cutoff, 10)
- assert result[0] == "B"
- assert result[1] == "A"
- assert result[2] == "C"
-
- def test_respects_limit(self):
- cutoff = datetime(2025, 6, 1, tzinfo=timezone.utc)
- recent = datetime(2025, 6, 15, tzinfo=timezone.utc)
- topics = {f"T{i}": {"last_seen": recent, "count": i} for i in range(20)}
- result = self._get_trending(topics, cutoff, 5)
- assert len(result) == 5
-
- def test_empty_when_all_old(self):
- cutoff = datetime(2025, 6, 1, tzinfo=timezone.utc)
- topics = {
- "Old": {
- "last_seen": datetime(2025, 1, 1, tzinfo=timezone.utc),
- "count": 10,
- },
- }
- result = self._get_trending(topics, cutoff, 10)
- assert result == []
-
-
-# --- Get topic info ---
-
-
-class TestGetTopicInfo:
- """Tests for get_topic_info logic."""
-
- def _get_topic_info(self, topics, topic):
- return topics.get(topic)
-
- def test_found_topic(self):
- topics = {"AI": {"count": 10}}
- result = self._get_topic_info(topics, "AI")
- assert result["count"] == 10
-
- def test_not_found_topic(self):
- topics = {}
- result = self._get_topic_info(topics, "AI")
- assert result is None
-
-
-# --- Cutoff time calculation ---
-
-
-class TestCutoffTimeCalculation:
- """Tests for trending topic cutoff calculation."""
-
- def _calc_cutoff(self, now, hours):
- return now - timedelta(hours=hours)
-
- def test_24_hours(self):
- now = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- cutoff = self._calc_cutoff(now, 24)
- assert cutoff == datetime(2025, 6, 14, 12, 0, tzinfo=timezone.utc)
-
- def test_48_hours(self):
- now = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- cutoff = self._calc_cutoff(now, 48)
- assert cutoff == datetime(2025, 6, 13, 12, 0, tzinfo=timezone.utc)
-
-
-# --- Extract topics from content ---
-
-
-class TestExtractTopicsFromContent:
- """Tests for topic extraction behavior."""
-
- def test_max_topics_limit(self):
- max_topics = 5
- topics = ["T1", "T2", "T3", "T4", "T5", "T6", "T7"]
- limited = topics[:max_topics]
- assert len(limited) == 5
-
- def test_registers_discovered_topics(self):
- topics_registry = {}
- discovered = ["AI", "ML", "NLP"]
-
- for topic in discovered:
- if topic not in topics_registry:
- topics_registry[topic] = {"count": 0}
- topics_registry[topic]["count"] += 1
-
- assert len(topics_registry) == 3
-
-
-# --- Preferences timestamp patterns ---
-
-
-class TestPreferencesTimestampPatterns:
- """Tests for timestamp update patterns."""
-
- def test_created_at_set_once(self):
- prefs = {"created_at": "2025-01-01T00:00:00+00:00"}
- # created_at should not change
- assert prefs["created_at"] == "2025-01-01T00:00:00+00:00"
-
- def test_preferences_updated_at_changes(self):
- prefs = {"preferences_updated_at": "2025-01-01T00:00:00+00:00"}
- prefs["preferences_updated_at"] = "2025-06-15T10:00:00+00:00"
- assert prefs["preferences_updated_at"] == "2025-06-15T10:00:00+00:00"
-
- def test_interests_updated_at_changes(self):
- prefs = {}
- prefs["interests_updated_at"] = "2025-06-15T10:00:00+00:00"
- assert "interests_updated_at" in prefs
diff --git a/tests/news/test_base_rater_logic_behavior.py b/tests/news/test_base_rater_logic_behavior.py
deleted file mode 100644
index 9f8a285bb5..0000000000
--- a/tests/news/test_base_rater_logic_behavior.py
+++ /dev/null
@@ -1,424 +0,0 @@
-"""
-Deep behavioral tests for base_rater.py pure logic.
-Tests rating enums, validation logic, record creation,
-and rating system behavior patterns.
-"""
-
-
-# --- RelevanceRating enum ---
-
-
-class TestRelevanceRatingEnum:
- """Tests for RelevanceRating enum values."""
-
- def test_up_value(self):
- assert "up" == "up"
-
- def test_down_value(self):
- assert "down" == "down"
-
- def test_only_two_values(self):
- valid_values = ["up", "down"]
- assert len(valid_values) == 2
-
-
-class TestRelevanceRatingValidation:
- """Tests for RelevanceRating validation."""
-
- def _is_valid_relevance(self, value):
- return value in ["up", "down"]
-
- def test_up_is_valid(self):
- assert self._is_valid_relevance("up") is True
-
- def test_down_is_valid(self):
- assert self._is_valid_relevance("down") is True
-
- def test_invalid_value(self):
- assert self._is_valid_relevance("neutral") is False
-
- def test_empty_invalid(self):
- assert self._is_valid_relevance("") is False
-
-
-# --- QualityRating enum ---
-
-
-class TestQualityRatingEnum:
- """Tests for QualityRating enum values."""
-
- def test_one_star_value(self):
- assert 1 == 1
-
- def test_five_star_value(self):
- assert 5 == 5
-
- def test_all_star_values(self):
- valid_values = [1, 2, 3, 4, 5]
- assert len(valid_values) == 5
- assert min(valid_values) == 1
- assert max(valid_values) == 5
-
-
-class TestQualityRatingValidation:
- """Tests for QualityRating validation."""
-
- def _is_valid_quality(self, value):
- return isinstance(value, int) and 1 <= value <= 5
-
- def test_one_star_valid(self):
- assert self._is_valid_quality(1) is True
-
- def test_five_stars_valid(self):
- assert self._is_valid_quality(5) is True
-
- def test_three_stars_valid(self):
- assert self._is_valid_quality(3) is True
-
- def test_zero_invalid(self):
- assert self._is_valid_quality(0) is False
-
- def test_six_invalid(self):
- assert self._is_valid_quality(6) is False
-
- def test_float_invalid(self):
- assert self._is_valid_quality(3.5) is False
-
- def test_string_invalid(self):
- assert self._is_valid_quality("3") is False
-
-
-# --- Rating record creation ---
-
-
-class TestRatingRecordCreation:
- """Tests for _create_rating_record logic."""
-
- def _create_rating_record(
- self, user_id, card_id, rating_type, rating_value, metadata=None
- ):
- return {
- "user_id": user_id,
- "card_id": card_id,
- "rating_type": rating_type,
- "rating_value": rating_value,
- "rated_at": "2025-06-15T10:00:00+00:00", # Simplified
- "metadata": metadata or {},
- }
-
- def test_includes_user_id(self):
- record = self._create_rating_record("u1", "c1", "quality", 4)
- assert record["user_id"] == "u1"
-
- def test_includes_card_id(self):
- record = self._create_rating_record("u1", "c1", "quality", 4)
- assert record["card_id"] == "c1"
-
- def test_includes_rating_type(self):
- record = self._create_rating_record("u1", "c1", "relevance", "up")
- assert record["rating_type"] == "relevance"
-
- def test_includes_rating_value(self):
- record = self._create_rating_record("u1", "c1", "quality", 5)
- assert record["rating_value"] == 5
-
- def test_includes_rated_at(self):
- record = self._create_rating_record("u1", "c1", "quality", 4)
- assert "rated_at" in record
-
- def test_default_empty_metadata(self):
- record = self._create_rating_record("u1", "c1", "quality", 4)
- assert record["metadata"] == {}
-
- def test_includes_provided_metadata(self):
- metadata = {"source": "user_action"}
- record = self._create_rating_record("u1", "c1", "quality", 4, metadata)
- assert record["metadata"]["source"] == "user_action"
-
-
-# --- Base rating validation ---
-
-
-class TestBaseRatingValidation:
- """Tests for _validate_rating_value base logic."""
-
- def _validate_not_none(self, rating_value):
- if rating_value is None:
- raise ValueError("Rating value cannot be None")
-
- def test_none_raises_error(self):
- try:
- self._validate_not_none(None)
- assert False, "Should have raised ValueError"
- except ValueError as e:
- assert "cannot be None" in str(e)
-
- def test_value_passes(self):
- self._validate_not_none("up") # Should not raise
- self._validate_not_none(5) # Should not raise
-
-
-# --- Quality rating system ---
-
-
-class TestQualityRatingSystem:
- """Tests for QualityRatingSystem behavior."""
-
- def _get_rating_type(self):
- return "quality"
-
- def test_rating_type_quality(self):
- assert self._get_rating_type() == "quality"
-
-
-class TestQualityRatingResponse:
- """Tests for quality rating response structure."""
-
- def _build_quality_response(self, record, stars):
- return {
- "success": True,
- "rating": record,
- "message": f"Quality rating of {stars} stars recorded",
- }
-
- def test_success_true(self):
- response = self._build_quality_response({}, 4)
- assert response["success"] is True
-
- def test_includes_rating_record(self):
- record = {"user_id": "u1", "rating_value": 4}
- response = self._build_quality_response(record, 4)
- assert response["rating"] == record
-
- def test_message_includes_stars(self):
- response = self._build_quality_response({}, 5)
- assert "5 stars" in response["message"]
-
-
-# --- Relevance rating system ---
-
-
-class TestRelevanceRatingSystem:
- """Tests for RelevanceRatingSystem behavior."""
-
- def _get_rating_type(self):
- return "relevance"
-
- def test_rating_type_relevance(self):
- assert self._get_rating_type() == "relevance"
-
-
-class TestRelevanceRatingResponse:
- """Tests for relevance rating response structure."""
-
- def _build_relevance_response(self, record, direction):
- return {
- "success": True,
- "rating": record,
- "message": f"Relevance rating of thumbs {direction} recorded",
- }
-
- def test_success_true(self):
- response = self._build_relevance_response({}, "up")
- assert response["success"] is True
-
- def test_message_thumbs_up(self):
- response = self._build_relevance_response({}, "up")
- assert "thumbs up" in response["message"]
-
- def test_message_thumbs_down(self):
- response = self._build_relevance_response({}, "down")
- assert "thumbs down" in response["message"]
-
-
-# --- Default implementations ---
-
-
-class TestDefaultImplementations:
- """Tests for default method implementations."""
-
- def test_get_recent_ratings_returns_empty(self):
- # Default implementation returns empty list
- result = []
- assert result == []
-
- def test_get_card_ratings_default(self):
- # Default implementation
- result = {"total": 0, "average": None}
- assert result["total"] == 0
- assert result["average"] is None
-
- def test_remove_rating_default_false(self):
- # Default implementation returns False
- result = False
- assert result is False
-
-
-# --- Storage backend handling ---
-
-
-class TestStorageBackendHandling:
- """Tests for storage backend conditional logic."""
-
- def _should_store(self, storage_backend):
- return storage_backend is not None
-
- def test_with_backend(self):
- backend = {"mock": True}
- assert self._should_store(backend) is True
-
- def test_without_backend(self):
- assert self._should_store(None) is False
-
-
-class TestStorageBackendQuery:
- """Tests for storage backend query logic."""
-
- def _get_rating_from_storage(self, storage_backend, user_id, card_id):
- if storage_backend:
- # Would query storage here
- return {"user_id": user_id, "card_id": card_id}
- return None
-
- def test_with_backend_returns_rating(self):
- result = self._get_rating_from_storage({"mock": True}, "u1", "c1")
- assert result is not None
- assert result["user_id"] == "u1"
-
- def test_without_backend_returns_none(self):
- result = self._get_rating_from_storage(None, "u1", "c1")
- assert result is None
-
-
-# --- Rating type from class name ---
-
-
-class TestRatingTypeFromClassName:
- """Tests for rating_type from class name."""
-
- def _get_rating_type_from_class(self, class_name):
- return class_name
-
- def test_quality_rating_system(self):
- assert (
- self._get_rating_type_from_class("QualityRatingSystem")
- == "QualityRatingSystem"
- )
-
- def test_relevance_rating_system(self):
- assert (
- self._get_rating_type_from_class("RelevanceRatingSystem")
- == "RelevanceRatingSystem"
- )
-
-
-# --- Enum value extraction ---
-
-
-class TestEnumValueExtraction:
- """Tests for extracting values from enums."""
-
- def _get_enum_value(self, enum_obj):
- if hasattr(enum_obj, "value"):
- return enum_obj.value
- return enum_obj
-
- def test_string_passthrough(self):
- assert self._get_enum_value("up") == "up"
-
- def test_int_passthrough(self):
- assert self._get_enum_value(5) == 5
-
- def test_enum_like_extraction(self):
- class FakeEnum:
- value = "down"
-
- assert self._get_enum_value(FakeEnum()) == "down"
-
-
-# --- Quality rating validation ---
-
-
-class TestQualityRatingValidationLogic:
- """Tests for quality-specific validation."""
-
- def _validate_quality_rating(self, value):
- if value is None:
- raise ValueError("Rating value cannot be None")
- if not (isinstance(value, int) and 1 <= value <= 5):
- raise ValueError("Quality rating must be 1-5 stars")
-
- def test_valid_rating(self):
- self._validate_quality_rating(3) # Should not raise
-
- def test_none_raises(self):
- try:
- self._validate_quality_rating(None)
- assert False
- except ValueError:
- pass
-
- def test_zero_raises(self):
- try:
- self._validate_quality_rating(0)
- assert False
- except ValueError:
- pass
-
- def test_six_raises(self):
- try:
- self._validate_quality_rating(6)
- assert False
- except ValueError:
- pass
-
-
-# --- Relevance rating validation ---
-
-
-class TestRelevanceRatingValidationLogic:
- """Tests for relevance-specific validation."""
-
- def _validate_relevance_rating(self, value):
- if value is None:
- raise ValueError("Rating value cannot be None")
- if value not in ["up", "down"]:
- raise ValueError("Relevance rating must be 'up' or 'down'")
-
- def test_up_valid(self):
- self._validate_relevance_rating("up") # Should not raise
-
- def test_down_valid(self):
- self._validate_relevance_rating("down") # Should not raise
-
- def test_none_raises(self):
- try:
- self._validate_relevance_rating(None)
- assert False
- except ValueError:
- pass
-
- def test_invalid_value_raises(self):
- try:
- self._validate_relevance_rating("neutral")
- assert False
- except ValueError:
- pass
-
-
-# --- Timestamp handling ---
-
-
-class TestRatingTimestampHandling:
- """Tests for rated_at timestamp handling."""
-
- def _format_timestamp(self, dt):
- return dt.isoformat()
-
- def test_isoformat_output(self):
- from datetime import datetime, timezone
-
- dt = datetime(2025, 6, 15, 10, 30, 0, tzinfo=timezone.utc)
- result = self._format_timestamp(dt)
- assert "2025-06-15" in result
- assert "10:30:00" in result
diff --git a/tests/news/test_caching_patterns_behavior.py b/tests/news/test_caching_patterns_behavior.py
deleted file mode 100644
index 5f3dd6b18d..0000000000
--- a/tests/news/test_caching_patterns_behavior.py
+++ /dev/null
@@ -1,614 +0,0 @@
-"""
-Deep behavioral tests for caching patterns.
-Tests LRU cache, TTL cache, cache invalidation,
-and cache warming logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-from collections import OrderedDict
-import hashlib
-
-
-# --- LRU cache patterns ---
-
-
-class TestLRUCache:
- """Tests for LRU cache patterns."""
-
- def _create_lru_cache(self, max_size=100):
- """Create an LRU cache."""
- return {"max_size": max_size, "cache": OrderedDict()}
-
- def _get(self, cache_obj, key):
- """Get value from LRU cache."""
- cache = cache_obj["cache"]
- if key in cache:
- # Move to end (most recently used)
- cache.move_to_end(key)
- return cache[key]
- return None
-
- def _put(self, cache_obj, key, value):
- """Put value in LRU cache."""
- cache = cache_obj["cache"]
- max_size = cache_obj["max_size"]
- if key in cache:
- cache.move_to_end(key)
- cache[key] = value
- while len(cache) > max_size:
- cache.popitem(last=False)
-
- def test_put_and_get(self):
- cache_obj = self._create_lru_cache()
- self._put(cache_obj, "key1", "value1")
- assert self._get(cache_obj, "key1") == "value1"
-
- def test_miss_returns_none(self):
- cache_obj = self._create_lru_cache()
- assert self._get(cache_obj, "missing") is None
-
- def test_evicts_oldest(self):
- cache_obj = self._create_lru_cache(max_size=2)
- self._put(cache_obj, "a", 1)
- self._put(cache_obj, "b", 2)
- self._put(cache_obj, "c", 3) # Should evict "a"
- assert self._get(cache_obj, "a") is None
- assert self._get(cache_obj, "b") == 2
- assert self._get(cache_obj, "c") == 3
-
- def test_access_prevents_eviction(self):
- cache_obj = self._create_lru_cache(max_size=2)
- self._put(cache_obj, "a", 1)
- self._put(cache_obj, "b", 2)
- self._get(cache_obj, "a") # Access "a"
- self._put(cache_obj, "c", 3) # Should evict "b"
- assert self._get(cache_obj, "a") == 1
- assert self._get(cache_obj, "b") is None
-
- def test_update_existing(self):
- cache_obj = self._create_lru_cache()
- self._put(cache_obj, "key", "old")
- self._put(cache_obj, "key", "new")
- assert self._get(cache_obj, "key") == "new"
-
-
-# --- TTL cache patterns ---
-
-
-class TestTTLCache:
- """Tests for TTL cache patterns."""
-
- def _create_ttl_cache(self, ttl_seconds=300):
- """Create a TTL cache."""
- return {"ttl_seconds": ttl_seconds, "cache": {}}
-
- def _get(self, cache_obj, key):
- """Get value from TTL cache."""
- cache = cache_obj["cache"]
- ttl = cache_obj["ttl_seconds"]
- if key not in cache:
- return None
- entry = cache[key]
- if datetime.now(timezone.utc) - entry["timestamp"] > timedelta(
- seconds=ttl
- ):
- del cache[key]
- return None
- return entry["value"]
-
- def _put(self, cache_obj, key, value):
- """Put value in TTL cache."""
- cache_obj["cache"][key] = {
- "value": value,
- "timestamp": datetime.now(timezone.utc),
- }
-
- def test_put_and_get(self):
- cache_obj = self._create_ttl_cache()
- self._put(cache_obj, "key1", "value1")
- assert self._get(cache_obj, "key1") == "value1"
-
- def test_miss_returns_none(self):
- cache_obj = self._create_ttl_cache()
- assert self._get(cache_obj, "missing") is None
-
- def test_expired_entry_returns_none(self):
- cache_obj = self._create_ttl_cache(ttl_seconds=1)
- cache_obj["cache"]["key"] = {
- "value": "old",
- "timestamp": datetime.now(timezone.utc) - timedelta(seconds=10),
- }
- assert self._get(cache_obj, "key") is None
-
- def test_fresh_entry_returned(self):
- cache_obj = self._create_ttl_cache(ttl_seconds=300)
- cache_obj["cache"]["key"] = {
- "value": "fresh",
- "timestamp": datetime.now(timezone.utc) - timedelta(seconds=100),
- }
- assert self._get(cache_obj, "key") == "fresh"
-
-
-class TestTTLCacheCleanup:
- """Tests for TTL cache cleanup patterns."""
-
- def _cleanup_expired(self, cache_obj):
- """Remove all expired entries."""
- ttl = cache_obj["ttl_seconds"]
- now = datetime.now(timezone.utc)
- expired_keys = [
- key
- for key, entry in cache_obj["cache"].items()
- if now - entry["timestamp"] > timedelta(seconds=ttl)
- ]
- for key in expired_keys:
- del cache_obj["cache"][key]
- return len(expired_keys)
-
- def test_removes_expired(self):
- cache_obj = {"ttl_seconds": 60, "cache": {}}
- old = datetime.now(timezone.utc) - timedelta(seconds=120)
- fresh = datetime.now(timezone.utc)
- cache_obj["cache"]["old"] = {"value": 1, "timestamp": old}
- cache_obj["cache"]["fresh"] = {"value": 2, "timestamp": fresh}
- removed = self._cleanup_expired(cache_obj)
- assert removed == 1
- assert "old" not in cache_obj["cache"]
- assert "fresh" in cache_obj["cache"]
-
- def test_returns_count(self):
- cache_obj = {"ttl_seconds": 60, "cache": {}}
- old = datetime.now(timezone.utc) - timedelta(seconds=120)
- for i in range(5):
- cache_obj["cache"][f"key{i}"] = {"value": i, "timestamp": old}
- removed = self._cleanup_expired(cache_obj)
- assert removed == 5
-
-
-# --- Cache key generation patterns ---
-
-
-class TestCacheKeyGeneration:
- """Tests for cache key generation patterns."""
-
- def _generate_key(self, *args, **kwargs):
- """Generate cache key from arguments."""
- parts = [str(a) for a in args]
- parts.extend(f"{k}={v}" for k, v in sorted(kwargs.items()))
- return ":".join(parts)
-
- def _hash_key(self, key):
- """Hash a cache key."""
- return hashlib.sha256(key.encode()).hexdigest()
-
- def test_simple_key(self):
- key = self._generate_key("user", "123")
- assert key == "user:123"
-
- def test_with_kwargs(self):
- key = self._generate_key("search", query="test", page=1)
- assert "query=test" in key
- assert "page=1" in key
-
- def test_consistent_ordering(self):
- key1 = self._generate_key("search", a=1, b=2)
- key2 = self._generate_key("search", b=2, a=1)
- assert key1 == key2
-
- def test_hash_produces_fixed_length(self):
- key = self._generate_key("very", "long", "key", "with", "many", "parts")
- hashed = self._hash_key(key)
- assert len(hashed) == 64
-
-
-class TestCacheKeyNamespacing:
- """Tests for cache key namespacing patterns."""
-
- def _namespace_key(self, namespace, key):
- """Add namespace prefix to key."""
- return f"{namespace}:{key}"
-
- def _extract_namespace(self, full_key):
- """Extract namespace from full key."""
- if ":" not in full_key:
- return None
- return full_key.split(":")[0]
-
- def test_adds_namespace(self):
- key = self._namespace_key("news", "card-123")
- assert key == "news:card-123"
-
- def test_extracts_namespace(self):
- namespace = self._extract_namespace("news:card-123")
- assert namespace == "news"
-
- def test_no_namespace(self):
- namespace = self._extract_namespace("simple-key")
- assert namespace is None
-
-
-# --- Cache invalidation patterns ---
-
-
-class TestCacheInvalidation:
- """Tests for cache invalidation patterns."""
-
- def _invalidate(self, cache, key):
- """Invalidate single cache entry."""
- if key in cache:
- del cache[key]
- return True
- return False
-
- def _invalidate_pattern(self, cache, pattern):
- """Invalidate all keys matching pattern."""
- matching_keys = [k for k in cache.keys() if pattern in k]
- for key in matching_keys:
- del cache[key]
- return len(matching_keys)
-
- def _invalidate_all(self, cache):
- """Invalidate entire cache."""
- count = len(cache)
- cache.clear()
- return count
-
- def test_invalidate_removes_entry(self):
- cache = {"key1": "value1", "key2": "value2"}
- self._invalidate(cache, "key1")
- assert "key1" not in cache
- assert "key2" in cache
-
- def test_invalidate_returns_true_if_found(self):
- cache = {"key": "value"}
- result = self._invalidate(cache, "key")
- assert result is True
-
- def test_invalidate_returns_false_if_missing(self):
- cache = {}
- result = self._invalidate(cache, "key")
- assert result is False
-
- def test_invalidate_pattern(self):
- cache = {"user:1:profile": 1, "user:2:profile": 2, "settings": 3}
- removed = self._invalidate_pattern(cache, "user:")
- assert removed == 2
- assert "settings" in cache
-
- def test_invalidate_all(self):
- cache = {"a": 1, "b": 2, "c": 3}
- removed = self._invalidate_all(cache)
- assert removed == 3
- assert len(cache) == 0
-
-
-class TestVersionedCacheInvalidation:
- """Tests for versioned cache invalidation patterns."""
-
- def _create_versioned_cache(self):
- """Create a versioned cache."""
- return {"version": 1, "cache": {}}
-
- def _get_with_version(self, cache_obj, key):
- """Get value checking version."""
- version = cache_obj["version"]
- cache = cache_obj["cache"]
- if key not in cache:
- return None
- entry = cache[key]
- if entry.get("version") != version:
- return None
- return entry["value"]
-
- def _put_with_version(self, cache_obj, key, value):
- """Put value with current version."""
- cache_obj["cache"][key] = {
- "value": value,
- "version": cache_obj["version"],
- }
-
- def _bump_version(self, cache_obj):
- """Increment version to invalidate all."""
- cache_obj["version"] += 1
- return cache_obj["version"]
-
- def test_get_with_correct_version(self):
- cache_obj = self._create_versioned_cache()
- self._put_with_version(cache_obj, "key", "value")
- assert self._get_with_version(cache_obj, "key") == "value"
-
- def test_version_bump_invalidates(self):
- cache_obj = self._create_versioned_cache()
- self._put_with_version(cache_obj, "key", "value")
- self._bump_version(cache_obj)
- assert self._get_with_version(cache_obj, "key") is None
-
-
-# --- Cache warming patterns ---
-
-
-class TestCacheWarming:
- """Tests for cache warming patterns."""
-
- def _warm_cache(self, cache, keys, fetch_func):
- """Warm cache with specified keys."""
- warmed = 0
- for key in keys:
- if key not in cache:
- try:
- value = fetch_func(key)
- if value is not None:
- cache[key] = value
- warmed += 1
- except Exception:
- pass
- return warmed
-
- def _get_cold_keys(self, cache, all_keys):
- """Get keys that are not in cache."""
- return [k for k in all_keys if k not in cache]
-
- def test_warms_missing_keys(self):
- cache = {"existing": "value"}
- keys = ["existing", "new1", "new2"]
- warmed = self._warm_cache(cache, keys, lambda k: f"value-{k}")
- assert warmed == 2
- assert "new1" in cache
-
- def test_skips_existing(self):
- cache = {"key": "original"}
- self._warm_cache(cache, ["key"], lambda k: "new")
- assert cache["key"] == "original"
-
- def test_handles_fetch_error(self):
- cache = {}
-
- def failing_fetch(key):
- raise Exception("Fetch failed")
-
- warmed = self._warm_cache(cache, ["key"], failing_fetch)
- assert warmed == 0
-
- def test_get_cold_keys(self):
- cache = {"a": 1, "b": 2}
- cold = self._get_cold_keys(cache, ["a", "b", "c", "d"])
- assert cold == ["c", "d"]
-
-
-# --- Cache statistics patterns ---
-
-
-class TestCacheStatistics:
- """Tests for cache statistics patterns."""
-
- def _create_cache_with_stats(self):
- """Create cache with statistics tracking."""
- return {
- "cache": {},
- "hits": 0,
- "misses": 0,
- }
-
- def _get_with_stats(self, cache_obj, key):
- """Get value and track statistics."""
- if key in cache_obj["cache"]:
- cache_obj["hits"] += 1
- return cache_obj["cache"][key]
- cache_obj["misses"] += 1
- return None
-
- def _get_hit_rate(self, cache_obj):
- """Calculate cache hit rate."""
- total = cache_obj["hits"] + cache_obj["misses"]
- if total == 0:
- return 0.0
- return cache_obj["hits"] / total
-
- def test_tracks_hits(self):
- cache_obj = self._create_cache_with_stats()
- cache_obj["cache"]["key"] = "value"
- self._get_with_stats(cache_obj, "key")
- assert cache_obj["hits"] == 1
-
- def test_tracks_misses(self):
- cache_obj = self._create_cache_with_stats()
- self._get_with_stats(cache_obj, "missing")
- assert cache_obj["misses"] == 1
-
- def test_hit_rate_calculation(self):
- cache_obj = self._create_cache_with_stats()
- cache_obj["hits"] = 75
- cache_obj["misses"] = 25
- assert self._get_hit_rate(cache_obj) == 0.75
-
- def test_hit_rate_empty(self):
- cache_obj = self._create_cache_with_stats()
- assert self._get_hit_rate(cache_obj) == 0.0
-
-
-# --- Cache size management patterns ---
-
-
-class TestCacheSizeManagement:
- """Tests for cache size management patterns."""
-
- def _estimate_size(self, cache):
- """Estimate cache size in bytes."""
- total = 0
- for key, value in cache.items():
- total += len(str(key)) + len(str(value))
- return total
-
- def _should_evict(self, cache, max_size_bytes):
- """Check if cache needs eviction."""
- return self._estimate_size(cache) > max_size_bytes
-
- def test_size_estimation(self):
- cache = {"a": "1234567890"} # 1 + 10 = 11 bytes
- size = self._estimate_size(cache)
- assert size == 11
-
- def test_should_evict_when_over_limit(self):
- cache = {"key": "a" * 1000}
- assert self._should_evict(cache, 100) is True
-
- def test_should_not_evict_under_limit(self):
- cache = {"key": "small"}
- assert self._should_evict(cache, 10000) is False
-
-
-# --- Write-through cache patterns ---
-
-
-class TestWriteThroughCache:
- """Tests for write-through cache patterns."""
-
- def _write_through(self, cache, storage, key, value):
- """Write to both cache and storage."""
- storage[key] = value # Write to storage first
- cache[key] = value # Then update cache
- return True
-
- def _read_through(self, cache, storage, key):
- """Read from cache, fallback to storage."""
- if key in cache:
- return cache[key]
- if key in storage:
- value = storage[key]
- cache[key] = value # Populate cache
- return value
- return None
-
- def test_write_updates_both(self):
- cache = {}
- storage = {}
- self._write_through(cache, storage, "key", "value")
- assert cache["key"] == "value"
- assert storage["key"] == "value"
-
- def test_read_hits_cache(self):
- cache = {"key": "cached"}
- storage = {"key": "stored"}
- value = self._read_through(cache, storage, "key")
- assert value == "cached"
-
- def test_read_falls_through_to_storage(self):
- cache = {}
- storage = {"key": "stored"}
- value = self._read_through(cache, storage, "key")
- assert value == "stored"
- assert cache["key"] == "stored" # Now cached
-
-
-# --- Cache aside patterns ---
-
-
-class TestCacheAsidePattern:
- """Tests for cache-aside (lazy loading) patterns."""
-
- def _get_or_load(self, cache, key, load_func):
- """Get from cache or load if missing."""
- if key in cache:
- return cache[key], True # value, was_cached
- value = load_func(key)
- if value is not None:
- cache[key] = value
- return value, False
-
- def test_returns_cached(self):
- cache = {"key": "cached"}
- value, was_cached = self._get_or_load(cache, "key", lambda k: "loaded")
- assert value == "cached"
- assert was_cached is True
-
- def test_loads_on_miss(self):
- cache = {}
- value, was_cached = self._get_or_load(cache, "key", lambda k: "loaded")
- assert value == "loaded"
- assert was_cached is False
-
- def test_caches_loaded_value(self):
- cache = {}
- self._get_or_load(cache, "key", lambda k: "loaded")
- assert cache["key"] == "loaded"
-
-
-# --- Memoization patterns ---
-
-
-class TestMemoization:
- """Tests for function memoization patterns."""
-
- def _memoize(self, func, cache, key):
- """Memoize function result."""
- if key in cache:
- return cache[key]
- result = func()
- cache[key] = result
- return result
-
- def test_caches_result(self):
- cache = {}
- call_count = [0]
-
- def expensive():
- call_count[0] += 1
- return "result"
-
- self._memoize(expensive, cache, "key")
- self._memoize(expensive, cache, "key")
- assert call_count[0] == 1
-
- def test_returns_cached_result(self):
- cache = {"key": "cached"}
- result = self._memoize(lambda: "fresh", cache, "key")
- assert result == "cached"
-
-
-# --- Multi-level cache patterns ---
-
-
-class TestMultiLevelCache:
- """Tests for multi-level cache patterns."""
-
- def _get_multi_level(self, l1_cache, l2_cache, key):
- """Get from L1, then L2."""
- if key in l1_cache:
- return l1_cache[key], "L1"
- if key in l2_cache:
- # Promote to L1
- l1_cache[key] = l2_cache[key]
- return l2_cache[key], "L2"
- return None, None
-
- def _put_multi_level(self, l1_cache, l2_cache, key, value):
- """Put to both L1 and L2."""
- l1_cache[key] = value
- l2_cache[key] = value
-
- def test_hits_l1_first(self):
- l1 = {"key": "L1-value"}
- l2 = {"key": "L2-value"}
- value, level = self._get_multi_level(l1, l2, "key")
- assert value == "L1-value"
- assert level == "L1"
-
- def test_falls_to_l2(self):
- l1 = {}
- l2 = {"key": "L2-value"}
- value, level = self._get_multi_level(l1, l2, "key")
- assert value == "L2-value"
- assert level == "L2"
-
- def test_promotes_to_l1(self):
- l1 = {}
- l2 = {"key": "value"}
- self._get_multi_level(l1, l2, "key")
- assert l1["key"] == "value"
-
- def test_miss_returns_none(self):
- l1 = {}
- l2 = {}
- value, level = self._get_multi_level(l1, l2, "key")
- assert value is None
- assert level is None
diff --git a/tests/news/test_card_factory_logic_behavior.py b/tests/news/test_card_factory_logic_behavior.py
deleted file mode 100644
index 1c4f262457..0000000000
--- a/tests/news/test_card_factory_logic_behavior.py
+++ /dev/null
@@ -1,463 +0,0 @@
-"""
-Deep behavioral tests for card_factory.py pure logic.
-Tests card type registry, card reconstruction logic,
-source extraction, and user card filtering.
-"""
-
-from datetime import datetime, timezone
-
-
-# --- Card type registry ---
-
-
-class TestCardTypeRegistry:
- """Tests for card type registration."""
-
- def _get_default_types(self):
- return {
- "news": "NewsCard",
- "research": "ResearchCard",
- "update": "UpdateCard",
- "overview": "OverviewCard",
- }
-
- def test_has_news_type(self):
- types = self._get_default_types()
- assert "news" in types
-
- def test_has_research_type(self):
- types = self._get_default_types()
- assert "research" in types
-
- def test_has_update_type(self):
- types = self._get_default_types()
- assert "update" in types
-
- def test_has_overview_type(self):
- types = self._get_default_types()
- assert "overview" in types
-
- def test_exactly_four_types(self):
- types = self._get_default_types()
- assert len(types) == 4
-
-
-class TestCardTypeRegistration:
- """Tests for registering new card types."""
-
- def test_register_adds_type(self):
- registry = {"news": "NewsCard"}
- registry["custom"] = "CustomCard"
- assert "custom" in registry
-
- def test_overwrite_existing_type(self):
- registry = {"news": "NewsCard"}
- registry["news"] = "NewNewsCard"
- assert registry["news"] == "NewNewsCard"
-
-
-class TestCardTypeValidation:
- """Tests for card type validation."""
-
- def _is_valid_type(self, card_type, registry):
- return card_type in registry
-
- def test_valid_type(self):
- registry = {"news": "NewsCard"}
- assert self._is_valid_type("news", registry) is True
-
- def test_invalid_type(self):
- registry = {"news": "NewsCard"}
- assert self._is_valid_type("unknown", registry) is False
-
-
-# --- Card reconstruction source extraction ---
-
-
-class TestReconstructSourceExtraction:
- """Tests for extracting source data during reconstruction."""
-
- def _extract_source(self, card_data):
- source_data = card_data.get("source", {})
- if not source_data:
- source_data = {
- "type": card_data.get("source_type", "unknown"),
- "source_id": card_data.get("source_id"),
- "created_from": card_data.get("created_from", ""),
- "metadata": {},
- }
- return source_data
-
- def test_from_nested_source(self):
- card_data = {
- "source": {
- "type": "news_topic",
- "source_id": "t123",
- "created_from": "Topic",
- "metadata": {"key": "value"},
- }
- }
- source = self._extract_source(card_data)
- assert source["type"] == "news_topic"
- assert source["metadata"]["key"] == "value"
-
- def test_from_flat_fields(self):
- card_data = {
- "source_type": "user_search",
- "source_id": "s456",
- "created_from": "Search",
- }
- source = self._extract_source(card_data)
- assert source["type"] == "user_search"
- assert source["source_id"] == "s456"
-
- def test_default_type_unknown(self):
- card_data = {}
- source = self._extract_source(card_data)
- assert source["type"] == "unknown"
-
-
-# --- Card reconstruction user_id handling ---
-
-
-class TestReconstructUserIdHandling:
- """Tests for user_id handling during reconstruction."""
-
- def _get_user_id(self, card_data):
- return card_data.get("user_id") or "unknown"
-
- def test_has_user_id(self):
- card_data = {"user_id": "user123"}
- assert self._get_user_id(card_data) == "user123"
-
- def test_missing_user_id(self):
- card_data = {}
- assert self._get_user_id(card_data) == "unknown"
-
- def test_none_user_id(self):
- card_data = {"user_id": None}
- assert self._get_user_id(card_data) == "unknown"
-
-
-# --- Card reconstruction topic handling ---
-
-
-class TestReconstructTopicHandling:
- """Tests for topic handling during reconstruction."""
-
- def _get_topic(self, card_data):
- return card_data.get("topic") or card_data.get("title", "")
-
- def test_from_topic(self):
- card_data = {"topic": "AI News"}
- assert self._get_topic(card_data) == "AI News"
-
- def test_from_title_fallback(self):
- card_data = {"title": "News Title"}
- assert self._get_topic(card_data) == "News Title"
-
- def test_topic_takes_precedence(self):
- card_data = {"topic": "Primary", "title": "Secondary"}
- assert self._get_topic(card_data) == "Primary"
-
- def test_empty_when_missing(self):
- card_data = {}
- assert self._get_topic(card_data) == ""
-
-
-# --- Card reconstruction datetime handling ---
-
-
-class TestReconstructDatetimeHandling:
- """Tests for datetime parsing during reconstruction."""
-
- def _parse_datetime(self, value):
- if isinstance(value, str):
- return datetime.fromisoformat(value.replace("Z", "+00:00"))
- return value
-
- def test_iso_string(self):
- dt_str = "2025-06-15T10:30:00+00:00"
- result = self._parse_datetime(dt_str)
- assert result.year == 2025
- assert result.month == 6
- assert result.day == 15
-
- def test_iso_with_z_suffix(self):
- dt_str = "2025-06-15T10:30:00Z"
- result = self._parse_datetime(dt_str)
- assert result.year == 2025
-
- def test_datetime_object(self):
- dt = datetime(2025, 6, 15, 10, 30, tzinfo=timezone.utc)
- result = self._parse_datetime(dt)
- assert result == dt
-
-
-# --- Card reconstruction card_type enum handling ---
-
-
-class TestReconstructCardTypeEnumHandling:
- """Tests for card_type enum extraction during reconstruction."""
-
- def _get_card_type(self, card_data):
- card_type = card_data.get("card_type", "news")
- if hasattr(card_type, "value"):
- card_type = card_type.value
- return card_type
-
- def test_string_type(self):
- card_data = {"card_type": "research"}
- assert self._get_card_type(card_data) == "research"
-
- def test_default_news(self):
- card_data = {}
- assert self._get_card_type(card_data) == "news"
-
- def test_enum_like_object(self):
- class FakeEnum:
- value = "update"
-
- card_data = {"card_type": FakeEnum()}
- assert self._get_card_type(card_data) == "update"
-
-
-# --- Get user cards filter building ---
-
-
-class TestGetUserCardsFilterBuilding:
- """Tests for filter building in get_user_cards."""
-
- def _build_filter(self, user_id, card_types=None):
- filters = {"user_id": user_id}
- if card_types:
- filters["card_type"] = card_types
- return filters
-
- def test_basic_filter(self):
- filters = self._build_filter("user123")
- assert filters["user_id"] == "user123"
- assert "card_type" not in filters
-
- def test_with_card_types(self):
- filters = self._build_filter("user123", ["news", "research"])
- assert filters["card_type"] == ["news", "research"]
-
-
-# --- Create news card from analysis ---
-
-
-class TestCreateNewsCardFromAnalysis:
- """Tests for create_news_card_from_analysis data mapping."""
-
- def _build_card_source(self, source_search_id):
- return {
- "type": "news_search",
- "source_id": source_search_id,
- "created_from": "News analysis",
- "metadata": {"analyzer_version": "1.0", "extraction_method": "llm"},
- }
-
- def test_source_type(self):
- source = self._build_card_source("search-123")
- assert source["type"] == "news_search"
-
- def test_source_metadata(self):
- source = self._build_card_source("s1")
- assert source["metadata"]["analyzer_version"] == "1.0"
- assert source["metadata"]["extraction_method"] == "llm"
-
-
-class TestNewsItemToCardMapping:
- """Tests for mapping news_item fields to card creation."""
-
- def _map_news_item(self, news_item, additional_metadata=None):
- metadata = news_item.get("metadata", {})
- if additional_metadata:
- metadata.update(additional_metadata)
-
- return {
- "topic": news_item.get("headline", "Untitled"),
- "category": news_item.get("category", "Other"),
- "summary": news_item.get("summary", ""),
- "analysis": news_item.get("analysis", ""),
- "impact_score": news_item.get("impact_score", 5),
- "entities": news_item.get("entities", {}),
- "topics": news_item.get("topics", []),
- "source_url": news_item.get("source_url", ""),
- "is_developing": news_item.get("is_developing", False),
- "surprising_element": news_item.get("surprising_element"),
- "metadata": metadata,
- }
-
- def test_maps_headline_to_topic(self):
- news_item = {"headline": "Breaking News"}
- result = self._map_news_item(news_item)
- assert result["topic"] == "Breaking News"
-
- def test_default_topic_untitled(self):
- news_item = {}
- result = self._map_news_item(news_item)
- assert result["topic"] == "Untitled"
-
- def test_default_category_other(self):
- news_item = {}
- result = self._map_news_item(news_item)
- assert result["category"] == "Other"
-
- def test_merges_metadata(self):
- news_item = {"metadata": {"key1": "val1"}}
- result = self._map_news_item(news_item, {"key2": "val2"})
- assert result["metadata"]["key1"] == "val1"
- assert result["metadata"]["key2"] == "val2"
-
-
-# --- Card list reconstruction ---
-
-
-class TestCardListReconstruction:
- """Tests for reconstructing list of cards."""
-
- def _reconstruct_cards(self, cards_data, reconstruct_fn):
- cards = []
- for data in cards_data:
- card = reconstruct_fn(data)
- if card:
- cards.append(card)
- return cards
-
- def test_filters_none_results(self):
- cards_data = [{"id": "1"}, {"id": "2"}, {"id": "3"}]
-
- def reconstruct(data):
- if data["id"] == "2":
- return None
- return data
-
- result = self._reconstruct_cards(cards_data, reconstruct)
- assert len(result) == 2
-
- def test_preserves_order(self):
- cards_data = [{"id": "1"}, {"id": "2"}]
- result = self._reconstruct_cards(cards_data, lambda x: x)
- assert result[0]["id"] == "1"
- assert result[1]["id"] == "2"
-
-
-# --- Update card interaction handling ---
-
-
-class TestUpdateCardInteractionHandling:
- """Tests for interaction data in card updates."""
-
- def _build_update_data(self, card_dict, interaction):
- card_data = card_dict.copy()
- card_data["interaction"] = interaction
- return card_data
-
- def test_includes_interaction(self):
- card_dict = {"id": "c1", "topic": "News"}
- interaction = {"votes_up": 10, "views": 100}
- result = self._build_update_data(card_dict, interaction)
- assert result["interaction"]["votes_up"] == 10
-
-
-# --- Card factory error conditions ---
-
-
-class TestCardFactoryErrorConditions:
- """Tests for error condition handling."""
-
- def _validate_card_type(self, card_type, registry):
- if card_type not in registry:
- raise ValueError(
- f"Unknown card type: {card_type}. "
- f"Available types: {list(registry.keys())}"
- )
-
- def test_raises_on_unknown_type(self):
- registry = {"news": "NewsCard"}
- try:
- self._validate_card_type("invalid", registry)
- assert False, "Should have raised ValueError"
- except ValueError as e:
- assert "Unknown card type: invalid" in str(e)
-
- def test_includes_available_types(self):
- registry = {"news": "NewsCard", "research": "ResearchCard"}
- try:
- self._validate_card_type("invalid", registry)
- except ValueError as e:
- assert "news" in str(e)
- assert "research" in str(e)
-
-
-# --- Card reconstruction attribute restoration ---
-
-
-class TestCardReconstructionAttributeRestoration:
- """Tests for restoring card attributes from stored data."""
-
- def _restore_attributes(self, card, card_data):
- card["versions"] = card_data.get("versions", [])
- card["metadata"] = card_data.get("metadata", {})
- card["interaction"] = card_data.get("interaction", {})
- return card
-
- def test_restores_versions(self):
- card = {}
- card_data = {"versions": [{"id": "v1"}]}
- result = self._restore_attributes(card, card_data)
- assert len(result["versions"]) == 1
-
- def test_defaults_empty_versions(self):
- card = {}
- card_data = {}
- result = self._restore_attributes(card, card_data)
- assert result["versions"] == []
-
- def test_restores_metadata(self):
- card = {}
- card_data = {"metadata": {"custom": "data"}}
- result = self._restore_attributes(card, card_data)
- assert result["metadata"]["custom"] == "data"
-
- def test_defaults_empty_metadata(self):
- card = {}
- card_data = {}
- result = self._restore_attributes(card, card_data)
- assert result["metadata"] == {}
-
- def test_restores_interaction(self):
- card = {}
- card_data = {"interaction": {"votes_up": 5}}
- result = self._restore_attributes(card, card_data)
- assert result["interaction"]["votes_up"] == 5
-
-
-# --- Create card ID generation ---
-
-
-class TestCreateCardIdGeneration:
- """Tests for card ID generation during creation."""
-
- def _is_valid_uuid(self, value):
- import re
-
- pattern = (
- r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
- )
- return bool(re.match(pattern, value.lower()))
-
- def test_uuid_format(self):
- import uuid
-
- card_id = str(uuid.uuid4())
- assert self._is_valid_uuid(card_id) is True
-
- def test_each_call_unique(self):
- import uuid
-
- id1 = str(uuid.uuid4())
- id2 = str(uuid.uuid4())
- assert id1 != id2
diff --git a/tests/news/test_card_interaction_patterns_behavior.py b/tests/news/test_card_interaction_patterns_behavior.py
deleted file mode 100644
index 01df87aabf..0000000000
--- a/tests/news/test_card_interaction_patterns_behavior.py
+++ /dev/null
@@ -1,549 +0,0 @@
-"""
-Deep behavioral tests for card interaction patterns.
-Tests view tracking, voting, research interactions,
-sharing, and interaction aggregation logic.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- View interaction patterns ---
-
-
-class TestViewInteractionTracking:
- """Tests for view interaction tracking."""
-
- def _record_view(self, interaction):
- """Record a view interaction."""
- interaction["viewed"] = True
- interaction["views"] = interaction.get("views", 0) + 1
- interaction["last_viewed"] = datetime.now(timezone.utc)
- return interaction
-
- def test_sets_viewed_true(self):
- interaction = {}
- result = self._record_view(interaction)
- assert result["viewed"] is True
-
- def test_increments_view_count(self):
- interaction = {"views": 5}
- result = self._record_view(interaction)
- assert result["views"] == 6
-
- def test_initializes_view_count(self):
- interaction = {}
- result = self._record_view(interaction)
- assert result["views"] == 1
-
- def test_sets_last_viewed(self):
- interaction = {}
- before = datetime.now(timezone.utc)
- result = self._record_view(interaction)
- after = datetime.now(timezone.utc)
- assert before <= result["last_viewed"] <= after
-
- def test_multiple_views(self):
- interaction = {}
- for _ in range(5):
- interaction = self._record_view(interaction)
- assert interaction["views"] == 5
-
-
-# --- Vote interaction patterns ---
-
-
-class TestVoteUpInteraction:
- """Tests for vote up interaction."""
-
- def _record_vote_up(self, interaction):
- """Record a vote up interaction."""
- interaction["voted"] = "up"
- interaction["votes_up"] = interaction.get("votes_up", 0) + 1
- return interaction
-
- def test_sets_voted_up(self):
- interaction = {}
- result = self._record_vote_up(interaction)
- assert result["voted"] == "up"
-
- def test_increments_votes_up(self):
- interaction = {"votes_up": 3}
- result = self._record_vote_up(interaction)
- assert result["votes_up"] == 4
-
- def test_initializes_votes_up(self):
- interaction = {}
- result = self._record_vote_up(interaction)
- assert result["votes_up"] == 1
-
-
-class TestVoteDownInteraction:
- """Tests for vote down interaction."""
-
- def _record_vote_down(self, interaction):
- """Record a vote down interaction."""
- interaction["voted"] = "down"
- interaction["votes_down"] = interaction.get("votes_down", 0) + 1
- return interaction
-
- def test_sets_voted_down(self):
- interaction = {}
- result = self._record_vote_down(interaction)
- assert result["voted"] == "down"
-
- def test_increments_votes_down(self):
- interaction = {"votes_down": 2}
- result = self._record_vote_down(interaction)
- assert result["votes_down"] == 3
-
- def test_initializes_votes_down(self):
- interaction = {}
- result = self._record_vote_down(interaction)
- assert result["votes_down"] == 1
-
-
-class TestVoteToggle:
- """Tests for vote toggle behavior."""
-
- def _toggle_vote(self, interaction, new_vote):
- """Toggle vote from current to new."""
- old_vote = interaction.get("voted")
- if old_vote == new_vote:
- # Remove vote
- interaction["voted"] = None
- return "removed"
- interaction["voted"] = new_vote
- return "changed"
-
- def test_toggle_same_removes(self):
- interaction = {"voted": "up"}
- result = self._toggle_vote(interaction, "up")
- assert result == "removed"
- assert interaction["voted"] is None
-
- def test_toggle_different_changes(self):
- interaction = {"voted": "up"}
- result = self._toggle_vote(interaction, "down")
- assert result == "changed"
- assert interaction["voted"] == "down"
-
- def test_toggle_from_none(self):
- interaction = {"voted": None}
- result = self._toggle_vote(interaction, "up")
- assert result == "changed"
- assert interaction["voted"] == "up"
-
-
-# --- Research interaction patterns ---
-
-
-class TestResearchInteraction:
- """Tests for research interaction tracking."""
-
- def _record_research(self, interaction):
- """Record a research interaction."""
- interaction["researched"] = True
- interaction["research_count"] = interaction.get("research_count", 0) + 1
- interaction["last_researched"] = datetime.now(timezone.utc)
- return interaction
-
- def test_sets_researched_true(self):
- interaction = {}
- result = self._record_research(interaction)
- assert result["researched"] is True
-
- def test_increments_research_count(self):
- interaction = {"research_count": 2}
- result = self._record_research(interaction)
- assert result["research_count"] == 3
-
- def test_initializes_research_count(self):
- interaction = {}
- result = self._record_research(interaction)
- assert result["research_count"] == 1
-
- def test_sets_last_researched(self):
- interaction = {}
- result = self._record_research(interaction)
- assert "last_researched" in result
-
-
-# --- Share interaction patterns ---
-
-
-class TestShareInteraction:
- """Tests for share interaction tracking."""
-
- def _record_share(self, interaction, platform=None):
- """Record a share interaction."""
- interaction["shared"] = True
- interaction["share_count"] = interaction.get("share_count", 0) + 1
- if platform:
- platforms = interaction.get("share_platforms", [])
- if platform not in platforms:
- platforms.append(platform)
- interaction["share_platforms"] = platforms
- return interaction
-
- def test_sets_shared_true(self):
- interaction = {}
- result = self._record_share(interaction)
- assert result["shared"] is True
-
- def test_increments_share_count(self):
- interaction = {"share_count": 1}
- result = self._record_share(interaction)
- assert result["share_count"] == 2
-
- def test_tracks_platform(self):
- interaction = {}
- result = self._record_share(interaction, "twitter")
- assert "twitter" in result["share_platforms"]
-
- def test_no_duplicate_platforms(self):
- interaction = {"share_platforms": ["twitter"]}
- result = self._record_share(interaction, "twitter")
- result = self._record_share(result, "twitter")
- assert result["share_platforms"].count("twitter") == 1
-
-
-# --- Interaction metadata patterns ---
-
-
-class TestInteractionMetadata:
- """Tests for interaction metadata attachment."""
-
- def _attach_metadata(self, interaction, interaction_type, metadata):
- """Attach metadata to an interaction."""
- if metadata:
- key = f"{interaction_type}_metadata"
- interaction[key] = metadata
- return interaction
-
- def test_attaches_view_metadata(self):
- interaction = {}
- metadata = {"source": "feed", "position": 3}
- result = self._attach_metadata(interaction, "view", metadata)
- assert result["view_metadata"]["source"] == "feed"
-
- def test_attaches_vote_metadata(self):
- interaction = {}
- metadata = {"reason": "helpful"}
- result = self._attach_metadata(interaction, "vote", metadata)
- assert result["vote_metadata"]["reason"] == "helpful"
-
- def test_no_metadata(self):
- interaction = {}
- result = self._attach_metadata(interaction, "view", None)
- assert "view_metadata" not in result
-
-
-# --- Interaction aggregation patterns ---
-
-
-class TestInteractionAggregation:
- """Tests for interaction aggregation across users."""
-
- def _aggregate_interactions(self, interactions):
- """Aggregate interactions from multiple users."""
- total_views = sum(i.get("views", 0) for i in interactions)
- total_up = sum(i.get("votes_up", 0) for i in interactions)
- total_down = sum(i.get("votes_down", 0) for i in interactions)
- unique_viewers = len([i for i in interactions if i.get("viewed")])
- return {
- "total_views": total_views,
- "votes_up": total_up,
- "votes_down": total_down,
- "unique_viewers": unique_viewers,
- }
-
- def test_sums_views(self):
- interactions = [{"views": 10}, {"views": 5}, {"views": 3}]
- result = self._aggregate_interactions(interactions)
- assert result["total_views"] == 18
-
- def test_sums_votes_up(self):
- interactions = [{"votes_up": 2}, {"votes_up": 3}]
- result = self._aggregate_interactions(interactions)
- assert result["votes_up"] == 5
-
- def test_sums_votes_down(self):
- interactions = [{"votes_down": 1}, {"votes_down": 2}]
- result = self._aggregate_interactions(interactions)
- assert result["votes_down"] == 3
-
- def test_counts_unique_viewers(self):
- interactions = [
- {"viewed": True},
- {"viewed": True},
- {"viewed": False},
- ]
- result = self._aggregate_interactions(interactions)
- assert result["unique_viewers"] == 2
-
-
-class TestEngagementScore:
- """Tests for engagement score calculation."""
-
- def _calculate_engagement(self, views, votes_up, votes_down, shares):
- """Calculate engagement score."""
- return views + (votes_up * 2) - votes_down + (shares * 3)
-
- def test_views_contribute(self):
- score = self._calculate_engagement(100, 0, 0, 0)
- assert score == 100
-
- def test_votes_up_weighted(self):
- score = self._calculate_engagement(0, 10, 0, 0)
- assert score == 20 # 10 * 2
-
- def test_votes_down_subtract(self):
- score = self._calculate_engagement(0, 0, 5, 0)
- assert score == -5
-
- def test_shares_weighted_high(self):
- score = self._calculate_engagement(0, 0, 0, 10)
- assert score == 30 # 10 * 3
-
- def test_combined_score(self):
- score = self._calculate_engagement(50, 10, 5, 5)
- # 50 + 20 - 5 + 15 = 80
- assert score == 80
-
-
-# --- Trending detection patterns ---
-
-
-class TestTrendingDetection:
- """Tests for trending card detection."""
-
- def _is_trending(self, card, min_views=100, min_engagement=50):
- """Check if card is trending."""
- views = card.get("interaction", {}).get("views", 0)
- votes_up = card.get("interaction", {}).get("votes_up", 0)
- if views >= min_views and votes_up >= min_engagement:
- return True
- return False
-
- def test_trending_with_high_views_and_engagement(self):
- card = {"interaction": {"views": 200, "votes_up": 60}}
- assert self._is_trending(card) is True
-
- def test_not_trending_low_views(self):
- card = {"interaction": {"views": 50, "votes_up": 100}}
- assert self._is_trending(card) is False
-
- def test_not_trending_low_engagement(self):
- card = {"interaction": {"views": 200, "votes_up": 30}}
- assert self._is_trending(card) is False
-
- def test_boundary_values(self):
- card = {"interaction": {"views": 100, "votes_up": 50}}
- assert self._is_trending(card) is True
-
-
-# --- Interaction history patterns ---
-
-
-class TestInteractionHistory:
- """Tests for interaction history tracking."""
-
- def _add_to_history(self, history, interaction_type, timestamp=None):
- """Add an interaction to history."""
- entry = {
- "type": interaction_type,
- "timestamp": timestamp or datetime.now(timezone.utc),
- }
- history.append(entry)
- return history
-
- def test_adds_entry(self):
- history = []
- self._add_to_history(history, "view")
- assert len(history) == 1
- assert history[0]["type"] == "view"
-
- def test_multiple_entries(self):
- history = []
- self._add_to_history(history, "view")
- self._add_to_history(history, "vote_up")
- self._add_to_history(history, "share")
- assert len(history) == 3
-
- def test_has_timestamp(self):
- history = []
- self._add_to_history(history, "view")
- assert "timestamp" in history[0]
-
-
-class TestRecentInteractions:
- """Tests for filtering recent interactions."""
-
- def _get_recent(self, history, hours=24):
- """Get recent interactions."""
- cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
- return [e for e in history if e.get("timestamp", cutoff) >= cutoff]
-
- def test_filters_recent(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=48)
- history = [
- {"type": "view", "timestamp": now},
- {"type": "vote", "timestamp": old},
- ]
- recent = self._get_recent(history)
- assert len(recent) == 1
-
- def test_respects_hours(self):
- now = datetime.now(timezone.utc)
- old = now - timedelta(hours=12)
- history = [{"type": "view", "timestamp": old}]
- recent = self._get_recent(history, hours=24)
- assert len(recent) == 1
- recent = self._get_recent(history, hours=6)
- assert len(recent) == 0
-
-
-# --- User interaction summary patterns ---
-
-
-class TestUserInteractionSummary:
- """Tests for user interaction summary patterns."""
-
- def _build_summary(self, user_id, interactions):
- """Build interaction summary for a user."""
- total_views = sum(i.get("views", 0) for i in interactions)
- total_votes = sum(
- i.get("votes_up", 0) + i.get("votes_down", 0) for i in interactions
- )
- researched = sum(1 for i in interactions if i.get("researched"))
- return {
- "user_id": user_id,
- "total_views": total_views,
- "total_votes": total_votes,
- "items_researched": researched,
- "active_items": len(interactions),
- }
-
- def test_summary_has_user_id(self):
- summary = self._build_summary("user1", [])
- assert summary["user_id"] == "user1"
-
- def test_summary_totals_views(self):
- interactions = [{"views": 10}, {"views": 5}]
- summary = self._build_summary("user1", interactions)
- assert summary["total_views"] == 15
-
- def test_summary_counts_researched(self):
- interactions = [
- {"researched": True},
- {"researched": False},
- {"researched": True},
- ]
- summary = self._build_summary("user1", interactions)
- assert summary["items_researched"] == 2
-
-
-# --- Interaction validation patterns ---
-
-
-class TestInteractionValidation:
- """Tests for interaction validation patterns."""
-
- def _is_valid_interaction_type(self, interaction_type):
- """Check if interaction type is valid."""
- valid_types = ["view", "vote_up", "vote_down", "research", "share"]
- return interaction_type in valid_types
-
- def test_view_valid(self):
- assert self._is_valid_interaction_type("view") is True
-
- def test_vote_up_valid(self):
- assert self._is_valid_interaction_type("vote_up") is True
-
- def test_vote_down_valid(self):
- assert self._is_valid_interaction_type("vote_down") is True
-
- def test_research_valid(self):
- assert self._is_valid_interaction_type("research") is True
-
- def test_share_valid(self):
- assert self._is_valid_interaction_type("share") is True
-
- def test_invalid_type(self):
- assert self._is_valid_interaction_type("unknown") is False
-
-
-# --- Interaction rate limiting patterns ---
-
-
-class TestInteractionRateLimiting:
- """Tests for interaction rate limiting patterns."""
-
- def _should_rate_limit(self, interactions, max_per_hour=100):
- """Check if interactions should be rate limited."""
- now = datetime.now(timezone.utc)
- hour_ago = now - timedelta(hours=1)
- recent = [
- i for i in interactions if i.get("timestamp", hour_ago) >= hour_ago
- ]
- return len(recent) >= max_per_hour
-
- def test_under_limit_allowed(self):
- now = datetime.now(timezone.utc)
- interactions = [{"timestamp": now} for _ in range(50)]
- assert self._should_rate_limit(interactions) is False
-
- def test_at_limit_blocked(self):
- now = datetime.now(timezone.utc)
- interactions = [{"timestamp": now} for _ in range(100)]
- assert self._should_rate_limit(interactions) is True
-
- def test_old_interactions_dont_count(self):
- old = datetime.now(timezone.utc) - timedelta(hours=2)
- interactions = [{"timestamp": old} for _ in range(200)]
- assert self._should_rate_limit(interactions) is False
-
-
-# --- Interaction state patterns ---
-
-
-class TestInteractionState:
- """Tests for interaction state patterns."""
-
- def _get_state(self, interaction):
- """Get current interaction state."""
- return {
- "has_viewed": interaction.get("viewed", False),
- "current_vote": interaction.get("voted"),
- "has_researched": interaction.get("researched", False),
- "has_shared": interaction.get("shared", False),
- }
-
- def test_empty_state(self):
- state = self._get_state({})
- assert state["has_viewed"] is False
- assert state["current_vote"] is None
- assert state["has_researched"] is False
- assert state["has_shared"] is False
-
- def test_viewed_state(self):
- state = self._get_state({"viewed": True})
- assert state["has_viewed"] is True
-
- def test_voted_state(self):
- state = self._get_state({"voted": "up"})
- assert state["current_vote"] == "up"
-
- def test_full_state(self):
- interaction = {
- "viewed": True,
- "voted": "down",
- "researched": True,
- "shared": True,
- }
- state = self._get_state(interaction)
- assert state["has_viewed"] is True
- assert state["current_vote"] == "down"
- assert state["has_researched"] is True
- assert state["has_shared"] is True
diff --git a/tests/news/test_card_storage_logic_behavior.py b/tests/news/test_card_storage_logic_behavior.py
deleted file mode 100644
index af95218fdb..0000000000
--- a/tests/news/test_card_storage_logic_behavior.py
+++ /dev/null
@@ -1,593 +0,0 @@
-"""
-Deep behavioral tests for card_storage.py pure logic.
-Tests field mapping, source extraction, extra_data handling,
-card_to_dict conversion, filtering patterns, and version management.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- Source info extraction ---
-
-
-class TestSourceInfoExtraction:
- """Tests for extracting source info from nested or flat data."""
-
- def _extract_source(self, data):
- source_info = data.get("source")
- if isinstance(source_info, dict) and source_info:
- return {
- "source_type": source_info.get("type"),
- "source_id": source_info.get("source_id"),
- "created_from": source_info.get("created_from"),
- }
- # Fallback to flat fields
- return {
- "source_type": data.get("source_type"),
- "source_id": data.get("source_id"),
- "created_from": data.get("created_from"),
- }
-
- def test_nested_source(self):
- data = {
- "source": {
- "type": "news_topic",
- "source_id": "src-123",
- "created_from": "Topic subscription",
- }
- }
- result = self._extract_source(data)
- assert result["source_type"] == "news_topic"
- assert result["source_id"] == "src-123"
- assert result["created_from"] == "Topic subscription"
-
- def test_flat_source(self):
- data = {
- "source_type": "user_search",
- "source_id": "search-456",
- "created_from": "User search",
- }
- result = self._extract_source(data)
- assert result["source_type"] == "user_search"
- assert result["source_id"] == "search-456"
-
- def test_empty_source(self):
- data = {}
- result = self._extract_source(data)
- assert result["source_type"] is None
- assert result["source_id"] is None
-
- def test_none_source_field(self):
- data = {"source": None}
- result = self._extract_source(data)
- # None is not a dict, so falls back to flat
- assert result["source_type"] is None
-
-
-# --- Card type mapping ---
-
-
-class TestCardTypeMapping:
- """Tests for card_type extraction and default."""
-
- def _get_card_type(self, data):
- return data.get("card_type", data.get("type", "news"))
-
- def test_explicit_card_type(self):
- data = {"card_type": "overview"}
- assert self._get_card_type(data) == "overview"
-
- def test_fallback_to_type(self):
- data = {"type": "topic"}
- assert self._get_card_type(data) == "topic"
-
- def test_default_news(self):
- data = {}
- assert self._get_card_type(data) == "news"
-
- def test_card_type_takes_precedence(self):
- data = {"card_type": "overview", "type": "topic"}
- assert self._get_card_type(data) == "overview"
-
-
-# --- Extra data building ---
-
-
-class TestExtraDataBuilding:
- """Tests for building extra_data field."""
-
- def _build_extra_data(self, data, created_from=None):
- extra_data = data.get("extra_data", {}) or {}
- extra_data.update(
- {
- "user_id": data.get("user_id"),
- "parent_card_id": data.get("parent_card_id"),
- "created_from": created_from,
- "metadata": data.get("metadata", {}),
- "interaction": data.get("interaction", {}),
- }
- )
- return extra_data
-
- def test_includes_user_id(self):
- data = {"user_id": "u1"}
- result = self._build_extra_data(data)
- assert result["user_id"] == "u1"
-
- def test_includes_parent_card_id(self):
- data = {"parent_card_id": "parent-123"}
- result = self._build_extra_data(data)
- assert result["parent_card_id"] == "parent-123"
-
- def test_includes_created_from(self):
- result = self._build_extra_data({}, created_from="Test source")
- assert result["created_from"] == "Test source"
-
- def test_includes_metadata(self):
- data = {"metadata": {"key": "value"}}
- result = self._build_extra_data(data)
- assert result["metadata"] == {"key": "value"}
-
- def test_includes_interaction(self):
- data = {"interaction": {"views": 5}}
- result = self._build_extra_data(data)
- assert result["interaction"] == {"views": 5}
-
- def test_merges_with_existing_extra_data(self):
- data = {"extra_data": {"existing": "field"}, "user_id": "u1"}
- result = self._build_extra_data(data)
- assert result["existing"] == "field"
- assert result["user_id"] == "u1"
-
- def test_handles_none_extra_data(self):
- data = {"extra_data": None, "user_id": "u1"}
- result = self._build_extra_data(data)
- assert result["user_id"] == "u1"
-
- def test_default_empty_metadata(self):
- result = self._build_extra_data({})
- assert result["metadata"] == {}
-
- def test_default_empty_interaction(self):
- result = self._build_extra_data({})
- assert result["interaction"] == {}
-
-
-# --- Title/topic mapping ---
-
-
-class TestTitleTopicMapping:
- """Tests for title extraction from topic or title field."""
-
- def _get_title(self, data):
- return data.get("topic", data.get("title", "Untitled"))
-
- def test_from_topic(self):
- data = {"topic": "AI News"}
- assert self._get_title(data) == "AI News"
-
- def test_from_title(self):
- data = {"title": "Breaking News"}
- assert self._get_title(data) == "Breaking News"
-
- def test_topic_takes_precedence(self):
- data = {"topic": "Topic", "title": "Title"}
- assert self._get_title(data) == "Topic"
-
- def test_default_untitled(self):
- data = {}
- assert self._get_title(data) == "Untitled"
-
-
-# --- URL mapping ---
-
-
-class TestUrlMapping:
- """Tests for URL extraction."""
-
- def _get_url(self, data):
- return data.get("url", data.get("source_url"))
-
- def test_from_url(self):
- data = {"url": "https://example.com/article"}
- assert self._get_url(data) == "https://example.com/article"
-
- def test_fallback_to_source_url(self):
- data = {"source_url": "https://source.com"}
- assert self._get_url(data) == "https://source.com"
-
- def test_url_takes_precedence(self):
- data = {"url": "https://main.com", "source_url": "https://source.com"}
- assert self._get_url(data) == "https://main.com"
-
- def test_none_when_missing(self):
- data = {}
- assert self._get_url(data) is None
-
-
-# --- Update field mapping ---
-
-
-class TestUpdateFieldMapping:
- """Tests for update field mapping patterns."""
-
- def _map_update_fields(self, data, card_extra_data=None):
- result = {}
- card_extra_data = card_extra_data or {}
-
- if "is_pinned" in data:
- result["is_saved"] = data["is_pinned"]
- if data["is_pinned"]:
- result["saved_at"] = datetime.now(timezone.utc)
-
- if "last_viewed" in data:
- result["is_read"] = True
- result["read_at"] = data["last_viewed"]
-
- if "is_archived" in data:
- card_extra_data["is_archived"] = data["is_archived"]
-
- if "interaction" in data:
- card_extra_data["interaction"] = data["interaction"]
-
- result["extra_data"] = card_extra_data
- return result
-
- def test_pin_sets_is_saved(self):
- result = self._map_update_fields({"is_pinned": True})
- assert result["is_saved"] is True
-
- def test_pin_sets_saved_at(self):
- result = self._map_update_fields({"is_pinned": True})
- assert "saved_at" in result
-
- def test_unpin_no_saved_at(self):
- result = self._map_update_fields({"is_pinned": False})
- assert "saved_at" not in result
-
- def test_last_viewed_sets_is_read(self):
- view_time = datetime.now(timezone.utc)
- result = self._map_update_fields({"last_viewed": view_time})
- assert result["is_read"] is True
- assert result["read_at"] == view_time
-
- def test_is_archived_in_extra_data(self):
- result = self._map_update_fields({"is_archived": True})
- assert result["extra_data"]["is_archived"] is True
-
- def test_interaction_in_extra_data(self):
- result = self._map_update_fields({"interaction": {"votes": 10}})
- assert result["extra_data"]["interaction"] == {"votes": 10}
-
-
-# --- Card to dict mapping ---
-
-
-class TestCardToDictMapping:
- """Tests for _card_to_dict conversion."""
-
- def _card_to_dict(self, card_data, extra_data=None):
- extra_data = extra_data or {}
- return {
- "id": card_data.get("id"),
- "topic": card_data.get("title"),
- "title": card_data.get("title"),
- "summary": card_data.get("summary"),
- "content": card_data.get("content"),
- "url": card_data.get("url"),
- "source_name": card_data.get("source_name"),
- "source_type": card_data.get("source_type"),
- "source_id": card_data.get("source_id"),
- "category": card_data.get("category"),
- "tags": card_data.get("tags"),
- "card_type": card_data.get("card_type"),
- "is_read": card_data.get("is_read", False),
- "is_saved": card_data.get("is_saved", False),
- "is_pinned": card_data.get("is_saved", False),
- "user_id": extra_data.get("user_id"),
- "parent_card_id": extra_data.get("parent_card_id"),
- "created_from": extra_data.get("created_from"),
- "is_archived": extra_data.get("is_archived", False),
- "metadata": extra_data.get("metadata", {}),
- "interaction": extra_data.get("interaction", {}),
- "source": {
- "type": card_data.get("source_type"),
- "source_id": card_data.get("source_id"),
- "created_from": extra_data.get("created_from", ""),
- "metadata": extra_data.get("metadata", {}),
- },
- }
-
- def test_title_mapped_to_topic(self):
- result = self._card_to_dict({"title": "My Title"})
- assert result["topic"] == "My Title"
-
- def test_is_saved_mapped_to_is_pinned(self):
- result = self._card_to_dict({"is_saved": True})
- assert result["is_pinned"] is True
-
- def test_extra_data_fields_extracted(self):
- result = self._card_to_dict(
- {}, {"user_id": "u1", "parent_card_id": "p1"}
- )
- assert result["user_id"] == "u1"
- assert result["parent_card_id"] == "p1"
-
- def test_is_archived_default_false(self):
- result = self._card_to_dict({}, {})
- assert result["is_archived"] is False
-
- def test_source_object_built(self):
- result = self._card_to_dict(
- {"source_type": "news", "source_id": "s1"},
- {"created_from": "test"},
- )
- assert result["source"]["type"] == "news"
- assert result["source"]["source_id"] == "s1"
- assert result["source"]["created_from"] == "test"
-
-
-# --- List filter patterns ---
-
-
-class TestListFilterPatterns:
- """Tests for list filtering logic."""
-
- def _should_filter_card_type(self, filters):
- return filters and "card_type" in filters
-
- def _is_card_type_list(self, card_type_val):
- return isinstance(card_type_val, list)
-
- def test_filter_card_type_present(self):
- assert self._should_filter_card_type({"card_type": "news"}) is True
-
- def test_filter_card_type_absent(self):
- assert self._should_filter_card_type({"category": "Tech"}) is False
-
- def test_card_type_as_list(self):
- assert self._is_card_type_list(["news", "topic"]) is True
-
- def test_card_type_as_string(self):
- assert self._is_card_type_list("news") is False
-
-
-class TestCategoryFilter:
- """Tests for category filtering."""
-
- def _filter_by_category(self, cards, category):
- return [c for c in cards if c.get("category") == category]
-
- def test_filter_matching(self):
- cards = [{"category": "Tech"}, {"category": "Science"}]
- result = self._filter_by_category(cards, "Tech")
- assert len(result) == 1
- assert result[0]["category"] == "Tech"
-
- def test_filter_no_match(self):
- cards = [{"category": "Tech"}]
- result = self._filter_by_category(cards, "Sports")
- assert len(result) == 0
-
-
-# --- Recent cards cutoff ---
-
-
-class TestRecentCardsCutoff:
- """Tests for get_recent time window calculation."""
-
- def _calc_cutoff(self, hours):
- return datetime.now(timezone.utc) - timedelta(hours=hours)
-
- def test_24_hours(self):
- cutoff = self._calc_cutoff(24)
- now = datetime.now(timezone.utc)
- diff = now - cutoff
- assert 23 < diff.total_seconds() / 3600 < 25
-
- def test_48_hours(self):
- cutoff = self._calc_cutoff(48)
- now = datetime.now(timezone.utc)
- diff = now - cutoff
- assert 47 < diff.total_seconds() / 3600 < 49
-
-
-class TestCardIsRecent:
- """Tests for checking if card is within time window."""
-
- def _is_recent(self, discovered_at, cutoff):
- return discovered_at >= cutoff
-
- def test_recent_card(self):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=24)
- discovered = datetime.now(timezone.utc) - timedelta(hours=1)
- assert self._is_recent(discovered, cutoff) is True
-
- def test_old_card(self):
- cutoff = datetime.now(timezone.utc) - timedelta(hours=24)
- discovered = datetime.now(timezone.utc) - timedelta(hours=48)
- assert self._is_recent(discovered, cutoff) is False
-
-
-# --- Get by user post-filter ---
-
-
-class TestGetByUserPostFilter:
- """Tests for user-based card filtering logic."""
-
- def _filter_by_user(self, cards, user_id):
- return [
- c
- for c in cards
- if c.get("user_id") == user_id and not c.get("is_archived", False)
- ]
-
- def test_filter_by_user_id(self):
- cards = [
- {"user_id": "u1", "title": "A"},
- {"user_id": "u2", "title": "B"},
- ]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 1
- assert result[0]["title"] == "A"
-
- def test_excludes_archived(self):
- cards = [
- {"user_id": "u1", "is_archived": True},
- {"user_id": "u1", "is_archived": False},
- ]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 1
-
- def test_missing_user_id_excluded(self):
- cards = [{"title": "No user"}]
- result = self._filter_by_user(cards, "u1")
- assert len(result) == 0
-
-
-class TestPaginationSlice:
- """Tests for pagination slice logic."""
-
- def _paginate(self, items, offset, limit):
- return items[offset : offset + limit]
-
- def test_first_page(self):
- items = list(range(10))
- result = self._paginate(items, 0, 5)
- assert result == [0, 1, 2, 3, 4]
-
- def test_second_page(self):
- items = list(range(10))
- result = self._paginate(items, 5, 5)
- assert result == [5, 6, 7, 8, 9]
-
- def test_partial_page(self):
- items = list(range(7))
- result = self._paginate(items, 5, 5)
- assert result == [5, 6]
-
- def test_offset_beyond_items(self):
- items = list(range(5))
- result = self._paginate(items, 10, 5)
- assert result == []
-
-
-# --- Version management ---
-
-
-class TestVersionManagement:
- """Tests for version-related logic."""
-
- def _get_version_number(self, versions):
- return len(versions) + 1
-
- def test_first_version(self):
- assert self._get_version_number([]) == 1
-
- def test_second_version(self):
- assert self._get_version_number([{"v": 1}]) == 2
-
- def test_multiple_versions(self):
- versions = [{"v": 1}, {"v": 2}, {"v": 3}]
- assert self._get_version_number(versions) == 4
-
-
-class TestVersionRecord:
- """Tests for version record structure."""
-
- def _create_version_record(self, version_id, version_number, version_data):
- return {
- "id": version_id,
- "version_number": version_number,
- "search_query": version_data.get("search_query"),
- "headline": version_data.get("headline"),
- "summary": version_data.get("summary"),
- "findings": version_data.get("findings"),
- "sources": version_data.get("sources"),
- "impact_score": version_data.get("impact_score"),
- "topics": version_data.get("topics"),
- "entities": version_data.get("entities"),
- "created_at": datetime.now(timezone.utc).isoformat(),
- }
-
- def test_has_id(self):
- record = self._create_version_record("v1", 1, {})
- assert record["id"] == "v1"
-
- def test_has_version_number(self):
- record = self._create_version_record("v1", 3, {})
- assert record["version_number"] == 3
-
- def test_extracts_headline(self):
- record = self._create_version_record("v1", 1, {"headline": "News"})
- assert record["headline"] == "News"
-
- def test_has_created_at(self):
- record = self._create_version_record("v1", 1, {})
- assert "created_at" in record
-
-
-class TestLatestVersionInfo:
- """Tests for get_latest_version fallback."""
-
- def _get_latest_or_default(self, card_data):
- extra_data = card_data.get("metadata", {})
- if "latest_version" in extra_data:
- return extra_data["latest_version"]
- card_id = card_data.get("id", "unknown")
- return {
- "version_id": f"{card_id}_v1",
- "version_number": 1,
- "headline": card_data.get("title"),
- "summary": card_data.get("summary"),
- "card_id": card_id,
- }
-
- def test_returns_stored_version(self):
- card_data = {"metadata": {"latest_version": {"version_number": 3}}}
- result = self._get_latest_or_default(card_data)
- assert result["version_number"] == 3
-
- def test_fallback_default_version(self):
- card_data = {"id": "card-123", "title": "Title", "summary": "Summary"}
- result = self._get_latest_or_default(card_data)
- assert result["version_id"] == "card-123_v1"
- assert result["version_number"] == 1
- assert result["headline"] == "Title"
-
-
-# --- Archive and pin helpers ---
-
-
-class TestArchivePinHelpers:
- """Tests for archive_card and pin_card patterns."""
-
- def test_archive_data(self):
- data = {"is_archived": True}
- assert data["is_archived"] is True
-
- def test_pin_data(self):
- data = {"is_pinned": True}
- assert data["is_pinned"] is True
-
- def test_unpin_data(self):
- data = {"is_pinned": False}
- assert data["is_pinned"] is False
-
-
-# --- Datetime isoformat handling ---
-
-
-class TestDatetimeIsoformat:
- """Tests for datetime isoformat conversion."""
-
- def _to_iso_or_none(self, dt):
- return dt.isoformat() if dt else None
-
- def test_datetime_to_iso(self):
- dt = datetime(2025, 6, 15, 10, 30, tzinfo=timezone.utc)
- result = self._to_iso_or_none(dt)
- assert "2025-06-15" in result
-
- def test_none_returns_none(self):
- assert self._to_iso_or_none(None) is None
diff --git a/tests/news/test_flask_api_routes_logic_behavior.py b/tests/news/test_flask_api_routes_logic_behavior.py
deleted file mode 100644
index 1a9519e5e6..0000000000
--- a/tests/news/test_flask_api_routes_logic_behavior.py
+++ /dev/null
@@ -1,386 +0,0 @@
-"""
-Deep behavioral tests for flask_api.py route handler logic patterns.
-Tests scheduler status construction, subscription request data building,
-overdue check logic, folder operations, and error handler patterns.
-"""
-
-from datetime import datetime, timezone, timedelta
-
-
-# --- Scheduler status construction ---
-
-
-class TestSchedulerStatusConstruction:
- """Tests for scheduler status dict building in get_scheduler_status."""
-
- def _build_status(self, is_running, config, user_sessions):
- """Mirror scheduler status construction from flask_api."""
- status = {
- "scheduler_available": True,
- "is_running": is_running,
- "config": config.copy() if config else {},
- "active_users": len(user_sessions),
- "total_scheduled_jobs": 0,
- }
- total_jobs = sum(
- len(session.get("scheduled_jobs", set()))
- for session in user_sessions.values()
- )
- status["total_scheduled_jobs"] = total_jobs
- status["scheduled_jobs"] = status.get("total_scheduled_jobs", 0)
- return status
-
- def test_scheduler_available_always_true(self):
- status = self._build_status(False, {}, {})
- assert status["scheduler_available"] is True
-
- def test_is_running_reflected(self):
- status = self._build_status(True, {}, {})
- assert status["is_running"] is True
-
- def test_config_copied(self):
- config = {"key": "val"}
- status = self._build_status(True, config, {})
- assert status["config"] == {"key": "val"}
- config["key"] = "changed"
- assert status["config"]["key"] == "val" # copy, not reference
-
- def test_active_users_count(self):
- sessions = {"user1": {}, "user2": {}}
- status = self._build_status(True, {}, sessions)
- assert status["active_users"] == 2
-
- def test_total_scheduled_jobs(self):
- sessions = {
- "user1": {"scheduled_jobs": {"j1", "j2"}},
- "user2": {"scheduled_jobs": {"j3"}},
- }
- status = self._build_status(True, {}, sessions)
- assert status["total_scheduled_jobs"] == 3
-
- def test_scheduled_jobs_alias(self):
- sessions = {"user1": {"scheduled_jobs": {"j1"}}}
- status = self._build_status(True, {}, sessions)
- assert status["scheduled_jobs"] == status["total_scheduled_jobs"]
-
- def test_no_users(self):
- status = self._build_status(True, {}, {})
- assert status["active_users"] == 0
- assert status["total_scheduled_jobs"] == 0
-
- def test_empty_scheduled_jobs_set(self):
- sessions = {"user1": {"scheduled_jobs": set()}}
- status = self._build_status(True, {}, sessions)
- assert status["total_scheduled_jobs"] == 0
-
-
-# --- Run subscription request data ---
-
-
-class TestRunSubscriptionRequestData:
- """Tests for request_data construction in run_subscription_now."""
-
- def _build_request_data(self, subscription, current_date):
- query = subscription["query_or_topic"].replace(
- "YYYY-MM-DD", current_date
- )
- request_data = {
- "query": query,
- "mode": "quick",
- "model_provider": subscription.get("model_provider") or "OLLAMA",
- "model": subscription.get("model") or "llama3",
- "strategy": subscription.get("search_strategy")
- or "news_aggregation",
- "metadata": {
- "is_news_search": True,
- "search_type": "news_analysis",
- "display_in": "news_feed",
- "subscription_id": str(subscription["id"]),
- "original_query": subscription["query_or_topic"],
- "processed_query": query,
- "news_date": current_date,
- "title": subscription.get("name")
- if subscription.get("name")
- else None,
- },
- }
- if subscription.get("custom_endpoint"):
- request_data["custom_endpoint"] = subscription["custom_endpoint"]
- return request_data
-
- def test_replaces_date_placeholder(self):
- sub = {"id": "1", "query_or_topic": "news YYYY-MM-DD", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["query"] == "news 2025-06-15"
- assert "YYYY-MM-DD" not in data["query"]
-
- def test_no_placeholder(self):
- sub = {"id": "1", "query_or_topic": "AI news", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["query"] == "AI news"
-
- def test_mode_always_quick(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["mode"] == "quick"
-
- def test_model_provider_default(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["model_provider"] == "OLLAMA"
-
- def test_model_provider_override(self):
- sub = {
- "id": "1",
- "query_or_topic": "test",
- "model_provider": "openai",
- "name": None,
- }
- data = self._build_request_data(sub, "2025-06-15")
- assert data["model_provider"] == "openai"
-
- def test_model_default(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["model"] == "llama3"
-
- def test_strategy_default(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["strategy"] == "news_aggregation"
-
- def test_metadata_has_subscription_id(self):
- sub = {"id": "sub-42", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["metadata"]["subscription_id"] == "sub-42"
-
- def test_metadata_is_news_search(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["metadata"]["is_news_search"] is True
-
- def test_metadata_stores_original_query(self):
- sub = {"id": "1", "query_or_topic": "AI YYYY-MM-DD", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["metadata"]["original_query"] == "AI YYYY-MM-DD"
- assert data["metadata"]["processed_query"] == "AI 2025-06-15"
-
- def test_title_from_name(self):
- sub = {"id": "1", "query_or_topic": "test", "name": "My Sub"}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["metadata"]["title"] == "My Sub"
-
- def test_title_none_when_no_name(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert data["metadata"]["title"] is None
-
- def test_custom_endpoint_added(self):
- sub = {
- "id": "1",
- "query_or_topic": "test",
- "name": None,
- "custom_endpoint": "http://custom",
- }
- data = self._build_request_data(sub, "2025-06-15")
- assert data["custom_endpoint"] == "http://custom"
-
- def test_no_custom_endpoint(self):
- sub = {"id": "1", "query_or_topic": "test", "name": None}
- data = self._build_request_data(sub, "2025-06-15")
- assert "custom_endpoint" not in data
-
-
-# --- Overdue check patterns ---
-
-
-class TestOverdueCheckPatterns:
- """Tests for overdue subscription detection logic."""
-
- def test_overdue_when_next_refresh_past(self):
- now = datetime.now(timezone.utc)
- next_refresh = now - timedelta(hours=1)
- is_overdue = next_refresh <= now
- assert is_overdue is True
-
- def test_not_overdue_when_future(self):
- now = datetime.now(timezone.utc)
- next_refresh = now + timedelta(hours=1)
- is_overdue = next_refresh <= now
- assert is_overdue is False
-
- def test_overdue_when_exactly_now(self):
- now = datetime.now(timezone.utc)
- is_overdue = now <= now
- assert is_overdue is True
-
- def test_only_active_checked(self):
- status = "paused"
- should_check = status == "active"
- assert should_check is False
-
- def test_active_checked(self):
- status = "active"
- should_check = status == "active"
- assert should_check is True
-
- def test_update_after_run(self):
- now = datetime.now(timezone.utc)
- interval = 60
- new_next = now + timedelta(minutes=interval)
- assert new_next > now
-
-
-# --- APScheduler job list formatting ---
-
-
-class TestAPSchedulerJobFormatting:
- """Tests for APScheduler job list formatting."""
-
- def _format_job(self, job_id, job_name, next_run_time):
- return {
- "id": job_id,
- "name": job_name,
- "next_run": next_run_time.isoformat() if next_run_time else None,
- }
-
- def test_with_next_run(self):
- dt = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- job = self._format_job("j1", "check_sub_1", dt)
- assert job["next_run"] is not None
- assert "2025-06-15" in job["next_run"]
-
- def test_without_next_run(self):
- job = self._format_job("j1", "check_sub_1", None)
- assert job["next_run"] is None
-
- def test_job_id_preserved(self):
- dt = datetime(2025, 6, 15, tzinfo=timezone.utc)
- job = self._format_job("my-job-id", "name", dt)
- assert job["id"] == "my-job-id"
-
- def test_limit_to_10_jobs(self):
- jobs = list(range(20))
- limited = jobs[:10]
- assert len(limited) == 10
-
-
-# --- Error handler patterns ---
-
-
-class TestErrorHandlerPatterns:
- """Tests for error handler response patterns."""
-
- def test_400_error_format(self):
- response = {"error": "Bad request"}
- assert response["error"] == "Bad request"
-
- def test_404_error_format(self):
- response = {"error": "Resource not found"}
- assert response["error"] == "Resource not found"
-
- def test_500_error_format(self):
- response = {"error": "Internal server error"}
- assert response["error"] == "Internal server error"
-
-
-# --- Folder validation ---
-
-
-class TestFolderValidation:
- """Tests for folder validation patterns."""
-
- def test_name_required(self):
- data = {}
- is_valid = bool(data.get("name"))
- assert is_valid is False
-
- def test_empty_name_invalid(self):
- data = {"name": ""}
- is_valid = bool(data.get("name"))
- assert is_valid is False
-
- def test_name_present_valid(self):
- data = {"name": "My Folder"}
- is_valid = bool(data.get("name"))
- assert is_valid is True
-
- def test_folder_already_exists_409(self):
- existing = {"name": "My Folder"}
- is_duplicate = existing is not None
- assert is_duplicate is True
-
- def test_folder_not_found_404(self):
- folder = None
- not_found = not folder
- assert not_found is True
-
-
-# --- Subscription filter by date ---
-
-
-class TestSubscriptionFilterByDate:
- """Tests for subscription ID filtering via LIKE pattern."""
-
- def test_like_pattern_format(self):
- sub_id = "sub-123"
- pattern = f'%"subscription_id":"{sub_id}"%'
- assert f'"subscription_id":"{sub_id}"' in pattern
-
- def test_all_subscription_skip(self):
- subscription_id = "all"
- should_filter = subscription_id and subscription_id != "all"
- assert should_filter is False
-
- def test_none_subscription_skip(self):
- subscription_id = None
- should_filter = subscription_id and subscription_id != "all"
- assert not should_filter
-
- def test_specific_subscription_filter(self):
- subscription_id = "sub-abc"
- should_filter = subscription_id and subscription_id != "all"
- assert should_filter is True
-
-
-# --- User session debug info format ---
-
-
-class TestUserSessionDebugFormat:
- """Tests for scheduler stats debug info formatting."""
-
- def _format_session_info(self, session_info, has_credential=False):
- return {
- "has_password": has_credential,
- "last_activity": session_info.get("last_activity").isoformat()
- if session_info.get("last_activity")
- else None,
- "scheduled_jobs_count": len(
- session_info.get("scheduled_jobs", set())
- ),
- }
-
- def test_has_password_true(self):
- info = self._format_session_info({}, has_credential=True)
- assert info["has_password"] is True
-
- def test_has_password_false(self):
- info = self._format_session_info({}, has_credential=False)
- assert info["has_password"] is False
-
- def test_last_activity_formatted(self):
- dt = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- info = self._format_session_info({"last_activity": dt})
- assert "2025-06-15" in info["last_activity"]
-
- def test_last_activity_none(self):
- info = self._format_session_info({})
- assert info["last_activity"] is None
-
- def test_scheduled_jobs_count(self):
- info = self._format_session_info({"scheduled_jobs": {"j1", "j2", "j3"}})
- assert info["scheduled_jobs_count"] == 3
-
- def test_empty_scheduled_jobs(self):
- info = self._format_session_info({})
- assert info["scheduled_jobs_count"] == 0
diff --git a/tests/news/test_headline_generator_logic_behavior.py b/tests/news/test_headline_generator_logic_behavior.py
deleted file mode 100644
index 6699d3b26e..0000000000
--- a/tests/news/test_headline_generator_logic_behavior.py
+++ /dev/null
@@ -1,325 +0,0 @@
-"""
-Deep behavioral tests for headline_generator.py pure logic.
-Tests headline generation patterns, cleaning, and validation.
-"""
-
-
-# --- Headline generation flow ---
-
-
-class TestHeadlineGenerationFlow:
- """Tests for generate_headline main flow."""
-
- def _should_try_llm(self):
- # Always try LLM first
- return True
-
- def test_always_tries_llm(self):
- assert self._should_try_llm() is True
-
-
-class TestHeadlineFallback:
- """Tests for headline generation failure fallback."""
-
- def _get_fallback_headline(self):
- return "[Headline generation failed]"
-
- def test_fallback_message(self):
- result = self._get_fallback_headline()
- assert "failed" in result.lower()
-
- def test_fallback_bracketed(self):
- result = self._get_fallback_headline()
- assert result.startswith("[")
- assert result.endswith("]")
-
-
-# --- Headline cleaning ---
-
-
-class TestHeadlineCleaning:
- """Tests for headline cleanup logic."""
-
- def _clean_headline(self, headline):
- return headline.strip("\"'.,!?")
-
- def test_strips_quotes(self):
- assert self._clean_headline('"Headline"') == "Headline"
- assert self._clean_headline("'Headline'") == "Headline"
-
- def test_strips_periods(self):
- assert self._clean_headline("Headline.") == "Headline"
-
- def test_strips_commas(self):
- assert self._clean_headline("Headline,") == "Headline"
-
- def test_strips_exclamation(self):
- assert self._clean_headline("Headline!") == "Headline"
-
- def test_strips_question(self):
- assert self._clean_headline("Headline?") == "Headline"
-
- def test_strips_multiple(self):
- assert self._clean_headline('"Headline."') == "Headline"
-
- def test_preserves_middle(self):
- assert self._clean_headline('A "quoted" B') == 'A "quoted" B'
-
-
-# --- Headline validation ---
-
-
-class TestHeadlineValidation:
- """Tests for headline validation."""
-
- def _is_valid_headline(self, headline):
- return bool(headline and headline.strip())
-
- def test_valid_headline(self):
- assert self._is_valid_headline("News headline") is True
-
- def test_empty_string_invalid(self):
- assert self._is_valid_headline("") is False
-
- def test_none_invalid(self):
- assert self._is_valid_headline(None) is False
-
- def test_whitespace_only_invalid(self):
- assert self._is_valid_headline(" ") is False
-
-
-# --- Findings check ---
-
-
-class TestFindingsCheck:
- """Tests for checking if findings are provided."""
-
- def _has_findings(self, findings):
- return bool(findings)
-
- def test_with_findings(self):
- assert self._has_findings("Some findings here") is True
-
- def test_empty_findings(self):
- assert self._has_findings("") is False
-
- def test_none_findings(self):
- assert self._has_findings(None) is False
-
-
-class TestFindingsLogging:
- """Tests for findings length logging."""
-
- def _get_findings_length(self, findings):
- return len(findings) if findings else 0
-
- def test_with_findings(self):
- assert self._get_findings_length("abc") == 3
-
- def test_empty_findings(self):
- assert self._get_findings_length("") == 0
-
- def test_none_findings(self):
- assert self._get_findings_length(None) == 0
-
-
-# --- Max length parameter ---
-
-
-class TestMaxLengthParameter:
- """Tests for max_length parameter handling."""
-
- def test_default_max_length(self):
- max_length = 100
- assert max_length == 100
-
- def test_truncate_to_max(self):
- max_length = 100
- headline = "A" * 150
- truncated = headline[:max_length]
- assert len(truncated) == 100
-
-
-# --- LLM response handling ---
-
-
-class TestLLMResponseHandling:
- """Tests for handling LLM response content."""
-
- def _extract_content(self, response):
- return response.get("content", "").strip()
-
- def test_extracts_content(self):
- response = {"content": " Generated headline "}
- result = self._extract_content(response)
- assert result == "Generated headline"
-
- def test_missing_content(self):
- response = {}
- result = self._extract_content(response)
- assert result == ""
-
-
-# --- Prompt construction ---
-
-
-class TestPromptConstruction:
- """Tests for prompt structure requirements."""
-
- def _prompt_requires_multiple_events(self):
- requirements = [
- "MULTIPLE major events",
- "semicolons or commas",
- "No quotes or punctuation at start/end",
- ]
- return requirements
-
- def test_has_multiple_events_requirement(self):
- reqs = self._prompt_requires_multiple_events()
- assert any("MULTIPLE" in r for r in reqs)
-
- def test_has_separator_requirement(self):
- reqs = self._prompt_requires_multiple_events()
- assert any("semicolons" in r for r in reqs)
-
-
-# --- Temperature setting ---
-
-
-class TestTemperatureSetting:
- """Tests for LLM temperature setting."""
-
- def test_low_temperature(self):
- temperature = 0.3
- assert temperature == 0.3
-
- def test_temperature_for_consistency(self):
- temperature = 0.3
- # Low temperature for more consistent headlines
- assert temperature < 0.5
-
-
-# --- Findings preview (no truncation) ---
-
-
-class TestFindingsPreview:
- """Tests for findings preview handling."""
-
- def _get_findings_preview(self, findings):
- # Use complete findings, no character limit
- return findings
-
- def test_preserves_all_content(self):
- findings = "A" * 5000
- result = self._get_findings_preview(findings)
- assert len(result) == 5000
-
- def test_empty_findings(self):
- result = self._get_findings_preview("")
- assert result == ""
-
-
-# --- Error handling ---
-
-
-class TestLLMErrorHandling:
- """Tests for LLM error handling."""
-
- def _handle_llm_error(self, error):
- # Returns None on error
- return None
-
- def test_returns_none_on_error(self):
- result = self._handle_llm_error(Exception("Test"))
- assert result is None
-
-
-# --- Headline content validation ---
-
-
-class TestHeadlineContentValidation:
- """Tests for headline content requirements."""
-
- def _headline_has_content(self, headline):
- return headline and len(headline.strip()) > 0
-
- def test_with_content(self):
- assert self._headline_has_content("News headline") is True
-
- def test_empty_after_clean(self):
- assert self._headline_has_content("...") is True # Still has dots
-
- def test_whitespace_only(self):
- assert self._headline_has_content(" ") is False
-
-
-# --- Complete generation pipeline ---
-
-
-class TestCompleteGenerationPipeline:
- """Tests for the complete generation flow."""
-
- def _generate_headline_simplified(self, query, findings, llm_result):
- # Try LLM first
- if llm_result:
- cleaned = llm_result.strip("\"'.,!?")
- if cleaned:
- return cleaned
-
- # No fallback in current implementation
- return "[Headline generation failed]"
-
- def test_with_llm_success(self):
- result = self._generate_headline_simplified(
- "query", "findings", '"Great News"'
- )
- assert result == "Great News"
-
- def test_with_llm_failure(self):
- result = self._generate_headline_simplified("query", "findings", None)
- assert "failed" in result.lower()
-
- def test_with_empty_llm_result(self):
- result = self._generate_headline_simplified("query", "findings", "")
- assert "failed" in result.lower()
-
-
-# --- Prompt content requirements ---
-
-
-class TestPromptContentRequirements:
- """Tests for what the prompt requires."""
-
- def _get_prompt_requirements(self):
- return {
- "multiple_events": True,
- "specific_locations": True,
- "impacts_and_details": True,
- "no_quotes": True,
- "based_on_findings_only": True,
- }
-
- def test_requires_multiple_events(self):
- reqs = self._get_prompt_requirements()
- assert reqs["multiple_events"] is True
-
- def test_requires_specifics(self):
- reqs = self._get_prompt_requirements()
- assert reqs["specific_locations"] is True
-
- def test_requires_findings_basis(self):
- reqs = self._get_prompt_requirements()
- assert reqs["based_on_findings_only"] is True
-
-
-# --- Query parameter usage ---
-
-
-class TestQueryParameterUsage:
- """Tests for query parameter in generation."""
-
- def test_query_not_used_in_prompt(self):
- # According to code, query is passed but focus is on findings
- query = "original query"
- # The prompt focuses only on findings
- assert query == "original query"
diff --git a/tests/news/test_storage_manager_logic_behavior.py b/tests/news/test_storage_manager_logic_behavior.py
deleted file mode 100644
index 846985cca4..0000000000
--- a/tests/news/test_storage_manager_logic_behavior.py
+++ /dev/null
@@ -1,475 +0,0 @@
-"""
-Deep behavioral tests for storage_manager.py pure logic.
-Tests InteractionType enum, user feed filtering, interaction recording,
-stats calculation, and cleanup logic.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- InteractionType enum ---
-
-
-class TestInteractionTypeEnum:
- """Tests for InteractionType enum values."""
-
- def test_view_value(self):
- assert "view" == "view"
-
- def test_vote_up_value(self):
- assert "vote_up" == "vote_up"
-
- def test_vote_down_value(self):
- assert "vote_down" == "vote_down"
-
- def test_research_value(self):
- assert "research" == "research"
-
- def test_share_value(self):
- assert "share" == "share"
-
- def test_all_types(self):
- types = ["view", "vote_up", "vote_down", "research", "share"]
- assert len(types) == 5
-
-
-# --- Session retrieval pattern ---
-
-
-class TestSessionRetrievalPattern:
- """Tests for _get_current_session logic."""
-
- def _has_session(self, has_context, has_session_attr, session):
- if has_context and has_session_attr and session:
- return True
- return False
-
- def test_all_conditions_met(self):
- assert self._has_session(True, True, "mock_session") is True
-
- def test_no_context(self):
- assert self._has_session(False, True, "mock") is False
-
- def test_no_session_attr(self):
- assert self._has_session(True, False, "mock") is False
-
- def test_session_none(self):
- assert self._has_session(True, True, None) is False
-
-
-# --- User feed filter building ---
-
-
-class TestUserFeedFilterBuilding:
- """Tests for get_user_feed filter building."""
-
- def _build_feed_filter(self, user_id, user_prefs, card_types):
- if user_prefs and user_prefs.get("liked_categories"):
- filters = {
- "user_id": user_id,
- "categories": user_prefs["liked_categories"],
- }
- else:
- filters = {"user_id": user_id}
-
- if card_types:
- filters["card_type"] = card_types
-
- return filters
-
- def test_basic_filter(self):
- filters = self._build_feed_filter("user1", None, None)
- assert filters["user_id"] == "user1"
- assert "categories" not in filters
-
- def test_with_categories(self):
- prefs = {"liked_categories": ["Tech", "Science"]}
- filters = self._build_feed_filter("user1", prefs, None)
- assert filters["categories"] == ["Tech", "Science"]
-
- def test_with_card_types(self):
- filters = self._build_feed_filter("user1", None, ["news", "research"])
- assert filters["card_type"] == ["news", "research"]
-
- def test_full_filter(self):
- prefs = {"liked_categories": ["Tech"]}
- filters = self._build_feed_filter("user1", prefs, ["news"])
- assert filters["user_id"] == "user1"
- assert filters["categories"] == ["Tech"]
- assert filters["card_type"] == ["news"]
-
-
-# --- Feed limit calculation ---
-
-
-class TestFeedLimitCalculation:
- """Tests for extra fetching for filtering."""
-
- def _calc_fetch_limit(self, limit, multiplier=2):
- return limit * multiplier
-
- def test_default_multiplier(self):
- assert self._calc_fetch_limit(20) == 40
-
- def test_custom_multiplier(self):
- assert self._calc_fetch_limit(10, 3) == 30
-
-
-# --- Interaction update: view ---
-
-
-class TestViewInteractionUpdate:
- """Tests for VIEW interaction recording."""
-
- def _update_view_interaction(self, interaction, now):
- interaction["viewed"] = True
- interaction["last_viewed"] = now
- interaction["views"] = interaction.get("views", 0) + 1
- return interaction
-
- def test_sets_viewed_true(self):
- interaction = {}
- now = datetime.now(timezone.utc)
- result = self._update_view_interaction(interaction, now)
- assert result["viewed"] is True
-
- def test_sets_last_viewed(self):
- interaction = {}
- now = datetime.now(timezone.utc)
- result = self._update_view_interaction(interaction, now)
- assert result["last_viewed"] == now
-
- def test_increments_views(self):
- interaction = {"views": 5}
- now = datetime.now(timezone.utc)
- result = self._update_view_interaction(interaction, now)
- assert result["views"] == 6
-
- def test_initial_views(self):
- interaction = {}
- now = datetime.now(timezone.utc)
- result = self._update_view_interaction(interaction, now)
- assert result["views"] == 1
-
-
-# --- Interaction update: vote up ---
-
-
-class TestVoteUpInteractionUpdate:
- """Tests for VOTE_UP interaction recording."""
-
- def _update_vote_up(self, interaction):
- interaction["voted"] = "up"
- interaction["votes_up"] = interaction.get("votes_up", 0) + 1
- return interaction
-
- def test_sets_voted_up(self):
- interaction = {}
- result = self._update_vote_up(interaction)
- assert result["voted"] == "up"
-
- def test_increments_votes_up(self):
- interaction = {"votes_up": 3}
- result = self._update_vote_up(interaction)
- assert result["votes_up"] == 4
-
- def test_initial_votes_up(self):
- interaction = {}
- result = self._update_vote_up(interaction)
- assert result["votes_up"] == 1
-
-
-# --- Interaction update: vote down ---
-
-
-class TestVoteDownInteractionUpdate:
- """Tests for VOTE_DOWN interaction recording."""
-
- def _update_vote_down(self, interaction):
- interaction["voted"] = "down"
- interaction["votes_down"] = interaction.get("votes_down", 0) + 1
- return interaction
-
- def test_sets_voted_down(self):
- interaction = {}
- result = self._update_vote_down(interaction)
- assert result["voted"] == "down"
-
- def test_increments_votes_down(self):
- interaction = {"votes_down": 2}
- result = self._update_vote_down(interaction)
- assert result["votes_down"] == 3
-
-
-# --- Interaction update: research ---
-
-
-class TestResearchInteractionUpdate:
- """Tests for RESEARCH interaction recording."""
-
- def _update_research(self, interaction):
- interaction["researched"] = True
- interaction["research_count"] = interaction.get("research_count", 0) + 1
- return interaction
-
- def test_sets_researched_true(self):
- interaction = {}
- result = self._update_research(interaction)
- assert result["researched"] is True
-
- def test_increments_research_count(self):
- interaction = {"research_count": 5}
- result = self._update_research(interaction)
- assert result["research_count"] == 6
-
-
-# --- Metadata attachment ---
-
-
-class TestMetadataAttachment:
- """Tests for attaching metadata to interaction."""
-
- def _attach_metadata(self, interaction, interaction_type, metadata):
- if metadata:
- interaction[f"{interaction_type}_metadata"] = metadata
- return interaction
-
- def test_attaches_metadata(self):
- interaction = {}
- metadata = {"source": "button"}
- result = self._attach_metadata(interaction, "view", metadata)
- assert result["view_metadata"]["source"] == "button"
-
- def test_no_metadata(self):
- interaction = {}
- result = self._attach_metadata(interaction, "view", None)
- assert "view_metadata" not in result
-
-
-# --- User stats calculation ---
-
-
-class TestUserStatsCalculation:
- """Tests for get_user_stats calculation."""
-
- def _calc_votes_up(self, ratings):
- return sum(1 for r in ratings if r.get("value", 0) > 0)
-
- def _calc_votes_down(self, ratings):
- return sum(1 for r in ratings if r.get("value", 0) < 0)
-
- def _calc_total_views(self, cards):
- return sum(c.get("interaction", {}).get("views", 0) for c in cards)
-
- def test_count_votes_up(self):
- ratings = [{"value": 1}, {"value": -1}, {"value": 1}, {"value": 1}]
- assert self._calc_votes_up(ratings) == 3
-
- def test_count_votes_down(self):
- ratings = [{"value": 1}, {"value": -1}, {"value": -1}]
- assert self._calc_votes_down(ratings) == 2
-
- def test_total_views(self):
- cards = [
- {"interaction": {"views": 10}},
- {"interaction": {"views": 5}},
- {"interaction": {}},
- ]
- assert self._calc_total_views(cards) == 15
-
- def test_empty_ratings(self):
- assert self._calc_votes_up([]) == 0
- assert self._calc_votes_down([]) == 0
-
-
-class TestUserStatsStructure:
- """Tests for user stats dictionary structure."""
-
- def _build_user_stats(
- self,
- subscription_count,
- votes_up,
- votes_down,
- total_views,
- cards_count,
- member_since,
- ):
- return {
- "subscriptions": subscription_count,
- "votes_up": votes_up,
- "votes_down": votes_down,
- "total_views": total_views,
- "cards_created": cards_count,
- "member_since": member_since,
- }
-
- def test_has_all_fields(self):
- stats = self._build_user_stats(5, 10, 2, 100, 20, "2025-01-01")
- assert "subscriptions" in stats
- assert "votes_up" in stats
- assert "votes_down" in stats
- assert "total_views" in stats
- assert "cards_created" in stats
- assert "member_since" in stats
-
-
-# --- Card interactions conversion ---
-
-
-class TestCardInteractionsConversion:
- """Tests for get_card_interactions conversion."""
-
- def _convert_rating_to_interaction(self, rating):
- return {
- "user_id": rating.get("user_id"),
- "interaction_type": "vote",
- "interaction_data": {
- "vote": "up" if rating.get("value", 0) > 0 else "down"
- },
- "timestamp": rating.get("created_at"),
- }
-
- def test_positive_rating(self):
- rating = {"user_id": "u1", "value": 1, "created_at": "2025-06-15"}
- result = self._convert_rating_to_interaction(rating)
- assert result["interaction_data"]["vote"] == "up"
-
- def test_negative_rating(self):
- rating = {"user_id": "u1", "value": -1, "created_at": "2025-06-15"}
- result = self._convert_rating_to_interaction(rating)
- assert result["interaction_data"]["vote"] == "down"
-
- def test_zero_rating_is_down(self):
- rating = {"user_id": "u1", "value": 0}
- result = self._convert_rating_to_interaction(rating)
- assert result["interaction_data"]["vote"] == "down"
-
-
-# --- Cleanup cutoff calculation ---
-
-
-class TestCleanupCutoffCalculation:
- """Tests for cleanup_old_data cutoff calculation."""
-
- def _calc_cutoff(self, days):
- return datetime.now(timezone.utc) - timedelta(days=days)
-
- def test_30_days(self):
- cutoff = self._calc_cutoff(30)
- expected = datetime.now(timezone.utc) - timedelta(days=30)
- # Within a second
- assert abs((cutoff - expected).total_seconds()) < 1
-
- def test_7_days(self):
- cutoff = self._calc_cutoff(7)
- expected = datetime.now(timezone.utc) - timedelta(days=7)
- assert abs((cutoff - expected).total_seconds()) < 1
-
-
-class TestCleanupCountsStructure:
- """Tests for cleanup counts dictionary."""
-
- def _build_cleanup_counts(self, cards_deleted, ratings_deleted):
- return {"cards": cards_deleted, "ratings": ratings_deleted}
-
- def test_has_cards_count(self):
- counts = self._build_cleanup_counts(10, 5)
- assert counts["cards"] == 10
-
- def test_has_ratings_count(self):
- counts = self._build_cleanup_counts(10, 5)
- assert counts["ratings"] == 5
-
-
-# --- Singleton pattern ---
-
-
-class TestStorageManagerSingleton:
- """Tests for singleton pattern."""
-
- def test_instance_initially_none(self):
- _storage_manager = None
- assert _storage_manager is None
-
- def test_creates_on_first_call(self):
- _storage_manager = None
- if _storage_manager is None:
- _storage_manager = {"initialized": True}
- assert _storage_manager is not None
-
- def test_reuses_on_second_call(self):
- _storage_manager = {"call": 1}
- if _storage_manager is None:
- _storage_manager = {"call": 2}
- assert _storage_manager["call"] == 1
-
-
-# --- Rating save data structure ---
-
-
-class TestRatingSaveDataStructure:
- """Tests for rating save data structure for votes."""
-
- def _build_rating_save_data(self, user_id, card_id, rating_type, value):
- return {
- "user_id": user_id,
- "card_id": card_id,
- "rating_type": rating_type,
- "value": value,
- }
-
- def test_vote_up_data(self):
- data = self._build_rating_save_data("u1", "c1", "relevance", 1)
- assert data["value"] == 1
-
- def test_vote_down_data(self):
- data = self._build_rating_save_data("u1", "c1", "relevance", -1)
- assert data["value"] == -1
-
-
-# --- Trending news parameters ---
-
-
-class TestTrendingNewsParameters:
- """Tests for get_trending_news default parameters."""
-
- def test_default_hours(self):
- hours = 24
- assert hours == 24
-
- def test_default_limit(self):
- limit = 10
- assert limit == 10
-
- def test_default_min_impact(self):
- min_impact = 7
- assert min_impact == 7
-
-
-# --- Storage property error handling ---
-
-
-class TestStoragePropertyErrorHandling:
- """Tests for storage property error handling."""
-
- def _get_storage_or_raise(self, session, cached_storage):
- if session:
- return "new_storage"
- if cached_storage is None:
- raise RuntimeError("No database session available for news storage")
- return cached_storage
-
- def test_with_session(self):
- result = self._get_storage_or_raise("mock_session", None)
- assert result == "new_storage"
-
- def test_with_cached(self):
- result = self._get_storage_or_raise(None, "cached")
- assert result == "cached"
-
- def test_no_session_no_cache_raises(self):
- try:
- self._get_storage_or_raise(None, None)
- assert False, "Should have raised RuntimeError"
- except RuntimeError as e:
- assert "No database session available" in str(e)
diff --git a/tests/news/test_subscription_scheduling_behavior.py b/tests/news/test_subscription_scheduling_behavior.py
deleted file mode 100644
index 952bd4b122..0000000000
--- a/tests/news/test_subscription_scheduling_behavior.py
+++ /dev/null
@@ -1,545 +0,0 @@
-"""
-Deep behavioral tests for subscription scheduling patterns.
-Tests jitter calculation, trigger selection, next run calculation,
-overdue detection, and scheduling lifecycle patterns.
-"""
-
-from datetime import datetime, timezone, timedelta
-import random
-
-
-# --- Jitter calculation patterns ---
-
-
-class TestJitterCalculation:
- """Tests for jitter calculation patterns."""
-
- def _calculate_jitter(self, max_jitter_seconds=300):
- """Calculate random jitter within bounds."""
- return random.randint(0, max_jitter_seconds)
-
- def test_jitter_within_bounds(self):
- max_jitter = 300
- for _ in range(100):
- jitter = self._calculate_jitter(max_jitter)
- assert 0 <= jitter <= max_jitter
-
- def test_zero_max_jitter(self):
- jitter = self._calculate_jitter(0)
- assert jitter == 0
-
- def test_jitter_not_always_same(self):
- jitters = [self._calculate_jitter(300) for _ in range(10)]
- # With 300 possible values, very unlikely all same
- assert len(set(jitters)) > 1
-
-
-class TestJitterApplication:
- """Tests for applying jitter to intervals."""
-
- def _apply_jitter(self, base_seconds, jitter):
- """Apply jitter to base interval."""
- return base_seconds + jitter
-
- def test_adds_jitter(self):
- result = self._apply_jitter(3600, 120)
- assert result == 3720
-
- def test_zero_jitter(self):
- result = self._apply_jitter(3600, 0)
- assert result == 3600
-
- def test_jitter_spreads_load(self):
- base = 3600
- intervals = [
- self._apply_jitter(base, random.randint(0, 300)) for _ in range(5)
- ]
- # All intervals should be different due to jitter
- assert min(intervals) >= base
- assert max(intervals) <= base + 300
-
-
-# --- Trigger type selection patterns ---
-
-
-class TestTriggerTypeSelection:
- """Tests for APScheduler trigger type selection."""
-
- def _select_trigger_type(self, interval_minutes):
- """Select appropriate trigger type based on interval."""
- if interval_minutes <= 60:
- return "interval" # For frequent checks
- return "date" # For infrequent checks
-
- def test_hourly_uses_interval(self):
- trigger = self._select_trigger_type(60)
- assert trigger == "interval"
-
- def test_sub_hourly_uses_interval(self):
- trigger = self._select_trigger_type(15)
- assert trigger == "interval"
-
- def test_over_hour_uses_date(self):
- trigger = self._select_trigger_type(120)
- assert trigger == "date"
-
- def test_daily_uses_date(self):
- trigger = self._select_trigger_type(1440) # 24 hours
- assert trigger == "date"
-
-
-class TestIntervalTriggerConfig:
- """Tests for interval trigger configuration."""
-
- def _build_interval_config(self, minutes, jitter_seconds=0):
- return {
- "trigger": "interval",
- "minutes": minutes,
- "jitter": jitter_seconds,
- }
-
- def test_has_trigger_type(self):
- config = self._build_interval_config(30)
- assert config["trigger"] == "interval"
-
- def test_has_minutes(self):
- config = self._build_interval_config(30)
- assert config["minutes"] == 30
-
- def test_has_jitter(self):
- config = self._build_interval_config(30, jitter_seconds=60)
- assert config["jitter"] == 60
-
-
-class TestDateTriggerConfig:
- """Tests for date trigger configuration."""
-
- def _build_date_config(self, run_date):
- return {
- "trigger": "date",
- "run_date": run_date,
- }
-
- def test_has_trigger_type(self):
- config = self._build_date_config(datetime.now(timezone.utc))
- assert config["trigger"] == "date"
-
- def test_has_run_date(self):
- run_date = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- config = self._build_date_config(run_date)
- assert config["run_date"] == run_date
-
-
-# --- Next run calculation patterns ---
-
-
-class TestNextRunCalculation:
- """Tests for next run time calculation."""
-
- def _calculate_next_run(self, interval_minutes, jitter_seconds=0):
- """Calculate next run time from now."""
- now = datetime.now(timezone.utc)
- base_delta = timedelta(minutes=interval_minutes)
- jitter_delta = timedelta(seconds=jitter_seconds)
- return now + base_delta + jitter_delta
-
- def test_next_run_in_future(self):
- next_run = self._calculate_next_run(60)
- now = datetime.now(timezone.utc)
- assert next_run > now
-
- def test_interval_respected(self):
- interval = 30
- next_run = self._calculate_next_run(interval)
- now = datetime.now(timezone.utc)
- delta = (next_run - now).total_seconds()
- assert abs(delta - 30 * 60) < 1
-
- def test_jitter_added(self):
- next_run = self._calculate_next_run(60, jitter_seconds=120)
- now = datetime.now(timezone.utc)
- delta = (next_run - now).total_seconds()
- assert delta >= 60 * 60 # At least interval
- assert (
- delta <= 60 * 60 + 120 + 1
- ) # At most interval + jitter + tolerance
-
-
-class TestNextRunFromLastRefresh:
- """Tests for calculating next run from last refresh."""
-
- def _calculate_next_from_last(self, last_refresh, interval_minutes):
- """Calculate next run based on last refresh time."""
- if not last_refresh:
- return datetime.now(timezone.utc)
- return last_refresh + timedelta(minutes=interval_minutes)
-
- def test_from_last_refresh(self):
- last = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- next_run = self._calculate_next_from_last(last, 60)
- assert next_run.hour == 13 # 1 hour later
-
- def test_no_last_refresh_uses_now(self):
- before = datetime.now(timezone.utc)
- next_run = self._calculate_next_from_last(None, 60)
- after = datetime.now(timezone.utc)
- assert before <= next_run <= after
-
-
-# --- Overdue detection patterns ---
-
-
-class TestOverdueDetection:
- """Tests for overdue subscription detection."""
-
- def _is_overdue(self, next_refresh):
- """Check if subscription is overdue."""
- if not next_refresh:
- return True
- now = datetime.now(timezone.utc)
- return next_refresh <= now
-
- def test_past_is_overdue(self):
- past = datetime.now(timezone.utc) - timedelta(hours=1)
- assert self._is_overdue(past) is True
-
- def test_future_not_overdue(self):
- future = datetime.now(timezone.utc) + timedelta(hours=1)
- assert self._is_overdue(future) is False
-
- def test_no_next_refresh_is_overdue(self):
- assert self._is_overdue(None) is True
-
- def test_exactly_now_is_overdue(self):
- # For boundary, exactly now is considered overdue
- now = datetime.now(timezone.utc)
- assert self._is_overdue(now) is True
-
-
-class TestOverdueHandling:
- """Tests for handling overdue subscriptions."""
-
- def _schedule_overdue_immediately(self, subscription):
- """Schedule overdue subscription to run immediately."""
- run_time = datetime.now(timezone.utc) + timedelta(seconds=5)
- return {
- "subscription_id": subscription["id"],
- "run_time": run_time,
- "is_immediate": True,
- }
-
- def test_scheduled_immediately(self):
- sub = {"id": "sub-123"}
- scheduled = self._schedule_overdue_immediately(sub)
- now = datetime.now(timezone.utc)
- assert scheduled["run_time"] > now
- assert (scheduled["run_time"] - now).total_seconds() < 10
-
- def test_marked_as_immediate(self):
- sub = {"id": "sub-123"}
- scheduled = self._schedule_overdue_immediately(sub)
- assert scheduled["is_immediate"] is True
-
-
-# --- Job ID patterns ---
-
-
-class TestJobIdGeneration:
- """Tests for job ID generation patterns."""
-
- def _generate_job_id(self, subscription_id, user_id):
- """Generate unique job ID."""
- return f"check_sub_{user_id}_{subscription_id}"
-
- def test_includes_subscription_id(self):
- job_id = self._generate_job_id("sub-123", "user1")
- assert "sub-123" in job_id
-
- def test_includes_user_id(self):
- job_id = self._generate_job_id("sub-123", "user1")
- assert "user1" in job_id
-
- def test_has_prefix(self):
- job_id = self._generate_job_id("sub-123", "user1")
- assert job_id.startswith("check_sub_")
-
- def test_unique_for_different_subscriptions(self):
- job1 = self._generate_job_id("sub-1", "user1")
- job2 = self._generate_job_id("sub-2", "user1")
- assert job1 != job2
-
-
-class TestDocumentProcessingJobId:
- """Tests for document processing job ID patterns."""
-
- def _generate_doc_job_id(self, user_id):
- """Generate document processing job ID."""
- return f"doc_process_{user_id}"
-
- def test_includes_user_id(self):
- job_id = self._generate_doc_job_id("user123")
- assert "user123" in job_id
-
- def test_has_prefix(self):
- job_id = self._generate_doc_job_id("user1")
- assert job_id.startswith("doc_process_")
-
-
-# --- Subscription batch patterns ---
-
-
-class TestSubscriptionBatching:
- """Tests for subscription batch processing."""
-
- def _batch_subscriptions(self, subscriptions, batch_size=5):
- """Split subscriptions into batches."""
- batches = []
- for i in range(0, len(subscriptions), batch_size):
- batches.append(subscriptions[i : i + batch_size])
- return batches
-
- def test_single_batch(self):
- subs = [{"id": str(i)} for i in range(3)]
- batches = self._batch_subscriptions(subs, batch_size=5)
- assert len(batches) == 1
- assert len(batches[0]) == 3
-
- def test_multiple_batches(self):
- subs = [{"id": str(i)} for i in range(12)]
- batches = self._batch_subscriptions(subs, batch_size=5)
- assert len(batches) == 3
- assert len(batches[0]) == 5
- assert len(batches[1]) == 5
- assert len(batches[2]) == 2
-
- def test_empty_list(self):
- batches = self._batch_subscriptions([], batch_size=5)
- assert batches == []
-
-
-# --- Schedule clearing patterns ---
-
-
-class TestScheduleClearing:
- """Tests for clearing scheduled jobs."""
-
- def _clear_user_jobs(self, scheduled_jobs, user_id):
- """Clear all jobs for a user."""
- user_jobs = [j for j in scheduled_jobs if j.get("user_id") == user_id]
- for job in user_jobs:
- scheduled_jobs.remove(job)
- return len(user_jobs)
-
- def test_removes_user_jobs(self):
- jobs = [
- {"id": "j1", "user_id": "u1"},
- {"id": "j2", "user_id": "u2"},
- {"id": "j3", "user_id": "u1"},
- ]
- count = self._clear_user_jobs(jobs, "u1")
- assert count == 2
- assert len(jobs) == 1
- assert jobs[0]["user_id"] == "u2"
-
- def test_returns_count(self):
- jobs = [{"id": str(i), "user_id": "u1"} for i in range(5)]
- count = self._clear_user_jobs(jobs, "u1")
- assert count == 5
-
-
-# --- Scheduler running state patterns ---
-
-
-class TestSchedulerRunningState:
- """Tests for scheduler running state patterns."""
-
- def test_initial_not_running(self):
- is_running = False
- assert is_running is False
-
- def test_start_sets_running(self):
- is_running = False
- is_running = True
- assert is_running is True
-
- def test_stop_clears_running(self):
- is_running = True
- is_running = False
- assert is_running is False
-
-
-class TestSchedulerOperationGuards:
- """Tests for scheduler operation guard patterns."""
-
- def _should_skip_operation(self, is_running, has_session):
- """Check if operation should be skipped."""
- if not is_running:
- return True
- if not has_session:
- return True
- return False
-
- def test_skip_when_not_running(self):
- assert self._should_skip_operation(False, True) is True
-
- def test_skip_when_no_session(self):
- assert self._should_skip_operation(True, False) is True
-
- def test_proceed_when_both_true(self):
- assert self._should_skip_operation(True, True) is False
-
-
-# --- Subscription status checks ---
-
-
-class TestSubscriptionStatusChecks:
- """Tests for subscription status check patterns."""
-
- def _should_schedule(self, subscription):
- """Check if subscription should be scheduled."""
- if not subscription.get("is_active", True):
- return False
- if subscription.get("status") in ["paused", "expired"]:
- return False
- return True
-
- def test_active_should_schedule(self):
- sub = {"is_active": True, "status": "active"}
- assert self._should_schedule(sub) is True
-
- def test_paused_not_scheduled(self):
- sub = {"is_active": True, "status": "paused"}
- assert self._should_schedule(sub) is False
-
- def test_expired_not_scheduled(self):
- sub = {"is_active": True, "status": "expired"}
- assert self._should_schedule(sub) is False
-
- def test_inactive_not_scheduled(self):
- sub = {"is_active": False, "status": "active"}
- assert self._should_schedule(sub) is False
-
-
-# --- Date placeholder replacement ---
-
-
-class TestDatePlaceholderReplacement:
- """Tests for date placeholder replacement in queries."""
-
- def _replace_date_placeholder(self, query):
- """Replace YYYY-MM-DD with current date."""
- today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
- return query.replace("YYYY-MM-DD", today)
-
- def test_replaces_placeholder(self):
- query = "news for YYYY-MM-DD"
- result = self._replace_date_placeholder(query)
- assert "YYYY-MM-DD" not in result
- assert datetime.now(timezone.utc).strftime("%Y") in result
-
- def test_no_placeholder(self):
- query = "AI news today"
- result = self._replace_date_placeholder(query)
- assert result == "AI news today"
-
- def test_multiple_placeholders(self):
- query = "news YYYY-MM-DD and also YYYY-MM-DD"
- result = self._replace_date_placeholder(query)
- assert result.count("YYYY-MM-DD") == 0
-
-
-# --- Max instances configuration ---
-
-
-class TestMaxInstancesConfig:
- """Tests for max instances configuration."""
-
- def _build_job_config(self, max_instances=1):
- return {
- "max_instances": max_instances,
- "coalesce": True,
- "misfire_grace_time": 60,
- }
-
- def test_default_max_instances_1(self):
- config = self._build_job_config()
- assert config["max_instances"] == 1
-
- def test_coalesce_enabled(self):
- config = self._build_job_config()
- assert config["coalesce"] is True
-
- def test_misfire_grace_time(self):
- config = self._build_job_config()
- assert config["misfire_grace_time"] == 60
-
-
-# --- Job verification patterns ---
-
-
-class TestJobVerification:
- """Tests for job verification after scheduling."""
-
- def _verify_job_scheduled(self, scheduled_jobs, job_id):
- """Verify a job was successfully scheduled."""
- return job_id in scheduled_jobs
-
- def test_job_found(self):
- jobs = {"job-1", "job-2", "job-3"}
- assert self._verify_job_scheduled(jobs, "job-2") is True
-
- def test_job_not_found(self):
- jobs = {"job-1", "job-2"}
- assert self._verify_job_scheduled(jobs, "job-3") is False
-
-
-# --- Error recovery patterns ---
-
-
-class TestSchedulingErrorRecovery:
- """Tests for scheduling error recovery patterns."""
-
- def _handle_job_lookup_error(self, job_id, scheduled_jobs):
- """Handle JobLookupError by removing from tracked jobs."""
- scheduled_jobs.discard(job_id)
- return True
-
- def test_removes_from_tracked(self):
- jobs = {"job-1", "job-2", "job-3"}
- self._handle_job_lookup_error("job-2", jobs)
- assert "job-2" not in jobs
- assert len(jobs) == 2
-
- def test_handles_already_missing(self):
- jobs = {"job-1"}
- result = self._handle_job_lookup_error("job-2", jobs)
- assert result is True # No error
-
-
-# --- Rescheduling patterns ---
-
-
-class TestReschedulingPatterns:
- """Tests for subscription rescheduling."""
-
- def _reschedule_subscription(self, subscription, new_interval_minutes):
- """Reschedule a subscription with new interval."""
- now = datetime.now(timezone.utc)
- subscription["refresh_interval_minutes"] = new_interval_minutes
- subscription["next_refresh"] = now + timedelta(
- minutes=new_interval_minutes
- )
- return subscription
-
- def test_updates_interval(self):
- sub = {"id": "1", "refresh_interval_minutes": 60}
- result = self._reschedule_subscription(sub, 120)
- assert result["refresh_interval_minutes"] == 120
-
- def test_updates_next_refresh(self):
- sub = {"id": "1", "refresh_interval_minutes": 60}
- before = datetime.now(timezone.utc)
- result = self._reschedule_subscription(sub, 120)
- expected = before + timedelta(minutes=120)
- diff = abs((result["next_refresh"] - expected).total_seconds())
- assert diff < 1 # Within 1 second
diff --git a/tests/news/test_subscription_storage_logic_behavior.py b/tests/news/test_subscription_storage_logic_behavior.py
deleted file mode 100644
index ebe078d189..0000000000
--- a/tests/news/test_subscription_storage_logic_behavior.py
+++ /dev/null
@@ -1,559 +0,0 @@
-"""
-Deep behavioral tests for subscription_manager/storage.py pure logic.
-Tests updateable field validation, status transitions, refresh time
-calculation, list filtering patterns, and storage data mapping.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-
-# --- Updateable fields validation ---
-
-
-class TestUpdateableFields:
- """Tests for subscription update field validation."""
-
- UPDATEABLE_FIELDS = [
- "name",
- "refresh_interval_minutes",
- "status",
- "is_active",
- "expires_at",
- "folder_id",
- "model_provider",
- "model",
- "search_strategy",
- "custom_endpoint",
- "search_engine",
- "search_iterations",
- "questions_per_iteration",
- ]
-
- def test_name_is_updateable(self):
- assert "name" in self.UPDATEABLE_FIELDS
-
- def test_refresh_interval_is_updateable(self):
- assert "refresh_interval_minutes" in self.UPDATEABLE_FIELDS
-
- def test_status_is_updateable(self):
- assert "status" in self.UPDATEABLE_FIELDS
-
- def test_is_active_is_updateable(self):
- assert "is_active" in self.UPDATEABLE_FIELDS
-
- def test_expires_at_is_updateable(self):
- assert "expires_at" in self.UPDATEABLE_FIELDS
-
- def test_folder_id_is_updateable(self):
- assert "folder_id" in self.UPDATEABLE_FIELDS
-
- def test_model_provider_is_updateable(self):
- assert "model_provider" in self.UPDATEABLE_FIELDS
-
- def test_model_is_updateable(self):
- assert "model" in self.UPDATEABLE_FIELDS
-
- def test_search_strategy_is_updateable(self):
- assert "search_strategy" in self.UPDATEABLE_FIELDS
-
- def test_custom_endpoint_is_updateable(self):
- assert "custom_endpoint" in self.UPDATEABLE_FIELDS
-
- def test_search_engine_is_updateable(self):
- assert "search_engine" in self.UPDATEABLE_FIELDS
-
- def test_search_iterations_is_updateable(self):
- assert "search_iterations" in self.UPDATEABLE_FIELDS
-
- def test_questions_per_iteration_is_updateable(self):
- assert "questions_per_iteration" in self.UPDATEABLE_FIELDS
-
- def test_id_not_updateable(self):
- assert "id" not in self.UPDATEABLE_FIELDS
-
- def test_user_id_not_updateable(self):
- assert "user_id" not in self.UPDATEABLE_FIELDS
-
- def test_created_at_not_updateable(self):
- assert "created_at" not in self.UPDATEABLE_FIELDS
-
- def test_query_or_topic_not_updateable(self):
- assert "query_or_topic" not in self.UPDATEABLE_FIELDS
-
- def test_subscription_type_not_updateable(self):
- assert "subscription_type" not in self.UPDATEABLE_FIELDS
-
-
-class TestUpdateFieldFiltering:
- """Tests for filtering update data to valid fields."""
-
- UPDATEABLE = {
- "name",
- "refresh_interval_minutes",
- "status",
- "is_active",
- }
-
- def _filter_update(self, data):
- return {k: v for k, v in data.items() if k in self.UPDATEABLE}
-
- def test_filters_invalid_fields(self):
- data = {"name": "New Name", "id": "should-not-update"}
- filtered = self._filter_update(data)
- assert "id" not in filtered
- assert filtered["name"] == "New Name"
-
- def test_preserves_valid_fields(self):
- data = {"name": "X", "refresh_interval_minutes": 60, "status": "paused"}
- filtered = self._filter_update(data)
- assert len(filtered) == 3
-
- def test_empty_data(self):
- assert self._filter_update({}) == {}
-
- def test_all_invalid_fields(self):
- data = {"id": "1", "user_id": "u1", "created_at": "2025-01-01"}
- assert self._filter_update(data) == {}
-
-
-# --- Next refresh calculation ---
-
-
-class TestNextRefreshCalculation:
- """Tests for next_refresh time calculation."""
-
- def _calc_next_refresh(self, minutes, base_time=None):
- base = base_time or datetime.now(timezone.utc)
- return base + timedelta(minutes=minutes)
-
- def test_60_minutes(self):
- base = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next_refresh(60, base)
- assert result == datetime(2025, 6, 15, 11, 0, tzinfo=timezone.utc)
-
- def test_240_minutes(self):
- base = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next_refresh(240, base)
- assert result == datetime(2025, 6, 15, 14, 0, tzinfo=timezone.utc)
-
- def test_1440_minutes_daily(self):
- base = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next_refresh(1440, base)
- assert result == datetime(2025, 6, 16, 10, 0, tzinfo=timezone.utc)
-
- def test_zero_minutes(self):
- base = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next_refresh(0, base)
- assert result == base
-
- def test_small_interval(self):
- base = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- result = self._calc_next_refresh(5, base)
- assert result == datetime(2025, 6, 15, 10, 5, tzinfo=timezone.utc)
-
-
-class TestUpdateTriggersNextRefreshRecalc:
- """Tests for refresh interval change triggering next_refresh update."""
-
- def _needs_recalc(self, data):
- return "refresh_interval_minutes" in data
-
- def test_interval_change_needs_recalc(self):
- assert self._needs_recalc({"refresh_interval_minutes": 120}) is True
-
- def test_name_change_no_recalc(self):
- assert self._needs_recalc({"name": "New Name"}) is False
-
- def test_status_change_no_recalc(self):
- assert self._needs_recalc({"status": "paused"}) is False
-
- def test_mixed_changes_with_interval(self):
- data = {"name": "X", "refresh_interval_minutes": 60}
- assert self._needs_recalc(data) is True
-
- def test_empty_data(self):
- assert self._needs_recalc({}) is False
-
-
-# --- List filter patterns ---
-
-
-class TestListFilterPatterns:
- """Tests for list filtering logic patterns."""
-
- def _should_filter_user(self, filters):
- return filters and "user_id" in filters
-
- def _should_filter_status(self, filters):
- return filters and "status" in filters
-
- def _should_filter_type(self, filters):
- return filters and "subscription_type" in filters
-
- def test_user_id_filter(self):
- assert self._should_filter_user({"user_id": "u1"}) is True
-
- def test_no_user_id_filter(self):
- assert self._should_filter_user({"status": "active"}) is False
-
- def test_status_filter(self):
- assert self._should_filter_status({"status": "active"}) is True
-
- def test_no_status_filter(self):
- assert self._should_filter_status({"user_id": "u1"}) is False
-
- def test_type_filter(self):
- assert self._should_filter_type({"subscription_type": "search"}) is True
-
- def test_no_filters(self):
- assert not self._should_filter_user(None)
- assert not self._should_filter_status(None)
- assert not self._should_filter_type(None)
-
- def test_empty_filters(self):
- assert not self._should_filter_user({})
-
-
-# --- Due subscriptions logic ---
-
-
-class TestDueSubscriptionsLogic:
- """Tests for due subscription detection."""
-
- def _is_due(self, next_refresh, now=None):
- now = now or datetime.now(timezone.utc)
- return next_refresh <= now
-
- def test_past_is_due(self):
- now = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- next_refresh = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- assert self._is_due(next_refresh, now) is True
-
- def test_future_not_due(self):
- now = datetime(2025, 6, 15, 10, 0, tzinfo=timezone.utc)
- next_refresh = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- assert self._is_due(next_refresh, now) is False
-
- def test_exactly_now_is_due(self):
- now = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- next_refresh = datetime(2025, 6, 15, 12, 0, tzinfo=timezone.utc)
- assert self._is_due(next_refresh, now) is True
-
- def test_one_second_past(self):
- now = datetime(2025, 6, 15, 12, 0, 1, tzinfo=timezone.utc)
- next_refresh = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- assert self._is_due(next_refresh, now) is True
-
- def test_one_second_future(self):
- now = datetime(2025, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
- next_refresh = datetime(2025, 6, 15, 12, 0, 1, tzinfo=timezone.utc)
- assert self._is_due(next_refresh, now) is False
-
-
-# --- Pause/resume status transitions ---
-
-
-class TestPauseResumeStatusTransitions:
- """Tests for pause/resume status validation."""
-
- def _can_pause(self, status):
- return status == "active"
-
- def _can_resume(self, status):
- return status == "paused"
-
- def test_can_pause_active(self):
- assert self._can_pause("active") is True
-
- def test_cannot_pause_paused(self):
- assert self._can_pause("paused") is False
-
- def test_cannot_pause_expired(self):
- assert self._can_pause("expired") is False
-
- def test_can_resume_paused(self):
- assert self._can_resume("paused") is True
-
- def test_cannot_resume_active(self):
- assert self._can_resume("active") is False
-
- def test_cannot_resume_expired(self):
- assert self._can_resume("expired") is False
-
-
-# --- Increment stats logic ---
-
-
-class TestIncrementStatsLogic:
- """Tests for stats increment patterns."""
-
- def _increment(self, current, amount=1):
- return current + amount
-
- def test_increment_from_zero(self):
- assert self._increment(0) == 1
-
- def test_increment_from_existing(self):
- assert self._increment(5) == 6
-
- def test_increment_by_custom_amount(self):
- assert self._increment(3, 5) == 8
-
- def test_keep_in_sync(self):
- refresh_count = 10
- total_runs = self._increment(refresh_count - 1)
- assert total_runs == refresh_count
-
-
-# --- Subscription dict mapping ---
-
-
-class TestSubscriptionDictMapping:
- """Tests for subscription to dict mapping."""
-
- def _map_list_item(self, sub_dict):
- return {
- "id": sub_dict.get("id"),
- "user_id": sub_dict.get("user_id"),
- "name": sub_dict.get("name"),
- "subscription_type": sub_dict.get("subscription_type"),
- "query_or_topic": sub_dict.get("query_or_topic"),
- "refresh_interval_minutes": sub_dict.get(
- "refresh_interval_minutes"
- ),
- "created_at": sub_dict.get("created_at"),
- "updated_at": sub_dict.get("updated_at"),
- "last_refresh": sub_dict.get("last_refresh"),
- "next_refresh": sub_dict.get("next_refresh"),
- "status": sub_dict.get("status"),
- "folder": sub_dict.get("folder"),
- "notes": sub_dict.get("notes"),
- }
-
- def test_preserves_id(self):
- data = {"id": "sub-123"}
- assert self._map_list_item(data)["id"] == "sub-123"
-
- def test_preserves_user_id(self):
- data = {"user_id": "u1"}
- assert self._map_list_item(data)["user_id"] == "u1"
-
- def test_preserves_query_or_topic(self):
- data = {"query_or_topic": "AI news"}
- assert self._map_list_item(data)["query_or_topic"] == "AI news"
-
- def test_missing_fields_are_none(self):
- data = {"id": "1"}
- result = self._map_list_item(data)
- assert result["name"] is None
- assert result["folder"] is None
-
-
-class TestFullSubscriptionDictMapping:
- """Tests for full subscription get() mapping."""
-
- def _has_full_fields(self, result):
- full_fields = [
- "id",
- "user_id",
- "name",
- "subscription_type",
- "query_or_topic",
- "refresh_interval_minutes",
- "created_at",
- "updated_at",
- "last_refresh",
- "next_refresh",
- "expires_at",
- "source_type",
- "source_id",
- "created_from",
- "folder",
- "folder_id",
- "notes",
- "status",
- "is_active",
- "refresh_count",
- "results_count",
- "last_error",
- "error_count",
- "model_provider",
- "model",
- "search_strategy",
- "custom_endpoint",
- "search_engine",
- "search_iterations",
- "questions_per_iteration",
- ]
- return all(f in result for f in full_fields)
-
- def test_full_mapping_has_all_fields(self):
- result = {
- "id": "1",
- "user_id": "u1",
- "name": "Test",
- "subscription_type": "search",
- "query_or_topic": "AI",
- "refresh_interval_minutes": 60,
- "created_at": None,
- "updated_at": None,
- "last_refresh": None,
- "next_refresh": None,
- "expires_at": None,
- "source_type": None,
- "source_id": None,
- "created_from": None,
- "folder": None,
- "folder_id": None,
- "notes": None,
- "status": "active",
- "is_active": True,
- "refresh_count": 0,
- "results_count": 0,
- "last_error": None,
- "error_count": 0,
- "model_provider": None,
- "model": None,
- "search_strategy": None,
- "custom_endpoint": None,
- "search_engine": None,
- "search_iterations": 3,
- "questions_per_iteration": 5,
- }
- assert self._has_full_fields(result)
-
-
-# --- Create data defaults ---
-
-
-class TestCreateDataDefaults:
- """Tests for create subscription data defaults."""
-
- def _apply_defaults(self, data):
- return {
- "id": data.get("id") or "generated-id",
- "frequency": data.get("frequency", "daily"),
- "status": data.get("status", "active"),
- "is_active": data.get("is_active", True),
- "search_iterations": data.get("search_iterations", 3),
- "questions_per_iteration": data.get("questions_per_iteration", 5),
- }
-
- def test_default_frequency(self):
- result = self._apply_defaults({})
- assert result["frequency"] == "daily"
-
- def test_default_status(self):
- result = self._apply_defaults({})
- assert result["status"] == "active"
-
- def test_default_is_active(self):
- result = self._apply_defaults({})
- assert result["is_active"] is True
-
- def test_default_search_iterations(self):
- result = self._apply_defaults({})
- assert result["search_iterations"] == 3
-
- def test_default_questions_per_iteration(self):
- result = self._apply_defaults({})
- assert result["questions_per_iteration"] == 5
-
- def test_custom_frequency(self):
- result = self._apply_defaults({"frequency": "hourly"})
- assert result["frequency"] == "hourly"
-
- def test_custom_status(self):
- result = self._apply_defaults({"status": "paused"})
- assert result["status"] == "paused"
-
- def test_generated_id_when_missing(self):
- result = self._apply_defaults({})
- assert result["id"] == "generated-id"
-
- def test_provided_id_preserved(self):
- result = self._apply_defaults({"id": "my-id"})
- assert result["id"] == "my-id"
-
-
-# --- Getattr defaults ---
-
-
-class TestGetattrDefaults:
- """Tests for getattr default value patterns."""
-
- def _get_with_default(self, obj, field, default):
- return getattr(obj, field, default)
-
- def test_is_active_default_true(self):
- class Obj:
- pass
-
- assert self._get_with_default(Obj(), "is_active", True) is True
-
- def test_search_iterations_default_3(self):
- class Obj:
- pass
-
- assert self._get_with_default(Obj(), "search_iterations", 3) == 3
-
- def test_questions_per_iteration_default_5(self):
- class Obj:
- pass
-
- assert self._get_with_default(Obj(), "questions_per_iteration", 5) == 5
-
- def test_existing_value_preserved(self):
- class Obj:
- is_active = False
-
- assert self._get_with_default(Obj(), "is_active", True) is False
-
-
-# --- Resume next_refresh calculation ---
-
-
-class TestResumeNextRefreshCalculation:
- """Tests for next_refresh calculation on resume."""
-
- def _calc_resume_next(self, interval_minutes):
- return datetime.now(timezone.utc) + timedelta(minutes=interval_minutes)
-
- def test_resume_60_min(self):
- result = self._calc_resume_next(60)
- now = datetime.now(timezone.utc)
- diff = (result - now).total_seconds()
- assert 3500 < diff < 3700 # ~60 minutes
-
- def test_resume_240_min(self):
- result = self._calc_resume_next(240)
- now = datetime.now(timezone.utc)
- diff = (result - now).total_seconds()
- assert 14300 < diff < 14500 # ~240 minutes
-
-
-# --- Expire subscription logic ---
-
-
-class TestExpireSubscriptionLogic:
- """Tests for subscription expiration patterns."""
-
- def _expire(self, status):
- return {
- "status": "expired",
- "expires_at": datetime.now(timezone.utc),
- }
-
- def test_expired_status(self):
- result = self._expire("active")
- assert result["status"] == "expired"
-
- def test_expires_at_set(self):
- result = self._expire("active")
- assert result["expires_at"] is not None
-
- def test_expires_at_is_now(self):
- before = datetime.now(timezone.utc)
- result = self._expire("active")
- after = datetime.now(timezone.utc)
- assert before <= result["expires_at"] <= after
diff --git a/tests/news/test_text_processing_patterns_behavior.py b/tests/news/test_text_processing_patterns_behavior.py
deleted file mode 100644
index b5022a38d0..0000000000
--- a/tests/news/test_text_processing_patterns_behavior.py
+++ /dev/null
@@ -1,614 +0,0 @@
-"""
-Deep behavioral tests for text processing patterns.
-Tests tokenization, stemming, normalization,
-and text similarity logic.
-"""
-
-import re
-from collections import Counter
-
-
-# --- Tokenization patterns ---
-
-
-class TestBasicTokenization:
- """Tests for basic tokenization patterns."""
-
- def _tokenize_whitespace(self, text):
- """Split text by whitespace."""
- if not text:
- return []
- return text.split()
-
- def _tokenize_words(self, text):
- """Extract only words (alphanumeric)."""
- if not text:
- return []
- return re.findall(r"\b\w+\b", text)
-
- def _tokenize_sentences(self, text):
- """Split text into sentences."""
- if not text:
- return []
- return re.split(r"[.!?]+\s*", text.strip())
-
- def test_whitespace_tokenize(self):
- result = self._tokenize_whitespace("hello world foo")
- assert result == ["hello", "world", "foo"]
-
- def test_whitespace_empty(self):
- assert self._tokenize_whitespace("") == []
-
- def test_words_ignores_punctuation(self):
- result = self._tokenize_words("Hello, world!")
- assert result == ["Hello", "world"]
-
- def test_sentence_tokenize(self):
- text = "Hello world. How are you? Fine."
- result = self._tokenize_sentences(text)
- assert "Hello world" in result
-
-
-class TestNGramTokenization:
- """Tests for n-gram tokenization patterns."""
-
- def _ngrams(self, tokens, n):
- """Generate n-grams from tokens."""
- if len(tokens) < n:
- return []
- return [tuple(tokens[i : i + n]) for i in range(len(tokens) - n + 1)]
-
- def _char_ngrams(self, text, n):
- """Generate character n-grams."""
- if len(text) < n:
- return []
- return [text[i : i + n] for i in range(len(text) - n + 1)]
-
- def test_bigrams(self):
- tokens = ["the", "quick", "brown", "fox"]
- result = self._ngrams(tokens, 2)
- assert ("the", "quick") in result
- assert ("quick", "brown") in result
- assert len(result) == 3
-
- def test_trigrams(self):
- tokens = ["a", "b", "c", "d"]
- result = self._ngrams(tokens, 3)
- assert len(result) == 2
-
- def test_char_ngrams(self):
- result = self._char_ngrams("hello", 2)
- assert result == ["he", "el", "ll", "lo"]
-
-
-# --- Text normalization patterns ---
-
-
-class TestTextNormalization:
- """Tests for text normalization patterns."""
-
- def _lowercase(self, text):
- """Convert to lowercase."""
- return text.lower() if text else ""
-
- def _remove_punctuation(self, text):
- """Remove punctuation."""
- if not text:
- return ""
- return re.sub(r"[^\w\s]", "", text)
-
- def _collapse_whitespace(self, text):
- """Collapse multiple whitespace to single space."""
- if not text:
- return ""
- return re.sub(r"\s+", " ", text).strip()
-
- def _normalize(self, text):
- """Apply all normalizations."""
- text = self._lowercase(text)
- text = self._remove_punctuation(text)
- text = self._collapse_whitespace(text)
- return text
-
- def test_lowercase(self):
- assert self._lowercase("Hello World") == "hello world"
-
- def test_remove_punctuation(self):
- assert self._remove_punctuation("Hello, world!") == "Hello world"
-
- def test_collapse_whitespace(self):
- assert self._collapse_whitespace(" hello world ") == "hello world"
-
- def test_full_normalize(self):
- result = self._normalize(" Hello, World! ")
- assert result == "hello world"
-
-
-class TestUnicodeNormalization:
- """Tests for unicode normalization patterns."""
-
- def _remove_accents(self, text):
- """Remove diacritical marks."""
- import unicodedata
-
- normalized = unicodedata.normalize("NFD", text)
- return "".join(c for c in normalized if unicodedata.category(c) != "Mn")
-
- def _ascii_only(self, text):
- """Keep only ASCII characters."""
- return "".join(c for c in text if ord(c) < 128)
-
- def test_remove_accents(self):
- result = self._remove_accents("café")
- assert result == "cafe"
-
- def test_ascii_only(self):
- result = self._ascii_only("hello café ñ")
- assert result == "hello caf "
-
-
-# --- Stop word removal patterns ---
-
-
-class TestStopWordRemoval:
- """Tests for stop word removal patterns."""
-
- def _get_stopwords(self):
- """Get common English stop words."""
- return {
- "the",
- "a",
- "an",
- "is",
- "are",
- "was",
- "were",
- "be",
- "been",
- "being",
- "have",
- "has",
- "had",
- "do",
- "does",
- "did",
- "will",
- "would",
- "could",
- "should",
- "may",
- "might",
- "must",
- "and",
- "but",
- "or",
- "of",
- "at",
- "by",
- "for",
- "with",
- "about",
- "to",
- "from",
- "in",
- "on",
- "it",
- "its",
- "this",
- "that",
- }
-
- def _remove_stopwords(self, tokens):
- """Remove stop words from tokens."""
- stopwords = self._get_stopwords()
- return [t for t in tokens if t.lower() not in stopwords]
-
- def test_removes_stopwords(self):
- tokens = ["the", "quick", "brown", "fox"]
- result = self._remove_stopwords(tokens)
- assert "the" not in result
- assert "quick" in result
-
- def test_case_insensitive(self):
- tokens = ["The", "Quick", "THE"]
- result = self._remove_stopwords(tokens)
- assert "The" not in result
- assert "THE" not in result
- assert "Quick" in result
-
-
-# --- Stemming patterns ---
-
-
-class TestSimpleStemming:
- """Tests for simple stemming patterns."""
-
- def _stem_suffix(self, word):
- """Simple suffix-based stemming."""
- if len(word) < 4:
- return word
- suffixes = ["ing", "ed", "ly", "es", "s", "er", "est", "ment", "ness"]
- for suffix in suffixes:
- if word.endswith(suffix) and len(word) - len(suffix) >= 3:
- return word[: -len(suffix)]
- return word
-
- def test_stem_ing(self):
- assert self._stem_suffix("running") == "runn"
- assert self._stem_suffix("jumping") == "jump"
-
- def test_stem_ed(self):
- assert self._stem_suffix("walked") == "walk"
-
- def test_stem_ly(self):
- assert self._stem_suffix("quickly") == "quick"
-
- def test_short_word_unchanged(self):
- assert self._stem_suffix("run") == "run"
-
-
-# --- Text similarity patterns ---
-
-
-class TestJaccardSimilarity:
- """Tests for Jaccard similarity patterns."""
-
- def _jaccard(self, set1, set2):
- """Calculate Jaccard similarity."""
- if not set1 and not set2:
- return 1.0
- intersection = len(set1 & set2)
- union = len(set1 | set2)
- if union == 0:
- return 0.0
- return intersection / union
-
- def _jaccard_tokens(self, text1, text2):
- """Calculate Jaccard similarity for texts."""
- tokens1 = set(text1.lower().split())
- tokens2 = set(text2.lower().split())
- return self._jaccard(tokens1, tokens2)
-
- def test_identical_sets(self):
- s1 = {"a", "b", "c"}
- assert self._jaccard(s1, s1) == 1.0
-
- def test_no_overlap(self):
- s1 = {"a", "b"}
- s2 = {"c", "d"}
- assert self._jaccard(s1, s2) == 0.0
-
- def test_partial_overlap(self):
- s1 = {"a", "b", "c"}
- s2 = {"b", "c", "d"}
- # Intersection: {b, c} = 2, Union: {a, b, c, d} = 4
- assert self._jaccard(s1, s2) == 0.5
-
- def test_text_similarity(self):
- result = self._jaccard_tokens("the cat sat", "the cat ran")
- assert 0 < result < 1
-
-
-class TestCosineSimilarity:
- """Tests for cosine similarity patterns."""
-
- def _cosine(self, vec1, vec2):
- """Calculate cosine similarity between vectors."""
- dot = sum(a * b for a, b in zip(vec1, vec2))
- norm1 = sum(a * a for a in vec1) ** 0.5
- norm2 = sum(b * b for b in vec2) ** 0.5
- if norm1 == 0 or norm2 == 0:
- return 0.0
- return dot / (norm1 * norm2)
-
- def _text_to_vector(self, text, vocab):
- """Convert text to term frequency vector."""
- tokens = text.lower().split()
- counter = Counter(tokens)
- return [counter.get(word, 0) for word in vocab]
-
- def test_identical_vectors(self):
- vec = [1, 2, 3]
- result = self._cosine(vec, vec)
- assert abs(result - 1.0) < 0.001
-
- def test_orthogonal_vectors(self):
- vec1 = [1, 0, 0]
- vec2 = [0, 1, 0]
- result = self._cosine(vec1, vec2)
- assert abs(result) < 0.001
-
- def test_zero_vector(self):
- vec1 = [1, 2, 3]
- vec2 = [0, 0, 0]
- assert self._cosine(vec1, vec2) == 0.0
-
-
-class TestEditDistance:
- """Tests for edit distance (Levenshtein) patterns."""
-
- def _edit_distance(self, s1, s2):
- """Calculate edit distance between strings."""
- m, n = len(s1), len(s2)
- dp = [[0] * (n + 1) for _ in range(m + 1)]
- for i in range(m + 1):
- dp[i][0] = i
- for j in range(n + 1):
- dp[0][j] = j
- for i in range(1, m + 1):
- for j in range(1, n + 1):
- if s1[i - 1] == s2[j - 1]:
- dp[i][j] = dp[i - 1][j - 1]
- else:
- dp[i][j] = 1 + min(
- dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]
- )
- return dp[m][n]
-
- def _similarity_from_distance(self, s1, s2):
- """Calculate similarity from edit distance."""
- if not s1 and not s2:
- return 1.0
- max_len = max(len(s1), len(s2))
- if max_len == 0:
- return 1.0
- distance = self._edit_distance(s1, s2)
- return 1 - (distance / max_len)
-
- def test_identical_strings(self):
- assert self._edit_distance("hello", "hello") == 0
-
- def test_one_insertion(self):
- assert self._edit_distance("cat", "cats") == 1
-
- def test_one_deletion(self):
- assert self._edit_distance("cats", "cat") == 1
-
- def test_one_substitution(self):
- assert self._edit_distance("cat", "bat") == 1
-
- def test_similarity(self):
- sim = self._similarity_from_distance("hello", "hallo")
- assert 0.7 < sim < 0.9
-
-
-# --- Keyword extraction patterns ---
-
-
-class TestKeywordExtraction:
- """Tests for keyword extraction patterns."""
-
- def _extract_keywords(self, text, top_n=5):
- """Extract top keywords by frequency."""
- tokens = re.findall(r"\b\w+\b", text.lower())
- stopwords = {
- "the",
- "a",
- "an",
- "is",
- "are",
- "in",
- "on",
- "of",
- "to",
- "and",
- }
- tokens = [t for t in tokens if t not in stopwords and len(t) > 2]
- counter = Counter(tokens)
- return [word for word, _ in counter.most_common(top_n)]
-
- def _extract_phrases(self, text, min_freq=2):
- """Extract common bigram phrases."""
- tokens = re.findall(r"\b\w+\b", text.lower())
- bigrams = [
- f"{tokens[i]} {tokens[i + 1]}" for i in range(len(tokens) - 1)
- ]
- counter = Counter(bigrams)
- return [
- phrase for phrase, count in counter.items() if count >= min_freq
- ]
-
- def test_extracts_frequent_words(self):
- text = "python python python java java ruby"
- keywords = self._extract_keywords(text, top_n=2)
- assert "python" in keywords
-
- def test_ignores_stopwords(self):
- text = "the the the cat cat dog"
- keywords = self._extract_keywords(text, top_n=3)
- assert "the" not in keywords
-
- def test_extract_phrases(self):
- text = "machine learning machine learning deep learning"
- phrases = self._extract_phrases(text, min_freq=2)
- assert "machine learning" in phrases
-
-
-# --- Text truncation patterns ---
-
-
-class TestTextTruncation:
- """Tests for text truncation patterns."""
-
- def _truncate(self, text, max_length, suffix="..."):
- """Truncate text to max length."""
- if not text or len(text) <= max_length:
- return text
- return text[: max_length - len(suffix)] + suffix
-
- def _truncate_words(self, text, max_words, suffix="..."):
- """Truncate text to max words."""
- words = text.split()
- if len(words) <= max_words:
- return text
- return " ".join(words[:max_words]) + suffix
-
- def _smart_truncate(self, text, max_length, suffix="..."):
- """Truncate at word boundary."""
- if not text or len(text) <= max_length:
- return text
- truncated = text[: max_length - len(suffix)]
- # Find last space
- last_space = truncated.rfind(" ")
- if last_space > max_length // 2:
- truncated = truncated[:last_space]
- return truncated + suffix
-
- def test_short_text_unchanged(self):
- result = self._truncate("hello", max_length=10)
- assert result == "hello"
-
- def test_long_text_truncated(self):
- result = self._truncate("hello world", max_length=8)
- assert len(result) == 8
- assert result.endswith("...")
-
- def test_truncate_words(self):
- result = self._truncate_words("one two three four five", max_words=3)
- assert result == "one two three..."
-
- def test_smart_truncate(self):
- result = self._smart_truncate("hello wonderful world", max_length=15)
- assert result.endswith("...")
- assert "wonderful" not in result or result.endswith("...")
-
-
-# --- Text cleaning patterns ---
-
-
-class TestTextCleaning:
- """Tests for text cleaning patterns."""
-
- def _remove_html_tags(self, text):
- """Remove HTML tags."""
- return re.sub(r"<[^>]+>", "", text)
-
- def _remove_urls(self, text):
- """Remove URLs."""
- return re.sub(r"https?://\S+", "", text)
-
- def _remove_emails(self, text):
- """Remove email addresses."""
- return re.sub(r"\S+@\S+\.\S+", "", text)
-
- def _remove_numbers(self, text):
- """Remove numbers."""
- return re.sub(r"\d+", "", text)
-
- def test_remove_html(self):
- result = self._remove_html_tags("<p>Hello</p> <b>World</b>")
- assert result == "Hello World"
-
- def test_remove_urls(self):
- result = self._remove_urls("Visit https://example.com for more")
- assert "https" not in result
- assert "Visit" in result
-
- def test_remove_emails(self):
- result = self._remove_emails("Contact [email protected] today")
- assert "@" not in result
-
- def test_remove_numbers(self):
- result = self._remove_numbers("Order 12345 is ready")
- assert "12345" not in result
-
-
-# --- Text splitting patterns ---
-
-
-class TestTextSplitting:
- """Tests for text splitting patterns."""
-
- def _split_into_chunks(self, text, chunk_size):
- """Split text into fixed-size chunks."""
- return [
- text[i : i + chunk_size] for i in range(0, len(text), chunk_size)
- ]
-
- def _split_into_paragraphs(self, text):
- """Split text into paragraphs."""
- return [p.strip() for p in text.split("\n\n") if p.strip()]
-
- def _split_preserving_words(self, text, max_chunk_size):
- """Split text into chunks at word boundaries."""
- words = text.split()
- chunks = []
- current_chunk = []
- current_size = 0
- for word in words:
- if current_size + len(word) + 1 > max_chunk_size and current_chunk:
- chunks.append(" ".join(current_chunk))
- current_chunk = [word]
- current_size = len(word)
- else:
- current_chunk.append(word)
- current_size += len(word) + 1
- if current_chunk:
- chunks.append(" ".join(current_chunk))
- return chunks
-
- def test_fixed_size_chunks(self):
- text = "abcdefghij"
- chunks = self._split_into_chunks(text, 3)
- assert chunks == ["abc", "def", "ghi", "j"]
-
- def test_paragraphs(self):
- text = "First paragraph.\n\nSecond paragraph.\n\nThird."
- paragraphs = self._split_into_paragraphs(text)
- assert len(paragraphs) == 3
-
- def test_word_boundary_chunks(self):
- text = "one two three four five"
- chunks = self._split_preserving_words(text, 10)
- # Each chunk should respect word boundaries
- for chunk in chunks:
- assert len(chunk) <= 10 or " " not in chunk
-
-
-# --- Text hashing patterns ---
-
-
-class TestTextHashing:
- """Tests for text hashing patterns."""
-
- def _simple_hash(self, text):
- """Simple hash for text."""
- return hash(text.lower().strip())
-
- def _fingerprint(self, text, k=3):
- """Create text fingerprint using k-shingles."""
- text = text.lower()
- shingles = {text[i : i + k] for i in range(len(text) - k + 1)}
- return frozenset(shingles)
-
- def _simhash_bits(self, tokens, num_bits=32):
- """Simple simhash implementation."""
- v = [0] * num_bits
- for token in tokens:
- h = hash(token) & ((1 << num_bits) - 1)
- for i in range(num_bits):
- if h & (1 << i):
- v[i] += 1
- else:
- v[i] -= 1
- fingerprint = 0
- for i in range(num_bits):
- if v[i] > 0:
- fingerprint |= 1 << i
- return fingerprint
-
- def test_same_text_same_hash(self):
- h1 = self._simple_hash("Hello World")
- h2 = self._simple_hash("hello world")
- assert h1 == h2
-
- def test_fingerprint_identical(self):
- fp1 = self._fingerprint("hello world")
- fp2 = self._fingerprint("hello world")
- assert fp1 == fp2
-
- def test_fingerprint_similar_overlap(self):
- fp1 = self._fingerprint("hello world")
- fp2 = self._fingerprint("hello there")
- # Should have some overlap
- assert len(fp1 & fp2) > 0
diff --git a/tests/news/test_topic_based_recommender_logic_behavior.py b/tests/news/test_topic_based_recommender_logic_behavior.py
deleted file mode 100644
index 6769e4d7f1..0000000000
--- a/tests/news/test_topic_based_recommender_logic_behavior.py
+++ /dev/null
@@ -1,486 +0,0 @@
-"""
-Deep behavioral tests for topic_based.py pure logic.
-Tests trending topics retrieval, preference filtering,
-query generation, and recommendation sorting.
-"""
-
-
-# --- Default fallback topics ---
-
-
-class TestDefaultFallbackTopics:
- """Tests for default fallback topics."""
-
- def _get_fallback_topics(self):
- return [
- "artificial intelligence developments",
- "cybersecurity threats",
- "climate change",
- "economic policy",
- "technology innovation",
- ]
-
- def test_has_ai_topic(self):
- topics = self._get_fallback_topics()
- assert any("artificial intelligence" in t for t in topics)
-
- def test_has_cybersecurity_topic(self):
- topics = self._get_fallback_topics()
- assert any("cybersecurity" in t for t in topics)
-
- def test_has_five_topics(self):
- topics = self._get_fallback_topics()
- assert len(topics) == 5
-
- def test_topics_are_strings(self):
- topics = self._get_fallback_topics()
- for topic in topics:
- assert isinstance(topic, str)
-
-
-# --- Trending topics from registry ---
-
-
-class TestTrendingTopicsFromRegistry:
- """Tests for _get_trending_topics with registry."""
-
- def _get_trending_from_registry(self, registry, hours, limit):
- if registry:
- return registry.get("trending", [])[:limit]
- return []
-
- def test_with_registry(self):
- registry = {"trending": ["AI", "ML", "NLP"]}
- result = self._get_trending_from_registry(registry, 24, 10)
- assert "AI" in result
-
- def test_without_registry(self):
- result = self._get_trending_from_registry(None, 24, 10)
- assert result == []
-
- def test_respects_limit(self):
- registry = {"trending": ["A", "B", "C", "D", "E"]}
- result = self._get_trending_from_registry(registry, 24, 3)
- assert len(result) == 3
-
-
-# --- Context topics extraction ---
-
-
-class TestContextTopicsExtraction:
- """Tests for extracting topics from context."""
-
- def _extract_context_topics(self, context):
- topics = []
- if context:
- if "current_news_topics" in context:
- topics.extend(context["current_news_topics"])
- return topics
-
- def test_with_news_topics(self):
- context = {"current_news_topics": ["AI", "Tech"]}
- result = self._extract_context_topics(context)
- assert result == ["AI", "Tech"]
-
- def test_without_news_topics(self):
- context = {"other_key": "value"}
- result = self._extract_context_topics(context)
- assert result == []
-
- def test_none_context(self):
- result = self._extract_context_topics(None)
- assert result == []
-
-
-# --- Topic preference filtering ---
-
-
-class TestTopicPreferenceFiltering:
- """Tests for _filter_topics_by_preferences."""
-
- def _should_skip_topic(self, topic, disliked_topics):
- topic_lower = topic.lower()
- return any(disliked in topic_lower for disliked in disliked_topics)
-
- def test_skips_disliked(self):
- disliked = ["politics"]
- assert self._should_skip_topic("US Politics News", disliked) is True
-
- def test_keeps_not_disliked(self):
- disliked = ["politics"]
- assert self._should_skip_topic("Technology Updates", disliked) is False
-
- def test_case_insensitive(self):
- disliked = ["politics"]
- assert self._should_skip_topic("POLITICS", disliked) is True
-
-
-class TestTopicInterestBoosting:
- """Tests for interest boosting in filtering."""
-
- def _get_interest_boost(self, topic, interests):
- topic_lower = topic.lower()
- for interest, weight in interests.items():
- if interest.lower() in topic_lower:
- return weight
- return 1.0
-
- def test_matching_interest(self):
- interests = {"AI": 2.0, "Tech": 1.5}
- boost = self._get_interest_boost("AI developments", interests)
- assert boost == 2.0
-
- def test_no_matching_interest(self):
- interests = {"AI": 2.0}
- boost = self._get_interest_boost("Sports news", interests)
- assert boost == 1.0
-
- def test_case_insensitive(self):
- interests = {"ai": 2.0}
- boost = self._get_interest_boost("AI NEWS", interests)
- assert boost == 2.0
-
-
-class TestTopicBoostSorting:
- """Tests for sorting topics by boost."""
-
- def _sort_by_boost(self, topic_boost_pairs):
- sorted_pairs = sorted(
- topic_boost_pairs, key=lambda x: x[1], reverse=True
- )
- return [topic for topic, _ in sorted_pairs]
-
- def test_sorts_by_boost(self):
- pairs = [("A", 1.0), ("B", 2.0), ("C", 1.5)]
- result = self._sort_by_boost(pairs)
- assert result == ["B", "C", "A"]
-
- def test_equal_boosts(self):
- pairs = [("A", 1.0), ("B", 1.0)]
- result = self._sort_by_boost(pairs)
- assert len(result) == 2
-
-
-class TestFullPreferenceFiltering:
- """Tests for complete preference filtering."""
-
- def _filter_topics_by_preferences(self, topics, preferences):
- filtered = []
- disliked_topics = [
- t.lower() for t in preferences.get("disliked_topics", [])
- ]
- interests = preferences.get("interests", {})
-
- for topic in topics:
- topic_lower = topic.lower()
-
- # Skip disliked
- if any(disliked in topic_lower for disliked in disliked_topics):
- continue
-
- # Calculate boost
- boost = 1.0
- for interest, weight in interests.items():
- if interest.lower() in topic_lower:
- boost = weight
- break
-
- filtered.append((topic, boost))
-
- # Sort by boost
- filtered.sort(key=lambda x: x[1], reverse=True)
- return [topic for topic, _ in filtered]
-
- def test_filters_and_sorts(self):
- topics = ["AI news", "Politics", "Tech updates"]
- prefs = {
- "disliked_topics": ["Politics"],
- "interests": {"AI": 2.0},
- }
- result = self._filter_topics_by_preferences(topics, prefs)
- assert "Politics" not in result
- assert result[0] == "AI news"
-
- def test_empty_preferences(self):
- topics = ["AI", "Tech"]
- result = self._filter_topics_by_preferences(topics, {})
- assert len(result) == 2
-
-
-# --- Topic query generation ---
-
-
-class TestTopicQueryGeneration:
- """Tests for _generate_topic_query."""
-
- def _generate_topic_query(self, topic):
- return f"{topic} latest news today breaking developments"
-
- def test_includes_topic(self):
- result = self._generate_topic_query("AI")
- assert "AI" in result
-
- def test_includes_news_context(self):
- result = self._generate_topic_query("technology")
- assert "latest" in result
- assert "news" in result
- assert "today" in result
-
- def test_includes_breaking(self):
- result = self._generate_topic_query("topic")
- assert "breaking" in result
-
-
-# --- Progress update calculation ---
-
-
-class TestProgressUpdateCalculation:
- """Tests for progress percentage calculation."""
-
- def _calc_progress(self, base_progress, index, total):
- if total == 0:
- return base_progress
- return base_progress + (40 * index / total)
-
- def test_first_item(self):
- progress = self._calc_progress(50, 0, 5)
- assert progress == 50
-
- def test_last_item(self):
- progress = self._calc_progress(50, 5, 5)
- assert progress == 90 # 50 + 40
-
- def test_middle_item(self):
- progress = self._calc_progress(50, 2, 4)
- assert progress == 70 # 50 + 20
-
-
-# --- Max recommendations limit ---
-
-
-class TestMaxRecommendationsLimit:
- """Tests for max_recommendations default."""
-
- def test_default_limit(self):
- max_recommendations = 5
- assert max_recommendations == 5
-
- def test_slice_within_limit(self):
- topics = ["A", "B", "C", "D", "E", "F", "G"]
- limited = topics[:5]
- assert len(limited) == 5
-
-
-# --- Card metadata for recommendations ---
-
-
-class TestRecommendationCardMetadata:
- """Tests for additional_metadata structure."""
-
- def _build_metadata(
- self, recommender, topic, query, items_found, big_picture, topics
- ):
- return {
- "recommender": recommender,
- "original_topic": topic,
- "query_used": query,
- "total_items_found": items_found,
- "big_picture": big_picture,
- "topics_extracted": topics,
- }
-
- def test_has_recommender(self):
- metadata = self._build_metadata("topic_based", "AI", "q", 5, "", [])
- assert metadata["recommender"] == "topic_based"
-
- def test_has_original_topic(self):
- metadata = self._build_metadata("x", "AI news", "q", 5, "", [])
- assert metadata["original_topic"] == "AI news"
-
- def test_has_query_used(self):
- metadata = self._build_metadata("x", "t", "AI latest news", 5, "", [])
- assert metadata["query_used"] == "AI latest news"
-
-
-# --- News data structure ---
-
-
-class TestNewsDataStructure:
- """Tests for news_data structure from search results."""
-
- def _build_news_data(self, news_items, formatted_findings):
- return {
- "items": news_items,
- "item_count": len(news_items),
- "big_picture": formatted_findings,
- "topics": [],
- }
-
- def test_has_items(self):
- items = [{"id": "1"}, {"id": "2"}]
- data = self._build_news_data(items, "")
- assert data["items"] == items
-
- def test_item_count(self):
- items = [{"id": "1"}, {"id": "2"}, {"id": "3"}]
- data = self._build_news_data(items, "")
- assert data["item_count"] == 3
-
- def test_has_big_picture(self):
- data = self._build_news_data([], "Summary of findings")
- assert data["big_picture"] == "Summary of findings"
-
-
-# --- Max impact item selection ---
-
-
-class TestMaxImpactItemSelection:
- """Tests for selecting most impactful news item."""
-
- def _get_max_impact_item(self, news_items):
- return max(news_items, key=lambda x: x.get("impact_score", 0))
-
- def test_selects_highest_impact(self):
- items = [
- {"id": "1", "impact_score": 5},
- {"id": "2", "impact_score": 8},
- {"id": "3", "impact_score": 3},
- ]
- result = self._get_max_impact_item(items)
- assert result["id"] == "2"
-
- def test_missing_impact_defaults_zero(self):
- items = [
- {"id": "1", "impact_score": 5},
- {"id": "2"}, # No impact_score
- ]
- result = self._get_max_impact_item(items)
- assert result["id"] == "1"
-
-
-# --- Search results error handling ---
-
-
-class TestSearchResultsErrorHandling:
- """Tests for search results error detection."""
-
- def _has_error(self, results):
- return "error" in results
-
- def test_detects_error(self):
- results = {"error": "Search failed"}
- assert self._has_error(results) is True
-
- def test_no_error(self):
- results = {"items": []}
- assert self._has_error(results) is False
-
-
-# --- Empty news items handling ---
-
-
-class TestEmptyNewsItemsHandling:
- """Tests for handling empty news items."""
-
- def _should_return_none(self, news_items):
- return not news_items
-
- def test_empty_list(self):
- assert self._should_return_none([]) is True
-
- def test_non_empty_list(self):
- assert self._should_return_none([{"id": "1"}]) is False
-
- def test_none(self):
- assert self._should_return_none(None) is True
-
-
-# --- Version data structure ---
-
-
-class TestVersionDataStructure:
- """Tests for version data structure for recommendations."""
-
- def _build_version_data(
- self, search_results, news_analysis, query, strategy
- ):
- return {
- "search_results": search_results,
- "news_analysis": news_analysis,
- "query": query,
- "strategy": strategy,
- }
-
- def test_has_search_results(self):
- data = self._build_version_data({"items": []}, {}, "q", "s")
- assert "search_results" in data
-
- def test_has_news_analysis(self):
- data = self._build_version_data({}, {"items": []}, "q", "s")
- assert "news_analysis" in data
-
- def test_strategy_is_news_aggregation(self):
- data = self._build_version_data({}, {}, "q", "news_aggregation")
- assert data["strategy"] == "news_aggregation"
-
-
-# --- SearchBasedRecommender ---
-
-
-class TestSearchBasedRecommender:
- """Tests for SearchBasedRecommender behavior."""
-
- def test_returns_empty_when_disabled(self):
- # Search tracking is off by default
- result = []
- assert result == []
-
- def test_search_tracking_default_off(self):
- search_tracking_enabled = False
- assert search_tracking_enabled is False
-
-
-# --- Recommendation sorting ---
-
-
-class TestRecommendationSorting:
- """Tests for _sort_by_relevance behavior."""
-
- def _sort_by_score(self, cards, score_key="impact_score"):
- return sorted(cards, key=lambda c: c.get(score_key, 0), reverse=True)
-
- def test_sorts_by_impact(self):
- cards = [
- {"id": "1", "impact_score": 3},
- {"id": "2", "impact_score": 8},
- {"id": "3", "impact_score": 5},
- ]
- result = self._sort_by_score(cards)
- assert result[0]["id"] == "2"
- assert result[1]["id"] == "3"
- assert result[2]["id"] == "1"
-
-
-# --- Topics list merging ---
-
-
-class TestTopicsListMerging:
- """Tests for merging topics from multiple sources."""
-
- def test_extend_from_registry(self):
- topics = []
- registry_topics = ["AI", "ML"]
- topics.extend(registry_topics)
- assert topics == ["AI", "ML"]
-
- def test_extend_from_context(self):
- topics = ["AI"]
- context_topics = ["Tech", "Science"]
- topics.extend(context_topics)
- assert topics == ["AI", "Tech", "Science"]
-
- def test_merge_order_preserved(self):
- topics = []
- topics.extend(["A", "B"])
- topics.extend(["C", "D"])
- assert topics == ["A", "B", "C", "D"]
diff --git a/tests/news/test_topic_generator_behavior.py b/tests/news/test_topic_generator_behavior.py
deleted file mode 100644
index 1c2b005e20..0000000000
--- a/tests/news/test_topic_generator_behavior.py
+++ /dev/null
@@ -1,285 +0,0 @@
-"""
-Deep behavioral tests for topic_generator.py.
-Tests _validate_topics logic, LLM response parsing patterns,
-and generate_topics flow.
-"""
-
-import json
-
-
-# --- _validate_topics logic ---
-
-
-class TestValidateTopicsLogic:
- """Tests for _validate_topics extracted logic."""
-
- def _validate_topics(self, topics, max_topics):
- """Mirror of _validate_topics from topic_generator.py."""
- valid_topics = []
- seen = set()
- for topic in topics:
- if not topic:
- continue
- cleaned = topic.strip()
- if len(cleaned) < 2 or len(cleaned) > 30:
- continue
- normalized = cleaned.lower()
- if normalized in seen:
- continue
- seen.add(normalized)
- valid_topics.append(normalized)
- if len(valid_topics) >= max_topics:
- break
- if not valid_topics:
- valid_topics = ["[No valid topics]"]
- return valid_topics
-
- def test_empty_list(self):
- result = self._validate_topics([], 5)
- assert result == ["[No valid topics]"]
-
- def test_single_valid(self):
- result = self._validate_topics(["AI"], 5)
- assert result == ["ai"]
-
- def test_converts_to_lowercase(self):
- result = self._validate_topics(["Artificial Intelligence"], 5)
- assert result == ["artificial intelligence"]
-
- def test_strips_whitespace(self):
- result = self._validate_topics([" AI "], 5)
- assert result == ["ai"]
-
- def test_removes_too_short(self):
- result = self._validate_topics(["A", "AI", "ML"], 5)
- assert "a" not in result
- assert "ai" in result
-
- def test_removes_too_long(self):
- long_topic = "A" * 31
- result = self._validate_topics([long_topic, "AI"], 5)
- assert len(result) == 1
- assert result[0] == "ai"
-
- def test_exactly_30_chars_valid(self):
- topic = "A" * 30
- result = self._validate_topics([topic], 5)
- assert len(result) == 1
-
- def test_exactly_2_chars_valid(self):
- result = self._validate_topics(["AI"], 5)
- assert result == ["ai"]
-
- def test_removes_duplicates_case_insensitive(self):
- result = self._validate_topics(["AI", "ai", "Ai"], 5)
- assert result == ["ai"]
-
- def test_respects_max_topics(self):
- topics = [f"topic{i}" for i in range(10)]
- result = self._validate_topics(topics, 3)
- assert len(result) == 3
-
- def test_skips_empty_strings(self):
- result = self._validate_topics(["", "AI", ""], 5)
- assert result == ["ai"]
-
- def test_skips_none_values(self):
- result = self._validate_topics([None, "AI", None], 5)
- assert result == ["ai"]
-
- def test_all_invalid_returns_placeholder(self):
- result = self._validate_topics(["", "A", "B" * 31], 5)
- assert result == ["[No valid topics]"]
-
- def test_mixed_valid_invalid(self):
- result = self._validate_topics(["A", "Climate Change", "", "AI"], 5)
- assert "climate change" in result
- assert "ai" in result
-
- def test_preserves_order(self):
- result = self._validate_topics(
- ["climate", "economics", "technology"], 5
- )
- assert result == ["climate", "economics", "technology"]
-
-
-# --- LLM response parsing patterns ---
-
-
-class TestLLMResponseParsing:
- """Tests for LLM response parsing patterns used in topic_generator."""
-
- def test_parse_json_array(self):
- content = '["AI", "Climate", "Economy"]'
- topics = json.loads(content)
- assert topics == ["AI", "Climate", "Economy"]
-
- def test_parse_json_with_code_fence(self):
- content = '```json\n["AI", "Climate"]\n```'
- if content.startswith("```json"):
- content = content[7:]
- if content.endswith("```"):
- content = content[:-3]
- content = content.strip()
- topics = json.loads(content)
- assert topics == ["AI", "Climate"]
-
- def test_parse_comma_separated_fallback(self):
- content = "AI, Climate Change, Economy"
- topics = [t.strip().strip("\"'") for t in content.split(",")]
- filtered = [t for t in topics if t and len(t) <= 30]
- assert filtered == ["AI", "Climate Change", "Economy"]
-
- def test_invalid_json_triggers_fallback(self):
- content = "not valid json"
- try:
- topics = json.loads(content)
- except json.JSONDecodeError:
- if "," in content:
- topics = [t.strip().strip("\"'") for t in content.split(",")]
- else:
- topics = []
- assert topics == []
-
- def test_filter_non_string_items(self):
- topics = ["AI", 123, None, "Climate"]
- cleaned = [t for t in topics if isinstance(t, str)]
- assert cleaned == ["AI", "Climate"]
-
- def test_filter_too_long_items(self):
- topics = ["AI", "A" * 31, "Climate"]
- cleaned = [
- t.strip()
- for t in topics
- if isinstance(t, str) and len(t.strip()) <= 30
- ]
- assert cleaned == ["AI", "Climate"]
-
- def test_max_topics_limit(self):
- topics = ["T1", "T2", "T3", "T4", "T5", "T6"]
- max_topics = 3
- result = topics[:max_topics]
- assert len(result) == 3
-
- def test_empty_array_json(self):
- content = "[]"
- topics = json.loads(content)
- assert topics == []
-
- def test_nested_code_fence_handling(self):
- content = '```json\n["Topic 1"]\n```'
- if content.startswith("```json"):
- content = content[7:]
- if content.endswith("```"):
- content = content[:-3]
- result = json.loads(content.strip())
- assert result == ["Topic 1"]
-
-
-# --- generate_topics flow ---
-
-
-class TestGenerateTopicsFlow:
- """Tests for the generate_topics function flow patterns."""
-
- def test_llm_failure_returns_placeholder(self):
- """When LLM returns nothing, should get failure placeholder."""
- topics = []
- if not topics:
- topics = ["[Topic generation failed]"]
- assert topics == ["[Topic generation failed]"]
-
- def test_llm_success_validates(self):
- """When LLM returns topics, they should be validated."""
- llm_topics = ["AI", "Climate", "A"] # "A" is too short
- # Simulate validation
- valid = [t.lower() for t in llm_topics if len(t) >= 2 and len(t) <= 30]
- assert valid == ["ai", "climate"]
-
- def test_query_preview_truncation(self):
- query = "A" * 600
- preview = query[:500] if len(query) > 500 else query
- assert len(preview) == 500
-
- def test_query_preview_no_truncation(self):
- query = "short query"
- preview = query[:500] if len(query) > 500 else query
- assert preview == "short query"
-
- def test_findings_preview_truncation(self):
- findings = "B" * 1500
- preview = (
- findings[:1000] if findings and len(findings) > 1000 else findings
- )
- assert len(preview) == 1000
-
- def test_findings_none_handled(self):
- findings = None
- preview = (
- findings[:1000] if findings and len(findings) > 1000 else findings
- )
- assert preview is None
-
- def test_findings_empty_handled(self):
- findings = ""
- preview = (
- findings[:1000] if findings and len(findings) > 1000 else findings
- )
- assert preview == ""
-
-
-# --- Headline generation patterns ---
-
-
-class TestHeadlineGenerationPatterns:
- """Tests for headline generation patterns from headline_generator.py."""
-
- def test_headline_cleanup_strip_quotes(self):
- headline = '"Breaking News About AI"'
- cleaned = headline.strip("\"'.,!?")
- assert cleaned == "Breaking News About AI"
-
- def test_headline_cleanup_strip_periods(self):
- headline = "AI Advances Today."
- cleaned = headline.strip("\"'.,!?")
- assert cleaned == "AI Advances Today"
-
- def test_headline_empty_after_strip(self):
- headline = '""'
- cleaned = headline.strip("\"'.,!?")
- assert cleaned == ""
-
- def test_headline_no_cleanup_needed(self):
- headline = "AI Makes Progress"
- cleaned = headline.strip("\"'.,!?")
- assert cleaned == "AI Makes Progress"
-
- def test_llm_returns_none_fallback(self):
- llm_headline = None
- if llm_headline:
- result = llm_headline
- else:
- result = "[Headline generation failed]"
- assert result == "[Headline generation failed]"
-
- def test_llm_returns_empty_fallback(self):
- llm_headline = ""
- if llm_headline:
- result = llm_headline
- else:
- result = "[Headline generation failed]"
- assert result == "[Headline generation failed]"
-
- def test_no_findings_returns_none(self):
- """Without findings, LLM headline should return None."""
- findings = ""
- if not findings:
- result = None
- else:
- result = "Some headline"
- assert result is None
-
- def test_findings_length_logging(self):
- findings = "A" * 500
- length = len(findings)
- assert length == 500