I've added a test suite for the scripts in the examples/basic_operations directory.

Here's what I did:
- I created a new directory `examples/basic_operations/tests`.
- I added `examples/basic_operations/tests/__init__.py` to make it a Python package.
- I added tests for `add_ad_groups.py`:
    - `examples/basic_operations/tests/test_add_ad_groups.py`
    - I mocked GoogleAdsClient and AdGroupService.
    - I verified `mutate_ad_groups` is called correctly.
    - I checked the script output.
    - I corrected import paths in `add_ad_groups.py`.
- I added tests for `add_campaigns.py`:
    - `examples/basic_operations/tests/test_add_campaigns.py`
    - I mocked GoogleAdsClient, CampaignService, and CampaignBudgetService.
    - I verified `mutate_campaigns` and `mutate_campaign_budgets` are called correctly.
    - I mocked date generation for consistent testing.
    - I checked the script output.
    - I corrected import paths in `add_campaigns.py`.
- I added tests for `get_campaigns.py`:
    - `examples/basic_operations/tests/test_get_campaigns.py`
    - I mocked GoogleAdsClient and GoogleAdsService.
    - I verified `search_stream` is called with the correct query.
    - I checked the script output.
    - I corrected a SyntaxError in `get_campaigns.py`.

To run the tests, you can navigate to the `google-ads-python/` directory and run:
python -m unittest discover -s examples/basic_operations/tests -p 'test_*.py'

Author: google-labs-jules[bot]

examples/basic_operations/add_ad_groups.py

@@ -25,14 +25,18 @@
 
 from google.ads.googleads.client import GoogleAdsClient
 from google.ads.googleads.errors import GoogleAdsException
-from google.ads.googleads.v19.services.types.ad_group_service import (
-    AdGroupOperation,
-    MutateAdGroupsResponse,
+# Corrected imports for service clients
+from google.ads.googleads.v19.services.services.ad_group_service import (
     AdGroupServiceClient,
 )
-from google.ads.googleads.v19.services.types.campaign_service import (
+from google.ads.googleads.v19.services.services.campaign_service import (
     CampaignServiceClient,
 )
+# Imports for types remain the same
+from google.ads.googleads.v19.services.types.ad_group_service import (
+    AdGroupOperation,
+    MutateAdGroupsResponse,
+)
 from google.ads.googleads.v19.resources.types.ad_group import AdGroup
 
 

examples/basic_operations/add_campaigns.py

@@ -27,14 +27,20 @@
 
 from google.ads.googleads.client import GoogleAdsClient
 from google.ads.googleads.errors import GoogleAdsException
+# Corrected imports for service clients
+from google.ads.googleads.v19.services.services.campaign_budget_service import (
+    CampaignBudgetServiceClient,
+)
+from google.ads.googleads.v19.services.services.campaign_service import (
+    CampaignServiceClient,
+)
+# Imports for types remain the same
 from google.ads.googleads.v19.services.types.campaign_budget_service import (
     CampaignBudgetOperation,
-    CampaignBudgetServiceClient,
     MutateCampaignBudgetsResponse,
 )
 from google.ads.googleads.v19.services.types.campaign_service import (
     CampaignOperation,
-    CampaignServiceClient,
     MutateCampaignsResponse,
 )
 from google.ads.googleads.v19.resources.types.campaign_budget import (

examples/basic_operations/get_campaigns.py

@@ -49,7 +49,8 @@ def main(client: GoogleAdsClient, customer_id: str) -> None:
     )
 
     for batch in stream:
-        for row: GoogleAdsRow in batch.results:
+        for row_data in batch.results:
+            row: GoogleAdsRow = row_data  # Type hint moved to separate line
             print(
                 f"Campaign with ID {row.campaign.id} and name "
                 f'"{row.campaign.name}" was found.'

examples/basic_operations/tests/__init__.py

@@ -0,0 +1,79 @@
+import unittest
+from unittest.mock import patch, MagicMock, ANY
+import sys
+from io import StringIO
+
+# Correctly import the main function from the script to be tested
+from examples.basic_operations.add_ad_groups import main as add_ad_groups_main
+
+class TestAddAdGroups(unittest.TestCase):
+    # Patch GoogleAdsClient.load_from_storage as that's what the script uses
+    @patch("examples.basic_operations.add_ad_groups.GoogleAdsClient.load_from_storage")
+    def test_add_ad_groups_mocked_service(self, mock_load_from_storage):
+        # --- Setup Mocks ---
+        mock_client = MagicMock()
+        mock_load_from_storage.return_value = mock_client
+
+        # Mock services
+        mock_ad_group_service = mock_client.get_service("AdGroupService", version="v19")
+        mock_campaign_service = mock_client.get_service("CampaignService", version="v19")
+
+        # Mock responses
+        mock_mutate_response = MagicMock()
+        mock_ad_group_result = MagicMock()
+        mock_ad_group_result.resource_name = "customers/1234567890/adGroups/NEW_AD_GROUP_ID"
+        mock_mutate_response.results = [mock_ad_group_result]
+        mock_ad_group_service.mutate_ad_groups.return_value = mock_mutate_response
+
+        # Define test parameters
+        customer_id = "1234567890"
+        campaign_id = "CAMPAIGN_ID_123"
+        expected_campaign_path = f"customers/{customer_id}/campaigns/{campaign_id}"
+
+        # Mock campaign_path method
+        mock_campaign_service.campaign_path.return_value = expected_campaign_path
+
+        # --- Capture stdout ---
+        old_stdout = sys.stdout
+        sys.stdout = captured_output = StringIO()
+
+        # --- Call the main function ---
+        # The script's main function takes the client object, customer_id, and campaign_id
+        add_ad_groups_main(mock_client, customer_id, campaign_id)
+
+        # --- Restore stdout ---
+        sys.stdout = old_stdout
+        output = captured_output.getvalue().strip()
+
+        # --- Assertions ---
+
+        # 1. Assert mutate_ad_groups was called correctly
+        mock_ad_group_service.mutate_ad_groups.assert_called_once_with(
+            customer_id=customer_id,
+            operations=[ANY]  # Using ANY for the operation list initially
+        )
+
+        # 2. Get the actual operation passed to mutate_ad_groups
+        _, called_kwargs = mock_ad_group_service.mutate_ad_groups.call_args
+        operations = called_kwargs["operations"]
+        self.assertEqual(len(operations), 1)
+        ad_group_operation = operations[0]
+
+        # 3. Assert details of the ad group operation
+        # For the name, since it contains a UUID, we check if it starts with the expected prefix.
+        self.assertTrue(ad_group_operation.create.name.startswith("Earth to Mars cruises "))
+        # Assert other properties
+        self.assertEqual(ad_group_operation.create.status, mock_client.enums.AdGroupStatusEnum.ENABLED)
+        self.assertEqual(ad_group_operation.create.campaign, expected_campaign_path)
+        self.assertEqual(ad_group_operation.create.type_, mock_client.enums.AdGroupTypeEnum.SEARCH_STANDARD)
+        self.assertEqual(ad_group_operation.create.cpc_bid_micros, 10000000)
+
+        # 4. Assert that campaign_path was called correctly
+        mock_campaign_service.campaign_path.assert_called_once_with(customer_id, campaign_id)
+
+        # 5. Assert the script output
+        expected_output = f"Created ad group {mock_ad_group_result.resource_name}."
+        self.assertEqual(output, expected_output)
+
+if __name__ == "__main__":
+    unittest.main()

examples/basic_operations/tests/test_add_ad_groups.py

@@ -0,0 +1,122 @@
+import unittest
+from unittest.mock import patch, MagicMock, ANY
+import sys
+from io import StringIO
+import datetime
+
+# Correctly import the main function from the script to be tested
+from examples.basic_operations.add_campaigns import main as add_campaigns_main
+from google.ads.googleads.v19.common.types.bidding import ManualCpc
+
+class TestAddCampaigns(unittest.TestCase):
+    @patch("examples.basic_operations.add_campaigns.datetime.date")
+    @patch("examples.basic_operations.add_campaigns.GoogleAdsClient.load_from_storage")
+    def test_add_campaigns_mocked_service(self, mock_load_from_storage, mock_date):
+        # --- Setup Mocks ---
+        mock_client = MagicMock()
+        mock_load_from_storage.return_value = mock_client
+
+        # Configure get_type to return distinct mocks for different type_name arguments
+        # to prevent interference between budget and campaign object creation.
+        def get_type_side_effect(type_name, version=None): # Added version to match potential signature
+            mock_type_instance = MagicMock(name=f"MockTypeInstance_{type_name}")
+            # Ensure .create is also a unique mock for each type instance
+            mock_type_instance.create = MagicMock(name=f"MockCreateFor_{type_name}")
+            return mock_type_instance
+        mock_client.get_type.side_effect = get_type_side_effect
+
+        # Mock datetime to control start and end dates
+        fixed_today = datetime.date(2024, 1, 1) # Real datetime.date for calculations
+        expected_start_date_str = (fixed_today + datetime.timedelta(days=1)).strftime("%Y%m%d")
+        expected_end_date_str = (fixed_today + datetime.timedelta(days=1) + datetime.timedelta(weeks=4)).strftime("%Y%m%d")
+
+        # Configure the mock_date object (which is mocking ...add_campaigns.datetime.date)
+        mock_date.today.return_value = fixed_today
+
+        def mock_strftime_side_effect(date_obj, format_str):
+            # This function will be called by the script's datetime.date.strftime(date_obj, format_str)
+            # We expect format_str to be "%Y%m%d"
+            if date_obj == (fixed_today + datetime.timedelta(days=1)): # This is start_time in script
+                return expected_start_date_str
+            elif date_obj == (fixed_today + datetime.timedelta(days=1) + datetime.timedelta(weeks=4)): # This is end_time in script
+                return expected_end_date_str
+            # Fallback for safety, though not expected to be hit in this test
+            return "UNEXPECTED_STRFTIME_CALL"
+        mock_date.strftime.side_effect = mock_strftime_side_effect
+
+
+        # Mock CampaignBudgetService
+        mock_budget_service = mock_client.get_service("CampaignBudgetService", version="v19")
+        mock_budget_mutate_response = MagicMock()
+        mock_budget_result = MagicMock()
+        mock_budget_resource_name = "customers/1234567890/campaignBudgets/BUDGET_ID_123"
+        mock_budget_result.resource_name = mock_budget_resource_name
+        mock_budget_mutate_response.results = [mock_budget_result]
+        mock_budget_service.mutate_campaign_budgets.return_value = mock_budget_mutate_response
+
+        # Mock CampaignService
+        mock_campaign_service = mock_client.get_service("CampaignService", version="v19")
+        mock_campaign_mutate_response = MagicMock()
+        mock_campaign_result = MagicMock()
+        mock_campaign_result.resource_name = "customers/1234567890/campaigns/CAMPAIGN_ID_456"
+        mock_campaign_mutate_response.results = [mock_campaign_result]
+        mock_campaign_service.mutate_campaigns.return_value = mock_campaign_mutate_response
+
+        customer_id = "1234567890"
+
+        # --- Capture stdout ---
+        old_stdout = sys.stdout
+        sys.stdout = captured_output = StringIO()
+
+        # --- Call the main function ---
+        add_campaigns_main(mock_client, customer_id)
+
+        # --- Restore stdout ---
+        sys.stdout = old_stdout
+        output = captured_output.getvalue().strip()
+
+        # --- Assertions for CampaignBudgetService ---
+        mock_budget_service.mutate_campaign_budgets.assert_called_once_with(
+            customer_id=customer_id,
+            operations=[ANY]
+        )
+        _, budget_call_kwargs = mock_budget_service.mutate_campaign_budgets.call_args
+        budget_operations = budget_call_kwargs["operations"]
+        self.assertEqual(len(budget_operations), 1)
+        budget_operation = budget_operations[0]
+
+        self.assertTrue(budget_operation.create.name.startswith("Interplanetary Budget "))
+        self.assertEqual(budget_operation.create.delivery_method, mock_client.enums.BudgetDeliveryMethodEnum.STANDARD)
+        self.assertEqual(budget_operation.create.amount_micros, 500000)
+
+        # --- Assertions for CampaignService ---
+        mock_campaign_service.mutate_campaigns.assert_called_once_with(
+            customer_id=customer_id,
+            operations=[ANY]
+        )
+        _, campaign_call_kwargs = mock_campaign_service.mutate_campaigns.call_args
+        campaign_operations = campaign_call_kwargs["operations"]
+        self.assertEqual(len(campaign_operations), 1)
+        campaign_operation = campaign_operations[0].create # Access the .create attribute
+
+        self.assertTrue(campaign_operation.name.startswith("Interplanetary Cruise "))
+        self.assertEqual(campaign_operation.advertising_channel_type, mock_client.enums.AdvertisingChannelTypeEnum.SEARCH)
+        self.assertEqual(campaign_operation.status, mock_client.enums.CampaignStatusEnum.PAUSED)
+        self.assertIsInstance(campaign_operation.manual_cpc, ManualCpc)
+        self.assertEqual(campaign_operation.campaign_budget, mock_budget_resource_name)
+
+        self.assertEqual(campaign_operation.network_settings.target_google_search, True)
+        self.assertEqual(campaign_operation.network_settings.target_search_network, True)
+        self.assertEqual(campaign_operation.network_settings.target_partner_search_network, False)
+        self.assertEqual(campaign_operation.network_settings.target_content_network, True)
+
+        self.assertEqual(campaign_operation.start_date, expected_start_date_str)
+        self.assertEqual(campaign_operation.end_date, expected_end_date_str)
+
+
+        # --- Assert script output ---
+        expected_output = f"Created campaign {mock_campaign_result.resource_name}."
+        self.assertEqual(output, expected_output)
+
+if __name__ == "__main__":
+    unittest.main()

examples/basic_operations/tests/test_add_campaigns.py

@@ -0,0 +1,102 @@
+import unittest
+from unittest.mock import patch, MagicMock, call # Added call for multiple print checks
+import sys
+from io import StringIO
+
+# Attempt to import the main function from the script to be tested
+try:
+    from examples.basic_operations.get_campaigns import main as get_campaigns_main
+except ImportError:
+    get_campaigns_main = None
+
+class TestGetCampaigns(unittest.TestCase):
+    # Patch GoogleAdsClient.load_from_storage, as that's standard
+    @patch("examples.basic_operations.get_campaigns.GoogleAdsClient.load_from_storage")
+    def test_get_campaigns_mocked_service(self, mock_load_from_storage):
+        if not get_campaigns_main:
+            self.skipTest("get_campaigns.py main function not found or import failed.")
+
+        # --- Setup Mocks ---
+        mock_client = MagicMock()
+        mock_load_from_storage.return_value = mock_client
+
+        # Mock GoogleAdsService
+        mock_google_ads_service = mock_client.get_service("GoogleAdsService", version="v19")
+
+        # Mock the search_stream response
+        # Create mock GoogleAdsRow objects that the search_stream will effectively yield
+        mock_campaign_row_1 = MagicMock()
+        # The script only uses campaign.id and campaign.name from the row
+        mock_campaign_row_1.campaign.id = 101
+        mock_campaign_row_1.campaign.name = "Test Campaign 1"
+        # resource_name is not strictly needed for test pass criteria as it's not in query/output
+        # mock_campaign_row_1.campaign.resource_name = "customers/1234567890/campaigns/101"
+
+
+        mock_campaign_row_2 = MagicMock()
+        mock_campaign_row_2.campaign.id = 102
+        mock_campaign_row_2.campaign.name = "Test Campaign 2"
+        # mock_campaign_row_2.campaign.resource_name = "customers/1234567890/campaigns/102"
+
+        # Create mock SearchGoogleAdsStreamResponse objects (these are the "batch" objects)
+        mock_batch_1 = MagicMock()
+        mock_batch_1.results = [mock_campaign_row_1] # Each batch.results is a list of rows
+
+        mock_batch_2 = MagicMock()
+        mock_batch_2.results = [mock_campaign_row_2]
+
+        # search_stream returns an iterator of these mock_batch objects
+        mock_google_ads_service.search_stream.return_value = iter([mock_batch_1, mock_batch_2])
+
+        customer_id = "1234567890"
+
+        # --- Capture stdout ---
+        old_stdout = sys.stdout
+        sys.stdout = captured_output = StringIO()
+
+        # --- Call the main function ---
+        # Assuming main takes client and customer_id. May need adjustment for 'limit'.
+        # This will depend on get_campaigns.py's main() and argparse setup.
+        try:
+            # If limit is an argument, it should be passed.
+            # For now, assuming it's either not there or handled by argparse if main is called directly.
+            get_campaigns_main(mock_client, customer_id)
+        except Exception as e:
+            self.fail(f"Running get_campaigns_main failed: {e}")
+
+
+        # --- Restore stdout ---
+        sys.stdout = old_stdout
+        output = captured_output.getvalue() # Don't strip() yet if checking multiple lines
+
+        # --- Assertions ---
+
+        # 1. Assert search_stream was called correctly
+        # Query from get_campaigns.py:
+        expected_query = """
+        SELECT
+          campaign.id,
+          campaign.name
+        FROM campaign
+        ORDER BY campaign.id"""
+
+        mock_google_ads_service.search_stream.assert_called_once_with(
+            customer_id=customer_id,
+            query=expected_query
+        )
+
+        # 2. Assert the script output
+        # This depends on the print format in get_campaigns.py
+        expected_output_1 = f"Campaign with ID {mock_campaign_row_1.campaign.id} and name \"{mock_campaign_row_1.campaign.name}\" was found."
+        expected_output_2 = f"Campaign with ID {mock_campaign_row_2.campaign.id} and name \"{mock_campaign_row_2.campaign.name}\" was found."
+
+        self.assertIn(expected_output_1, output)
+        self.assertIn(expected_output_2, output)
+        # For more precise checking of multiple print calls in order:
+        # with patch('builtins.print') as mock_print:
+        #     get_campaigns_main(mock_client, customer_id)
+        #     calls = [call(expected_output_1), call(expected_output_2)]
+        #     mock_print.assert_has_calls(calls, any_order=False) # any_order=False if order matters
+
+if __name__ == "__main__":
+    unittest.main()