[rest] add decompression tests and fix multiple body() calls (Azure#21630)

Author: iscai-msft

sdk/core/azure-core/azure/core/rest/_requests_basic.py

@@ -68,7 +68,8 @@ def _body(self):
         # be able to access the body directly without loading it first (like we have to do
         # in aiohttp). So here, we set self._content to self._internal_response.content,
         # which is similar to read, without the async call.
-        self._content = self._internal_response.content
+        if self._content is None:
+            self._content = self._internal_response.content
         return self._content
 
 class _RestRequestsTransportResponseBase(_HttpResponseBaseImpl, _RestRequestsTransportResponseBaseMixin):

sdk/core/azure-core/tests/async_tests/test_rest_asyncio_transport.py

@@ -11,8 +11,14 @@
 import pytest
 from utils import readonly_checks
 
+@pytest.fixture
+async def client(port):
+    async with AsyncioRequestsTransport() as transport:
+        async with AsyncTestRestClient(port, transport=transport) as client:
+            yield client
+
 @pytest.mark.asyncio
-async def test_async_gen_data(port):
+async def test_async_gen_data(port, client):
     class AsyncGen:
         def __init__(self):
             self._range = iter([b"azerty"])
@@ -26,29 +32,52 @@ async def __anext__(self):
             except StopIteration:
                 raise StopAsyncIteration
 
-    async with AsyncioRequestsTransport() as transport:
-        client = AsyncTestRestClient(port, transport=transport)
-        request = HttpRequest('GET', 'http://localhost:{}/basic/anything'.format(port), content=AsyncGen())
-        response = await client.send_request(request)
-        assert response.json()['data'] == "azerty"
+    request = HttpRequest('GET', 'http://localhost:{}/basic/anything'.format(port), content=AsyncGen())
+    response = await client.send_request(request)
+    assert response.json()['data'] == "azerty"
 
 @pytest.mark.asyncio
-async def test_send_data(port):
-    async with AsyncioRequestsTransport() as transport:
-        client = AsyncTestRestClient(port, transport=transport)
-        request = HttpRequest('PUT', 'http://localhost:{}/basic/anything'.format(port), content=b"azerty")
-        response = await client.send_request(request)
+async def test_send_data(port, client):
+    request = HttpRequest('PUT', 'http://localhost:{}/basic/anything'.format(port), content=b"azerty")
+    response = await client.send_request(request)
 
-        assert response.json()['data'] == "azerty"
+    assert response.json()['data'] == "azerty"
 
 @pytest.mark.asyncio
-async def test_readonly(port):
+async def test_readonly(client):
     """Make sure everything that is readonly is readonly"""
-    async with AsyncioRequestsTransport() as transport:
-        client = AsyncTestRestClient(port, transport=transport)
-        response = await client.send_request(HttpRequest("GET", "/health"))
-        response.raise_for_status()
+    response = await client.send_request(HttpRequest("GET", "/health"))
+    response.raise_for_status()
 
     assert isinstance(response, RestAsyncioRequestsTransportResponse)
     from azure.core.pipeline.transport import AsyncioRequestsTransportResponse
     readonly_checks(response, old_response_class=AsyncioRequestsTransportResponse)
+
+@pytest.mark.asyncio
+async def test_decompress_compressed_header(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request)
+    content = await response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+@pytest.mark.asyncio
+async def test_decompress_compressed_header_stream(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request, stream=True)
+    content = await response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+@pytest.mark.asyncio
+async def test_decompress_compressed_header_stream_body_content(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request, stream=True)
+    await response.read()
+    content = response.content
+    assert content == response.body()

sdk/core/azure-core/tests/async_tests/test_rest_trio_transport.py

@@ -10,9 +10,14 @@
 from utils import readonly_checks
 import pytest
 
+@pytest.fixture
+async def client(port):
+    async with TrioRequestsTransport() as transport:
+        async with AsyncTestRestClient(port, transport=transport) as client:
+            yield client
 
 @pytest.mark.trio
-async def test_async_gen_data(port):
+async def test_async_gen_data(client, port):
     class AsyncGen:
         def __init__(self):
             self._range = iter([b"azerty"])
@@ -26,30 +31,51 @@ async def __anext__(self):
             except StopIteration:
                 raise StopAsyncIteration
 
-    async with TrioRequestsTransport() as transport:
-        client = AsyncTestRestClient(port, transport=transport)
-        request = HttpRequest('GET', 'http://localhost:{}/basic/anything'.format(port), content=AsyncGen())
-        response = await client.send_request(request)
-        assert response.json()['data'] == "azerty"
+    request = HttpRequest('GET', 'http://localhost:{}/basic/anything'.format(port), content=AsyncGen())
+    response = await client.send_request(request)
+    assert response.json()['data'] == "azerty"
 
 @pytest.mark.trio
-async def test_send_data(port):
-    async with TrioRequestsTransport() as transport:
-        request = HttpRequest('PUT', 'http://localhost:{}/basic/anything'.format(port), content=b"azerty")
-        client = AsyncTestRestClient(port, transport=transport)
-        response = await client.send_request(request)
-
-        assert response.json()['data'] == "azerty"
+async def test_send_data(port, client):
+    request = HttpRequest('PUT', 'http://localhost:{}/basic/anything'.format(port), content=b"azerty")
+    response = await client.send_request(request)
+    assert response.json()['data'] == "azerty"
 
 @pytest.mark.trio
-async def test_readonly(port):
+async def test_readonly(client):
     """Make sure everything that is readonly is readonly"""
-    async with TrioRequestsTransport() as transport:
-        request = HttpRequest('GET', 'http://localhost:{}/health'.format(port))
-        client = AsyncTestRestClient(port, transport=transport)
-        response = await client.send_request(HttpRequest("GET", "/health"))
-        response.raise_for_status()
+    response = await client.send_request(HttpRequest("GET", "/health"))
+    response.raise_for_status()
 
     assert isinstance(response, RestTrioRequestsTransportResponse)
     from azure.core.pipeline.transport import TrioRequestsTransportResponse
     readonly_checks(response, old_response_class=TrioRequestsTransportResponse)
+
+@pytest.mark.trio
+async def test_decompress_compressed_header(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request)
+    content = await response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+@pytest.mark.trio
+async def test_decompress_compressed_header_stream(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request, stream=True)
+    content = await response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+@pytest.mark.trio
+async def test_decompress_compressed_header_stream_body_content(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = await client.send_request(request, stream=True)
+    await response.read()
+    content = response.content
+    assert content == response.body()

sdk/core/azure-core/tests/test_rest_stream_responses.py

@@ -241,3 +241,29 @@ def test_pass_kwarg_to_iter_raw(client):
     response = client.send_request(request, stream=True)
     for part in response.iter_raw(chunk_size=5):
         assert part
+
+def test_decompress_compressed_header(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = client.send_request(request)
+    content = response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+def test_decompress_compressed_header_stream(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = client.send_request(request, stream=True)
+    content = response.read()
+    assert content == b"hello world"
+    assert response.content == content
+    assert response.text() == "hello world"
+
+def test_decompress_compressed_header_stream_body_content(client):
+    # expect plain text
+    request = HttpRequest("GET", "/encoding/gzip")
+    response = client.send_request(request, stream=True)
+    response.read()
+    content = response.content
+    assert content == response.body()