~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.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
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.pydeleted file mode 100644index 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 prefsdiff --git a/tests/news/test_base_rater_logic_behavior.py b/tests/news/test_base_rater_logic_behavior.pydeleted file mode 100644index 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 resultdiff --git a/tests/news/test_caching_patterns_behavior.py b/tests/news/test_caching_patterns_behavior.pydeleted file mode 100644index 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 Nonediff --git a/tests/news/test_card_factory_logic_behavior.py b/tests/news/test_card_factory_logic_behavior.pydeleted file mode 100644index 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 != id2diff --git a/tests/news/test_card_interaction_patterns_behavior.py b/tests/news/test_card_interaction_patterns_behavior.pydeleted file mode 100644index 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 Truediff --git a/tests/news/test_card_storage_logic_behavior.py b/tests/news/test_card_storage_logic_behavior.pydeleted file mode 100644index 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 Nonediff --git a/tests/news/test_flask_api_routes_logic_behavior.py b/tests/news/test_flask_api_routes_logic_behavior.pydeleted file mode 100644index 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"] == 0diff --git a/tests/news/test_headline_generator_logic_behavior.py b/tests/news/test_headline_generator_logic_behavior.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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 seconddiff --git a/tests/news/test_subscription_storage_logic_behavior.py b/tests/news/test_subscription_storage_logic_behavior.pydeleted file mode 100644index 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"] <= afterdiff --git a/tests/news/test_text_processing_patterns_behavior.py b/tests/news/test_text_processing_patterns_behavior.pydeleted file mode 100644index 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) > 0diff --git a/tests/news/test_topic_based_recommender_logic_behavior.py b/tests/news/test_topic_based_recommender_logic_behavior.pydeleted file mode 100644index 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.pydeleted file mode 100644index 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