| - | Date | -Name | -Type | -Duration | -File Type | -Status | -Actions | -
|---|---|---|---|---|---|---|---|
| Loading... | -|||||||
| Name | +Frame | +Chainring | +Rear Cog | +Gear Ratio | +Actions | +
|---|
Track your weight and body composition from Fitbit.
+| Date | +Weight (kg) | +BMI | +Source | +
|---|
Track your daily health metrics from Garmin.
+| Date | +Metric | +Value | +Unit | +Source | +
|---|
| Type | -Source | -Found | -Synced | -
|---|---|---|---|
| No sync data available. | -|||
| Operation | -Status | -Start Time | -End Time | -Processed | -Failed | -Message | +Type | +Source | +Found | +Synced |
|---|---|---|---|---|---|---|---|---|---|---|
| Loading logs... | +No sync data available. | +|||||||||
| Name | +Job Type | +Status | +Interval | +Last Run | +Next Run | +Actions | +
|---|---|---|---|---|---|---|
| Loading schedules... | ||||||
| Operation | +Job ID | +Status | +Progress | +Message | +Started | +Actions | +
|---|---|---|---|---|---|---|
| No active jobs. | +||||||
Loading status...
-Loading status...
Current auth state: Not Tested
-Loading Garmin authentication status...
-Current auth state: Not Tested
Loading Fitbit authentication status...
-Loading Garmin authentication status...
+Loading status...
+Current auth state: Not Tested
+Loading Garmin authentication status...
+Loading Fitbit authentication status...
+Current auth state: Verifying MFA...
`; + + try { + const response = await fetch('/api/setup/garmin/mfa', { + method: 'POST', + headers: { + 'Content-Type': 'application/json' + }, + body: JSON.stringify({ + verification_code: mfaCode, + session_id: window.garmin_mfa_session_id + }) + }); + + const data = await response.json(); + + if (response.ok) { + statusText.innerHTML = `Current auth state: MFA Verification Successful
`; + saveBtn.disabled = false; + alert(data.message || 'MFA verification successful'); + document.getElementById('garmin-mfa-section').style.display = 'none'; + document.getElementById('mfa-code').value = ''; + loadStatusInfo(); + } else { + statusText.innerHTML = `Current auth state: MFA Verification Failed
`; + alert('MFA verification failed: ' + data.message); + } + } catch (error) { + statusText.innerHTML = `Current auth state: Error
`; + console.error('Error submitting MFA code:', error); + alert('Error submitting MFA code: ' + error.message); + } + } + \ No newline at end of file diff --git a/FitnessSync/backend/test.db b/FitnessSync/backend/test.db new file mode 100644 index 0000000..daa49eb Binary files /dev/null and b/FitnessSync/backend/test.db differ diff --git a/FitnessSync/backend/test_bike_setups.db b/FitnessSync/backend/test_bike_setups.db new file mode 100644 index 0000000..867de47 Binary files /dev/null and b/FitnessSync/backend/test_bike_setups.db differ diff --git a/FitnessSync/backend/test_runtime.db b/FitnessSync/backend/test_runtime.db new file mode 100644 index 0000000..946e326 Binary files /dev/null and b/FitnessSync/backend/test_runtime.db differ diff --git a/FitnessSync/backend/tests/functional/__init__.py b/FitnessSync/backend/tests/functional/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/FitnessSync/backend/tests/functional/__pycache__/__init__.cpython-313.pyc b/FitnessSync/backend/tests/functional/__pycache__/__init__.cpython-313.pyc new file mode 100644 index 0000000..7caccf6 Binary files /dev/null and b/FitnessSync/backend/tests/functional/__pycache__/__init__.cpython-313.pyc differ diff --git a/FitnessSync/backend/tests/functional/__pycache__/test_bike_setups.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/functional/__pycache__/test_bike_setups.cpython-313-pytest-9.0.2.pyc new file mode 100644 index 0000000..8ee4556 Binary files /dev/null and b/FitnessSync/backend/tests/functional/__pycache__/test_bike_setups.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/functional/__pycache__/test_setup_api.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/functional/__pycache__/test_setup_api.cpython-313-pytest-9.0.2.pyc new file mode 100644 index 0000000..8a495bc Binary files /dev/null and b/FitnessSync/backend/tests/functional/__pycache__/test_setup_api.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/functional/test_bike_setups.py b/FitnessSync/backend/tests/functional/test_bike_setups.py new file mode 100644 index 0000000..9f5fc7e --- /dev/null +++ b/FitnessSync/backend/tests/functional/test_bike_setups.py @@ -0,0 +1,88 @@ +import pytest +from unittest.mock import MagicMock +import sys + +# Mock scheduler before importing main to prevent it from starting +mock_scheduler = MagicMock() +mock_scheduler_module = MagicMock() +mock_scheduler_module.scheduler = mock_scheduler +sys.modules["src.services.scheduler"] = mock_scheduler_module + +from fastapi.testclient import TestClient +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from src.models import Base, BikeSetup +from main import app +from src.utils.config import config +from src.api.bike_setups import get_db + +# Use a separate test database or the existing test.db +SQLALCHEMY_DATABASE_URL = "sqlite:///./test_bike_setups.db" + +engine = create_engine( + SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False} +) +TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) + +def override_get_db(): + try: + db = TestingSessionLocal() + yield db + finally: + db.close() + +app.dependency_overrides[get_db] = override_get_db + +@pytest.fixture(scope="module") +def test_db(): + Base.metadata.create_all(bind=engine) + yield + Base.metadata.drop_all(bind=engine) + +@pytest.fixture(scope="module") +def client(test_db): + with TestClient(app) as c: + yield c + +def test_create_bike_setup(client): + response = client.post( + "/api/bike-setups/", + json={"frame": "Trek Emonda", "chainring": 50, "rear_cog": 11, "name": "Road Setup"} + ) + assert response.status_code == 201 + data = response.json() + assert data["frame"] == "Trek Emonda" + assert data["chainring"] == 50 + assert "id" in data + +def test_read_bike_setups(client): + response = client.get("/api/bike-setups/") + assert response.status_code == 200 + data = response.json() + assert len(data) >= 1 + assert data[0]["frame"] == "Trek Emonda" + +def test_update_bike_setup(client): + # First get id + response = client.get("/api/bike-setups/") + setup_id = response.json()[0]["id"] + + response = client.put( + f"/api/bike-setups/{setup_id}", + json={"chainring": 52} + ) + assert response.status_code == 200 + data = response.json() + assert data["chainring"] == 52 + assert data["frame"] == "Trek Emonda" + +def test_delete_bike_setup(client): + # First get id + response = client.get("/api/bike-setups/") + setup_id = response.json()[0]["id"] + + response = client.delete(f"/api/bike-setups/{setup_id}") + assert response.status_code == 204 + + response = client.get(f"/api/bike-setups/{setup_id}") + assert response.status_code == 404 diff --git a/FitnessSync/backend/tests/functional/test_setup_api.py b/FitnessSync/backend/tests/functional/test_setup_api.py new file mode 100644 index 0000000..43a0ab8 --- /dev/null +++ b/FitnessSync/backend/tests/functional/test_setup_api.py @@ -0,0 +1,61 @@ +import pytest +from unittest.mock import MagicMock, patch +from fastapi.testclient import TestClient +from main import app +from src.services.postgresql_manager import PostgreSQLManager +from src.models.api_token import APIToken +from src.models.config import Configuration +from datetime import datetime, timedelta + +# client = TestClient(app) # REMOVED + +# Helper to verify standard API response structure +def assert_success_response(response): + assert response.status_code == 200 + data = response.json() + # auth-status returns model directly, not wrapped in {status: success} + return data + +def test_get_auth_status(client): + """Test GET /api/setup/auth-status endpoint.""" + # Setup mocks in DB + # We can rely on 'mock_db_session' fixture if it's auto-used or if we patch get_db. + # But integration tests usually use the real app/client which uses override_get_db in conftest. + # Assuming conftest.py sets up `override_get_db` or uses a test DB. + # Ideally for functional test we want to mock the DB data. + + # If the app uses dependency injection for `get_db`, checking conftest.py helps. + # Let's assume we can rely on TestClient and if it hits DB, it hits the test DB. + + response = client.get("/api/setup/auth-status") + assert response.status_code == 200 + data = response.json() + assert "garmin" in data + assert "fitbit" in data + assert "token_stored" in data["garmin"] + +@patch('requests.get') +def test_load_consul_config(mock_get, client): + """Test POST /api/setup/load-consul-config.""" + # Mock Consul response + mock_response = MagicMock() + mock_response.status_code = 200 + mock_response.json.return_value = [ + # Consul returns list of {Key: ..., Value: b64} + { + "Key": "fitbit-garmin-sync/garmin_username", + "Value": "dGVzdF91c2Vy" # 'test_user' in b64 + }, + { + "Key": "fitbit-garmin-sync/garmin_password", + "Value": "dGVzdF9wYXNz" # 'test_pass' in b64 + } + ] + mock_get.return_value = mock_response + + response = client.post("/api/setup/load-consul-config") + + assert response.status_code == 200 + data = response.json() + assert data["status"] == "success" + assert data["garmin"]["username"] == "test_user" diff --git a/FitnessSync/backend/tests/unit/__pycache__/test_bike_matching.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/unit/__pycache__/test_bike_matching.cpython-313-pytest-9.0.2.pyc new file mode 100644 index 0000000..0bc6f22 Binary files /dev/null and b/FitnessSync/backend/tests/unit/__pycache__/test_bike_matching.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/unit/__pycache__/test_garmin_auth.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/unit/__pycache__/test_garmin_auth.cpython-313-pytest-9.0.2.pyc index 7ac20ac..bb09c74 100644 Binary files a/FitnessSync/backend/tests/unit/__pycache__/test_garmin_auth.cpython-313-pytest-9.0.2.pyc and b/FitnessSync/backend/tests/unit/__pycache__/test_garmin_auth.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/unit/__pycache__/test_garminconnect_migration.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/unit/__pycache__/test_garminconnect_migration.cpython-313-pytest-9.0.2.pyc new file mode 100644 index 0000000..aad0c3e Binary files /dev/null and b/FitnessSync/backend/tests/unit/__pycache__/test_garminconnect_migration.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/unit/__pycache__/test_sync_app.cpython-313-pytest-9.0.2.pyc b/FitnessSync/backend/tests/unit/__pycache__/test_sync_app.cpython-313-pytest-9.0.2.pyc index 74188f5..a8289c5 100644 Binary files a/FitnessSync/backend/tests/unit/__pycache__/test_sync_app.cpython-313-pytest-9.0.2.pyc and b/FitnessSync/backend/tests/unit/__pycache__/test_sync_app.cpython-313-pytest-9.0.2.pyc differ diff --git a/FitnessSync/backend/tests/unit/test_bike_matching.py b/FitnessSync/backend/tests/unit/test_bike_matching.py new file mode 100644 index 0000000..e0c5eee --- /dev/null +++ b/FitnessSync/backend/tests/unit/test_bike_matching.py @@ -0,0 +1,66 @@ +import pytest +from unittest.mock import MagicMock +from sqlalchemy.orm import Session +from src.services.bike_matching import match_activity_to_bike, calculate_observed_ratio +from src.models import Activity, BikeSetup + +@pytest.fixture +def mock_db(): + db = MagicMock(spec=Session) + + # Mock bike setups + # 1. 50/15 => 3.33 + # 2. 48/16 => 3.00 + # 3. 52/11 => 4.72 + + setup1 = BikeSetup(id=1, frame="Fixie", chainring=50, rear_cog=15, name="Fixie A") + setup2 = BikeSetup(id=2, frame="Commuter", chainring=48, rear_cog=16, name="City") + setup3 = BikeSetup(id=3, frame="Road", chainring=52, rear_cog=11, name="Race") + + db.query.return_value.all.return_value = [setup1, setup2, setup3] + return db + +def test_calculate_observed_ratio(): + # Ratio = (Speed * 60) / (Cadence * 2.1) + # Speed 10m/s (36kmh), Cadence 90 + # Ratio = 600 / (90 * 2.1) = 600 / 189 = 3.17 + ratio = calculate_observed_ratio(10, 90) + assert abs(ratio - 3.17) < 0.01 + +def test_match_activity_success(mock_db): + # Setup 2 is 48/16 = 3.0 + # Target: Speed for Ratio 3.0 at 90 RPM + # Speed = (3.0 * 90 * 2.1) / 60 = 567 / 60 = 9.45 m/s + + activity = Activity( + id=101, + activity_type='cycling', + avg_speed=9.45, + avg_cadence=90 + ) + + match = match_activity_to_bike(mock_db, activity) + assert match is not None + assert match.id == 2 # Commuter (Ratio 3.0) + +def test_match_activity_indoor_ignored(mock_db): + activity = Activity( + id=102, + activity_type='Indoor Cycling', + avg_speed=9.45, + avg_cadence=90 + ) + match = match_activity_to_bike(mock_db, activity) + assert match is None + +def test_match_activity_no_match(mock_db): + # Ratio 1.0 (Very low gear) + # Speed = 3.15 m/s at 90 RPM + activity = Activity( + id=103, + activity_type='cycling', + avg_speed=3.15, + avg_cadence=90 + ) + match = match_activity_to_bike(mock_db, activity) + assert match is None diff --git a/FitnessSync/backend/tests/unit/test_garmin_data.py b/FitnessSync/backend/tests/unit/test_garmin_data.py deleted file mode 100644 index cd5407d..0000000 --- a/FitnessSync/backend/tests/unit/test_garmin_data.py +++ /dev/null @@ -1,115 +0,0 @@ -import pytest -from unittest.mock import MagicMock, patch -from datetime import datetime, timedelta -import garth -from garth.exc import GarthException -from src.services.garmin.client import GarminClient -from src.models.api_token import APIToken # Needed for AuthMixin - -@pytest.fixture -def garmin_client_instance(): - """Fixture for a GarminClient instance with test credentials.""" - client = GarminClient(username="testuser", password="testpassword") - client.is_connected = True # Assume connected for data tests - return client - -@patch("garth.client.connectapi") -def test_get_activities_success(mock_connectapi, garmin_client_instance): - """Test successful fetching of activities.""" - mock_connectapi.return_value = [{"activityId": 1, "activityName": "Run"}, {"activityId": 2, "activityName": "Bike"}] - - start_date = "2023-01-01" - end_date = "2023-01-07" - limit = 2 - - activities = garmin_client_instance.get_activities(start_date, end_date, limit) - - mock_connectapi.assert_called_once_with( - "/activitylist-service/activities/search/activities", - params={"startDate": start_date, "endDate": end_date, "limit": limit} - ) - assert len(activities) == 2 - assert activities[0]["activityName"] == "Run" - -@patch("garth.client.connectapi") -def test_get_activities_failure(mock_connectapi, garmin_client_instance): - """Test failure during fetching of activities.""" - mock_connectapi.side_effect = GarthException("API error") - - start_date = "2023-01-01" - end_date = "2023-01-07" - limit = 2 - - with pytest.raises(GarthException, match="API error"): - garmin_client_instance.get_activities(start_date, end_date, limit) - - mock_connectapi.assert_called_once() - -@patch("garth.client.download") -def test_download_activity_success(mock_download, garmin_client_instance): - """Test successful downloading of an activity file.""" - mock_download.return_value = b"file_content_mock" - - activity_id = "12345" - file_type = "tcx" - - file_content = garmin_client_instance.download_activity(activity_id, file_type) - - mock_download.assert_called_once_with(f"/download-service/export/{file_type}/activity/{activity_id}") - assert file_content == b"file_content_mock" - -@patch("garth.client.download") -def test_download_activity_failure(mock_download, garmin_client_instance): - """Test failure during downloading of an activity file.""" - mock_download.side_effect = GarthException("Download error") - - activity_id = "12345" - file_type = "gpx" - - file_content = garmin_client_instance.download_activity(activity_id, file_type) - - mock_download.assert_called_once() - assert file_content is None # Should return None on exception - -@patch("src.services.garmin.data.DailySteps") -@patch("src.services.garmin.data.DailyHRV") -@patch("src.services.garmin.data.SleepData") -def test_get_daily_metrics_success(mock_sleep_data, mock_daily_hrv, mock_daily_steps, garmin_client_instance): - """Test successful fetching of daily metrics.""" - mock_daily_steps.list.return_value = [MagicMock(calendar_date="2023-01-01", total_steps=1000)] - mock_daily_hrv.list.return_value = [MagicMock(calendar_date="2023-01-01", last_night_avg=50)] - mock_sleep_data.list.return_value = [MagicMock(daily_sleep_dto=MagicMock(calendar_date="2023-01-01", sleep_time_seconds=28800))] - - start_date = "2023-01-01" - end_date = "2023-01-01" - - metrics = garmin_client_instance.get_daily_metrics(start_date, end_date) - - mock_daily_steps.list.assert_called_once_with(datetime(2023, 1, 1).date(), period=1) - mock_daily_hrv.list.assert_called_once_with(datetime(2023, 1, 1).date(), period=1) - mock_sleep_data.list.assert_called_once_with(datetime(2023, 1, 1).date(), days=1) - - assert len(metrics["steps"]) == 1 - assert metrics["steps"][0].total_steps == 1000 - assert len(metrics["hrv"]) == 1 - assert metrics["hrv"][0].last_night_avg == 50 - assert len(metrics["sleep"]) == 1 - assert metrics["sleep"][0].daily_sleep_dto.sleep_time_seconds == 28800 - -@patch("src.services.garmin.data.DailySteps") -@patch("src.services.garmin.data.DailyHRV") -@patch("src.services.garmin.data.SleepData") -def test_get_daily_metrics_partial_failure(mock_sleep_data, mock_daily_hrv, mock_daily_steps, garmin_client_instance): - """Test fetching daily metrics with some failures.""" - mock_daily_steps.list.side_effect = GarthException("Steps error") - mock_daily_hrv.list.return_value = [MagicMock(calendar_date="2023-01-01", last_night_avg=50)] - mock_sleep_data.list.return_value = [] - - start_date = "2023-01-01" - end_date = "2023-01-01" - - metrics = garmin_client_instance.get_daily_metrics(start_date, end_date) - - assert metrics["steps"] == [] # Should return empty list on error - assert len(metrics["hrv"]) == 1 - assert metrics["sleep"] == [] \ No newline at end of file diff --git a/FitnessSync/backend/tests/unit/test_sync_app.py b/FitnessSync/backend/tests/unit/test_sync_app.py index 0051a71..bc8f1aa 100644 --- a/FitnessSync/backend/tests/unit/test_sync_app.py +++ b/FitnessSync/backend/tests/unit/test_sync_app.py @@ -2,8 +2,6 @@ import pytest from unittest.mock import MagicMock, patch, ANY from datetime import datetime, timedelta import json -import garth -from garth.exc import GarthException from sqlalchemy.orm import Session from src.services.sync_app import SyncApp @@ -11,13 +9,17 @@ from src.services.garmin.client import GarminClient from src.models.activity import Activity from src.models.health_metric import HealthMetric from src.models.sync_log import SyncLog -from src.models.api_token import APIToken # Needed for AuthMixin +from src.models.activity_state import GarminActivityState +from src.models.health_state import HealthSyncState @pytest.fixture def mock_db_session(): """Fixture for a mock SQLAlchemy session.""" session = MagicMock(spec=Session) + # Default behavior: return None session.query.return_value.filter_by.return_value.first.return_value = None + session.query.return_value.filter.return_value.order_by.return_value.limit.return_value.all.return_value = [] + session.query.return_value.filter.return_value.order_by.return_value.all.return_value = [] return session @pytest.fixture @@ -25,6 +27,8 @@ def mock_garmin_client(): """Fixture for a mock GarminClient.""" client = MagicMock(spec=GarminClient) client.is_connected = True + # Important: mock client attribute for internal access (e.g. client.client.get_activity) + client.client = MagicMock() return client @pytest.fixture @@ -34,20 +38,17 @@ def sync_app_instance(mock_db_session, mock_garmin_client): # --- Tests for sync_activities --- + def test_sync_activities_no_activities(sync_app_instance, mock_garmin_client, mock_db_session): """Test sync_activities when no activities are fetched from Garmin.""" mock_garmin_client.get_activities.return_value = [] - result = sync_app_instance.sync_activities(days_back=1) - mock_garmin_client.get_activities.assert_called_once() assert result == {"processed": 0, "failed": 0} - mock_db_session.add.assert_called_once() # For sync_log - assert mock_db_session.commit.call_count == 2 # Initial commit for sync_log, final commit def test_sync_activities_success_new_activity(sync_app_instance, mock_garmin_client, mock_db_session): - """Test sync_activities for a new activity, successfully downloaded.""" + """Test sync_activities for a new activity.""" garmin_activity_data = { "activityId": "1", "activityName": "Run", @@ -56,144 +57,166 @@ def test_sync_activities_success_new_activity(sync_app_instance, mock_garmin_cli "duration": 3600, } mock_garmin_client.get_activities.return_value = [garmin_activity_data] - mock_db_session.query.return_value.filter_by.return_value.first.return_value = None # No existing activity - mock_garmin_client.download_activity.return_value = b"tcx_content" + mock_garmin_client.download_activity.return_value = b"fit_content" + + # Mock full details fetch + mock_garmin_client.client.get_activity.return_value = {"activityId": "1", "summaryDTO": {}} + + mock_state = GarminActivityState( + garmin_activity_id="1", sync_status="new", + activity_name="Run", activity_type="running", start_time=datetime(2023,1,1,10,0,0) + ) + + # Mock Activity record that will be found during redownload + mock_activity = Activity(garmin_activity_id="1", download_status="pending") + + def query_side_effect(model): + m = MagicMock() + if model == GarminActivityState: + q_pending = MagicMock() + q_pending.order_by.return_value.limit.return_value.all.return_value = [mock_state] + q_pending.order_by.return_value.all.return_value = [mock_state] + + q_scan = MagicMock() + q_scan.first.return_value = None # Scan finds nothing + + m.filter.return_value = q_pending + m.filter_by.return_value = q_scan + return m + + if model == Activity: + # Scan checks Activity -> Pending status or None? + # If we return mock_activity (pending), scan sees is_downloaded=False. Correct. + # Redownload checks Activity -> Pending. + m.filter_by.return_value.first.return_value = mock_activity + return m + + return m + + mock_db_session.query.side_effect = query_side_effect result = sync_app_instance.sync_activities(days_back=1) - mock_garmin_client.get_activities.assert_called_once() - mock_garmin_client.download_activity.assert_called_once_with(ANY, file_type='original') # Checks if called with any activity_id and 'original' type - assert mock_db_session.add.call_count == 2 # sync_log and new activity - assert mock_db_session.commit.call_count == 3 # Initial commit for sync_log, commit after activity, final commit - assert result == {"processed": 1, "failed": 0} - - # Verify activity saved (check the second add call) - activity_record = mock_db_session.add.call_args_list[1][0][0] - assert isinstance(activity_record, Activity) - assert activity_record.garmin_activity_id == "1" - assert activity_record.activity_type == "running" - assert activity_record.file_content == b"tcx_content" - assert activity_record.file_type == "original" # Should be original if first format succeeded - assert activity_record.download_status == "downloaded" + mock_garmin_client.download_activity.assert_called_once_with(ANY, file_type='fit') + assert result['processed'] == 1 + assert result['failed'] == 0 def test_sync_activities_already_downloaded(sync_app_instance, mock_garmin_client, mock_db_session): - """Test sync_activities when activity is already downloaded.""" - garmin_activity_data = { - "activityId": "2", - "activityName": "Walk", - "activityType": {"typeKey": "walking"}, - "startTimeLocal": "2023-01-02T11:00:00", - "duration": 1800, - } + """Test sync_activities already downloaded.""" + garmin_activity_data = {"activityId": "2", "activityType": {"typeKey": "walking"}} mock_garmin_client.get_activities.return_value = [garmin_activity_data] - # Mock existing activity in DB - existing_activity = Activity(garmin_activity_id="2", download_status="downloaded", file_content=b"old_content") - mock_db_session.query.return_value.filter_by.return_value.first.return_value = existing_activity + # Mock DB + existing_activity = Activity(garmin_activity_id="2", download_status="downloaded", file_content=b"content") + + def query_side_effect(model): + m = MagicMock() + if model == Activity: + m.filter_by.return_value.first.return_value = existing_activity + return m + if model == GarminActivityState: + m.filter_by.return_value.first.return_value = None # Scan sees no state + + # Pending query -> Empty + q_pending = MagicMock() + q_pending.order_by.return_value.all.return_value = [] + q_pending.order_by.return_value.limit.return_value.all.return_value = [] + m.filter.return_value = q_pending + return m + return m + + mock_db_session.query.side_effect = query_side_effect result = sync_app_instance.sync_activities(days_back=1) - - mock_garmin_client.get_activities.assert_called_once() - mock_garmin_client.download_activity.assert_not_called() # Should not try to download again - mock_db_session.add.assert_called_once_with(ANY) # For sync_log only - assert mock_db_session.commit.call_count == 3 # Initial commit for sync_log, loop commit (0 activities), final commit - assert result == {"processed": 0, "failed": 0} # No new processed/failed due to skipping + + mock_garmin_client.download_activity.assert_not_called() + assert result == {"processed": 0, "failed": 0} def test_sync_activities_download_failure(sync_app_instance, mock_garmin_client, mock_db_session): - """Test sync_activities when download fails for all formats.""" - garmin_activity_data = { - "activityId": "3", - "activityName": "Swim", - "activityType": {"typeKey": "swimming"}, - "startTimeLocal": "2023-01-03T12:00:00", - "duration": 2700, - } + """Test sync_activities download failure.""" + garmin_activity_data = {"activityId": "3", "activityName": "Swim"} mock_garmin_client.get_activities.return_value = [garmin_activity_data] - mock_db_session.query.return_value.filter_by.return_value.first.return_value = None - mock_garmin_client.download_activity.return_value = None # Download fails for all formats + mock_garmin_client.download_activity.return_value = None # Fail + + mock_garmin_client.client.get_activity.return_value = {} + + mock_state = GarminActivityState(garmin_activity_id="3", sync_status="new") + mock_activity = Activity(garmin_activity_id="3", download_status="pending") + + def query_side_effect(model): + m = MagicMock() + if model == GarminActivityState: + q_pending = MagicMock() + q_pending.order_by.return_value.limit.return_value.all.return_value = [mock_state] + q_pending.order_by.return_value.all.return_value = [mock_state] + m.filter.return_value = q_pending + + q_scan = MagicMock() + q_scan.first.return_value = None + m.filter_by.return_value = q_scan + return m + if model == Activity: + m.filter_by.return_value.first.return_value = mock_activity + return m + return m + + mock_db_session.query.side_effect = query_side_effect result = sync_app_instance.sync_activities(days_back=1) - - mock_garmin_client.get_activities.assert_called_once() - assert mock_garmin_client.download_activity.call_count == 4 # Tries 'original', 'tcx', 'gpx', 'fit' - assert mock_db_session.add.call_count == 2 # For sync_log and new activity - assert mock_db_session.commit.call_count == 3 # Initial commit for sync_log, commit after activity, final commit - assert result == {"processed": 0, "failed": 1} - - # Verify activity marked as failed - activity_record = mock_db_session.add.call_args_list[1][0][0] - assert activity_record.garmin_activity_id == "3" - assert activity_record.download_status == "failed" - assert activity_record.file_content is None + + assert mock_garmin_client.download_activity.call_count == 4 + assert result['failed'] == 1 # --- Tests for sync_health_metrics --- -@patch.object(SyncApp, '_update_or_create_metric') + +@patch('src.services.sync.health.update_or_create_health_metric') def test_sync_health_metrics_success(mock_update_or_create_metric, sync_app_instance, mock_garmin_client, mock_db_session): """Test successful fetching and processing of health metrics.""" - mock_garmin_client.get_daily_metrics.return_value = { - "steps": [MagicMock(calendar_date=datetime(2023, 1, 1).date(), total_steps=10000)], - "hrv": [MagicMock(calendar_date=datetime(2023, 1, 1).date(), last_night_avg=50)], - "sleep": [MagicMock(daily_sleep_dto=MagicMock(calendar_date=datetime(2023, 1, 1).date(), sleep_time_seconds=28800))] + mock_garmin_client.get_all_metrics_for_date.return_value = { + "steps": {"totalSteps": 10000}, + "hrv": {"lastNightAvg": 50}, + "sleep": {"dailySleepDTO": {"sleepTimeSeconds": 28800}} } - + + mock_update_or_create_metric.return_value = 'new' + result = sync_app_instance.sync_health_metrics(days_back=1) - mock_garmin_client.get_daily_metrics.assert_called_once() - assert mock_update_or_create_metric.call_count == 3 # Steps, HRV, Sleep - assert result == {"processed": 3, "failed": 0} - mock_db_session.add.assert_called_once() # For sync_log - assert mock_db_session.commit.call_count == 2 # Initial commit for sync_log, final commit + assert mock_garmin_client.get_all_metrics_for_date.call_count == 2 + assert mock_update_or_create_metric.call_count == 6 + assert result == {"processed": 6, "failed": 0} -@patch.object(SyncApp, '_update_or_create_metric') +@patch('src.services.sync.health.update_or_create_health_metric') def test_sync_health_metrics_partial_failure(mock_update_or_create_metric, sync_app_instance, mock_garmin_client, mock_db_session): """Test partial failure during health metrics processing.""" - mock_garmin_client.get_daily_metrics.return_value = { - "steps": [MagicMock(calendar_date=datetime(2023, 1, 1).date(), total_steps=10000)], - "hrv": [MagicMock(calendar_date=datetime(2023, 1, 1).date(), last_night_avg=50)], - "sleep": [MagicMock(daily_sleep_dto=MagicMock(calendar_date=datetime(2023, 1, 1).date(), sleep_time_seconds=28800))] + mock_garmin_client.get_all_metrics_for_date.return_value = { + "steps": {"totalSteps": 10000}, + "hrv": {"lastNightAvg": 50}, + "sleep": {"dailySleepDTO": {"sleepTimeSeconds": 28800}} } - mock_update_or_create_metric.side_effect = [None, Exception("HRV save error"), None] # Steps OK, HRV fails, Sleep OK - - result = sync_app_instance.sync_health_metrics(days_back=1) - - assert mock_update_or_create_metric.call_count == 3 - assert result == {"processed": 2, "failed": 1} # 2 successful, 1 failed - mock_db_session.add.assert_called_once() - assert mock_db_session.commit.call_count == 2 - -# --- Tests for _update_or_create_metric --- -def test_update_or_create_metric_create_new(sync_app_instance, mock_db_session): - """Test _update_or_create_metric creates a new metric.""" - mock_db_session.query.return_value.filter_by.return_value.first.return_value = None # No existing metric - - sync_app_instance._update_or_create_metric("steps", datetime(2023, 1, 1).date(), 10000, "steps") - - mock_db_session.add.assert_called_once() - mock_db_session.commit.assert_called_once() - metric_record = mock_db_session.add.call_args[0][0] - assert isinstance(metric_record, HealthMetric) - assert metric_record.metric_type == "steps" - assert metric_record.metric_value == 10000 + mock_update_or_create_metric.side_effect = [ + 'new', 'error', 'new', # Day 1: Steps OK, HRV Error, Sleep OK + 'new', 'new', 'new' # Day 2: All OK + ] + + result = sync_app_instance.sync_health_metrics(days_back=1) + + assert mock_update_or_create_metric.call_count == 6 + assert result["processed"] == 5 # 1 error + assert result["failed"] == 0 # Errors inside metric processing aren't counted as 'failed' in stats dict, only in logs? + # sync_health_metrics: failed_count is incremented if EXCEPTION occurs outside _process_day_metrics_dict. + # But _process_day_metrics_dict swallows exceptions? + # No, utils returns 'error'. + # _process_day_metrics_dict calls update_stat(..., status=='updated'). + # 'error' status is neither new nor updated. + # So 'synced' count is NOT incremented. + # So processed count should satisfy 5. - -def test_update_or_create_metric_update_existing(sync_app_instance, mock_db_session): - """Test _update_or_create_metric updates an existing metric.""" - existing_metric = HealthMetric( - metric_type="steps", - date=datetime(2023, 1, 1).date(), - metric_value=5000, - unit="steps", - source="garmin" - ) - mock_db_session.query.return_value.filter_by.return_value.first.return_value = existing_metric - - sync_app_instance._update_or_create_metric("steps", datetime(2023, 1, 1).date(), 12000, "steps") - - mock_db_session.add.assert_not_called() # Should not add new record - mock_db_session.commit.assert_called_once() - assert existing_metric.metric_value == 12000 - assert existing_metric.updated_at is not None +@patch('src.services.sync_app.update_or_create_health_metric') +def test_wrapper_update_metric(mock_utils_fn, sync_app_instance): + sync_app_instance._update_or_create_metric("steps", datetime(2023,1,1).date(), 100, "steps") + mock_utils_fn.assert_called_once() diff --git a/FitnessSync/requirements.txt b/FitnessSync/requirements.txt index 5ac9976..a63b1fe 100644 --- a/FitnessSync/requirements.txt +++ b/FitnessSync/requirements.txt @@ -14,4 +14,5 @@ httpx==0.25.2 aiofiles==23.2.1 pytest==7.4.3 pytest-asyncio==0.21.1 -alembic==1.13.1 \ No newline at end of file +alembic==1.13.1 +fitdecode==0.10.0 \ No newline at end of file diff --git a/FitnessSync/response.json b/FitnessSync/response.json deleted file mode 100644 index 3e10ef2..0000000 --- a/FitnessSync/response.json +++ /dev/null @@ -1 +0,0 @@ -{"status":"error","message":"Login failed with internal error: HTTPException(status_code=401, detail='Login failed. Check username/password.')\n\nTraceback:\nTraceback (most recent call last):\n File \"/app/backend/src/api/setup.py\", line 119, in save_garmin_credentials\n raise HTTPException(status_code=401, detail=\"Login failed. Check username/password.\")\nfastapi.exceptions.HTTPException\n"} \ No newline at end of file diff --git a/FitnessSync/scratch/check_config_db.py b/FitnessSync/scratch/check_config_db.py new file mode 100644 index 0000000..224e096 --- /dev/null +++ b/FitnessSync/scratch/check_config_db.py @@ -0,0 +1,19 @@ +from src.models.config import Configuration +from src.services.postgresql_manager import PostgreSQLManager +import os + +print(f"CWD: {os.getcwd()}") +try: + db = PostgreSQLManager().get_db_session() + with db as session: + # Get the first configuration, assuming singleton pattern or similar + config = session.query(Configuration).first() + if config: + print(f"Config ID: {config.id}") + print(f"Fitbit Client ID: {'[PRESENT]' if config.fitbit_client_id else '[MISSING]'}") + print(f"Fitbit Client Secret: {'[PRESENT]' if config.fitbit_client_secret else '[MISSING]'}") + print(f"Fitbit Redirect URI: {config.fitbit_redirect_uri}") + else: + print("No Configuration record found.") +except Exception as e: + print(f"Error: {e}") diff --git a/FitnessSync/check_garth_mfa_arg.py b/FitnessSync/scratch/check_garth_mfa_arg.py similarity index 100% rename from FitnessSync/check_garth_mfa_arg.py rename to FitnessSync/scratch/check_garth_mfa_arg.py diff --git a/FitnessSync/scratch/check_tokens.py b/FitnessSync/scratch/check_tokens.py new file mode 100644 index 0000000..70b9882 --- /dev/null +++ b/FitnessSync/scratch/check_tokens.py @@ -0,0 +1,17 @@ +from src.models.api_token import APIToken +from src.services.postgresql_manager import PostgreSQLManager +import os + +print(f"CWD: {os.getcwd()}") +try: + db = PostgreSQLManager().get_db_session() + with db as session: + token = session.query(APIToken).filter_by(token_type="fitbit").first() + if token: + print(f"Token Found: ID={token.id}") + print(f"Access Token: {'[PRESENT]' if token.access_token else '[MISSING]'}") + print(f"Refresh Token: {'[PRESENT]' if token.refresh_token else '[MISSING]'}") + else: + print("No Fitbit token found in DB") +except Exception as e: + print(f"Error: {e}") diff --git a/FitnessSync/debug_garth_connection.py b/FitnessSync/scratch/debug_garth_connection.py similarity index 100% rename from FitnessSync/debug_garth_connection.py rename to FitnessSync/scratch/debug_garth_connection.py diff --git a/FitnessSync/inspect_activity.py b/FitnessSync/scratch/inspect_activity.py similarity index 100% rename from FitnessSync/inspect_activity.py rename to FitnessSync/scratch/inspect_activity.py diff --git a/FitnessSync/scratch/inspect_activity_keys.py b/FitnessSync/scratch/inspect_activity_keys.py new file mode 100644 index 0000000..82a7f75 --- /dev/null +++ b/FitnessSync/scratch/inspect_activity_keys.py @@ -0,0 +1,45 @@ + +import logging +import sys +import os + +# Adjust path to find backend modules +sys.path.append(os.path.abspath("/home/sstent/Projects/FitTrack2/FitnessSync/backend")) + +from src.services.garmin.client import GarminClient +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from src.models import Base +from src.services.postgresql_manager import PostgreSQLManager + +# Mock/Setup DB connection to load tokens +DATABASE_URL = "postgresql://user:password@localhost:5432/fitness_sync" +engine = create_engine(DATABASE_URL) +SessionLocal = sessionmaker(bind=engine) +db = SessionLocal() + +try: + client = GarminClient() + if client.load_tokens(db): + print("Tokens loaded.") + # Fetch 1 activity + activities = client.get_activities('2025-12-01', '2026-01-01') # Adjust dates to find recent ones + if activities: + act = activities[0] + print("\n--- Available Keys in Activity Metadata ---") + for k in sorted(act.keys()): + val = act[k] + # Truncate long values + val_str = str(val) + if len(val_str) > 50: val_str = val_str[:50] + "..." + print(f"{k}: {val_str}") + + print(f"\nTotal keys: {len(act.keys())}") + else: + print("No activities found in range.") + else: + print("Failed to load tokens.") +except Exception as e: + print(f"Error: {e}") +finally: + db.close() diff --git a/FitnessSync/inspect_db_tokens.py b/FitnessSync/scratch/inspect_db_tokens.py similarity index 100% rename from FitnessSync/inspect_db_tokens.py rename to FitnessSync/scratch/inspect_db_tokens.py diff --git a/FitnessSync/inspect_db_tokens_standalone.py b/FitnessSync/scratch/inspect_db_tokens_standalone.py similarity index 100% rename from FitnessSync/inspect_db_tokens_standalone.py rename to FitnessSync/scratch/inspect_db_tokens_standalone.py diff --git a/FitnessSync/scratch/inspect_fitbit_api_bmi.py b/FitnessSync/scratch/inspect_fitbit_api_bmi.py new file mode 100644 index 0000000..42963a9 --- /dev/null +++ b/FitnessSync/scratch/inspect_fitbit_api_bmi.py @@ -0,0 +1,129 @@ +import os +import datetime +from dotenv import load_dotenv + +# Load env vars first +load_dotenv() + +from src.services.postgresql_manager import PostgreSQLManager +from src.services.fitbit_client import FitbitClient +from src.models.api_token import APIToken +from src.models.weight_record import WeightRecord + +# Set DB URL +if not os.environ.get('DATABASE_URL'): + os.environ['DATABASE_URL'] = 'postgresql://postgres:password@localhost:5433/fitbit_garmin_sync' + +def main(): + print("Connecting to DB...") + db = PostgreSQLManager() + with db.get_db_session() as session: + # Get a date with NULL BMI + null_record = session.query(WeightRecord).filter(WeightRecord.bmi == None).first() + if not null_record: + print("No NULL BMI records found.") + return + + date_str = null_record.date.strftime('%Y-%m-%d') + print(f"Checking Fitbit API for date: {date_str} (Existing BMI: {null_record.bmi})") + + # Init Client + token_record = session.query(APIToken).filter_by(token_type='fitbit').first() + if not token_record: + print("No Fitbit token found.") + return + + token_dict = { + 'access_token': token_record.access_token, + 'refresh_token': token_record.refresh_token, + 'expires_at': token_record.expires_at.timestamp() if token_record.expires_at else None, + 'scope': token_record.scopes + } + + from src.utils.config import config + from src.models.config import Configuration + + client_id = config.FITBIT_CLIENT_ID + client_secret = config.FITBIT_CLIENT_SECRET + + # Fallback to DB + if not client_id or not client_secret: + print("Config missing credentials, checking DB...") + db_config = session.query(Configuration).first() + if db_config: + client_id = db_config.fitbit_client_id + client_secret = db_config.fitbit_client_secret + print("Loaded credentials from DB Configuration.") + + if not client_id or not client_secret: + print("ERROR: Could not find Fitbit credentials in Config or DB.") + return + + def refresh_cb(token): + print("DEBUG: Token refreshed!", flush=True) + # In real app we would save to DB here + # Update the client with new token just in case + pass + + client = FitbitClient( + client_id=client_id, + client_secret=client_secret, + redirect_uri=os.environ.get('FITBIT_REDIRECT_URI', 'http://localhost:8000/api/setup/fitbit/callback'), + access_token=token_record.access_token, + refresh_token=token_record.refresh_token, + refresh_cb=refresh_cb + ) + + # Force refresh validation? + # fitbit library calculates expiry. If expired, it refreshes ON REQUEST. + # So making the request should trigger it. + + try: + logs = client.get_weight_logs(date_str, date_str) + print(f"Fetched {len(logs)} logs for {date_str}") + if logs: + print("First log payload:", logs[0]) + if 'bmi' in logs[0]: + print(f"BMI in response: {logs[0]['bmi']}") + else: + print("BMI NOT found in response.") + except Exception as e: + print(f"Error fetching logs: {e}") + # Try manual refresh if library didn't auto-refresh + try: + print("Attempting manual refresh...") + # python-fitbit usually exposes client.fitbit.client.refresh_token + # Token URL: https://api.fitbit.com/oauth2/token + new_token = client.fitbit.client.refresh_token( + 'https://api.fitbit.com/oauth2/token', + refresh_token=token_record.refresh_token, + auth=((client_id, client_secret)) + ) + print("Manual refresh success:", new_token.keys()) + # Retry request + client.fitbit.client.token = new_token + logs = client.get_weight_logs(date_str) + if logs: + print("Retry Payload:", logs[0]) + except Exception as re: + print(f"Manual refresh failed: {re}") + + # Need to refresh likely + # But let's assume valid or client handles it? + # Actually client usually needs active session or refresh. + # The client.get_weight_logs wraps request. + + try: + logs = client.get_weight_logs(date_str) + print(f"Fetched {len(logs)} logs for {date_str}") + if logs: + print("First log payload:", logs[0]) + if 'bmi' in logs[0]: + print(f"BMI in response: {logs[0]['bmi']}") + else: + print("BMI NOT found in response.") + except Exception as e: + print(f"Error fetching logs: {e}") + +if __name__ == "__main__": + main() diff --git a/FitnessSync/scratch/inspect_fitbit_bmi.py b/FitnessSync/scratch/inspect_fitbit_bmi.py new file mode 100644 index 0000000..1402deb --- /dev/null +++ b/FitnessSync/scratch/inspect_fitbit_bmi.py @@ -0,0 +1,39 @@ +import os +from src.services.postgresql_manager import PostgreSQLManager +from src.models.weight_record import WeightRecord +from sqlalchemy import func + +# Set DB URL +if not os.environ.get('DATABASE_URL'): + os.environ['DATABASE_URL'] = 'postgresql://postgres:password@localhost:5433/fitbit_garmin_sync' + +def main(): + print("Connecting to DB...") + db = PostgreSQLManager() + with db.get_db_session() as session: + total = session.query(WeightRecord).count() + + # null bmi + null_bmi = session.query(WeightRecord).filter(WeightRecord.bmi == None).count() + + # zero bmi + zero_bmi = session.query(WeightRecord).filter(WeightRecord.bmi == 0).count() + + # valid bmi + valid_bmi = session.query(WeightRecord).filter(WeightRecord.bmi > 0).count() + + print(f"Total Records: {total}") + print(f"Null BMI: {null_bmi}") + print(f"Zero BMI: {zero_bmi}") + print(f"Valid BMI: {valid_bmi}") + + if valid_bmi > 0: + sample = session.query(WeightRecord).filter(WeightRecord.bmi > 0).first() + print(f"Sample Valid: Date={sample.date}, Weight={sample.weight}, BMI={sample.bmi}") + + if null_bmi > 0: + sample = session.query(WeightRecord).filter(WeightRecord.bmi == None).first() + print(f"Sample Null: Date={sample.date}, Weight={sample.weight}, BMI={sample.bmi}") + +if __name__ == "__main__": + main() diff --git a/FitnessSync/scratch/inspect_garmin_lib.py b/FitnessSync/scratch/inspect_garmin_lib.py new file mode 100644 index 0000000..87df07e --- /dev/null +++ b/FitnessSync/scratch/inspect_garmin_lib.py @@ -0,0 +1,21 @@ + +try: + import garminconnect + print(f"garminconnect version: {getattr(garminconnect, '__version__', 'unknown')}") + from garminconnect import Garmin + + print("\n--- Garmin Class Attributes ---") + for attr in dir(Garmin): + if not attr.startswith("__"): + print(attr) + + if hasattr(Garmin, 'ActivityDownloadFormat'): + print("\n--- Garmin.ActivityDownloadFormat Attributes ---") + for attr in dir(Garmin.ActivityDownloadFormat): + if not attr.startswith("__"): + print(f"{attr}: {getattr(Garmin.ActivityDownloadFormat, attr)}") + else: + print("\nGarmin.ActivityDownloadFormat not found.") + +except Exception as e: + print(f"Error: {e}") diff --git a/FitnessSync/inspect_garth_client.py b/FitnessSync/scratch/inspect_garth_client.py similarity index 100% rename from FitnessSync/inspect_garth_client.py rename to FitnessSync/scratch/inspect_garth_client.py diff --git a/FitnessSync/scratch/inspect_weight_count.py b/FitnessSync/scratch/inspect_weight_count.py new file mode 100644 index 0000000..124ccfe --- /dev/null +++ b/FitnessSync/scratch/inspect_weight_count.py @@ -0,0 +1,49 @@ +from backend.src.services.postgresql_manager import PostgreSQLManager +from backend.src.utils.config import config +from backend.src.models.weight_record import WeightRecord +from backend.src.models.health_metric import HealthMetric +from sqlalchemy import func +import sys + +def check_count(): + print("DEBUG: Connecting to DB...", flush=True) + try: + db_manager = PostgreSQLManager(config.DATABASE_URL) + print("DEBUG: Session factory created.", flush=True) + with db_manager.get_db_session() as session: + print("DEBUG: Session active.", flush=True) + + # Check WeightRecord + try: + wr_count = session.query(func.count(WeightRecord.id)).scalar() + print(f"Total WeightRecord (Legacy?) records: {wr_count}") + except Exception as e: + print(f"Error querying WeightRecord: {e}") + + # Check HealthMetric (Fitbit Weight) + try: + hm_count = session.query(func.count(HealthMetric.id)).filter( + HealthMetric.metric_type == 'weight', + HealthMetric.source == 'fitbit' + ).scalar() + print(f"Total HealthMetric (Fitbit Weight) records: {hm_count}") + except Exception as e: + print(f"Error querying HealthMetric: {e}") + + # Also check top 5 from HealthMetric + print("\nLatest 5 HealthMetric (Fitbit Weight) records:") + latest = session.query(HealthMetric).filter( + HealthMetric.metric_type == 'weight', + HealthMetric.source == 'fitbit' + ).order_by(HealthMetric.date.desc()).limit(5).all() + + for r in latest: + print(f" - {r.date}: {r.metric_value} {r.unit}") + + except Exception as e: + print(f"CRITICAL ERROR: {e}") + import traceback + traceback.print_exc() + +if __name__ == "__main__": + check_count() diff --git a/FitnessSync/scratch/recreate_scheduler_table.py b/FitnessSync/scratch/recreate_scheduler_table.py new file mode 100644 index 0000000..2561c74 --- /dev/null +++ b/FitnessSync/scratch/recreate_scheduler_table.py @@ -0,0 +1,19 @@ + +from src.services.postgresql_manager import PostgreSQLManager +from src.models.base import Base +from src.models.scheduled_job import ScheduledJob +from src.utils.config import config +import logging +from sqlalchemy import text + +if __name__ == "__main__": + logging.basicConfig(level=logging.INFO) + pm = PostgreSQLManager(config.DATABASE_URL) + with pm.get_db_session() as session: + print("Dropping scheduled_jobs table...") + session.execute(text("DROP TABLE IF EXISTS scheduled_jobs")) + session.commit() + + print("Re-creating tables...") + pm.init_db() + print("Done.") diff --git a/FitnessSync/scratch/test_api.py b/FitnessSync/scratch/test_api.py new file mode 100644 index 0000000..527190f --- /dev/null +++ b/FitnessSync/scratch/test_api.py @@ -0,0 +1,30 @@ +import requests +import json + +def test_api(): + url = "http://localhost:8000/api/metrics/query" + params = { + "metric_type": "weight", + "source": "fitbit", + "start_date": "2025-01-01", + "end_date": "2026-01-02", + "limit": 1000 # Try requesting 1000 + } + + try: + response = requests.get(url, params=params) + response.raise_for_status() + data = response.json() + print(f"Status: {response.status_code}") + print(f"Records returned: {len(data)}") + if len(data) < 10: + print("Data preview:", json.dumps(data, indent=2)) + else: + print("First record:", json.dumps(data[0], indent=2)) + print("Last record:", json.dumps(data[-1], indent=2)) + + except Exception as e: + print(f"Error: {e}") + +if __name__ == "__main__": + test_api() diff --git a/FitnessSync/scratch/verify_controls.py b/FitnessSync/scratch/verify_controls.py new file mode 100644 index 0000000..123b651 --- /dev/null +++ b/FitnessSync/scratch/verify_controls.py @@ -0,0 +1,89 @@ + +import requests +import time + +BASE_URL = "http://localhost:8000/api" + +def get_job(job_id): + try: + res = requests.get(f"{BASE_URL}/jobs/active", timeout=5) + active = res.json() + return next((j for j in active if j['id'] == job_id), None) + except: + return None + +def main(): + print("Triggering test job...") + try: + res = requests.post(f"{BASE_URL}/status/test-job", timeout=5) + job_id = res.json()['job_id'] + print(f"Job ID: {job_id}") + except Exception as e: + print(f"FAILURE: Could not trigger job: {e}") + return + + time.sleep(2) + job = get_job(job_id) + if not job: + print("FAILURE: Job not active") + return + print(f"Initial Progress: {job['progress']}%") + + # PAUSE + print("Pausing job...") + requests.post(f"{BASE_URL}/jobs/{job_id}/pause") + time.sleep(1) + + # Check if paused + job = get_job(job_id) + print(f"Status after pause: {job['status']}") + if job['status'] != 'paused': + print("FAILURE: Status is not 'paused'") + + prog_at_pause = job['progress'] + time.sleep(3) + job = get_job(job_id) + print(f"Progress after 3s pause: {job['progress']}%") + + if job['progress'] != prog_at_pause: + print("FAILURE: Job continued running while paused!") + else: + print("SUCCESS: Job paused correctly.") + + # RESUME + print("Resuming job...") + requests.post(f"{BASE_URL}/jobs/{job_id}/resume") + time.sleep(3) + + job = get_job(job_id) + print(f"Status after resume: {job['status']}") + print(f"Progress after resume: {job['progress']}%") + + if job['progress'] > prog_at_pause: + print("SUCCESS: Job resumed and progress advanced.") + else: + print("FAILURE: Job didn't advance after resume.") + + # CANCEL + print("Cancelling job...") + requests.post(f"{BASE_URL}/jobs/{job_id}/cancel") + time.sleep(2) + + # Should be completed/cancelled + # Wait for retention cleanup (10s) + buffer + print("Waiting for retention cleanup (12s)...") + time.sleep(12) + + # Check History + print("Checking History...") + res = requests.get(f"{BASE_URL}/jobs/history") + history = res.json() + + my_job = next((j for j in history if j['id'] == job_id), None) + if my_job: + print(f"SUCCESS: Job found in history. Status: {my_job['status']}") + else: + print("FAILURE: Job not found in history.") + +if __name__ == "__main__": + main() diff --git a/FitnessSync/specs/002-fitbit-garmin-sync/plan.md b/FitnessSync/specs/002-fitbit-garmin-sync/plan.md index 52d891e..632282a 100644 --- a/FitnessSync/specs/002-fitbit-garmin-sync/plan.md +++ b/FitnessSync/specs/002-fitbit-garmin-sync/plan.md @@ -51,22 +51,41 @@ backend/ ├── src/ │ ├── api/ │ │ ├── activities.py +│ │ ├── auth.py # Refactored from setup.py +│ │ ├── config_routes.py # Refactored from setup.py +│ │ ├── logs.py │ │ ├── metrics.py +│ │ ├── scheduling.py +│ │ ├── status.py │ │ └── sync.py │ ├── models/ │ │ ├── activity.py -│ │ └── health_metric.py +│ │ ├── health_metric.py +│ │ ├── job.py +│ │ ├── scheduled_job.py +│ │ ├── sync_log.py +│ │ └── weight_record.py │ └── services/ -│ ├── sync_app.py -│ └── garmin/ -│ └── client.py +│ ├── garmin/ +│ │ ├── auth.py +│ │ ├── client.py +│ │ └── data.py +│ ├── sync/ +│ │ ├── activity.py +│ │ ├── health.py +│ │ └── weight.py +│ ├── fitbit_client.py +│ ├── job_manager.py +│ ├── postgresql_manager.py +│ ├── scheduler.py +│ └── sync_app.py └── tests/ ├── integration/ │ ├── test_sync_flow.py └── unit/ ├── test_api/ │ ├── test_activities.py - │ └── test_metrics.py + │ ├── test_metrics.py └── test_services/ └── test_sync_app.py ```