Refine test_requests_batch.py

Author: HayaoSuzuki

tests/test_requests_batch.py

@@ -73,14 +73,28 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            # Execute query synchronously
-            results = session.execute_batch(query)
+            # Execute query synchronously with timeout and get_execution_result=True
+            execution_results = session.execute_batch(
+                query, get_execution_result=True, timeout=10
+            )
 
-            continents = results[0]["continents"]
+            # Verify the ExecutionResult structure
+            assert len(execution_results) == 1
+            result = execution_results[0]
 
-            africa = continents[0]
+            # Verify errors is None (not just missing)
+            assert result.errors is None
+            # Verify extensions is None (response has no extensions)
+            assert result.extensions is None
+
+            # Verify data content
+            assert result.data is not None
+            continents = result.data["continents"]
+            assert len(continents) == 7
 
+            africa = continents[0]
             assert africa["code"] == "AF"
+            assert africa["name"] == "Africa"
 
             # Checking response headers are saved in the transport
             assert hasattr(transport, "response_headers")
@@ -90,6 +104,55 @@ def test_code():
     await run_sync_test(server, test_code)
 
 
+@pytest.mark.aiohttp
+@pytest.mark.asyncio
+async def test_requests_query_two_requests(aiohttp_server, run_sync_test):
+    from aiohttp import web
+
+    from gql.transport.requests import RequestsHTTPTransport
+
+    async def handler(request):
+        return web.Response(
+            text=query1_server_answer_twice_list,
+            content_type="application/json",
+        )
+
+    app = web.Application()
+    app.router.add_route("POST", "/", handler)
+    server = await aiohttp_server(app)
+
+    url = server.make_url("/")
+
+    def test_code():
+        transport = RequestsHTTPTransport(url=url)
+
+        with Client(transport=transport) as session:
+
+            # Two requests in batch
+            query = [GraphQLRequest(query1_str), GraphQLRequest(query1_str)]
+
+            # Execute query synchronously with timeout and get_execution_result=True
+            execution_results = session.execute_batch(
+                query, get_execution_result=True, timeout=10
+            )
+
+            # Verify we got exactly 2 results
+            assert len(execution_results) == 2
+
+            # Verify both results
+            for result in execution_results:
+                assert result.errors is None
+                assert result.extensions is None
+                assert result.data is not None
+
+                continents = result.data["continents"]
+                assert len(continents) == 7
+                assert continents[0]["code"] == "AF"
+                assert continents[0]["name"] == "Africa"
+
+    await run_sync_test(server, test_code)
+
+
 @pytest.mark.aiohttp
 @pytest.mark.asyncio
 async def test_requests_query_auto_batch_enabled(aiohttp_server, run_sync_test):
@@ -227,14 +290,22 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            # Execute query synchronously
-            results = session.execute_batch(query)
+            # Execute query synchronously with timeout and get_execution_result=True
+            execution_results = session.execute_batch(
+                query, get_execution_result=True, timeout=10
+            )
 
-            continents = results[0]["continents"]
+            result = execution_results[0]
 
-            africa = continents[0]
+            # Verify ExecutionResult structure
+            assert result.errors is None
+            assert result.extensions is None
+            assert result.data is not None
 
+            continents = result.data["continents"]
+            africa = continents[0]
             assert africa["code"] == "AF"
+            assert africa["name"] == "Africa"
 
     await run_sync_test(server, test_code)
 
@@ -271,6 +342,7 @@ def test_code():
                 session.execute_batch(query)
 
             assert "401 Client Error: Unauthorized" in str(exc_info.value)
+            assert exc_info.value.code == 401
 
     await run_sync_test(server, test_code)
 
@@ -312,6 +384,7 @@ def test_code():
                 session.execute(request)
 
             assert "401 Client Error: Unauthorized" in str(exc_info.value)
+            assert exc_info.value.code == 401
 
     await run_sync_test(server, test_code)
 
@@ -359,6 +432,7 @@ def test_code():
                 session.execute_batch(query)
 
             assert "429, message='Too Many Requests'" in str(exc_info.value)
+            assert exc_info.value.code == 429
 
         # Checking response headers are saved in the transport
         assert hasattr(transport, "response_headers")
@@ -390,9 +464,13 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            with pytest.raises(TransportServerError):
+            with pytest.raises(TransportServerError) as exc_info:
                 session.execute_batch(query)
 
+            # Verify the error contains 500 status code
+            assert "500" in str(exc_info.value)
+            assert exc_info.value.code == 500
+
     await run_sync_test(server, test_code)
 
 
@@ -424,28 +502,71 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            with pytest.raises(TransportQueryError):
+            with pytest.raises(TransportQueryError) as exc_info:
                 session.execute_batch(query)
 
+            # Verify error message
+            assert str(exc_info.value) == "Error 1"
+
+            # Verify errors list from exception
+            assert exc_info.value.errors == ["Error 1", "Error 2"]
+
+            # Verify data is None (no data in response)
+            assert exc_info.value.data is None
+
+            # Verify extensions is None (no extensions in response)
+            assert exc_info.value.extensions is None
+
     await run_sync_test(server, test_code)
 
 
 invalid_protocol_responses = [
-    "{}",
-    "qlsjfqsdlkj",
-    '{"not_data_or_errors": 35}',
-    "[{}]",
-    "[qlsjfqsdlkj]",
-    '[{"not_data_or_errors": 35}]',
-    "[]",
-    "[1]",
+    (
+        "{}",
+        "Server did not return a valid GraphQL result: Answer is not a list: {}",
+    ),
+    (
+        "qlsjfqsdlkj",
+        "Server did not return a GraphQL result: Not a JSON answer: qlsjfqsdlkj",
+    ),
+    (
+        '{"not_data_or_errors": 35}',
+        "Server did not return a valid GraphQL result: "
+        "Answer is not a list: {'not_data_or_errors': 35}",
+    ),
+    (
+        "[{}]",
+        "Server did not return a valid GraphQL result: "
+        'No "data" or "errors" keys in answer: [{}]',
+    ),
+    (
+        "[qlsjfqsdlkj]",
+        "Server did not return a GraphQL result: Not a JSON answer: [qlsjfqsdlkj]",
+    ),
+    (
+        '[{"not_data_or_errors": 35}]',
+        "Server did not return a valid GraphQL result: "
+        'No "data" or "errors" keys in answer: [{\'not_data_or_errors\': 35}]',
+    ),
+    (
+        "[]",
+        "Server did not return a valid GraphQL result: "
+        "Invalid number of answers: 0 answers received for 1 requests: []",
+    ),
+    (
+        "[1]",
+        "Server did not return a valid GraphQL result: "
+        "Not every answer is dict: [1]",
+    ),
 ]
 
 
 @pytest.mark.aiohttp
 @pytest.mark.asyncio
-@pytest.mark.parametrize("response", invalid_protocol_responses)
-async def test_requests_invalid_protocol(aiohttp_server, response, run_sync_test):
+@pytest.mark.parametrize("response,expected_message", invalid_protocol_responses)
+async def test_requests_invalid_protocol(
+    aiohttp_server, response, expected_message, run_sync_test
+):
     from aiohttp import web
 
     from gql.transport.requests import RequestsHTTPTransport
@@ -466,9 +587,11 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            with pytest.raises(TransportProtocolError):
+            with pytest.raises(TransportProtocolError) as exc_info:
                 session.execute_batch(query)
 
+            assert str(exc_info.value) == expected_message
+
     await run_sync_test(server, test_code)
 
 
@@ -495,9 +618,11 @@ def test_code():
 
         query = [GraphQLRequest(query1_str)]
 
-        with pytest.raises(TransportClosed):
+        with pytest.raises(TransportClosed) as exc_info:
             transport.execute_batch(query)
 
+        assert str(exc_info.value) == "Transport is not connected"
+
     await run_sync_test(server, test_code)
 
 
@@ -538,9 +663,22 @@ def test_code():
 
             query = [GraphQLRequest(query1_str)]
 
-            execution_results = session.execute_batch(query, get_execution_result=True)
+            execution_results = session.execute_batch(
+                query, get_execution_result=True, timeout=10
+            )
+
+            result = execution_results[0]
+
+            # Verify errors is None
+            assert result.errors is None
+
+            # Verify data content
+            assert result.data is not None
+            assert result.data["continents"][0]["code"] == "AF"
 
-            assert execution_results[0].extensions["key1"] == "val1"
+            # Verify extensions
+            assert result.extensions is not None
+            assert result.extensions["key1"] == "val1"
 
     await run_sync_test(server, test_code)