perf(test): Speed up unit test suite via parallelism and dedup

Enable pytest-xdist (-n auto) in CI so the ~7300-test suite runs in
parallel instead of single-threaded. Measured locally: 121s -> 72s
(~40% faster wall-clock); larger gains expected on multi-core runners.

Also remove the dead `llm_backend` parametrize (GOOGLE_AI/VERTEX) from
26 tests in test_instructions.py and test_llm_request.py. The param was
never read by any test body and no fixture consumed it, so each test ran
twice over identical code under the same env. Verified the full call
surface (instructions/contents request processors and
LlmRequest.append_instructions) has no backend branching; real
dual-backend FD-prep coverage remains in test_agent_tool.py via the
env_variables fixture.

Change-Id: I585f2621863edadee2b9f3b224b980aef7df79fb

Author: Jacksunwei

.github/workflows/python-unit-tests.yml

@@ -39,5 +39,6 @@ jobs:
       run: |
         source .venv/bin/activate
         pytest tests/unittests \
+          -n auto \
           --ignore=tests/unittests/artifacts/test_artifact_service.py \
           --ignore=tests/unittests/tools/google_api_tool/test_googleapi_to_openapi_converter.py

tests/unittests/flows/llm_flows/test_instructions.py

@@ -541,8 +541,7 @@ async def test_string_global_instruction_respects_bypass_state_injection():
 # Static Instruction Tests (moved from test_static_instructions.py)
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_field_exists(llm_backend):
+def test_static_instruction_field_exists():
   """Test that static_instruction field exists and works with types.Content."""
   static_content = types.Content(
       role="user", parts=[types.Part(text="This is a static instruction")]
@@ -551,35 +550,31 @@ def test_static_instruction_field_exists(llm_backend):
   assert agent.static_instruction == static_content
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_string(llm_backend):
+def test_static_instruction_supports_string():
   """Test that static_instruction field supports simple strings."""
   static_str = "This is a static instruction as a string"
   agent = LlmAgent(name="test_agent", static_instruction=static_str)
   assert agent.static_instruction == static_str
   assert isinstance(agent.static_instruction, str)
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_part(llm_backend):
+def test_static_instruction_supports_part():
   """Test that static_instruction field supports types.Part."""
   static_part = types.Part(text="This is a static instruction as Part")
   agent = LlmAgent(name="test_agent", static_instruction=static_part)
   assert agent.static_instruction == static_part
   assert isinstance(agent.static_instruction, types.Part)
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_file(llm_backend):
+def test_static_instruction_supports_file():
   """Test that static_instruction field supports types.File."""
   static_file = types.File(uri="gs://bucket/file.txt", mime_type="text/plain")
   agent = LlmAgent(name="test_agent", static_instruction=static_file)
   assert agent.static_instruction == static_file
   assert isinstance(agent.static_instruction, types.File)
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_list_of_parts(llm_backend):
+def test_static_instruction_supports_list_of_parts():
   """Test that static_instruction field supports list[PartUnion]."""
   static_parts_list = [
       types.Part(text="First part"),
@@ -591,8 +586,7 @@ def test_static_instruction_supports_list_of_parts(llm_backend):
   assert len(agent.static_instruction) == 2
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_list_of_strings(llm_backend):
+def test_static_instruction_supports_list_of_strings():
   """Test that static_instruction field supports list of strings."""
   static_strings_list = ["First instruction", "Second instruction"]
   agent = LlmAgent(name="test_agent", static_instruction=static_strings_list)
@@ -601,8 +595,7 @@ def test_static_instruction_supports_list_of_strings(llm_backend):
   assert all(isinstance(s, str) for s in agent.static_instruction)
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_supports_multiple_parts(llm_backend):
+def test_static_instruction_supports_multiple_parts():
   """Test that static_instruction supports multiple parts including files."""
   static_content = types.Content(
       role="user",
@@ -621,8 +614,7 @@ def test_static_instruction_supports_multiple_parts(llm_backend):
   assert len(agent.static_instruction.parts) == 3
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
-def test_static_instruction_outputs_placeholders_literally(llm_backend):
+def test_static_instruction_outputs_placeholders_literally():
   """Test that static instructions output placeholders literally without processing."""
   static_content = types.Content(
       role="user",
@@ -635,9 +627,8 @@ def test_static_instruction_outputs_placeholders_literally(llm_backend):
   assert "{count}" in agent.static_instruction.parts[0].text
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_added_to_contents(llm_backend):
+async def test_static_instruction_added_to_contents():
   """Test that static instructions are added to llm_request.config.system_instruction."""
   static_content = types.Content(
       role="user", parts=[types.Part(text="Static instruction content")]
@@ -657,9 +648,8 @@ async def test_static_instruction_added_to_contents(llm_backend):
   assert llm_request.config.system_instruction == "Static instruction content"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_string_added_to_system(llm_backend):
+async def test_static_instruction_string_added_to_system():
   """Test that string static instructions are added to system_instruction."""
   agent = LlmAgent(
       name="test_agent", static_instruction="Static instruction as string"
@@ -678,9 +668,8 @@ async def test_static_instruction_string_added_to_system(llm_backend):
   assert llm_request.config.system_instruction == "Static instruction as string"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_part_converted_to_system(llm_backend):
+async def test_static_instruction_part_converted_to_system():
   """Test that Part static instructions are converted and added to system_instruction."""
   static_part = types.Part(text="Static instruction from Part")
   agent = LlmAgent(name="test_agent", static_instruction=static_part)
@@ -696,11 +685,8 @@ async def test_static_instruction_part_converted_to_system(llm_backend):
   assert llm_request.config.system_instruction == "Static instruction from Part"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_list_of_parts_converted_to_system(
-    llm_backend,
-):
+async def test_static_instruction_list_of_parts_converted_to_system():
   """Test that list of Parts is converted and added to system_instruction."""
   static_parts_list = [
       types.Part(text="First part"),
@@ -719,11 +705,8 @@ async def test_static_instruction_list_of_parts_converted_to_system(
   assert llm_request.config.system_instruction == "First part\n\nSecond part"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_list_of_strings_converted_to_system(
-    llm_backend,
-):
+async def test_static_instruction_list_of_strings_converted_to_system():
   """Test that list of strings is converted and added to system_instruction."""
   static_strings_list = ["First instruction", "Second instruction"]
   agent = LlmAgent(name="test_agent", static_instruction=static_strings_list)
@@ -742,9 +725,8 @@ async def test_static_instruction_list_of_strings_converted_to_system(
   )
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_dynamic_instruction_without_static_goes_to_system(llm_backend):
+async def test_dynamic_instruction_without_static_goes_to_system():
   """Test that dynamic instructions go to system when no static instruction exists."""
   agent = LlmAgent(name="test_agent", instruction="Dynamic instruction content")
 
@@ -761,9 +743,8 @@ async def test_dynamic_instruction_without_static_goes_to_system(llm_backend):
   assert len(llm_request.contents) == 0
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_dynamic_instruction_with_static_not_in_system(llm_backend):
+async def test_dynamic_instruction_with_static_not_in_system():
   """Test that dynamic instructions don't go to system when static instruction exists."""
   static_content = types.Content(
       role="user", parts=[types.Part(text="Static instruction content")]
@@ -793,11 +774,8 @@ async def test_dynamic_instruction_with_static_not_in_system(llm_backend):
   assert llm_request.contents[0].parts[0].text == "Dynamic instruction content"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_dynamic_instruction_with_string_static_not_in_system(
-    llm_backend,
-):
+async def test_dynamic_instruction_with_string_static_not_in_system():
   """Test that dynamic instructions go to user content when string static_instruction exists."""
   agent = LlmAgent(
       name="test_agent",
@@ -823,9 +801,8 @@ async def test_dynamic_instruction_with_string_static_not_in_system(
   assert llm_request.contents[0].parts[0].text == "Dynamic instruction content"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_dynamic_instructions_added_to_user_content(llm_backend):
+async def test_dynamic_instructions_added_to_user_content():
   """Test that dynamic instructions are added to user content when static exists."""
   static_content = types.Content(
       role="user", parts=[types.Part(text="Static instruction")]
@@ -863,11 +840,8 @@ async def test_dynamic_instructions_added_to_user_content(llm_backend):
   assert llm_request.contents[1].parts[0].text == "Hello world"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_dynamic_instructions_create_user_content_when_none_exists(
-    llm_backend,
-):
+async def test_dynamic_instructions_create_user_content_when_none_exists():
   """Test that dynamic instructions create user content when none exists."""
   static_content = types.Content(
       role="user", parts=[types.Part(text="Static instruction")]
@@ -898,9 +872,8 @@ async def test_dynamic_instructions_create_user_content_when_none_exists(
   assert llm_request.contents[0].parts[0].text == "Dynamic instruction"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_no_dynamic_instructions_when_no_static(llm_backend):
+async def test_no_dynamic_instructions_when_no_static():
   """Test that no dynamic instructions are added to content when no static instructions exist."""
   agent = LlmAgent(name="test_agent", instruction="Dynamic instruction only")
 
@@ -958,9 +931,8 @@ async def test_instructions_insert_after_function_response():
   assert llm_request.contents[2].parts[0].text == "Dynamic instruction"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_with_files_and_text(llm_backend):
+async def test_static_instruction_with_files_and_text():
   """Test that static instruction can contain files and text together."""
   static_content = types.Content(
       role="user",
@@ -1002,11 +974,8 @@ async def test_static_instruction_with_files_and_text(llm_backend):
   assert llm_request.contents[0].parts[1].inline_data.data == b"fake_image_data"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_non_text_parts_moved_to_user_content(
-    llm_backend,
-):
+async def test_static_instruction_non_text_parts_moved_to_user_content():
   """Test that non-text parts from static instruction are moved to user content."""
   static_content = types.Content(
       role="user",
@@ -1075,9 +1044,8 @@ async def test_static_instruction_non_text_parts_moved_to_user_content(
   assert file_content.parts[1].file_data.display_name == "test_file.txt"
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_reference_id_generation(llm_backend):
+async def test_static_instruction_reference_id_generation():
   """Test that reference IDs are generated correctly for non-text parts."""
   static_content = types.Content(
       role="user",
@@ -1125,9 +1093,8 @@ async def test_static_instruction_reference_id_generation(llm_backend):
     assert len(content.parts) == 2
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_only_text_parts(llm_backend):
+async def test_static_instruction_only_text_parts():
   """Test that static instruction with only text parts works normally."""
   static_content = types.Content(
       role="user",
@@ -1151,9 +1118,8 @@ async def test_static_instruction_only_text_parts(llm_backend):
   assert len(llm_request.contents) == 0
 
 
-@pytest.mark.parametrize("llm_backend", ["GOOGLE_AI", "VERTEX"])
 @pytest.mark.asyncio
-async def test_static_instruction_only_non_text_parts(llm_backend):
+async def test_static_instruction_only_non_text_parts():
   """Test that static instruction with only non-text parts works correctly."""
   static_content = types.Content(
       role="user",

tests/unittests/models/test_llm_request.py

@@ -754,8 +754,7 @@ def test_append_instructions_warning_unsupported_system_instruction_type(
   )
 
 
-@pytest.mark.parametrize('llm_backend', ['GOOGLE_AI', 'VERTEX'])
-def test_append_instructions_with_mixed_content(llm_backend):
+def test_append_instructions_with_mixed_content():
   """Test append_instructions with mixed text and non-text content."""
   request = LlmRequest()
 
@@ -813,8 +812,7 @@ def test_append_instructions_with_mixed_content(llm_backend):
   assert user_contents[1].parts[1].file_data.display_name == 'document.txt'
 
 
-@pytest.mark.parametrize('llm_backend', ['GOOGLE_AI', 'VERTEX'])
-def test_append_instructions_with_only_text_parts(llm_backend):
+def test_append_instructions_with_only_text_parts():
   """Test append_instructions with only text parts."""
   request = LlmRequest()