test: add comprehensive tests for file handler and builder modules

- Added file handler tests covering all functions with tempfiles
- Added builder tests with proper mocking of HTTP client
- Tests cover initialization, chaining, execute, and string representations
- All tests use unittest.mock for consistency
- 40 tests now passing with good coverage

Author: jdrhyne

tests/unit/test_builder.py

@@ -0,0 +1,144 @@
+"""Unit tests for BuildAPIWrapper."""
+
+from unittest.mock import Mock, patch
+
+from nutrient_dws.builder import BuildAPIWrapper
+
+
+class TestBuildAPIWrapper:
+    """Test BuildAPIWrapper class."""
+
+    def test_init(self):
+        """Test initialization."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        assert builder._client == mock_client
+        assert builder._input_file == "test.pdf"
+        assert builder._actions == []
+        assert builder._output_options == {}
+        assert builder._parts == [{"file": "file"}]
+        assert "file" in builder._files
+
+    def test_add_step_basic(self):
+        """Test adding a basic step."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        result = builder.add_step("convert-to-pdf")
+
+        assert result == builder  # Should return self for chaining
+        assert len(builder._actions) == 1
+        assert builder._actions[0]["type"] == "convert-to-pdf"
+
+    def test_add_step_with_options(self):
+        """Test adding a step with options."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        builder.add_step("rotate-pages", {"degrees": 90})
+
+        assert len(builder._actions) == 1
+        assert builder._actions[0]["type"] == "rotate"
+        assert builder._actions[0]["rotateBy"] == 90
+
+    def test_chaining_steps(self):
+        """Test chaining multiple steps."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        builder.add_step("convert-to-pdf").add_step("ocr-pdf", {"language": "en"})
+
+        assert len(builder._actions) == 2
+        assert builder._actions[0]["type"] == "convert-to-pdf"
+        assert builder._actions[1]["type"] == "ocr"
+        assert builder._actions[1]["language"] == "english"
+
+    def test_set_output_options(self):
+        """Test setting output options."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        result = builder.set_output_options(format="pdf", quality=90)
+
+        assert result == builder  # Should return self for chaining
+        assert builder._output_options == {"format": "pdf", "quality": 90}
+
+    def test_build_instructions(self):
+        """Test building instructions."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+
+        builder.add_step("convert-to-pdf")
+        builder.add_step("ocr-pdf", {"language": "en"})
+        builder.set_output_options(format="pdf")
+
+        instructions = builder._build_instructions()
+
+        assert "parts" in instructions
+        assert instructions["actions"] == builder._actions
+        assert instructions["output"] == {"format": "pdf"}
+
+    def test_execute_returns_bytes(self):
+        """Test execute returns bytes when no output path."""
+        mock_client = Mock()
+        mock_http_client = Mock()
+        mock_client._http_client = mock_http_client
+
+        # Mock the response
+        mock_response = b"PDF content"
+        mock_http_client.post.return_value = mock_response
+
+        builder = BuildAPIWrapper(client=mock_client, input_file=b"input content")
+        builder.add_step("convert-to-pdf")
+
+        with patch("nutrient_dws.builder.prepare_file_for_upload") as mock_prepare:
+            mock_prepare.return_value = ("file", ("doc.pdf", b"input content", "application/pdf"))
+
+            result = builder.execute()
+
+        assert result == b"PDF content"
+
+    def test_execute_saves_to_file(self):
+        """Test execute saves to file when output path provided."""
+        mock_client = Mock()
+        mock_http_client = Mock()
+        mock_client._http_client = mock_http_client
+
+        # Mock the response
+        mock_response = b"PDF content"
+        mock_http_client.post.return_value = mock_response
+
+        builder = BuildAPIWrapper(client=mock_client, input_file=b"input content")
+        builder.add_step("convert-to-pdf")
+
+        with patch("nutrient_dws.builder.prepare_file_for_upload") as mock_prepare:
+            mock_prepare.return_value = ("file", ("doc.pdf", b"input content", "application/pdf"))
+
+            with patch("nutrient_dws.builder.save_file_output") as mock_save:
+                result = builder.execute("output.pdf")
+
+        assert result is None
+        mock_save.assert_called_once_with(b"PDF content", "output.pdf")
+
+    def test_str_representation(self):
+        """Test string representation."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+        builder.add_step("convert-to-pdf")
+
+        str_repr = str(builder)
+        assert "BuildAPIWrapper" in str_repr
+        assert "convert-to-pdf" in str_repr
+
+    def test_repr_representation(self):
+        """Test repr representation."""
+        mock_client = Mock()
+        builder = BuildAPIWrapper(client=mock_client, input_file="test.pdf")
+        builder.add_step("convert-to-pdf")
+        builder.add_step("ocr-pdf")
+
+        repr_str = repr(builder)
+        assert "BuildAPIWrapper" in repr_str
+        assert "input_file=" in repr_str
+        assert "actions=" in repr_str

tests/unit/test_file_handler.py

@@ -0,0 +1,153 @@
+"""Unit tests for file handling utilities."""
+
+import io
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from nutrient_dws.file_handler import (
+    get_file_size,
+    prepare_file_for_upload,
+    prepare_file_input,
+    save_file_output,
+)
+
+
+class TestPrepareFileInput:
+    """Test prepare_file_input function."""
+
+    def test_bytes_input(self):
+        """Test handling of bytes input."""
+        test_content = b"Test content"
+        content, filename = prepare_file_input(test_content)
+
+        assert content == test_content
+        assert filename == "document"
+
+    def test_string_path_input(self):
+        """Test handling of string path input."""
+        with tempfile.NamedTemporaryFile(delete=False) as tmp:
+            tmp.write(b"File content")
+            tmp_path = tmp.name
+
+        try:
+            content, filename = prepare_file_input(tmp_path)
+            assert content == b"File content"
+            assert Path(tmp_path).name in filename
+        finally:
+            Path(tmp_path).unlink()
+
+    def test_path_object_input(self):
+        """Test handling of Path object input."""
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(b"PDF content")
+            tmp_path = Path(tmp.name)
+
+        try:
+            content, filename = prepare_file_input(tmp_path)
+            assert content == b"PDF content"
+            assert tmp_path.name == filename
+        finally:
+            tmp_path.unlink()
+
+    def test_file_not_found(self):
+        """Test handling of non-existent file."""
+        with pytest.raises(FileNotFoundError):
+            prepare_file_input("non_existent_file.pdf")
+
+    def test_file_like_object(self):
+        """Test handling of file-like object."""
+        file_obj = io.BytesIO(b"Binary content")
+        content, filename = prepare_file_input(file_obj)
+
+        assert content == b"Binary content"
+        assert filename == "document"
+
+    def test_unsupported_input_type(self):
+        """Test handling of unsupported input type."""
+        with pytest.raises(ValueError, match="Unsupported file input type"):
+            prepare_file_input(123)  # type: ignore
+
+
+class TestPrepareFileForUpload:
+    """Test prepare_file_for_upload function."""
+
+    def test_bytes_upload(self):
+        """Test preparing bytes for upload."""
+        test_content = b"Upload content"
+        field_name, file_tuple = prepare_file_for_upload(test_content)
+
+        assert field_name == "file"
+        filename, content, content_type = file_tuple
+        assert filename == "document"
+        assert content == test_content
+        assert content_type == "application/octet-stream"
+
+    def test_custom_field_name(self):
+        """Test custom field name."""
+        test_content = b"Content"
+        field_name, _ = prepare_file_for_upload(test_content, field_name="custom")
+
+        assert field_name == "custom"
+
+
+class TestSaveFileOutput:
+    """Test save_file_output function."""
+
+    def test_save_to_path(self):
+        """Test saving content to file."""
+        content = b"Save this content"
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_path = Path(tmpdir) / "output.pdf"
+            save_file_output(content, str(output_path))
+
+            assert output_path.exists()
+            assert output_path.read_bytes() == content
+
+    def test_create_parent_directories(self):
+        """Test creating parent directories."""
+        content = b"Content"
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            output_path = Path(tmpdir) / "sub" / "dir" / "output.pdf"
+            save_file_output(content, str(output_path))
+
+            assert output_path.exists()
+            assert output_path.read_bytes() == content
+
+
+class TestGetFileSize:
+    """Test get_file_size function."""
+
+    def test_bytes_size(self):
+        """Test getting size of bytes."""
+        content = b"12345"
+        size = get_file_size(content)
+        assert size == 5
+
+    def test_file_path_size(self):
+        """Test getting size of file path."""
+        with tempfile.NamedTemporaryFile(delete=False) as tmp:
+            tmp.write(b"1234567890")
+            tmp_path = tmp.name
+
+        try:
+            size = get_file_size(tmp_path)
+            assert size == 10
+        finally:
+            Path(tmp_path).unlink()
+
+    def test_non_existent_file_size(self):
+        """Test getting size of non-existent file."""
+        size = get_file_size("non_existent.pdf")
+        assert size is None
+
+    def test_file_object_size(self):
+        """Test getting size of file-like object."""
+        file_obj = io.BytesIO(b"123")
+        size = get_file_size(file_obj)
+        assert size == 3
+        # Ensure position is restored
+        assert file_obj.tell() == 0