chore: moved tests scripts

scripts/debug_dose_save.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Debug test to see what happens to dose data during save."""
+
+import logging
+import os
+import sys
+import tkinter as tk
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
+
+from medicine_manager import MedicineManager
+from pathology_manager import PathologyManager
+from ui_manager import UIManager
+
+
+def debug_dose_save():
+    """Debug test to track dose data through the save process."""
+
+    # Setup logging
+    logging.basicConfig(level=logging.DEBUG)
+    logger = logging.getLogger("test")
+
+    # Initialize managers
+    medicine_manager = MedicineManager()
+    pathology_manager = PathologyManager()
+
+    # Create root window
+    root = tk.Tk()
+    root.withdraw()
+
+    # Initialize UI manager
+    ui_manager = UIManager(
+        root=root,
+        logger=logger,
+        medicine_manager=medicine_manager,
+        pathology_manager=pathology_manager,
+    )
+
+    # Create test data with different medicines having different dose states
+    test_values = ["2025-07-31"]  # date
+
+    # Add pathology values
+    pathologies = pathology_manager.get_all_pathologies()
+    for _ in pathologies:
+        test_values.append(3)  # pathology value
+
+    # Add medicine values and doses - simulate one with history, others empty
+    medicines = medicine_manager.get_all_medicines()
+    medicine_keys = list(medicines.keys())
+
+    for i, _ in enumerate(medicines):
+        test_values.append(1)  # medicine checkbox value
+        if i == 0:  # First medicine has dose history
+            test_values.append(
+                "2025-07-31 08:00:00:150mg|2025-07-31 14:00:00:25mg"
+            )  # existing doses in storage format
+        else:  # Other medicines have no dose history
+            test_values.append("")
+
+    test_values.append("Test note")  # note
+
+    print("Test setup:")
+    print(f"  Medicine keys: {medicine_keys}")
+    print(f"  First medicine ({medicine_keys[0]}) has dose history")
+    print("  Other medicines have no dose history")
+    print(f"Test values: {test_values}")
+
+    # Track what gets saved
+    saved_data = None
+
+    def mock_save_callback(*args):
+        nonlocal saved_data
+        saved_data = args
+        print("\n=== SAVE CALLBACK ===")
+        print(f"Save callback called with {len(args)} arguments")
+
+        if len(args) >= 2:
+            dose_data = args[-1]  # Last argument should be dose data
+            print(f"Dose data type: {type(dose_data)}")
+            print("Dose data contents:")
+
+            if isinstance(dose_data, dict):
+                for med_key, dose_str in dose_data.items():
+                    print(f"  {med_key}: '{dose_str}' (length: {len(dose_str)})")
+                    if dose_str:
+                        doses = dose_str.split("|") if "|" in dose_str else [dose_str]
+                        print(f"    -> {len(doses)} dose(s): {doses}")
+
+        # Don't destroy window, just close it
+        root.quit()
+
+    def mock_delete_callback(win):
+        print("Delete callback called")
+        win.destroy()
+        root.quit()
+
+    callbacks = {"save": mock_save_callback, "delete": mock_delete_callback}
+
+    # Create edit window
+    edit_window = ui_manager.create_edit_window(tuple(test_values), callbacks)
+    print("\nEdit window created.")
+    print("Instructions:")
+    print("1. The first medicine tab should show existing dose history")
+    print("2. Add a new dose to a DIFFERENT medicine tab")
+    print("3. Click Save and observe the output")
+
+    # Show the window so user can interact
+    root.deiconify()
+    edit_window.lift()
+    edit_window.focus_force()
+
+    # Run main loop
+    root.mainloop()
+
+    if saved_data:
+        print("✅ Test completed - data was saved")
+        return True
+    else:
+        print("❌ Test failed - no data saved")
+        return False
+
+
+if __name__ == "__main__":
+    debug_dose_save()

scripts/test_dose_parsing_simple.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Simple test of the dose parsing workflow."""
+
+import sys
+
+sys.path.append("src")
+
+
+# Test the fixed parsing workflow
+def test_dose_parsing():
+    print("Testing dose parsing workflow...\n")
+
+    # Import UIManager after path setup
+    import logging
+    import tkinter as tk
+    from unittest.mock import Mock
+
+    from ui_manager import UIManager
+
+    # Create minimal mocks
+    root = tk.Tk()
+    root.withdraw()
+    logger = logging.getLogger("test")
+    mock_medicine_manager = Mock()
+    mock_pathology_manager = Mock()
+
+    # Create UIManager
+    ui_manager = UIManager(root, logger, mock_medicine_manager, mock_pathology_manager)
+
+    # Test case 1: Simulate what happens in the UI
+    print("1. Testing _populate_dose_history...")
+
+    # Mock text widget
+    class MockText:
+        def __init__(self):
+            self.content = ""
+
+        def configure(self, state):
+            pass
+
+        def delete(self, start, end):
+            self.content = ""
+
+        def insert(self, pos, text):
+            self.content = text
+
+        def get(self, start, end):
+            return self.content
+
+    mock_text = MockText()
+    saved_doses = "2025-01-30 08:00:00:150mg|2025-01-30 14:00:00:25mg"
+
+    ui_manager._populate_dose_history(mock_text, saved_doses)
+    print(f"Populated display: '{mock_text.content}'")
+
+    # Test case 2: User adds a new dose
+    print("\n2. Testing user editing...")
+    user_edited = mock_text.content + "\n• 06:00 PM - 50mg"
+    print(f"User edited content: '{user_edited}'")
+
+    # Test case 3: Parse back for saving
+    print("\n3. Testing _parse_dose_history_for_saving...")
+    parsed_result = ui_manager._parse_dose_history_for_saving(user_edited, "2025-01-30")
+    print(f"Parsed for saving: '{parsed_result}'")
+
+    # Count doses
+    dose_count = len([d for d in parsed_result.split("|") if d.strip()])
+    print(f"Final dose count: {dose_count}")
+
+    if dose_count == 3:
+        print("\n✅ SUCCESS: All 3 doses preserved!")
+        return True
+    else:
+        print(f"\n❌ FAILURE: Expected 3 doses, got {dose_count}")
+        return False
+
+
+if __name__ == "__main__":
+    success = test_dose_parsing()
+    sys.exit(0 if success else 1)

scripts/test_dose_save.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Quick test to verify dose tracking save functionality.
+"""
+
+import logging
+import os
+import sys
+import tkinter as tk
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
+
+from medicine_manager import MedicineManager
+from pathology_manager import PathologyManager
+from ui_manager import UIManager
+
+
+def test_dose_save():
+    """Test that dose data is properly saved."""
+
+    # Setup logging
+    logging.basicConfig(level=logging.DEBUG)
+    logger = logging.getLogger("test")
+
+    # Initialize managers
+    medicine_manager = MedicineManager()
+    pathology_manager = PathologyManager()
+
+    # Create root window
+    root = tk.Tk()
+    root.withdraw()
+
+    # Initialize UI manager
+    ui_manager = UIManager(
+        root=root,
+        logger=logger,
+        medicine_manager=medicine_manager,
+        pathology_manager=pathology_manager,
+    )
+
+    # Create test data
+    test_values = ["2025-07-31"]  # date
+
+    # Add pathology values
+    pathologies = pathology_manager.get_all_pathologies()
+    for _ in pathologies:
+        test_values.append(3)  # pathology value
+
+    # Add medicine values and doses
+    medicines = medicine_manager.get_all_medicines()
+    for _ in medicines:
+        test_values.append(1)  # medicine checkbox value
+        test_values.append(
+            "2025-07-31 08:00:00:150mg|2025-07-31 14:00:00:25mg"
+        )  # existing doses in storage format
+
+    test_values.append("Test note")  # note
+
+    print(f"Test values: {test_values}")
+
+    # Track what gets saved
+    saved_data = None
+
+    def mock_save_callback(*args):
+        nonlocal saved_data
+        saved_data = args
+        print(f"Save callback called with {len(args)} arguments")
+        print(f"Arguments: {args}")
+
+        if len(args) >= 2:
+            dose_data = args[-1]  # Last argument should be dose data
+            print(f"Dose data type: {type(dose_data)}")
+            print(f"Dose data: {dose_data}")
+
+            if isinstance(dose_data, dict):
+                for med_key, dose_str in dose_data.items():
+                    print(f"  {med_key}: '{dose_str}'")
+
+        # Don't destroy window, just close it
+        root.quit()
+
+    def mock_delete_callback(win):
+        print("Delete callback called")
+        win.destroy()
+        root.quit()
+
+    callbacks = {"save": mock_save_callback, "delete": mock_delete_callback}
+
+    # Create edit window
+    edit_window = ui_manager.create_edit_window(tuple(test_values), callbacks)
+    print("Edit window created, please test dose tracking and save...")
+
+    # Show the window so user can interact
+    root.deiconify()
+    edit_window.lift()
+    edit_window.focus_force()
+
+    # Run main loop
+    root.mainloop()
+
+    if saved_data:
+        print("✅ Test completed - data was saved")
+        return True
+    else:
+        print("❌ Test failed - no data saved")
+        return False
+
+
+if __name__ == "__main__":
+    test_dose_save()

scripts/test_dose_save_simple.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Test dose tracking functionality programmatically.
+"""
+
+import os
+import sys
+import tempfile
+import tkinter as tk
+
+sys.path.append(os.path.join(os.path.dirname(__file__), "src"))
+
+import logging
+
+from data_manager import DataManager
+from medicine_manager import MedicineManager
+from pathology_manager import PathologyManager
+from ui_manager import UIManager
+
+
+def test_dose_save_programmatically():
+    """Test dose saving functionality without UI interaction."""
+
+    # Setup logging
+    logging.basicConfig(level=logging.DEBUG)
+    logger = logging.getLogger("test")
+
+    # Initialize managers
+    medicine_manager = MedicineManager()
+    pathology_manager = PathologyManager()
+
+    # Create temporary CSV file
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", delete=False) as f:
+        temp_csv = f.name
+
+    try:
+        # Create data manager
+        data_manager = DataManager(
+            temp_csv, logger, medicine_manager, pathology_manager
+        )
+
+        # Create root window (hidden)
+        root = tk.Tk()
+        root.withdraw()
+
+        # Initialize UI manager
+        ui_manager = UIManager(
+            root=root,
+            logger=logger,
+            medicine_manager=medicine_manager,
+            pathology_manager=pathology_manager,
+        )
+
+        # Test the parsing directly
+        test_dose_text = "• 08:00 AM - 150mg\n• 02:00 PM - 25mg"
+        date_str = "2025-07-31"
+
+        print("Testing dose parsing...")
+        parsed_result = ui_manager._parse_dose_history_for_saving(
+            test_dose_text, date_str
+        )
+        print(f"Input: {test_dose_text}")
+        print(f"Date: {date_str}")
+        print(f"Parsed result: {parsed_result}")
+
+        # Verify the format is correct
+        if "|" in parsed_result:
+            doses = parsed_result.split("|")
+            print(f"Number of parsed doses: {len(doses)}")
+            for i, dose in enumerate(doses):
+                print(f"  Dose {i + 1}: {dose}")
+                # Should be in format: YYYY-MM-DD HH:MM:SS:dose
+                if ":" in dose and len(dose.split(":")) >= 4:
+                    print("    ✅ Dose format looks correct")
+                else:
+                    print("    ❌ Dose format looks incorrect")
+
+        # Test with simple format
+        print("\nTesting simple format...")
+        simple_test = "08:00: 150mg\n14:00: 25mg"
+        simple_result = ui_manager._parse_dose_history_for_saving(simple_test, date_str)
+        print(f"Input: {simple_test}")
+        print(f"Parsed result: {simple_result}")
+
+        # Test saving to data manager
+        print("\nTesting data save...")
+
+        # Create entry data in the expected format
+        entry_data = ["2025-07-31"]  # date
+
+        # Add pathology values
+        pathologies = pathology_manager.get_all_pathologies()
+        for _ in pathologies:
+            entry_data.append(3)  # pathology value
+
+        # Add medicine values and doses
+        medicines = medicine_manager.get_all_medicines()
+        for med_key in medicines:
+            entry_data.append(1)  # medicine checkbox value
+            # Use the parsed result for the dose
+            if med_key == "bupropion":  # Test with first medicine
+                entry_data.append(parsed_result)
+            else:
+                entry_data.append("")  # Empty doses for other medicines
+
+        entry_data.append("Test note")  # note
+
+        print(f"Entry data length: {len(entry_data)}")
+        print(f"Entry data: {entry_data}")
+
+        # Try to add the entry
+        success = data_manager.add_entry(entry_data)
+        print(f"Data manager add_entry result: {success}")
+
+        if success:
+            # Load data back and check
+            df = data_manager.load_data()
+            print(f"Data loaded back, shape: {df.shape}")
+            if len(df) > 0:
+                bupropion_doses = df.iloc[0]["bupropion_doses"]
+                print(f"Saved bupropion doses: '{bupropion_doses}'")
+                print("✅ Dose data was successfully saved and retrieved!")
+            else:
+                print("❌ No data found after saving")
+        else:
+            print("❌ Failed to save entry to data manager")
+
+    finally:
+        # Clean up
+        os.unlink(temp_csv)
+        root.destroy()
+
+
+if __name__ == "__main__":
+    test_dose_save_programmatically()

scripts/test_final_workflow.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Test the complete dose tracking workflow after fixing the parsing issues."""
+
+import os
+import shutil
+import sys
+import tempfile
+from unittest.mock import Mock
+
+import pandas as pd
+
+sys.path.append("src")
+from data_manager import DataManager
+from ui_manager import UIManager
+
+
+def test_dose_workflow():
+    """Test that doses are preserved when editing through the UI."""
+
+    # Create temporary directory and CSV file
+    temp_dir = tempfile.mkdtemp()
+    csv_file = os.path.join(temp_dir, "test.csv")
+    print(f"Using temporary CSV: {csv_file}")
+
+    try:
+        # Create mock managers with known configurations
+        mock_medicine_manager = Mock()
+        mock_medicine_manager.get_dynamic_columns.return_value = [
+            "Medicine A",
+            "Medicine B",
+        ]
+        mock_medicine_manager.get_medicines.return_value = {
+            "med1": {"name": "Medicine A"},
+            "med2": {"name": "Medicine B"},
+        }
+        mock_medicine_manager.get_medicine_keys.return_value = ["med1", "med2"]
+
+        mock_pathology_manager = Mock()
+        mock_pathology_manager.get_dynamic_columns.return_value = [
+            "Pathology X",
+            "Pathology Y",
+        ]
+        mock_pathology_manager.get_pathology_keys.return_value = ["path1", "path2"]
+
+        # Create DataManager and UIManager
+        import logging
+        import tkinter as tk
+
+        logger = logging.getLogger("test")
+        root = tk.Tk()
+        root.withdraw()  # Hide the window during testing
+
+        data_manager = DataManager(
+            csv_file, logger, mock_medicine_manager, mock_pathology_manager
+        )
+        ui_manager = UIManager(
+            root, logger, mock_medicine_manager, mock_pathology_manager
+        )
+
+        # Add initial entry with some doses
+        print("\n1. Adding initial entry with two doses...")
+        initial_data = {
+            "Date": "2025-01-30",
+            "Depression": 3,
+            "Anxiety": 4,
+            "Sleep": 7,
+            "Appetite": 6,
+            "Medicine A": "2025-01-30 08:00:00:150mg|2025-01-30 14:00:00:25mg",
+            "Medicine B": "",
+            "Pathology X": 2,
+            "Pathology Y": 1,
+            "Notes": "Initial entry",
+        }
+        data_manager.add_entry(initial_data)
+
+        # Check what was saved
+        df = pd.read_csv(csv_file)
+        print(f'Medicine A after initial save: "{df.iloc[0]["Medicine A"]}"')
+
+        # Now simulate the UI editing workflow
+        print("\n2. Simulating UI edit workflow...")
+
+        # Get the saved data (as it would appear in edit window)
+        saved_medicine_a = df.iloc[0]["Medicine A"]
+        print(f'Saved Medicine A doses: "{saved_medicine_a}"')
+
+        # Create mock text widget to simulate _populate_dose_history
+        class MockText:
+            def __init__(self):
+                self.content = ""
+
+            def configure(self, state):
+                pass
+
+            def delete(self, start, end):
+                self.content = ""
+
+            def insert(self, pos, text):
+                self.content = text
+
+            def get(self, start, end):
+                return self.content
+
+        mock_text = MockText()
+        ui_manager._populate_dose_history(mock_text, saved_medicine_a)
+        print(f'UI display after _populate_dose_history: "{mock_text.content}"')
+
+        # Simulate user adding a new dose to the text widget
+        user_edited_content = mock_text.content + "\n• 06:00 PM - 50mg"
+        print(f'User adds new dose, text widget now contains: "{user_edited_content}"')
+
+        # Parse this back for saving
+        parsed_doses = ui_manager._parse_dose_history_for_saving(
+            user_edited_content, "2025-01-30"
+        )
+        print(f'Parsed for saving: "{parsed_doses}"')
+
+        # Update the entry
+        update_data = initial_data.copy()
+        update_data["Medicine A"] = parsed_doses
+        data_manager.update_entry("2025-01-30", update_data)
+
+        # Check final result
+        df = pd.read_csv(csv_file)
+        final_medicine_a = df.iloc[0]["Medicine A"]
+        print(f'\n3. Final Medicine A after update: "{final_medicine_a}"')
+
+        # Count doses
+        dose_count = len([d for d in final_medicine_a.split("|") if d.strip()])
+        print(f"Final dose count: {dose_count}")
+
+        if dose_count == 3:
+            print("✅ SUCCESS: All doses preserved!")
+            return True
+        else:
+            print("❌ FAILURE: Doses were lost!")
+            return False
+
+    finally:
+        # Clean up
+        shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    success = test_dose_workflow()
+    sys.exit(0 if success else 1)