Jules was unable to complete the task in time. Please review the work done so far and provide feedback for Jules to continue.

google-labs-jules[bot] · google-labs-jules[bot] · commit 97e4b6329628 · 2025-05-29T15:45:18.000Z
diff --git a/examples/planning/tests/.keep b/examples/planning/tests/.keep
@@ -0,0 +1 @@
+# This file is used to ensure the directory is tracked by Git.
diff --git a/examples/planning/tests/__init__.py b/examples/planning/tests/__init__.py
@@ -0,0 +1 @@
+# This file intentionally left blank.
diff --git a/examples/planning/tests/test_forecast_reach.py b/examples/planning/tests/test_forecast_reach.py
@@ -0,0 +1,177 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from google.ads.googleads.client import GoogleAdsClient
+
+# Assuming forecast_reach is importable, otherwise, we might need to adjust sys.path
+# For now, let's assume it's in the python path or PYTHONPATH is set up correctly
+# If not, we might need:
+# import sys
+# import os
+# SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+# PROJECT_ROOT = os.path.dirname(os.path.dirname(SCRIPT_DIR)) # Adjust based on actual structure
+# sys.path.insert(0, PROJECT_ROOT)
+from examples.planning import forecast_reach
+
+
+class TestForecastReach(unittest.TestCase):
+
+    MOCK_CUSTOMER_ID = "1234567890"
+    MOCK_LOCATION_ID = "2840"  # US
+    MOCK_CURRENCY_CODE = "USD"
+
+    @patch("examples.planning.forecast_reach.GoogleAdsClient.load_from_storage")
+    def test_main_flow(self, mock_load_client):
+        # Mock the client and service
+        mock_google_ads_client = MagicMock(spec=GoogleAdsClient)
+        mock_reach_plan_service = MagicMock()
+        mock_google_ads_client.get_service.return_value = mock_reach_plan_service
+        mock_load_client.return_value = mock_google_ads_client
+
+        # Call the main function with mocks
+        # We need to simulate the behavior of the main function's internal calls.
+        # The forecast_reach.py script's main calls other functions within it.
+        # We will test these functions more directly.
+
+        # --- Test show_plannable_locations ---
+        forecast_reach.show_plannable_locations(mock_reach_plan_service)
+        mock_reach_plan_service.list_plannable_locations.assert_called_once()
+
+        # Reset mock for the next call if necessary (though for different functions, it's fine)
+        mock_reach_plan_service.reset_mock()
+
+        # --- Test show_plannable_products ---
+        forecast_reach.show_plannable_products(
+            mock_reach_plan_service, self.MOCK_LOCATION_ID
+        )
+        mock_reach_plan_service.list_plannable_products.assert_called_once_with(
+            plannable_location_id=self.MOCK_LOCATION_ID
+        )
+        mock_reach_plan_service.reset_mock()
+
+        # --- Test forecast_manual_mix (which calls request_reach_curve) ---
+        # This is the most complex part due to the request construction.
+        # We need to ensure generate_reach_forecast is called with the correct structure.
+
+        # Mock the response for generate_reach_forecast to avoid issues if it expects a return
+        mock_reach_plan_service.generate_reach_forecast.return_value = MagicMock()
+
+        forecast_reach.forecast_manual_mix(
+            mock_google_ads_client, # main function passes the client
+            mock_reach_plan_service,
+            self.MOCK_CUSTOMER_ID,
+            self.MOCK_LOCATION_ID,
+            self.MOCK_CURRENCY_CODE,
+            5000000  # budget_micros
+        )
+
+        self.assertEqual(mock_load_client.call_args[1]["version"], "v19")
+        mock_google_ads_client.get_service.assert_called_with("ReachPlanService", version="v19")
+
+        # Assert generate_reach_forecast was called
+        mock_reach_plan_service.generate_reach_forecast.assert_called_once()
+        
+        # Get the actual request passed to generate_reach_forecast
+        call_args = mock_reach_plan_service.generate_reach_forecast.call_args
+        request = call_args[1]['request'] # request is a keyword argument
+
+        self.assertEqual(request.customer_id, self.MOCK_CUSTOMER_ID)
+        self.assertEqual(request.campaign_duration.duration_micros, 28 * 24 * 60 * 60 * 1000000) # 28 days in micros
+        self.assertEqual(request.currency_code, self.MOCK_CURRENCY_CODE)
+        self.assertEqual(request.targeting.plannable_location_id, self.MOCK_LOCATION_ID)
+        
+        # Check planned_products (simplified check for brevity, real one would be more detailed)
+        self.assertEqual(len(request.planned_products), 2)
+        # Product 1: TrueView
+        self.assertEqual(request.planned_products[0].plannable_product_code, "TRUEVIEW_IN_STREAM")
+        self.assertEqual(request.planned_products[0].budget_micros, 3500000) # 70% of 5000000
+        # Product 2: Bumper
+        self.assertEqual(request.planned_products[1].plannable_product_code, "BUMPER")
+        self.assertEqual(request.planned_products[1].budget_micros, 1500000) # 30% of 5000000
+
+        # Check targeting details
+        # Age ranges
+        self.assertTrue(any(age.age_range == forecast_reach.AgeRangeEnum.AGE_RANGE_18_24 for age in request.targeting.age_ranges))
+        self.assertTrue(any(age.age_range == forecast_reach.AgeRangeEnum.AGE_RANGE_25_34 for age in request.targeting.age_ranges))
+        
+        # Genders
+        self.assertTrue(any(gender.type == forecast_reach.GenderTypeEnum.FEMALE for gender in request.targeting.genders))
+        self.assertTrue(any(gender.type == forecast_reach.GenderTypeEnum.MALE for gender in request.targeting.genders))
+
+        # Devices
+        self.assertTrue(any(device.type == forecast_reach.DeviceEnum.DESKTOP for device in request.targeting.devices))
+        self.assertTrue(any(device.type == forecast_reach.DeviceEnum.MOBILE for device in request.targeting.devices))
+        self.assertTrue(any(device.type == forecast_reach.DeviceEnum.TABLET for device in request.targeting.devices))
+
+    # The main function in forecast_reach.py is `main(client, customer_id)`.
+    # We need to test this main entry point as well.
+    @patch("examples.planning.forecast_reach.GoogleAdsClient.load_from_storage")
+    @patch("examples.planning.forecast_reach.show_plannable_locations")
+    @patch("examples.planning.forecast_reach.show_plannable_products")
+    @patch("examples.planning.forecast_reach.forecast_manual_mix") # Actually calls forecast_reach_curve internally
+    @patch("examples.planning.forecast_reach.forecast_suggested_mix")
+    def test_main_function_calls(self, 
+                                 mock_forecast_suggested_mix,
+                                 mock_forecast_manual_mix,
+                                 mock_show_plannable_products,
+                                 mock_show_plannable_locations,
+                                 mock_load_client):
+
+        mock_google_ads_client = MagicMock(spec=GoogleAdsClient)
+        mock_reach_plan_service = MagicMock()
+        mock_google_ads_client.get_service.return_value = mock_reach_plan_service
+        mock_load_client.return_value = mock_google_ads_client
+        
+        # Call the actual main function from the script
+        forecast_reach.main(mock_google_ads_client, self.MOCK_CUSTOMER_ID)
+
+        # Assertions
+        mock_load_client.assert_called_once() # Check if load_from_storage was called by the script's main
+        self.assertEqual(mock_load_client.call_args[1]["version"], "v19")
+
+        mock_google_ads_client.get_service.assert_called_with("ReachPlanService", version="v19")
+
+        # Check that the helper functions were called by main
+        mock_show_plannable_locations.assert_called_once_with(mock_reach_plan_service)
+        
+        # The example script calls show_plannable_products with a hardcoded location_id if not provided
+        # We need to ensure our test uses the same assumptions or mocks appropriately.
+        # The script uses _DEFAULT_LOCATION as "2840" (US)
+        _DEFAULT_LOCATION = "2840" # from forecast_reach.py
+        _DEFAULT_CURRENCY_CODE = "USD" # from forecast_reach.py
+        _DEFAULT_BUDGET_MICROS = 5_000_000 # from forecast_reach.py
+
+
+        mock_show_plannable_products.assert_called_once_with(
+            mock_reach_plan_service, _DEFAULT_LOCATION
+        )
+        
+        mock_forecast_manual_mix.assert_called_once_with(
+            mock_google_ads_client,
+            mock_reach_plan_service,
+            self.MOCK_CUSTOMER_ID,
+            _DEFAULT_LOCATION,
+            _DEFAULT_CURRENCY_CODE,
+            _DEFAULT_BUDGET_MICROS,
+        )
+
+        # forecast_suggested_mix is also called in the original script's main
+        mock_forecast_suggested_mix.assert_called_once_with(
+            mock_google_ads_client,
+            mock_reach_plan_service,
+            self.MOCK_CUSTOMER_ID,
+            _DEFAULT_LOCATION,
+            _DEFAULT_CURRENCY_CODE,
+            _DEFAULT_BUDGET_MICROS,
+            # The following preferences are hardcoded in the example script's main
+            # when calling forecast_suggested_mix
+            is_trueview_ad_format_enabled=True,
+            is_bumper_ad_format_enabled=True,
+            is_in_stream_selectable_ad_format_enabled=False,
+            is_out_stream_selectable_ad_format_enabled=False,
+            is_non_skippable_ad_format_enabled=False
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/examples/planning/tests/test_generate_forecast_metrics.py b/examples/planning/tests/test_generate_forecast_metrics.py
@@ -0,0 +1,133 @@
+import unittest
+from unittest.mock import patch, MagicMock, call
+from datetime import datetime, timedelta
+
+from google.ads.googleads.client import GoogleAdsClient
+from google.ads.googleads.v19.enums.types import keyword_plan_network as keyword_plan_network_enum
+from google.ads.googleads.v19.enums.types import keyword_match_type as keyword_match_type_enum
+
+# Assuming generate_forecast_metrics is importable
+from examples.planning import generate_forecast_metrics
+
+
+class TestGenerateForecastMetrics(unittest.TestCase):
+
+    MOCK_CUSTOMER_ID = "1234567890"
+
+    @patch("examples.planning.generate_forecast_metrics.GoogleAdsClient.load_from_storage")
+    def test_main_execution(self, mock_load_client):
+        # Mock GoogleAdsClient and its services
+        mock_google_ads_client = MagicMock(spec=GoogleAdsClient)
+        mock_keyword_plan_idea_service = MagicMock()
+        mock_google_ads_service = MagicMock() # Though not directly used by the forecast part, main might get it.
+
+        mock_google_ads_client.get_service.side_effect = lambda service_name, version: {
+            "KeywordPlanIdeaService": mock_keyword_plan_idea_service,
+            "GoogleAdsService": mock_google_ads_service,
+        }[service_name]
+        
+        mock_load_client.return_value = mock_google_ads_client
+
+        # Call the main function
+        generate_forecast_metrics.main(mock_google_ads_client, self.MOCK_CUSTOMER_ID)
+
+        # 1. Assert GoogleAdsClient.load_from_storage was called
+        mock_load_client.assert_called_once_with(version="v19")
+
+        # 2. Assert client.get_service was called for KeywordPlanIdeaService
+        # and potentially GoogleAdsService if main uses it.
+        # The script uses get_service for KeywordPlanIdeaService for the core logic.
+        # It doesn't appear to use GoogleAdsService directly in the forecasting part.
+        mock_google_ads_client.get_service.assert_any_call("KeywordPlanIdeaService", version="v19")
+        # Check if GoogleAdsService was also requested if it's part of main's setup
+        # According to generate_forecast_metrics.py, GoogleAdsService is not explicitly fetched in main.
+
+        # 3. Verify the call to keyword_plan_idea_service.generate_keyword_forecast_metrics()
+        mock_keyword_plan_idea_service.generate_keyword_forecast_metrics.assert_called_once()
+        
+        # Get the actual request passed to generate_keyword_forecast_metrics
+        call_args = mock_keyword_plan_idea_service.generate_keyword_forecast_metrics.call_args
+        request = call_args[1]['request'] # request is a keyword argument or use call_args[0][0] if positional
+
+        # Verify customer_id in the request
+        self.assertEqual(request.customer_id, self.MOCK_CUSTOMER_ID)
+
+        # Verify forecast_period
+        # Dates are based on the day the test runs.
+        tomorrow = datetime.now().date() + timedelta(days=1)
+        thirty_days_from_tomorrow = tomorrow + timedelta(days=30)
+        
+        self.assertEqual(request.forecast_period.start_date.year, tomorrow.year)
+        self.assertEqual(request.forecast_period.start_date.month, tomorrow.month)
+        self.assertEqual(request.forecast_period.start_date.day, tomorrow.day)
+        
+        self.assertEqual(request.forecast_period.end_date.year, thirty_days_from_tomorrow.year)
+        self.assertEqual(request.forecast_period.end_date.month, thirty_days_from_tomorrow.month)
+        self.assertEqual(request.forecast_period.end_date.day, thirty_days_from_tomorrow.day)
+
+        # Verify CampaignToForecast object (implicitly tests create_campaign_to_forecast)
+        campaign_to_forecast = request.campaign_to_forecast
+        
+        self.assertEqual(
+            campaign_to_forecast.keyword_plan_network,
+            keyword_plan_network_enum.KeywordPlanNetworkEnum.KeywordPlanNetwork.GOOGLE_SEARCH
+        )
+        self.assertIsNotNone(campaign_to_forecast.bidding_strategy)
+        self.assertEqual(campaign_to_forecast.bidding_strategy.max_cpc_bid_ceiling_micros, 1_000_000) # Default from script
+
+        # Geo modifiers (Location)
+        self.assertEqual(len(campaign_to_forecast.geo_modifiers), 1)
+        # From the script: _GEO_TARGET_CONSTANT_US = "geoTargetConstants/2840"
+        self.assertEqual(campaign_to_forecast.geo_modifiers[0].geo_target_constant, "geoTargetConstants/2840")
+
+        # Language constant
+        self.assertEqual(len(campaign_to_forecast.language_constants), 1)
+        # From the script: _LANGUAGE_CONSTANT_EN = "languageConstants/1000"
+        self.assertEqual(campaign_to_forecast.language_constants[0], "languageConstants/1000")
+
+        # Ad Groups and Keywords
+        self.assertEqual(len(campaign_to_forecast.ad_groups), 2)
+
+        # Ad Group 1
+        ad_group1 = campaign_to_forecast.ad_groups[0]
+        self.assertEqual(ad_group1.max_cpc_bid_micros, 2_500_000) # Default from script
+        
+        # Biddable Keywords for Ad Group 1
+        # From script: ("mars cruise", BROAD), ("cheap cruise", PHRASE), ("jupiter cruise", EXACT)
+        self.assertEqual(len(ad_group1.biddable_keywords), 3)
+        self.assertEqual(ad_group1.biddable_keywords[0].keyword.text, "mars cruise")
+        self.assertEqual(ad_group1.biddable_keywords[0].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.BROAD)
+        self.assertEqual(ad_group1.biddable_keywords[1].keyword.text, "cheap cruise")
+        self.assertEqual(ad_group1.biddable_keywords[1].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.PHRASE)
+        self.assertEqual(ad_group1.biddable_keywords[2].keyword.text, "jupiter cruise")
+        self.assertEqual(ad_group1.biddable_keywords[2].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.EXACT)
+
+        # Negative Keywords for Ad Group 1
+        # From script: ("moon walk", BROAD)
+        self.assertEqual(len(ad_group1.negative_keywords), 1)
+        self.assertEqual(ad_group1.negative_keywords[0].text, "moon walk")
+        self.assertEqual(ad_group1.negative_keywords[0].match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.BROAD)
+        
+        # Ad Group 2
+        ad_group2 = campaign_to_forecast.ad_groups[1]
+        self.assertEqual(ad_group2.max_cpc_bid_micros, 1_990_000) # Default from script
+
+        # Biddable Keywords for Ad Group 2
+        # From script: ("saturn cruise", BROAD), ("expensive cruise", PHRASE), ("mercury cruise", EXACT)
+        self.assertEqual(len(ad_group2.biddable_keywords), 3)
+        self.assertEqual(ad_group2.biddable_keywords[0].keyword.text, "saturn cruise")
+        self.assertEqual(ad_group2.biddable_keywords[0].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.BROAD)
+        self.assertEqual(ad_group2.biddable_keywords[1].keyword.text, "expensive cruise")
+        self.assertEqual(ad_group2.biddable_keywords[1].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.PHRASE)
+        self.assertEqual(ad_group2.biddable_keywords[2].keyword.text, "mercury cruise")
+        self.assertEqual(ad_group2.biddable_keywords[2].keyword.match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.EXACT)
+
+        # Negative Keywords for Ad Group 2
+        # From script: ("venus walk", BROAD)
+        self.assertEqual(len(ad_group2.negative_keywords), 1)
+        self.assertEqual(ad_group2.negative_keywords[0].text, "venus walk")
+        self.assertEqual(ad_group2.negative_keywords[0].match_type, keyword_match_type_enum.KeywordMatchTypeEnum.KeywordMatchType.BROAD)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/examples/planning/tests/test_generate_historical_metrics.py b/examples/planning/tests/test_generate_historical_metrics.py
diff --git a/examples/planning/tests/test_generate_keyword_ideas.py b/examples/planning/tests/test_generate_keyword_ideas.py

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+# This file is used to ensure the directory is tracked by Git.`