more update

Author: pengfeiye

nylas/handler/http_client.py

@@ -90,20 +90,25 @@ def _execute(
         if overrides and overrides.get("timeout"):
             timeout = overrides["timeout"]
 
-        # Serialize request_body to JSON with ensure_ascii=False to preserve UTF-8 characters
-        # (special characters, emoji, accented letters, etc.) and encode as UTF-8 bytes
-        # to avoid Latin-1 encoding errors in the HTTP layer
-        json_data = None
-        if request_body is not None and data is None:
-            json_data = json.dumps(request_body, ensure_ascii=False).encode('utf-8')
+        # Use requests' json parameter for proper UTF-8 handling when sending JSON
+        # This avoids Latin-1 encoding errors with special characters (emoji, accented letters, etc.)
         try:
-            response = requests.request(
-                request["method"],
-                request["url"],
-                headers=request["headers"],
-                data=json_data or data,
-                timeout=timeout,
-            )
+            if request_body is not None and data is None:
+                response = requests.request(
+                    request["method"],
+                    request["url"],
+                    headers=request["headers"],
+                    json=request_body,
+                    timeout=timeout,
+                )
+            else:
+                response = requests.request(
+                    request["method"],
+                    request["url"],
+                    headers=request["headers"],
+                    data=data,
+                    timeout=timeout,
+                )
         except requests.exceptions.Timeout as exc:
             raise NylasSdkTimeoutError(url=request["url"], timeout=timeout) from exc
 

tests/handler/test_http_client.py

@@ -302,7 +302,7 @@ def test_execute(self, http_client, patched_version_and_sys, patched_request):
                 "Content-type": "application/json; charset=utf-8",
                 "test": "header",
             },
-            data=b'{"foo": "bar"}',
+            json={"foo": "bar"},
             timeout=30,
         )
 
@@ -336,7 +336,7 @@ def test_execute_override_timeout(
                 "Content-type": "application/json; charset=utf-8",
                 "test": "header",
             },
-            data=b'{"foo": "bar"}',
+            json={"foo": "bar"},
             timeout=60,
         )
 
@@ -426,7 +426,7 @@ def test_execute_with_headers(self, http_client, patched_version_and_sys, patche
                 "Content-type": "application/json; charset=utf-8",
                 "test": "header",
             },
-            data=b'{"foo": "bar"}',
+            json={"foo": "bar"},
             timeout=30,
         )
 
@@ -452,21 +452,15 @@ def test_execute_with_utf8_characters(self, http_client, patched_version_and_sys
         )
 
         assert response_json == {"success": True}
-        # Verify that the data is sent as UTF-8 encoded bytes
+        # Verify that the json parameter is used with original data
         call_kwargs = patched_request.call_args[1]
-        assert "data" in call_kwargs
-        sent_data = call_kwargs["data"]
-        
-        # Data should be bytes
-        assert isinstance(sent_data, bytes)
+        assert "json" in call_kwargs
+        sent_json = call_kwargs["json"]
 
-        # The JSON should contain actual UTF-8 characters (not escaped)
-        decoded = sent_data.decode('utf-8')
-        assert "Réunion d'équipe" in decoded
-        assert "De l'idée à la post-prod" in decoded
-        assert "café" in decoded
-        # Should NOT contain unicode escape sequences
-        assert "\\u" not in decoded
+        # The JSON should contain actual UTF-8 characters
+        assert sent_json["title"] == "Réunion d'équipe"
+        assert sent_json["description"] == "De l'idée à la post-prod, sans friction"
+        assert sent_json["location"] == "café"
 
     def test_execute_with_none_request_body(self, http_client, patched_version_and_sys, patched_request):
         """Test that None request_body is handled correctly."""
@@ -483,9 +477,33 @@ def test_execute_with_none_request_body(self, http_client, patched_version_and_s
         )
 
         assert response_json == {"success": True}
-        # Verify that data is None when request_body is None
+        # Verify that data branch is used when request_body is None
         call_kwargs = patched_request.call_args[1]
+        # Should use data= parameter, not json= parameter
         assert "data" in call_kwargs
+        assert "json" not in call_kwargs
+        assert call_kwargs["data"] is None
+
+    def test_execute_with_none_request_body_and_none_data(self, http_client, patched_version_and_sys, patched_request):
+        """Test that both None request_body and None data are handled correctly."""
+        mock_response = Mock()
+        mock_response.json.return_value = {"success": True}
+        mock_response.headers = {"X-Test-Header": "test"}
+        mock_response.status_code = 200
+        patched_request.return_value = mock_response
+
+        response_json, response_headers = http_client._execute(
+            method="DELETE",
+            path="/events/123",
+            request_body=None,
+            data=None,
+        )
+
+        assert response_json == {"success": True}
+        call_kwargs = patched_request.call_args[1]
+        # Should use data= parameter with None value
+        assert "data" in call_kwargs
+        assert "json" not in call_kwargs
         assert call_kwargs["data"] is None
 
     def test_execute_with_emoji_and_international_characters(self, http_client, patched_version_and_sys, patched_request):
@@ -513,21 +531,15 @@ def test_execute_with_emoji_and_international_characters(self, http_client, patc
 
         assert response_json == {"success": True}
         call_kwargs = patched_request.call_args[1]
-        sent_data = call_kwargs["data"]
+        sent_json = call_kwargs["json"]
 
-        # Data should be bytes
-        assert isinstance(sent_data, bytes)
-        
-        # All characters should be preserved (not escaped)
-        decoded = sent_data.decode('utf-8')
-        assert "🎉 Party time! 🥳" in decoded
-        assert "こんにちは" in decoded
-        assert "你好" in decoded
-        assert "Привет" in decoded
-        assert "Größe" in decoded
-        assert "¿Cómo estás?" in decoded
-        # Should NOT contain unicode escape sequences
-        assert "\\u" not in decoded
+        # All characters should be preserved in the json dict
+        assert sent_json["emoji"] == "🎉 Party time! 🥳"
+        assert sent_json["japanese"] == "こんにちは"
+        assert sent_json["chinese"] == "你好"
+        assert sent_json["russian"] == "Привет"
+        assert sent_json["german"] == "Größe"
+        assert sent_json["spanish"] == "¿Cómo estás?"
 
     def test_execute_with_right_single_quotation_mark(self, http_client, patched_version_and_sys, patched_request):
         """Test that right single quotation mark (\\u2019) is handled correctly.
@@ -555,18 +567,51 @@ def test_execute_with_right_single_quotation_mark(self, http_client, patched_ver
 
         assert response_json == {"success": True}
         call_kwargs = patched_request.call_args[1]
-        sent_data = call_kwargs["data"]
+        sent_json = call_kwargs["json"]
+        
+        # The \u2019 character should be preserved
+        assert "'" in sent_json["subject"]  # \u2019 right single quotation mark
+        assert sent_json["subject"] == "It's a test"
+        assert "'" in sent_json["body"]
+        assert "Here's another" in sent_json["body"]
+
+    def test_execute_with_emojis(self, http_client, patched_version_and_sys, patched_request):
+        """Test that emojis are handled correctly in request bodies.
         
-        # Data should be bytes
-        assert isinstance(sent_data, bytes)
+        Emojis are multi-byte UTF-8 characters that could cause encoding issues
+        if not handled properly.
+        """
+        mock_response = Mock()
+        mock_response.json.return_value = {"success": True}
+        mock_response.headers = {"X-Test-Header": "test"}
+        mock_response.status_code = 200
+        patched_request.return_value = mock_response
+
+        request_body = {
+            "subject": "Hello 👋 World 🌍",
+            "body": "Great job! 🎉 Keep up the good work 💪 See you soon 😊",
+            "emoji_only": "🔥🚀✨💯",
+            "mixed": "Meeting at 3pm 📅 Don't forget! ⏰",
+        }
+
+        response_json, response_headers = http_client._execute(
+            method="POST",
+            path="/messages/send",
+            request_body=request_body,
+        )
+
+        assert response_json == {"success": True}
+        call_kwargs = patched_request.call_args[1]
+        sent_json = call_kwargs["json"]
 
-        # The character should be preserved (not escaped)
-        decoded = sent_data.decode('utf-8')
-        assert "'" in decoded  # \u2019 right single quotation mark
-        assert "It's a test" in decoded
-        assert "Here's another" in decoded
-        # Should NOT contain unicode escape sequences
-        assert "\\u2019" not in decoded
+        # All emojis should be preserved exactly
+        assert sent_json["subject"] == "Hello 👋 World 🌍"
+        assert "🎉" in sent_json["body"]
+        assert "💪" in sent_json["body"]
+        assert "😊" in sent_json["body"]
+        assert sent_json["emoji_only"] == "🔥🚀✨💯"
+        assert "📅" in sent_json["mixed"]
+        assert "⏰" in sent_json["mixed"]
 
     def test_execute_with_multipart_data_not_affected(self, http_client, patched_version_and_sys, patched_request):
         """Test that multipart/form-data is not affected by the change."""