Add tests for EntryManager handling of separate diary and planner paths

Author: madebygps

tests/brain_cli/test_cli.py

@@ -1,9 +1,11 @@
 """Integration tests for CLI commands."""
 import pytest
-from unittest.mock import Mock, patch
+from unittest.mock import Mock, patch, MagicMock
+from datetime import date, timedelta
 from typer.testing import CliRunner
 
 from brain_cli.main import app as brain_app
+from brain_cli.plan_commands import parse_date_arg, extract_tasks_from_diary
 
 
 runner = CliRunner()
@@ -109,6 +111,193 @@ def test_plan_already_exists(self, mock_manager, mock_config, mock_env):
 
         assert "already exists" in result.stdout.lower()
 
+    @patch('brain_cli.plan_commands.get_config')
+    @patch('brain_cli.plan_commands.get_llm_client')
+    @patch('brain_cli.plan_commands.EntryManager')
+    def test_plan_with_diary_tasks(self, mock_manager, mock_llm, mock_config, mock_env):
+        """Test plan create with LLM task extraction from diary."""
+        from brain_core.entry_manager import DiaryEntry
+        
+        # Setup mocks
+        mock_config.return_value = Mock(
+            diary_path=mock_env["diary_path"],
+            planner_path=mock_env["planner_path"]
+        )
+
+        # Mock LLM to return tasks
+        mock_llm_client = Mock()
+        mock_llm_client.generate_sync.return_value = """1. Follow up with Sarah about project
+2. Review pull request #42
+3. Prepare slides for presentation"""
+        mock_llm.return_value = mock_llm_client
+
+        # Mock diary entry with substantial content
+        yesterday_diary = DiaryEntry(
+            date.today() - timedelta(days=1),
+            "## Brain Dump\n" + "A" * 100,
+            entry_type="reflection"
+        )
+        yesterday_diary._has_substantial_content = True
+
+        mock_manager_instance = Mock()
+        mock_manager_instance.entry_exists.return_value = False
+        mock_manager_instance.read_entry.side_effect = lambda d, entry_type: (
+            yesterday_diary if entry_type == "reflection" else None
+        )
+        mock_manager.return_value = mock_manager_instance
+
+        result = runner.invoke(brain_app, ["plan", "create", "today"])
+
+        assert result.exit_code == 0
+        assert "Created plan" in result.stdout
+        # Should show extracted tasks
+        assert "extracted from diary" in result.stdout
+
+    @patch('brain_cli.plan_commands.get_config')
+    @patch('brain_cli.plan_commands.EntryManager')
+    def test_plan_with_pending_todos(self, mock_manager, mock_config, mock_env):
+        """Test plan create carries forward unchecked todos."""
+        from brain_core.entry_manager import DiaryEntry
+        
+        mock_config.return_value = Mock(
+            diary_path=mock_env["diary_path"],
+            planner_path=mock_env["planner_path"]
+        )
+
+        # Mock yesterday's plan with unchecked todos
+        yesterday_plan = DiaryEntry(
+            date.today() - timedelta(days=1),
+            """## Action Items
+- [ ] Finish project documentation
+- [x] Completed task
+- [ ] Review team feedback""",
+            entry_type="plan"
+        )
+
+        mock_manager_instance = Mock()
+        mock_manager_instance.entry_exists.return_value = False
+        mock_manager_instance.read_entry.side_effect = lambda d, entry_type: (
+            yesterday_plan if entry_type == "plan" else None
+        )
+        mock_manager.return_value = mock_manager_instance
+
+        result = runner.invoke(brain_app, ["plan", "create", "today"])
+
+        assert result.exit_code == 0
+        assert "pending from plan" in result.stdout
+
+
+class TestPlanHelpers:
+    """Tests for plan command helper functions."""
+
+    def test_parse_date_today(self):
+        """Test parsing 'today' argument."""
+        result = parse_date_arg("today")
+        assert result == date.today()
+
+    def test_parse_date_tomorrow(self):
+        """Test parsing 'tomorrow' argument."""
+        result = parse_date_arg("tomorrow")
+        assert result == date.today() + timedelta(days=1)
+
+    def test_parse_date_iso(self):
+        """Test parsing ISO date string."""
+        result = parse_date_arg("2025-10-12")
+        assert result == date(2025, 10, 12)
+
+    def test_extract_tasks_from_empty_diary(self):
+        """Test task extraction with empty diary content."""
+        mock_llm = Mock()
+        tasks = extract_tasks_from_diary("", "2025-10-11", mock_llm)
+        assert tasks == []
+        # LLM should not be called for empty content
+        mock_llm.generate_sync.assert_not_called()
+
+    def test_extract_tasks_from_short_diary(self):
+        """Test task extraction with short diary content."""
+        mock_llm = Mock()
+        tasks = extract_tasks_from_diary("Too short", "2025-10-11", mock_llm)
+        assert tasks == []
+        # LLM should not be called for short content
+        mock_llm.generate_sync.assert_not_called()
+
+    def test_extract_tasks_success(self):
+        """Test successful task extraction from diary."""
+        mock_llm = Mock()
+        mock_llm.generate_sync.return_value = """Here are the tasks:
+1. Follow up with Sarah about the project proposal
+2. Review pull request #42 before EOD
+3. Prepare slides for Thursday presentation
+4. Send meeting notes to team"""
+
+        diary_content = "A" * 100  # Substantial content
+        tasks = extract_tasks_from_diary(diary_content, "2025-10-11", mock_llm)
+
+        assert len(tasks) == 4
+        assert "Follow up with Sarah about the project proposal" in tasks
+        assert "Review pull request #42 before EOD" in tasks
+        assert "Prepare slides for Thursday presentation" in tasks
+        assert "Send meeting notes to team" in tasks
+        
+        # Verify LLM was called with correct parameters
+        mock_llm.generate_sync.assert_called_once()
+        call_kwargs = mock_llm.generate_sync.call_args.kwargs
+        assert "prompt" in call_kwargs
+        assert "system" in call_kwargs
+        assert call_kwargs["temperature"] == 0.4
+        assert call_kwargs["max_tokens"] == 300
+
+    def test_extract_tasks_no_tasks_found(self):
+        """Test task extraction when LLM finds no tasks."""
+        mock_llm = Mock()
+        mock_llm.generate_sync.return_value = "NO_TASKS"
+
+        diary_content = "A" * 100
+        tasks = extract_tasks_from_diary(diary_content, "2025-10-11", mock_llm)
+
+        assert tasks == []
+
+    def test_extract_tasks_with_parentheses_format(self):
+        """Test task extraction with parentheses numbering."""
+        mock_llm = Mock()
+        mock_llm.generate_sync.return_value = """1) First task
+2) Second task
+3) Third task"""
+
+        diary_content = "A" * 100
+        tasks = extract_tasks_from_diary(diary_content, "2025-10-11", mock_llm)
+
+        assert len(tasks) == 3
+        assert "First task" in tasks
+        assert "Second task" in tasks
+
+    def test_extract_tasks_filters_short_tasks(self):
+        """Test that very short tasks are filtered out."""
+        mock_llm = Mock()
+        mock_llm.generate_sync.return_value = """1. OK
+2. This is a proper task description
+3. No
+4. Another valid task here"""
+
+        diary_content = "A" * 100
+        tasks = extract_tasks_from_diary(diary_content, "2025-10-11", mock_llm)
+
+        # Only tasks with >5 characters should be included
+        assert len(tasks) == 2
+        assert "This is a proper task description" in tasks
+        assert "Another valid task here" in tasks
+
+    def test_extract_tasks_handles_llm_error(self):
+        """Test task extraction gracefully handles LLM errors."""
+        mock_llm = Mock()
+        mock_llm.generate_sync.side_effect = Exception("LLM API error")
+
+        diary_content = "A" * 100
+        tasks = extract_tasks_from_diary(diary_content, "2025-10-11", mock_llm)
+
+        # Should return empty list on error, not crash
+        assert tasks == []
+
 
 class TestNotesCommands:
     """Tests for notes commands."""

tests/brain_core/test_entry_manager.py

@@ -110,6 +110,80 @@ def test_get_entry_path_plan(self, temp_dir):
         path = manager.get_entry_path(date(2025, 10, 12), entry_type="plan")
         assert path == temp_dir / "2025-10-12-plan.md"
 
+    def test_separate_planner_path(self, temp_dir):
+        """Test EntryManager with separate planner_path."""
+        diary_dir = temp_dir / "diary"
+        planner_dir = temp_dir / "planner"
+        diary_dir.mkdir()
+        planner_dir.mkdir()
+
+        manager = EntryManager(diary_dir, planner_dir)
+
+        # Reflection should go to diary_path
+        reflection_path = manager.get_entry_path(date(2025, 10, 12), entry_type="reflection")
+        assert reflection_path == diary_dir / "2025-10-12.md"
+
+        # Plan should go to planner_path
+        plan_path = manager.get_entry_path(date(2025, 10, 12), entry_type="plan")
+        assert plan_path == planner_dir / "2025-10-12-plan.md"
+
+    def test_planner_path_defaults_to_diary_path(self, temp_dir):
+        """Test that planner_path defaults to diary_path if not specified."""
+        manager = EntryManager(temp_dir)
+
+        # Both should use the same path
+        reflection_path = manager.get_entry_path(date(2025, 10, 12), entry_type="reflection")
+        plan_path = manager.get_entry_path(date(2025, 10, 12), entry_type="plan")
+        
+        assert reflection_path.parent == plan_path.parent
+        assert reflection_path.parent == temp_dir
+
+    def test_write_entry_to_separate_paths(self, temp_dir):
+        """Test writing entries to separate diary and planner paths."""
+        diary_dir = temp_dir / "diary"
+        planner_dir = temp_dir / "planner"
+        diary_dir.mkdir()
+        planner_dir.mkdir()
+
+        manager = EntryManager(diary_dir, planner_dir)
+        test_date = date(2025, 10, 12)
+
+        # Write reflection entry
+        reflection = DiaryEntry(test_date, "Reflection content", entry_type="reflection")
+        manager.write_entry(reflection)
+        assert (diary_dir / "2025-10-12.md").exists()
+        assert not (planner_dir / "2025-10-12.md").exists()
+
+        # Write plan entry
+        plan = DiaryEntry(test_date, "Plan content", entry_type="plan")
+        manager.write_entry(plan)
+        assert (planner_dir / "2025-10-12-plan.md").exists()
+        assert not (diary_dir / "2025-10-12-plan.md").exists()
+
+    def test_read_entry_from_separate_paths(self, temp_dir):
+        """Test reading entries from separate diary and planner paths."""
+        diary_dir = temp_dir / "diary"
+        planner_dir = temp_dir / "planner"
+        diary_dir.mkdir()
+        planner_dir.mkdir()
+
+        manager = EntryManager(diary_dir, planner_dir)
+        test_date = date(2025, 10, 12)
+
+        # Write entries to separate directories
+        (diary_dir / "2025-10-12.md").write_text("Reflection content")
+        (planner_dir / "2025-10-12-plan.md").write_text("Plan content")
+
+        # Read reflection from diary_path
+        reflection = manager.read_entry(test_date, entry_type="reflection")
+        assert reflection is not None
+        assert reflection.content == "Reflection content"
+
+        # Read plan from planner_path
+        plan = manager.read_entry(test_date, entry_type="plan")
+        assert plan is not None
+        assert plan.content == "Plan content"
+
     def test_entry_exists_reflection(self, temp_dir):
         """Test entry_exists for reflection entry."""
         manager = EntryManager(temp_dir)