superlocalmemory 2.8.6 → 3.0.0

package/src/learning/tests/test_workflow_miner.py

@@ -1,318 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-@pytest.fixture(autouse=True)
-def reset_singleton():
-    from src.learning.learning_db import LearningDB
-    LearningDB.reset_instance()
-    yield
-    LearningDB.reset_instance()
-
-
-@pytest.fixture
-def learning_db(tmp_path):
-    from src.learning.learning_db import LearningDB
-    db_path = tmp_path / "learning.db"
-    return LearningDB(db_path=db_path)
-
-
-@pytest.fixture
-def miner(learning_db):
-    from src.learning.workflow_pattern_miner import WorkflowPatternMiner
-    return WorkflowPatternMiner(learning_db=learning_db)
-
-
-@pytest.fixture
-def miner_no_db():
-    from src.learning.workflow_pattern_miner import WorkflowPatternMiner
-    return WorkflowPatternMiner(learning_db=None)
-
-
-# ---------------------------------------------------------------------------
-# Activity Classification
-# ---------------------------------------------------------------------------
-
-class TestClassifyActivity:
-    """Test _classify_activity for all 7 types + unknown."""
-
-    def test_docs(self, miner):
-        assert miner._classify_activity("Updated the documentation for API") == "docs"
-        assert miner._classify_activity("Added README and wiki pages") == "docs"
-
-    def test_architecture(self, miner):
-        assert miner._classify_activity("Designed the system architecture") == "architecture"
-        assert miner._classify_activity("Created ERD for data model") == "architecture"
-
-    def test_code(self, miner):
-        assert miner._classify_activity("Implemented the new function for parsing") == "code"
-        assert miner._classify_activity("Refactored the module structure") == "code"
-
-    def test_test(self, miner):
-        assert miner._classify_activity("Added pytest fixtures and assertions") == "test"
-        assert miner._classify_activity("Wrote unit test for the parser") == "test"
-
-    def test_debug(self, miner):
-        assert miner._classify_activity("Fixed the bug in authentication") == "debug"
-        assert miner._classify_activity("Analyzed error traceback in production") == "debug"
-
-    def test_deploy(self, miner):
-        assert miner._classify_activity("Deployed via Docker to production") == "deploy"
-        assert miner._classify_activity("Updated the CI/CD pipeline") == "deploy"
-
-    def test_config(self, miner):
-        assert miner._classify_activity("Updated config settings and env variables") == "config"
-        assert miner._classify_activity("Added package dependency to requirements") == "config"
-
-    def test_unknown(self, miner):
-        assert miner._classify_activity("Had a meeting about the roadmap") == "unknown"
-        assert miner._classify_activity("") == "unknown"
-        assert miner._classify_activity("random unrelated text") == "unknown"
-
-    def test_word_boundary_matching(self, miner):
-        """'test' should match 'test' but not 'latest'."""
-        assert miner._classify_activity("ran the test suite") == "test"
-        # "latest" contains "test" but word boundary prevents match
-        # However, 'release' is a deploy keyword
-        result = miner._classify_activity("checked the latest version of release")
-        assert result == "deploy"  # 'release' is deploy keyword
-
-
-# ---------------------------------------------------------------------------
-# Hour to Bucket Mapping
-# ---------------------------------------------------------------------------
-
-class TestHourToBucket:
-    def test_night_hours(self, miner):
-        for hour in [0, 1, 2, 3, 4, 5]:
-            assert miner._hour_to_bucket(hour) == "night", f"hour={hour}"
-
-    def test_morning_hours(self, miner):
-        for hour in [6, 7, 8, 9, 10, 11]:
-            assert miner._hour_to_bucket(hour) == "morning", f"hour={hour}"
-
-    def test_afternoon_hours(self, miner):
-        for hour in [12, 13, 14, 15, 16, 17]:
-            assert miner._hour_to_bucket(hour) == "afternoon", f"hour={hour}"
-
-    def test_evening_hours(self, miner):
-        for hour in [18, 19, 20, 21, 22, 23]:
-            assert miner._hour_to_bucket(hour) == "evening", f"hour={hour}"
-
-    def test_boundary_cases(self, miner):
-        assert miner._hour_to_bucket(0) == "night"
-        assert miner._hour_to_bucket(5) == "night"
-        assert miner._hour_to_bucket(6) == "morning"
-        assert miner._hour_to_bucket(11) == "morning"
-        assert miner._hour_to_bucket(12) == "afternoon"
-        assert miner._hour_to_bucket(17) == "afternoon"
-        assert miner._hour_to_bucket(18) == "evening"
-        assert miner._hour_to_bucket(23) == "evening"
-
-
-# ---------------------------------------------------------------------------
-# Sequence Mining
-# ---------------------------------------------------------------------------
-
-class TestMineSequences:
-    def test_basic_sequence(self, miner):
-        """A repeating pattern should be detected."""
-        memories = []
-        # Repeat: docs -> code -> test, 5 times
-        activity_words = {
-            "docs": "Updated the documentation",
-            "code": "Implemented new feature function",
-            "test": "Added pytest coverage",
-        }
-        for _ in range(5):
-            for act in ["docs", "code", "test"]:
-                memories.append({
-                    "content": activity_words[act],
-                    "created_at": "2026-02-16 10:00:00",
-                })
-
-        results = miner.mine_sequences(memories=memories, min_support=0.1)
-        assert len(results) > 0
-        # The docs->code->test pattern should appear
-        sequences_as_tuples = [tuple(r["sequence"]) for r in results]
-        assert ("docs", "code") in sequences_as_tuples or \
-               ("code", "test") in sequences_as_tuples or \
-               ("docs", "code", "test") in sequences_as_tuples
-
-    def test_min_support_filter(self, miner):
-        """High min_support should filter out rare 2-gram patterns.
-
-        With 4 distinct activities (docs, code, deploy, debug), each 2-gram
-        has support 1/3 ~ 0.33. Setting min_support=0.5 should exclude them.
-        Note: longer n-grams (4-gram) may have support=1.0 because there is
-        only 1 window of that length, so we specifically check 2-grams.
-        """
-        memories = [
-            {"content": "Updated documentation", "created_at": "2026-02-16 10:00:00"},
-            {"content": "Implemented function code", "created_at": "2026-02-16 11:00:00"},
-            {"content": "Deployed to production", "created_at": "2026-02-16 12:00:00"},
-            {"content": "Fixed the error bug", "created_at": "2026-02-16 13:00:00"},
-        ]
-        results = miner.mine_sequences(memories=memories, min_support=0.5)
-        # Filter results to only 2-grams (which cannot reach 0.5 support)
-        bigram_results = [r for r in results if r["length"] == 2]
-        assert len(bigram_results) == 0
-
-    def test_empty_memories(self, miner):
-        results = miner.mine_sequences(memories=[], min_support=0.1)
-        assert results == []
-
-    def test_single_memory(self, miner):
-        """Need at least 2 classified activities for sequence mining."""
-        memories = [{"content": "one code function", "created_at": "2026-02-16 10:00:00"}]
-        results = miner.mine_sequences(memories=memories, min_support=0.1)
-        assert results == []
-
-    def test_consecutive_identical_filtered(self, miner):
-        """N-grams with consecutive identical activities are filtered as noise."""
-        memories = [
-            {"content": "code function", "created_at": "2026-02-16 10:00:00"},
-            {"content": "code function", "created_at": "2026-02-16 11:00:00"},
-            {"content": "code function", "created_at": "2026-02-16 12:00:00"},
-        ]
-        results = miner.mine_sequences(memories=memories, min_support=0.1)
-        # All n-grams would be (code, code) or (code, code, code) -> filtered
-        assert len(results) == 0
-
-    def test_top_20_limit(self, miner):
-        """Results should be capped at 20."""
-        memories = []
-        types = ["docs", "code", "test", "debug", "deploy", "config"]
-        for i in range(100):
-            memories.append({
-                "content": f"Working on {types[i % len(types)]} implementation",
-                "created_at": f"2026-02-16 {i % 24:02d}:00:00",
-            })
-        results = miner.mine_sequences(memories=memories, min_support=0.01)
-        assert len(results) <= 20
-
-
-# ---------------------------------------------------------------------------
-# Temporal Pattern Mining
-# ---------------------------------------------------------------------------
-
-class TestMineTemporalPatterns:
-    def test_morning_coding(self, miner):
-        """Memories at morning hours with code content -> morning=code."""
-        memories = []
-        for hour in range(6, 12):
-            memories.append({
-                "content": "Implemented new function in the module",
-                "created_at": f"2026-02-16 {hour:02d}:30:00",
-            })
-        result = miner.mine_temporal_patterns(memories=memories)
-        assert "morning" in result
-        assert result["morning"]["dominant_activity"] == "code"
-        assert result["morning"]["evidence_count"] >= 5
-
-    def test_minimum_evidence_threshold(self, miner):
-        """Buckets with fewer than 5 evidence memories are omitted."""
-        memories = [
-            {"content": "Wrote code function", "created_at": "2026-02-16 09:00:00"},
-            {"content": "Wrote code class", "created_at": "2026-02-16 10:00:00"},
-        ]
-        result = miner.mine_temporal_patterns(memories=memories)
-        assert "morning" not in result  # Only 2 morning memories, need 5+
-
-    def test_time_bucketing(self, miner):
-        """Verify that memories are assigned to the correct time bucket."""
-        memories = []
-        # 6 evening test activities (18-23)
-        for i in range(6):
-            memories.append({
-                "content": f"Running pytest assertions {i}",
-                "created_at": f"2026-02-16 {20 + (i % 4):02d}:00:00",
-            })
-        result = miner.mine_temporal_patterns(memories=memories)
-        if "evening" in result:
-            assert result["evening"]["dominant_activity"] == "test"
-
-    def test_empty_memories(self, miner):
-        result = miner.mine_temporal_patterns(memories=[])
-        assert result == {}
-
-    def test_only_unknown_activities(self, miner):
-        """All unknown activities should produce empty result."""
-        memories = [
-            {"content": "random chat", "created_at": f"2026-02-16 {h:02d}:00:00"}
-            for h in range(6, 12)
-        ]
-        result = miner.mine_temporal_patterns(memories=memories)
-        assert "morning" not in result
-
-
-# ---------------------------------------------------------------------------
-# mine_all + persistence
-# ---------------------------------------------------------------------------
-
-class TestMineAll:
-    def test_mine_all_persists(self, miner, learning_db):
-        """mine_all should store patterns in learning_db."""
-        memories = []
-        for _ in range(3):
-            memories.extend([
-                {"content": "docs documentation wiki", "created_at": "2026-02-16 09:00:00"},
-                {"content": "code implement function", "created_at": "2026-02-16 10:00:00"},
-                {"content": "test pytest assertion", "created_at": "2026-02-16 11:00:00"},
-            ])
-
-        results = miner.mine_all(memories=memories)
-        assert "sequences" in results
-        assert "temporal" in results
-
-        # Check that patterns were stored
-        stored_seq = learning_db.get_workflow_patterns(pattern_type="sequence")
-        stored_temp = learning_db.get_workflow_patterns(pattern_type="temporal")
-        total_stored = len(stored_seq) + len(stored_temp)
-        assert total_stored >= 0  # At least attempted storage
-
-    def test_mine_all_no_db(self, miner_no_db):
-        """mine_all without DB should still return results, just not persist."""
-        memories = [
-            {"content": "docs documentation", "created_at": "2026-02-16 09:00:00"},
-            {"content": "code function", "created_at": "2026-02-16 10:00:00"},
-        ]
-        results = miner_no_db.mine_all(memories=memories)
-        assert "sequences" in results
-        assert "temporal" in results
-
-
-# ---------------------------------------------------------------------------
-# Parse Hour
-# ---------------------------------------------------------------------------
-
-class TestParseHour:
-    def test_iso_format(self, miner):
-        assert miner._parse_hour("2026-02-16T09:30:00") == 9
-
-    def test_sqlite_format(self, miner):
-        assert miner._parse_hour("2026-02-16 14:45:00") == 14
-
-    def test_with_microseconds(self, miner):
-        assert miner._parse_hour("2026-02-16 23:59:59.123456") == 23
-
-    def test_date_only_returns_none(self, miner):
-        # fromisoformat may or may not parse date-only; if it does, hour=0
-        result = miner._parse_hour("2026-02-16")
-        # Either None or 0 is acceptable
-        assert result is None or result == 0
-
-    def test_none_input(self, miner):
-        assert miner._parse_hour(None) is None
-
-    def test_empty_string(self, miner):
-        assert miner._parse_hour("") is None
-
-    def test_invalid_string(self, miner):
-        assert miner._parse_hour("not-a-timestamp") is None