Continue standardizing on mock_response_factory

- Update more test files to consistently use mock_response_factory:
  - nutrition/test_get_food_locales.py
  - nutrition/test_get_food_units.py
  - body_timeseries/test_get_body_timeseries_by_date_range.py
  - nutrition/test_get_recent_foods.py
  - nutrition/test_get_favorite_foods.py
  - activity_timeseries/test_get_activity_timeseries_by_date_range.py
  - active_zone_minutes/test_get_azm_timeseries_by_interval.py
  - nutrition/test_get_meal.py
  - nutrition/test_update_meal.py

This continues the standardization effort to ensure consistent usage of mock_response_factory throughout the test suite.

Author: jpstroop

tests/fitbit_client/resources/active_zone_minutes/test_get_azm_timeseries_by_interval.py

@@ -16,29 +16,32 @@
 from fitbit_client.exceptions import InvalidDateRangeException
 
 
-def test_get_azm_timeseries_by_interval_success(azm_resource, mock_response):
+def test_get_azm_timeseries_by_interval_success(azm_resource, mock_response_factory):
     """Test successful retrieval of AZM time series by date range"""
-    mock_response.json.return_value = {
-        "activities-active-zone-minutes": [
-            {
-                "dateTime": "2025-02-01",
-                "value": {
-                    "activeZoneMinutes": 102,
-                    "fatBurnActiveZoneMinutes": 90,
-                    "cardioActiveZoneMinutes": 8,
-                    "peakActiveZoneMinutes": 4,
+    mock_response = mock_response_factory(
+        200,
+        {
+            "activities-active-zone-minutes": [
+                {
+                    "dateTime": "2025-02-01",
+                    "value": {
+                        "activeZoneMinutes": 102,
+                        "fatBurnActiveZoneMinutes": 90,
+                        "cardioActiveZoneMinutes": 8,
+                        "peakActiveZoneMinutes": 4,
+                    },
                 },
-            },
-            {
-                "dateTime": "2025-02-02",
-                "value": {
-                    "activeZoneMinutes": 47,
-                    "fatBurnActiveZoneMinutes": 43,
-                    "cardioActiveZoneMinutes": 4,
+                {
+                    "dateTime": "2025-02-02",
+                    "value": {
+                        "activeZoneMinutes": 47,
+                        "fatBurnActiveZoneMinutes": 43,
+                        "cardioActiveZoneMinutes": 4,
+                    },
                 },
-            },
-        ]
-    }
+            ]
+        },
+    )
     azm_resource.oauth.request.return_value = mock_response
     result = azm_resource.get_azm_timeseries_by_interval(
         start_date="2025-02-01", end_date="2025-02-02"
@@ -54,9 +57,9 @@ def test_get_azm_timeseries_by_interval_success(azm_resource, mock_response):
     )
 
 
-def test_get_azm_timeseries_by_interval_with_user_id(azm_resource, mock_response):
+def test_get_azm_timeseries_by_interval_with_user_id(azm_resource, mock_response_factory):
     """Test getting AZM time series by date range for a specific user"""
-    mock_response.json.return_value = {"activities-active-zone-minutes": []}
+    mock_response = mock_response_factory(200, {"activities-active-zone-minutes": []})
     azm_resource.oauth.request.return_value = mock_response
     result = azm_resource.get_azm_timeseries_by_interval(
         start_date="2025-02-01", end_date="2025-02-02", user_id="123ABC"

tests/fitbit_client/resources/activity_timeseries/test_get_activity_timeseries_by_date.py

@@ -13,11 +13,13 @@
 from fitbit_client.resources._constants import Period
 
 
-def test_get_activity_timeseries_by_date_success(activity_timeseries_resource, mock_response):
+def test_get_activity_timeseries_by_date_success(
+    activity_timeseries_resource, mock_response_factory
+):
     """Test successful retrieval of activity time series by date"""
-    mock_response.json.return_value = {
-        "activities-steps": [{"dateTime": "2024-02-01", "value": "10000"}]
-    }
+    mock_response = mock_response_factory(
+        200, {"activities-steps": [{"dateTime": "2024-02-01", "value": "10000"}]}
+    )
     activity_timeseries_resource.oauth.request.return_value = mock_response
     result = activity_timeseries_resource.get_activity_timeseries_by_date(
         resource_path=ActivityTimeSeriesPath.STEPS, date="2024-02-01", period=Period.ONE_DAY
@@ -33,9 +35,11 @@ def test_get_activity_timeseries_by_date_success(activity_timeseries_resource, m
     )
 
 
-def test_get_activity_timeseries_by_date_with_user_id(activity_timeseries_resource, mock_response):
+def test_get_activity_timeseries_by_date_with_user_id(
+    activity_timeseries_resource, mock_response_factory
+):
     """Test getting time series for a specific user"""
-    mock_response.json.return_value = {"activities-steps": []}
+    mock_response = mock_response_factory(200, {"activities-steps": []})
     activity_timeseries_resource.oauth.request.return_value = mock_response
     result = activity_timeseries_resource.get_activity_timeseries_by_date(
         resource_path=ActivityTimeSeriesPath.STEPS,
@@ -68,13 +72,16 @@ def test_get_activity_timeseries_by_date_invalid_date(activity_timeseries_resour
 # Local imports
 
 
-def test_calories_variants(activity_timeseries_resource, mock_response):
+def test_calories_variants(activity_timeseries_resource, mock_response_factory):
     """Test different calorie measurement types return expected data"""
-    mock_response.json.return_value = {
-        "activities-activityCalories": [{"dateTime": "2024-02-01", "value": "300"}],
-        "activities-calories": [{"dateTime": "2024-02-01", "value": "2000"}],
-        "activities-caloriesBMR": [{"dateTime": "2024-02-01", "value": "1700"}],
-    }
+    mock_response = mock_response_factory(
+        200,
+        {
+            "activities-activityCalories": [{"dateTime": "2024-02-01", "value": "300"}],
+            "activities-calories": [{"dateTime": "2024-02-01", "value": "2000"}],
+            "activities-caloriesBMR": [{"dateTime": "2024-02-01", "value": "1700"}],
+        },
+    )
     activity_timeseries_resource.oauth.request.return_value = mock_response
     calorie_types = [
         ActivityTimeSeriesPath.ACTIVITY_CALORIES,

tests/fitbit_client/resources/activity_timeseries/test_get_activity_timeseries_by_date_range.py

@@ -14,14 +14,19 @@
 from fitbit_client.resources._constants import ActivityTimeSeriesPath
 
 
-def test_get_activity_timeseries_by_date_range_success(activity_timeseries_resource, mock_response):
+def test_get_activity_timeseries_by_date_range_success(
+    activity_timeseries_resource, mock_response_factory
+):
     """Test successful retrieval of activity time series by date range"""
-    mock_response.json.return_value = {
-        "activities-steps": [
-            {"dateTime": "2024-02-01", "value": "10000"},
-            {"dateTime": "2024-02-02", "value": "12000"},
-        ]
-    }
+    mock_response = mock_response_factory(
+        200,
+        {
+            "activities-steps": [
+                {"dateTime": "2024-02-01", "value": "10000"},
+                {"dateTime": "2024-02-02", "value": "12000"},
+            ]
+        },
+    )
     activity_timeseries_resource.oauth.request.return_value = mock_response
     result = activity_timeseries_resource.get_activity_timeseries_by_date_range(
         resource_path=ActivityTimeSeriesPath.STEPS, start_date="2024-02-01", end_date="2024-02-02"
@@ -43,10 +48,10 @@ def test_get_activity_timeseries_by_date_range_success(activity_timeseries_resou
 
 
 def test_get_activity_timeseries_by_date_range_with_user_id(
-    activity_timeseries_resource, mock_response
+    activity_timeseries_resource, mock_response_factory
 ):
     """Test getting time series by date range for a specific user"""
-    mock_response.json.return_value = {"activities-steps": []}
+    mock_response = mock_response_factory(200, {"activities-steps": []})
     activity_timeseries_resource.oauth.request.return_value = mock_response
     result = activity_timeseries_resource.get_activity_timeseries_by_date_range(
         resource_path=ActivityTimeSeriesPath.STEPS,

tests/fitbit_client/resources/body_timeseries/test_get_body_timeseries_by_date_range.py

@@ -54,11 +54,13 @@ def test_get_body_timeseries_by_date_range_max_days(body_timeseries):
             )
 
 
-def test_get_body_timeseries_by_date_range_makes_correct_request(body_timeseries, mock_response):
+def test_get_body_timeseries_by_date_range_makes_correct_request(
+    body_timeseries, mock_response_factory
+):
     """Test that the correct endpoint is called with proper parameters."""
     # Set up the mock response
+    mock_response = mock_response_factory(200, {"expected": "response"})
     body_timeseries.oauth.request.return_value = mock_response
-    mock_response.json.return_value = {"expected": "response"}
 
     # Call the method with valid parameters that don't exceed range limits
     result = body_timeseries.get_body_timeseries_by_date_range(

tests/fitbit_client/resources/body_timeseries/test_get_bodyfat_timeseries_by_date.py

@@ -36,11 +36,13 @@ def test_get_bodyfat_timeseries_by_date_period_validation(body_timeseries):
         assert f"Period {period.value} not supported for body fat" in str(exc_info.value)
 
 
-def test_get_bodyfat_timeseries_by_date_makes_correct_request(body_timeseries, mock_response):
+def test_get_bodyfat_timeseries_by_date_makes_correct_request(
+    body_timeseries, mock_response_factory
+):
     """Test that the correct endpoint is called with proper parameters."""
     # Set up the mock response
+    mock_response = mock_response_factory(200, {"expected": "response"})
     body_timeseries.oauth.request.return_value = mock_response
-    mock_response.json.return_value = {"expected": "response"}
 
     # Call the method
     result = body_timeseries.get_bodyfat_timeseries_by_date(

tests/fitbit_client/resources/body_timeseries/test_get_bodyfat_timeseries_by_date_range.py

@@ -42,11 +42,13 @@ def test_get_bodyfat_timeseries_by_date_range_max_days(body_timeseries):
     assert "body fat" in str(exc_info.value)
 
 
-def test_get_bodyfat_timeseries_by_date_range_makes_correct_request(body_timeseries, mock_response):
+def test_get_bodyfat_timeseries_by_date_range_makes_correct_request(
+    body_timeseries, mock_response_factory
+):
     """Test that the correct endpoint is called with proper parameters."""
     # Set up the mock response
+    mock_response = mock_response_factory(200, {"expected": "response"})
     body_timeseries.oauth.request.return_value = mock_response
-    mock_response.json.return_value = {"expected": "response"}
 
     # Call the method with a valid date range (under 30 days)
     result = body_timeseries.get_bodyfat_timeseries_by_date_range(

tests/fitbit_client/resources/heartrate_timeseries/test_get_heartrate_timeseries_by_date_range.py

@@ -13,15 +13,15 @@
 from fitbit_client.exceptions import ParameterValidationException
 
 
-def test_get_heartrate_timeseries_by_date_range_success(heartrate_resource, mock_response):
+def test_get_heartrate_timeseries_by_date_range_success(heartrate_resource, mock_response_factory):
     """Test successful retrieval of heart rate data by date range"""
     response_data = {
         "activities-heart": [
             {"dateTime": "2024-02-10", "value": {"restingHeartRate": 65, "heartRateZones": []}},
             {"dateTime": "2024-02-11", "value": {"restingHeartRate": 68, "heartRateZones": []}},
         ]
     }
-    mock_response.json.return_value = response_data
+    mock_response = mock_response_factory(200, response_data)
     heartrate_resource.oauth.request.return_value = mock_response
     result = heartrate_resource.get_heartrate_timeseries_by_date_range(
         start_date="2024-02-10", end_date="2024-02-11"
@@ -37,9 +37,9 @@ def test_get_heartrate_timeseries_by_date_range_success(heartrate_resource, mock
     )
 
 
-def test_get_heartrate_timeseries_by_date_range_today(heartrate_resource, mock_response):
+def test_get_heartrate_timeseries_by_date_range_today(heartrate_resource, mock_response_factory):
     """Test that 'today' is accepted in date range"""
-    mock_response.json.return_value = {"activities-heart": []}
+    mock_response = mock_response_factory(200, {"activities-heart": []})
     heartrate_resource.oauth.request.return_value = mock_response
     result = heartrate_resource.get_heartrate_timeseries_by_date_range(
         start_date="today", end_date="today"

tests/fitbit_client/resources/nutrition/test_get_favorite_foods.py

@@ -3,11 +3,11 @@
 """Tests for the get_favorite_foods endpoint."""
 
 
-def test_get_favorite_foods_success(nutrition_resource, mock_response):
+def test_get_favorite_foods_success(nutrition_resource, mock_response_factory):
     """Test successful retrieval of favorite foods"""
-    mock_response.json.return_value = [
-        {"foodId": 12345, "name": "Test Food", "defaultServingSize": 100.0, "calories": 100}
-    ]
+    mock_response = mock_response_factory(
+        200, [{"foodId": 12345, "name": "Test Food", "defaultServingSize": 100.0, "calories": 100}]
+    )
     nutrition_resource.oauth.request.return_value = mock_response
     result = nutrition_resource.get_favorite_foods()
     assert result == mock_response.json.return_value

tests/fitbit_client/resources/nutrition/test_get_food_locales.py

@@ -3,12 +3,15 @@
 """Tests for the get_food_locales endpoint."""
 
 
-def test_get_food_locales_success(nutrition_resource, mock_response):
+def test_get_food_locales_success(nutrition_resource, mock_response_factory):
     """Test successful retrieval of food locales"""
-    mock_response.json.return_value = [
-        {"value": "en_US", "label": "United States"},
-        {"value": "en_GB", "label": "United Kingdom"},
-    ]
+    mock_response = mock_response_factory(
+        200,
+        [
+            {"value": "en_US", "label": "United States"},
+            {"value": "en_GB", "label": "United Kingdom"},
+        ],
+    )
     nutrition_resource.oauth.request.return_value = mock_response
     result = nutrition_resource.get_food_locales()
     assert result == mock_response.json.return_value

tests/fitbit_client/resources/nutrition/test_get_food_log.py

@@ -11,12 +11,15 @@
 from fitbit_client.exceptions import InvalidDateException
 
 
-def test_get_food_log_success(nutrition_resource, mock_response):
+def test_get_food_log_success(nutrition_resource, mock_response_factory):
     """Test successful retrieval of food log entries"""
-    mock_response.json.return_value = {
-        "foods": [{"logId": 12345, "loggedFood": {"foodId": 67890, "amount": 100.0}}],
-        "summary": {"calories": 500},
-    }
+    mock_response = mock_response_factory(
+        200,
+        {
+            "foods": [{"logId": 12345, "loggedFood": {"foodId": 67890, "amount": 100.0}}],
+            "summary": {"calories": 500},
+        },
+    )
     nutrition_resource.oauth.request.return_value = mock_response
     result = nutrition_resource.get_food_log(date="2025-02-08")
     assert result == mock_response.json.return_value
@@ -36,9 +39,8 @@ def test_get_food_log_invalid_date(nutrition_resource):
         nutrition_resource.get_food_log("invalid-date")
 
 
-def test_get_food_log_allows_today(nutrition_resource, mock_response):
+def test_get_food_log_allows_today(nutrition_resource, mock_response_factory):
     """Test that 'today' is accepted as a valid date"""
-    mock_response.json.return_value = {"foods": []}
-    mock_response.headers = {"content-type": "application/json"}
+    mock_response = mock_response_factory(200, {"foods": []})
     nutrition_resource.oauth.request.return_value = mock_response
     nutrition_resource.get_food_log("today")