refactor: use pytest tmp_path fixture to isolate test file operations

This change:
- Replaces hardcoded directories with pytest's tmp_path fixture
- Eliminates filesystem pollution between tests
- Enables safe test parallelization
- Improves path validation and error messages
- Removes redundant cleanup code
- Makes tests follow pytest best practices

Author: AlePouroullis

tests/custom/conftest.py

@@ -86,10 +86,11 @@ def get_humanloop_client() -> GetHumanloopClientFn:
     if not os.getenv("HUMANLOOP_API_KEY"):
         pytest.fail("HUMANLOOP_API_KEY is not set for integration tests")
 
-    def _get_humanloop_client(use_local_files: bool = False) -> Humanloop:
+    def _get_humanloop_client(use_local_files: bool = False, local_files_directory: str = "humanloop") -> Humanloop:
         return Humanloop(
             api_key=os.getenv("HUMANLOOP_API_KEY"),
             use_local_files=use_local_files,
+            local_files_directory=local_files_directory,
         )
 
     return _get_humanloop_client

tests/custom/integration/test_overload.py …ntegration/test_local_file_operations.pytests/custom/integration/test_overload.py renamed to tests/custom/integration/test_local_file_operations.py tests/custom/integration/test_overload.py renamed to tests/custom/integration/test_local_file_operations.py

@@ -1,32 +1,19 @@
 from pathlib import Path
-import os
-import tempfile
 
 import pytest
 
 from humanloop.error import HumanloopRuntimeError
 from tests.custom.types import GetHumanloopClientFn, SyncableFile
 
 
-@pytest.fixture
-def cleanup_local_files():
-    """Cleanup any locally synced files after tests"""
-    yield
-    local_dir = Path("humanloop")
-    if local_dir.exists():
-        import shutil
-
-        shutil.rmtree(local_dir)
-
-
 def test_path_validation(
     get_humanloop_client: GetHumanloopClientFn,
     syncable_files_fixture: list[SyncableFile],
-    cleanup_local_files,
+    tmp_path: Path,
 ):
-    """Test path validation rules for local file usage."""
+    """Test validation of path formats for local file operations."""
     # GIVEN a client with local files enabled and remote files pulled
-    humanloop_client = get_humanloop_client(use_local_files=True)
+    humanloop_client = get_humanloop_client(use_local_files=True, local_files_directory=str(tmp_path))
     humanloop_client.pull()
     test_file = syncable_files_fixture[0]
 
@@ -79,10 +66,10 @@ def test_path_validation(
 
 def test_local_file_call(
     get_humanloop_client: GetHumanloopClientFn,
-    cleanup_local_files,
     sdk_test_dir: str,
+    tmp_path: Path,
 ):
-    """Test using a local file for call operations with the overloaded client."""
+    """Test calling the API with a local prompt file."""
     # GIVEN a local prompt file with proper system tag
     prompt_content = """---
 model: gpt-4o
@@ -102,16 +89,14 @@ def test_local_file_call(
 </system>
 """
 
-    # Create local file structure
-    humanloop_dir = Path("humanloop")
-    humanloop_dir.mkdir(exist_ok=True)
+    # Create local file structure in temporary directory
     test_path = f"{sdk_test_dir}/capital_prompt"
-    file_path = humanloop_dir / f"{test_path}.prompt"
+    file_path = tmp_path / f"{test_path}.prompt"
     file_path.parent.mkdir(parents=True, exist_ok=True)
     file_path.write_text(prompt_content)
 
     # GIVEN a client with local files enabled
-    client = get_humanloop_client(use_local_files=True)
+    client = get_humanloop_client(use_local_files=True, local_files_directory=str(tmp_path))
 
     # WHEN calling the API with the local file path (without extension)
     response = client.prompts.call(
@@ -133,10 +118,10 @@ def test_local_file_call(
 
 def test_local_file_log(
     get_humanloop_client: GetHumanloopClientFn,
-    cleanup_local_files,
     sdk_test_dir: str,
+    tmp_path: Path,
 ):
-    """Test using a local file for log operations with the overloaded client."""
+    """Test logging data with a local prompt file."""
     # GIVEN a local prompt file with proper system tag
     prompt_content = """---
 model: gpt-4o
@@ -155,16 +140,14 @@ def test_local_file_log(
 </system>
 """
 
-    # Create local file structure
-    humanloop_dir = Path("humanloop")
-    humanloop_dir.mkdir(exist_ok=True)
+    # Create local file structure in temporary directory
     test_path = f"{sdk_test_dir}/geography_prompt"
-    file_path = humanloop_dir / f"{test_path}.prompt"
+    file_path = tmp_path / f"{test_path}.prompt"
     file_path.parent.mkdir(parents=True, exist_ok=True)
     file_path.write_text(prompt_content)
 
     # GIVEN a client with local files enabled
-    client = get_humanloop_client(use_local_files=True)
+    client = get_humanloop_client(use_local_files=True, local_files_directory=str(tmp_path))
 
     # GIVEN message content to log
     test_messages = [{"role": "user", "content": "What is the capital of France?"}]
@@ -189,16 +172,17 @@ def test_local_file_log(
 def test_overload_version_environment_handling(
     get_humanloop_client: GetHumanloopClientFn,
     syncable_files_fixture: list[SyncableFile],
+    tmp_path: Path,
 ):
-    """Test that overload_with_local_files correctly handles version_id and environment parameters."""
+    """Test handling of version_id and environment parameters with local files."""
     # GIVEN a client with use_local_files=True and pulled files
-    humanloop_client = get_humanloop_client(use_local_files=True)
+    humanloop_client = get_humanloop_client(use_local_files=True, local_files_directory=str(tmp_path))
     humanloop_client.pull()
 
     # GIVEN a test file that exists locally
     test_file = syncable_files_fixture[0]
     extension = f".{test_file.type}"
-    local_path = Path("humanloop") / f"{test_file.path}{extension}"
+    local_path = tmp_path / f"{test_file.path}{extension}"
 
     # THEN the file should exist locally
     assert local_path.exists(), f"Expected pulled file at {local_path}"
@@ -257,10 +241,10 @@ def test_overload_version_environment_handling(
 
 # def test_agent_local_file_usage(
 #     get_humanloop_client: GetHumanloopClientFn,
-#     cleanup_local_files,
 #     sdk_test_dir: str,
+#     tmp_path: Path,
 # ):
-#     """Test using a local agent file for call operations with the overloaded client."""
+#     """Test using a local agent file for API calls."""
 #     # NOTE: This test has been disabled as it fails intermittently in automated test runs
 #     # but works correctly when tested manually. The issue appears to be related to test
 #     # environment differences rather than actual code functionality.
@@ -279,54 +263,52 @@ def test_overload_version_environment_handling(
 # endpoint: chat
 # tools: []
 # ---
-
+#
 # <system>
 # You are a helpful agent that provides concise answers. When asked about capitals of countries,
 # you respond with just the capital name, lowercase, with no punctuation or additional text.
 # </system>
 # """
-
-#     # Create local file structure
-#     humanloop_dir = Path("humanloop")
-#     humanloop_dir.mkdir(exist_ok=True)
+#
+#     # Create local file structure in temporary directory
 #     test_path = f"{sdk_test_dir}/capital_agent"
-#     file_path = humanloop_dir / f"{test_path}.agent"
+#     file_path = tmp_path / f"{test_path}.agent"
 #     file_path.parent.mkdir(parents=True, exist_ok=True)
 #     file_path.write_text(agent_content)
-
+#
 #     # GIVEN a client with local files enabled
-#     client = get_humanloop_client(use_local_files=True)
-
+#     client = get_humanloop_client(use_local_files=True, local_files_directory=str(tmp_path))
+#
 #     # WHEN calling the API with the local file path (without extension)
 #     response = client.agents.call(
 #         path=test_path, messages=[{"role": "user", "content": "What is the capital of France?"}]
 #     )
-
+#
 #     # THEN the response should be successful
 #     assert response is not None
 #     assert response.logs is not None
 #     assert len(response.logs) > 0
-
+#
 #     # AND the response should contain the expected output format (lowercase city name)
 #     assert "paris" in response.logs[0].output.lower()
-
+#
 #     # AND the agent used should match our expected path
 #     assert response.agent is not None
 #     assert response.agent.path == test_path
-
+#
 #     # WHEN logging with the local agent file
 #     test_messages = [{"role": "user", "content": "What is the capital of Germany?"}]
 #     test_output = "Berlin is the capital of Germany."
 #     log_response = client.agents.log(path=test_path, messages=test_messages, output=test_output)
-
+#
 #     # THEN the log should be successful
 #     assert log_response is not None
 #     assert log_response.agent_id is not None
 #     assert log_response.id is not None  # log ID
-
+#
 #     # WHEN retrieving the logged agent details
 #     agent_details = client.agents.get(id=log_response.agent_id)
-
+#
 #     # THEN the details should match our expected path
 #     assert agent_details is not None
 #     assert test_path in agent_details.path

tests/custom/integration/test_sync.py

@@ -9,18 +9,19 @@
 def test_pull_basic(
     syncable_files_fixture: list[SyncableFile],
     get_humanloop_client: GetHumanloopClientFn,
+    tmp_path: Path,
 ):
-    """Test that humanloop.sync() correctly syncs remote files to local filesystem"""
+    """Test basic file syncing from remote to local filesystem."""
     # GIVEN a set of files in the remote system (from syncable_files_fixture)
-    humanloop_client = get_humanloop_client()
+    humanloop_client = get_humanloop_client(local_files_directory=str(tmp_path))
 
     # WHEN running the sync
     humanloop_client.pull()
 
     # THEN our local filesystem should mirror the remote filesystem in the HL Workspace
     for file in syncable_files_fixture:
         extension = f".{file.type}"
-        local_path = Path("humanloop") / f"{file.path}{extension}"
+        local_path = tmp_path / f"{file.path}{extension}"
 
         # THEN the file and its directory should exist
         assert local_path.exists(), f"Expected synced file at {local_path}"
@@ -34,9 +35,10 @@ def test_pull_basic(
 def test_pull_with_invalid_path(
     get_humanloop_client: GetHumanloopClientFn,
     sdk_test_dir: str,
+    tmp_path: Path,
 ):
-    """Test that humanloop.sync() raises an error when the path is invalid"""
-    humanloop_client = get_humanloop_client()
+    """Test error handling when path doesn't exist."""
+    humanloop_client = get_humanloop_client(local_files_directory=str(tmp_path))
     non_existent_path = f"{sdk_test_dir}/non_existent_directory"
 
     # Note: This test currently relies on the specific error message from list_files().
@@ -47,9 +49,10 @@ def test_pull_with_invalid_path(
 
 def test_pull_with_invalid_environment(
     get_humanloop_client: GetHumanloopClientFn,
+    tmp_path: Path,
 ):
-    """Test that humanloop.sync() raises an error when the environment is invalid"""
-    humanloop_client = get_humanloop_client()
+    """Test error handling when environment doesn't exist."""
+    humanloop_client = get_humanloop_client(local_files_directory=str(tmp_path))
     with pytest.raises(HumanloopRuntimeError, match="Environment .* does not exist"):
         humanloop_client.pull(environment="invalid_environment")
 
@@ -58,7 +61,7 @@ def test_pull_with_invalid_environment(
 #     get_humanloop_client: GetHumanloopClientFn,
 #     syncable_files_fixture: list[SyncableFile],
 # ):
-#     """Test that humanloop.sync() correctly syncs files from a specific environment"""
+#     """Test pulling files filtered by a specific environment."""
 #     # NOTE: This test is currently not feasible to implement because:
 #     # 1. We have no way of deploying to an environment using its name, only by ID
 #     # 2. There's no API endpoint to retrieve environments for an organization
@@ -75,24 +78,22 @@ def test_pull_with_path_filter(
     get_humanloop_client: GetHumanloopClientFn,
     syncable_files_fixture: list[SyncableFile],
     sdk_test_dir: str,
+    tmp_path: Path,
 ):
-    """Test that humanloop.sync() correctly filters files by path when pulling"""
+    """Test that filtering by path correctly limits which files are synced."""
     # GIVEN a client
-    humanloop_client = get_humanloop_client()
-
-    # First clear any existing files to ensure clean state
-    import shutil
-
-    if Path("humanloop").exists():
-        shutil.rmtree("humanloop")
+    humanloop_client = get_humanloop_client(local_files_directory=str(tmp_path))
 
     # WHEN pulling only files from the sdk_test_dir path
     humanloop_client.pull(path=sdk_test_dir)
 
     # THEN count the total number of files synced
     synced_file_count = 0
-    for path in Path("humanloop").glob("**/*"):
+    for path in tmp_path.glob("**/*"):
         if path.is_file():
+            # Check that the file is not empty
+            content = path.read_text()
+            assert content, f"File at {path} should not be empty"
             synced_file_count += 1
 
     # The count should match our fixture length