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

Author: google-labs-jules[bot]

examples/planning/tests/.keep

@@ -0,0 +1,2 @@
+# This file is intentionally left blank.
+# It is used to ensure that the 'tests' directory is tracked by Git.

examples/planning/tests/__init__.py

@@ -0,0 +1,96 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+# Assuming forecast_reach.py is structured to be importable and its main logic is in functions.
+# We might need to adjust this if the script's structure is different.
+# For example, if main() directly calls other functions, we might patch those.
+from examples.planning import forecast_reach
+
+class TestForecastReach(unittest.TestCase):
+
+    @patch('examples.planning.forecast_reach.GoogleAdsClient.load_from_storage')
+    def test_main_forecast_reach(self, mock_load_from_storage):
+        # Mock the GoogleAdsClient and its services
+        mock_google_ads_client = MagicMock()
+        mock_load_from_storage.return_value = mock_google_ads_client
+
+        # Mock the ReachPlanService
+        mock_reach_plan_service = MagicMock()
+        mock_google_ads_client.get_service.return_value = mock_reach_plan_service
+
+        # Mock the responses from ReachPlanService
+        # list_plannable_locations response
+        mock_plannable_locations_response = MagicMock()
+        mock_plannable_locations_response.plannable_locations = [
+            MagicMock(name="Location1", id="123", parent_country_id="321"),
+            MagicMock(name="Location2", id="456", parent_country_id="654")
+        ]
+        # list_plannable_products response
+        mock_plannable_products_response = MagicMock()
+        mock_product_metadata = MagicMock()
+        mock_product_metadata.plannable_product_code = "YOUTUBE_REACH"
+        mock_product_metadata.plannable_product_name = "YouTube Reach"
+        mock_product_metadata.plannable_targeting.age_ranges = [MagicMock(name="AGE_RANGE_18_24")]
+        mock_product_metadata.plannable_targeting.genders = [MagicMock(type_=MagicMock(name="GENDER_FEMALE"))]
+        mock_product_metadata.plannable_targeting.devices = [MagicMock(type_=MagicMock(name="DEVICE_MOBILE"))]
+        mock_plannable_products_response.product_metadata = [mock_product_metadata]
+        # generate_reach_forecast response
+        mock_reach_forecast_response = MagicMock()
+        mock_reach_curve = MagicMock()
+        mock_forecast_point = MagicMock()
+        mock_forecast_point.cost_micros = 10000000 # e.g., 10 units of currency
+        mock_forecast_point.forecast.on_target_reach = 100000
+        mock_forecast_point.forecast.on_target_impressions = 150000
+        mock_forecast_point.forecast.total_reach = 120000
+        mock_forecast_point.forecast.total_impressions = 180000
+        mock_planned_product_reach_forecast = MagicMock()
+        mock_planned_product_reach_forecast.plannable_product_code = "YOUTUBE_REACH"
+        mock_planned_product_reach_forecast.cost_micros = 10000000
+        mock_forecast_point.planned_product_reach_forecasts = [mock_planned_product_reach_forecast]
+        mock_reach_curve.reach_forecasts = [mock_forecast_point]
+        mock_reach_forecast_response.reach_curve = mock_reach_curve
+
+        # Configure side_effects or return_values for service calls
+        mock_reach_plan_service.list_plannable_locations.return_value = mock_plannable_locations_response
+        mock_reach_plan_service.list_plannable_products.return_value = mock_plannable_products_response
+        mock_reach_plan_service.generate_reach_forecast.return_value = mock_reach_forecast_response
+
+        # Mock enums (this might be more complex depending on actual usage)
+        mock_enums = MagicMock()
+        mock_enums.ReachPlanAgeRangeEnum.AGE_RANGE_18_65_UP = "AGE_RANGE_18_65_UP"
+        mock_enums.GenderTypeEnum.FEMALE = "FEMALE"
+        mock_enums.GenderTypeEnum.MALE = "MALE"
+        mock_enums.DeviceEnum.DESKTOP = "DESKTOP"
+        mock_enums.DeviceEnum.MOBILE = "MOBILE"
+        mock_enums.DeviceEnum.TABLET = "TABLET"
+        mock_google_ads_client.enums = mock_enums
+
+        # Call the main function of forecast_reach.py
+        # We need a customer_id for this test
+        test_customer_id = "1234567890"
+
+        # Capture stdout to check output
+        with patch('sys.stdout', new_callable=MagicMock) as mock_stdout:
+            forecast_reach.main(mock_google_ads_client, test_customer_id)
+
+        # Assert that the main logic was called (e.g., services were used)
+        # mock_load_from_storage.assert_called_once_with(version="v19") # This is removed as client is injected
+        mock_google_ads_client.get_service.assert_any_call("ReachPlanService")
+
+        # Assert that the service methods were called
+        mock_reach_plan_service.list_plannable_locations.assert_called_once()
+        mock_reach_plan_service.list_plannable_products.assert_called_once()
+        # generate_reach_forecast is called by request_reach_curve, which is called by forecast_manual_mix
+        mock_reach_plan_service.generate_reach_forecast.assert_called_once()
+
+        # Example assertion on output (very basic, might need more specific checks)
+        # This checks if "Plannable Locations" was printed by show_plannable_locations
+        self.assertTrue(any("Plannable Locations" in call_args[0][0] for call_args in mock_stdout.write.call_args_list if call_args[0]))
+        # This checks if "Plannable Products for Location ID" was printed by show_plannable_products
+        self.assertTrue(any("Plannable Products for Location ID" in call_args[0][0] for call_args in mock_stdout.write.call_args_list if call_args[0]))
+        # This checks if "Currency, Cost, On-Target Reach" header was printed by request_reach_curve
+        self.assertTrue(any("Currency, Cost, On-Target Reach" in call_args[0][0] for call_args in mock_stdout.write.call_args_list if call_args[0]))
+
+
+if __name__ == "__main__":
+    unittest.main()

examples/planning/tests/test_forecast_reach.py

@@ -0,0 +1,67 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from datetime import datetime, timedelta
+
+from examples.planning import generate_forecast_metrics
+
+class TestGenerateForecastMetrics(unittest.TestCase):
+
+    @patch('examples.planning.generate_forecast_metrics.GoogleAdsClient.load_from_storage')
+    def test_main_generate_forecast_metrics(self, mock_load_from_storage):
+        mock_google_ads_client = MagicMock()
+        mock_load_from_storage.return_value = mock_google_ads_client
+
+        mock_keyword_plan_idea_service = MagicMock()
+        mock_google_ads_service = MagicMock()
+
+        # Configure get_service to return the correct mock based on the service name
+        def get_service_side_effect(service_name, version=None):
+            if service_name == "KeywordPlanIdeaService":
+                return mock_keyword_plan_idea_service
+            elif service_name == "GoogleAdsService":
+                return mock_google_ads_service
+            return MagicMock() # Default mock for other services if any
+
+        mock_google_ads_client.get_service.side_effect = get_service_side_effect
+
+        # Mock responses
+        mock_forecast_response = MagicMock()
+        mock_forecast_response.campaign_forecast_metrics.clicks = 100.0
+        mock_forecast_response.campaign_forecast_metrics.impressions = 1000.0
+        mock_forecast_response.campaign_forecast_metrics.average_cpc_micros = 1230000
+        mock_keyword_plan_idea_service.generate_keyword_forecast_metrics.return_value = mock_forecast_response
+
+        # Mock path methods
+        mock_google_ads_service.geo_target_constant_path.return_value = "geoTargetConstants/2840"
+        mock_google_ads_service.language_constant_path.return_value = "languageConstants/1000"
+
+        # Mock enums (adjust as per actual usage in the script)
+        mock_enums = MagicMock()
+        mock_enums.KeywordPlanNetworkEnum.GOOGLE_SEARCH = "GOOGLE_SEARCH"
+        mock_enums.KeywordMatchTypeEnum.BROAD = "BROAD"
+        mock_enums.KeywordMatchTypeEnum.PHRASE = "PHRASE"
+        mock_enums.KeywordMatchTypeEnum.EXACT = "EXACT"
+        mock_google_ads_client.enums = mock_enums
+
+        # Mock types for request construction
+        mock_google_ads_client.get_type.side_effect = lambda name: MagicMock(name=name)
+
+
+        test_customer_id = "1234567890"
+
+        with patch('sys.stdout', new_callable=MagicMock) as mock_stdout:
+            generate_forecast_metrics.main(mock_google_ads_client, test_customer_id)
+
+        # mock_load_from_storage.assert_called_once_with(version="v19") # This is removed as client is injected
+        mock_google_ads_client.get_service.assert_any_call("KeywordPlanIdeaService")
+        mock_google_ads_client.get_service.assert_any_call("GoogleAdsService")
+        mock_keyword_plan_idea_service.generate_keyword_forecast_metrics.assert_called_once()
+
+        # Check if the output contains expected metrics
+        output = "".join(call_args[0][0] for call_args in mock_stdout.write.call_args_list if call_args[0])
+        self.assertIn("Estimated daily clicks: 100.0", output)
+        self.assertIn("Estimated daily impressions: 1000.0", output)
+        self.assertIn("Estimated daily average CPC: 1230000", output)
+
+if __name__ == "__main__":
+    unittest.main()

examples/planning/tests/test_generate_forecast_metrics.py

@@ -0,0 +1,79 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from examples.planning import generate_historical_metrics
+
+class TestGenerateHistoricalMetrics(unittest.TestCase):
+
+    @patch('examples.planning.generate_historical_metrics.GoogleAdsClient.load_from_storage')
+    def test_main_generate_historical_metrics(self, mock_load_from_storage):
+        mock_google_ads_client = MagicMock()
+        mock_load_from_storage.return_value = mock_google_ads_client
+
+        mock_keyword_plan_idea_service = MagicMock()
+        mock_google_ads_service = MagicMock()
+
+        def get_service_side_effect(service_name, version=None):
+            if service_name == "KeywordPlanIdeaService":
+                return mock_keyword_plan_idea_service
+            elif service_name == "GoogleAdsService":
+                return mock_google_ads_service
+            return MagicMock()
+
+        mock_google_ads_client.get_service.side_effect = get_service_side_effect
+
+        # Mock responses
+        mock_historical_response = MagicMock()
+        mock_result = MagicMock()
+        mock_result.text = "mars cruise"
+        mock_result.close_variants = ["mars ship", "mars journey"]
+        mock_result.keyword_metrics.avg_monthly_searches = 1000
+        mock_result.keyword_metrics.competition = "HIGH" # This would be an enum actually
+        mock_result.keyword_metrics.competition_index = 80
+        mock_result.keyword_metrics.low_top_of_page_bid_micros = 1000000
+        mock_result.keyword_metrics.high_top_of_page_bid_micros = 5000000
+
+        mock_monthly_search_volume = MagicMock()
+        mock_monthly_search_volume.year = 2023
+        mock_month_enum = MagicMock()
+        mock_month_enum.name = "JANUARY" # Simulate enum's .name attribute
+        mock_monthly_search_volume.month = mock_month_enum
+        mock_monthly_search_volume.monthly_searches = 1200
+        mock_result.keyword_metrics.monthly_search_volumes = [mock_monthly_search_volume]
+
+        mock_historical_response.results = [mock_result]
+        mock_keyword_plan_idea_service.generate_keyword_historical_metrics.return_value = mock_historical_response
+
+        # Mock path methods
+        mock_google_ads_service.geo_target_constant_path.return_value = "geoTargetConstants/2840"
+        mock_google_ads_service.language_constant_path.return_value = "languageConstants/1000"
+
+        # Mock enums
+        mock_enums = MagicMock()
+        mock_enums.KeywordPlanNetworkEnum.GOOGLE_SEARCH = "GOOGLE_SEARCH"
+        # Assuming competition is an enum, e.g., KeywordPlanCompetitionLevelEnum
+        mock_enums.KeywordPlanCompetitionLevelEnum.HIGH = "HIGH"
+        mock_google_ads_client.enums = mock_enums
+
+        # Mock types for request construction
+        mock_google_ads_client.get_type.side_effect = lambda name: MagicMock(name=name)
+
+        test_customer_id = "1234567890"
+
+        with patch('sys.stdout', new_callable=MagicMock) as mock_stdout:
+            generate_historical_metrics.main(mock_google_ads_client, test_customer_id)
+
+        # mock_load_from_storage.assert_called_once_with(version="v19") # This is removed as client is injected
+        mock_google_ads_client.get_service.assert_any_call("KeywordPlanIdeaService")
+        mock_google_ads_client.get_service.assert_any_call("GoogleAdsService")
+        mock_keyword_plan_idea_service.generate_keyword_historical_metrics.assert_called_once()
+
+        output = "".join(call_args[0][0] for call_args in mock_stdout.write.call_args_list if call_args[0])
+        self.assertIn("The search query 'mars cruise'", output)
+        self.assertIn("Approximate monthly searches: 1000", output)
+        self.assertIn("Competition level: HIGH", output) # This will depend on how enum is converted to string
+        self.assertIn("Approximately 1200 searches in JANUARY, 2023", output)
+
+
+if __name__ == "__main__":
+    unittest.main()