improve test coverage from 69% to 85%+ with targeted unit tests

- Fix syntax errors in agentic modules (unparenthesized except clauses)
- Add tests for insights helpers (_score_bucket, _flatten_tags, _parse_iso, _collect_impl_tags)
- Add tests for SEO helpers (_lastmod, _build_sitemap_xml, BOT_HTML_TEMPLATE)
- Add tests for plots filter helpers (all 15 helper functions)
- Add tests for API schemas (all 8 Pydantic models)
- Add tests for config resolve_model (CLI/tier mapping)
- Add tests for database models (Spec, Library, Impl)
- Add tests for database repositories (CRUD, upsert, queries)
- Add tests for sync_to_postgres helpers (_validate_quality_score, _validate_spec_id, _parse_markdown_section)
- Add extended analytics tests (all 24+ platform detection patterns)

https://claude.ai/code/session_01KhAhJKpEoqCzmWzcALSfW6

Author: claude

agentic/workflows/modules/agent.py

@@ -144,7 +144,7 @@ def parse_json(output: str, target_type: Type[T] = None) -> Any:
                 return [target_type.model_validate(item) for item in parsed]
             return target_type.model_validate(parsed)
         return parsed
-    except json.JSONDecodeError, ValueError:
+    except (json.JSONDecodeError, ValueError):
         pass
 
     # Strategy 2: Strip markdown code fences
@@ -162,7 +162,7 @@ def parse_json(output: str, target_type: Type[T] = None) -> Any:
                         return [target_type.model_validate(item) for item in parsed]
                     return target_type.model_validate(parsed)
                 return parsed
-            except json.JSONDecodeError, ValueError:
+            except (json.JSONDecodeError, ValueError):
                 pass
 
     # Strategy 3: Find first JSON array or object in output
@@ -182,7 +182,7 @@ def parse_json(output: str, target_type: Type[T] = None) -> Any:
                     return [target_type.model_validate(item) for item in parsed]
                 return target_type.model_validate(parsed)
             return parsed
-        except json.JSONDecodeError, ValueError:
+        except (json.JSONDecodeError, ValueError):
             continue
 
     raise json.JSONDecodeError("No valid JSON found in output", output, 0)

agentic/workflows/modules/orchestrator.py

@@ -45,5 +45,5 @@ def extract_run_id(stdout: str) -> str | None:
     try:
         data = json.loads(stdout.strip())
         return data.get("run_id")
-    except json.JSONDecodeError, ValueError:
+    except (json.JSONDecodeError, ValueError):
         return None

agentic/workflows/modules/state.py

@@ -172,7 +172,7 @@ def from_stdin(cls) -> Optional["WorkflowState"]:
             state = cls(run_id=run_id, prompt=data.get("prompt", ""))
             state.data = data
             return state
-        except json.JSONDecodeError, EOFError:
+        except (json.JSONDecodeError, EOFError):
             return None
 
     def to_stdout(self) -> None:

tests/unit/api/test_analytics_extended.py

@@ -0,0 +1,116 @@
+"""
+Extended tests for analytics module.
+
+Covers edge cases and additional platform patterns.
+"""
+
+import pytest
+
+from api.analytics import (
+    PLATFORM_PATTERNS,
+    _detect_whatsapp_variant,
+    detect_platform,
+)
+
+
+class TestDetectWhatsappVariant:
+    """Tests for _detect_whatsapp_variant edge cases."""
+
+    def test_no_whatsapp(self) -> None:
+        assert _detect_whatsapp_variant("Mozilla/5.0") is None
+
+    def test_real_whatsapp_ios(self) -> None:
+        assert _detect_whatsapp_variant("WhatsApp/2.23.18.78 i") == "whatsapp"
+
+    def test_real_whatsapp_android(self) -> None:
+        assert _detect_whatsapp_variant("WhatsApp/2.21.22.23 A") == "whatsapp"
+
+    def test_signal_spoofed_simple(self) -> None:
+        assert _detect_whatsapp_variant("WhatsApp") == "whatsapp-lite"
+
+    def test_signal_spoofed_short_version(self) -> None:
+        assert _detect_whatsapp_variant("WhatsApp/2") == "whatsapp-lite"
+
+    def test_signal_spoofed_two_part_version(self) -> None:
+        assert _detect_whatsapp_variant("WhatsApp/2.23") == "whatsapp-lite"
+
+    def test_case_insensitive(self) -> None:
+        assert _detect_whatsapp_variant("whatsapp/2.23.18.78 i") == "whatsapp"
+
+
+class TestDetectPlatformExtended:
+    """Additional platform detection tests for full coverage."""
+
+    def test_slack(self) -> None:
+        assert detect_platform("Slackbot 1.0 (+https://api.slack.com/robots)") == "slack"
+
+    def test_discord(self) -> None:
+        assert detect_platform("Mozilla/5.0 (compatible; Discordbot/2.0)") == "discord"
+
+    def test_telegram(self) -> None:
+        assert detect_platform("TelegramBot/1.0") == "telegram"
+
+    def test_linkedin(self) -> None:
+        assert detect_platform("LinkedInBot/1.0") == "linkedin"
+
+    def test_pinterest(self) -> None:
+        assert detect_platform("Pinterestbot/1.0") == "pinterest"
+
+    def test_reddit(self) -> None:
+        assert detect_platform("redditbot/1.0") == "reddit"
+
+    def test_google(self) -> None:
+        assert detect_platform("Mozilla/5.0 (compatible; Googlebot/2.1)") == "google"
+
+    def test_bing(self) -> None:
+        assert detect_platform("Mozilla/5.0 (compatible; bingbot/2.0)") == "bing"
+
+    def test_mastodon(self) -> None:
+        assert detect_platform("http.rb/5.0.0 (Mastodon/4.0; +https://instance.social/)") == "mastodon"
+
+    def test_viber(self) -> None:
+        assert detect_platform("Viber/13.0") == "viber"
+
+    def test_skype(self) -> None:
+        assert detect_platform("SkypeUriPreview") == "skype"
+
+    def test_teams(self) -> None:
+        assert detect_platform("Mozilla/5.0 Microsoft Teams") == "teams"
+
+    def test_snapchat(self) -> None:
+        assert detect_platform("Snapchat/10.0") == "snapchat"
+
+    def test_yandex(self) -> None:
+        assert detect_platform("Mozilla/5.0 (compatible; YandexBot/3.0)") == "yandex"
+
+    def test_duckduckgo(self) -> None:
+        assert detect_platform("DuckDuckBot/1.0") == "duckduckgo"
+
+    def test_baidu(self) -> None:
+        assert detect_platform("Mozilla/5.0 (compatible; Baiduspider/2.0)") == "baidu"
+
+    def test_apple(self) -> None:
+        assert detect_platform("Applebot/0.1") == "apple"
+
+    def test_embedly(self) -> None:
+        assert detect_platform("Embedly/0.2") == "embedly"
+
+    def test_quora(self) -> None:
+        assert detect_platform("Quora Link Preview/1.0") == "quora"
+
+    def test_tumblr(self) -> None:
+        assert detect_platform("Tumblr/14.0") == "tumblr"
+
+    def test_unknown_agent(self) -> None:
+        assert detect_platform("Some Random Bot/1.0") == "unknown"
+
+    def test_empty_agent(self) -> None:
+        assert detect_platform("") == "unknown"
+
+    def test_whatsapp_takes_priority(self) -> None:
+        """WhatsApp detection happens before general pattern matching."""
+        assert detect_platform("WhatsApp/2.23.18.78 i") == "whatsapp"
+
+    def test_platform_patterns_not_empty(self) -> None:
+        """Ensure we have a comprehensive set of platform patterns."""
+        assert len(PLATFORM_PATTERNS) >= 20

tests/unit/api/test_insights_helpers.py

@@ -0,0 +1,187 @@
+"""
+Tests for insights helper functions.
+
+Directly tests the pure helper functions in api/routers/insights.py
+that don't require database or HTTP setup.
+"""
+
+from datetime import datetime, timezone
+
+import pytest
+
+from api.routers.insights import (
+    _collect_impl_tags,
+    _flatten_tags,
+    _parse_iso,
+    _score_bucket,
+)
+
+
+class TestScoreBucket:
+    """Tests for _score_bucket mapping."""
+
+    def test_minimum_score(self) -> None:
+        assert _score_bucket(50) == "50-55"
+
+    def test_maximum_score(self) -> None:
+        assert _score_bucket(100) == "95-100"
+
+    def test_middle_scores(self) -> None:
+        assert _score_bucket(72) == "70-75"
+        assert _score_bucket(85) == "85-90"
+        assert _score_bucket(90) == "90-95"
+
+    def test_boundary_at_55(self) -> None:
+        assert _score_bucket(55) == "55-60"
+
+    def test_below_50_clamped(self) -> None:
+        assert _score_bucket(30) == "50-55"
+
+    def test_above_100_clamped(self) -> None:
+        assert _score_bucket(110) == "95-100"
+
+    def test_exact_boundary(self) -> None:
+        assert _score_bucket(75) == "75-80"
+        assert _score_bucket(80) == "80-85"
+
+    def test_fractional_score(self) -> None:
+        assert _score_bucket(92.5) == "90-95"
+        assert _score_bucket(87.9) == "85-90"
+
+
+class TestFlattenTags:
+    """Tests for _flatten_tags."""
+
+    def test_none_tags(self) -> None:
+        assert _flatten_tags(None) == set()
+
+    def test_empty_dict(self) -> None:
+        assert _flatten_tags({}) == set()
+
+    def test_single_category(self) -> None:
+        tags = {"plot_type": ["scatter"]}
+        assert _flatten_tags(tags) == {"plot_type:scatter"}
+
+    def test_multiple_categories(self) -> None:
+        tags = {"plot_type": ["scatter", "line"], "domain": ["statistics"]}
+        result = _flatten_tags(tags)
+        assert result == {"plot_type:scatter", "plot_type:line", "domain:statistics"}
+
+    def test_non_list_values_skipped(self) -> None:
+        tags = {"plot_type": ["scatter"], "invalid": "not-a-list"}
+        result = _flatten_tags(tags)
+        assert result == {"plot_type:scatter"}
+
+    def test_empty_list(self) -> None:
+        tags = {"plot_type": []}
+        assert _flatten_tags(tags) == set()
+
+
+class TestParseIso:
+    """Tests for _parse_iso."""
+
+    def test_none_input(self) -> None:
+        assert _parse_iso(None) is None
+
+    def test_empty_string(self) -> None:
+        assert _parse_iso("") is None
+
+    def test_valid_iso_with_z(self) -> None:
+        result = _parse_iso("2025-01-15T10:30:00Z")
+        assert result is not None
+        assert result.year == 2025
+        assert result.month == 1
+        assert result.tzinfo is not None
+
+    def test_valid_iso_with_offset(self) -> None:
+        result = _parse_iso("2025-01-15T10:30:00+02:00")
+        assert result is not None
+        assert result.tzinfo is not None
+
+    def test_naive_datetime_gets_utc(self) -> None:
+        result = _parse_iso("2025-01-15T10:30:00")
+        assert result is not None
+        assert result.tzinfo == timezone.utc
+
+    def test_invalid_string(self) -> None:
+        assert _parse_iso("not-a-date") is None
+
+    def test_date_only(self) -> None:
+        result = _parse_iso("2025-01-15")
+        assert result is not None
+        assert result.year == 2025
+
+
+class TestCollectImplTags:
+    """Tests for _collect_impl_tags."""
+
+    def test_spec_with_no_tags(self) -> None:
+        from unittest.mock import MagicMock
+
+        spec = MagicMock()
+        spec.tags = None
+        spec.impls = []
+        result = _collect_impl_tags(spec)
+        assert result == set()
+
+    def test_spec_with_tags_and_impl_tags(self) -> None:
+        from unittest.mock import MagicMock
+
+        impl = MagicMock()
+        impl.library_id = "matplotlib"
+        impl.impl_tags = {"techniques": ["annotations"]}
+
+        spec = MagicMock()
+        spec.tags = {"plot_type": ["scatter"]}
+        spec.impls = [impl]
+
+        result = _collect_impl_tags(spec)
+        assert "plot_type:scatter" in result
+        assert "techniques:annotations" in result
+
+    def test_filter_by_library(self) -> None:
+        from unittest.mock import MagicMock
+
+        impl1 = MagicMock()
+        impl1.library_id = "matplotlib"
+        impl1.impl_tags = {"techniques": ["annotations"]}
+
+        impl2 = MagicMock()
+        impl2.library_id = "seaborn"
+        impl2.impl_tags = {"techniques": ["regression"]}
+
+        spec = MagicMock()
+        spec.tags = {"plot_type": ["scatter"]}
+        spec.impls = [impl1, impl2]
+
+        result = _collect_impl_tags(spec, library="matplotlib")
+        assert "techniques:annotations" in result
+        assert "techniques:regression" not in result
+
+    def test_impl_tags_none(self) -> None:
+        from unittest.mock import MagicMock
+
+        impl = MagicMock()
+        impl.library_id = "matplotlib"
+        impl.impl_tags = None
+
+        spec = MagicMock()
+        spec.tags = {"plot_type": ["scatter"]}
+        spec.impls = [impl]
+
+        result = _collect_impl_tags(spec)
+        assert result == {"plot_type:scatter"}
+
+    def test_impl_tags_not_dict(self) -> None:
+        from unittest.mock import MagicMock
+
+        impl = MagicMock()
+        impl.library_id = "matplotlib"
+        impl.impl_tags = "not-a-dict"
+
+        spec = MagicMock()
+        spec.tags = {}
+        spec.impls = [impl]
+
+        result = _collect_impl_tags(spec)
+        assert result == set()