helix.fhir.client.sdk 4.2.3__py3-none-any.whl → 4.2.19__py3-none-any.whl

tests/test_fhir_client_clone.py

@@ -0,0 +1,155 @@
+"""
+Tests for FhirClient.clone() method to ensure all properties are properly copied.
+"""
+
+from datetime import UTC, datetime, timedelta
+
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+from helix_fhir_client_sdk.fhir_client import FhirClient
+
+
+def test_clone_preserves_compress_setting() -> None:
+    """Test that clone() preserves the _compress setting"""
+    # Create a client with compression disabled
+    fhir_client = FhirClient().url("http://example.com").compress(False)
+    assert fhir_client._compress is False
+
+    # Clone and verify compression is still disabled
+    cloned_client = fhir_client.clone()
+    assert cloned_client._compress is False
+
+    # Test with compression enabled
+    fhir_client2 = FhirClient().url("http://example.com").compress(True)
+    assert fhir_client2._compress is True
+
+    cloned_client2 = fhir_client2.clone()
+    assert cloned_client2._compress is True
+
+
+def test_clone_preserves_storage_mode() -> None:
+    """Test that clone() preserves the _storage_mode setting"""
+    # Create a client with msgpack storage mode
+    storage_mode = CompressedDictStorageMode(storage_type="msgpack")
+    fhir_client = FhirClient().url("http://example.com").set_storage_mode(storage_mode)
+    assert fhir_client._storage_mode.storage_type == "msgpack"
+
+    # Clone and verify storage mode is preserved
+    cloned_client = fhir_client.clone()
+    assert cloned_client._storage_mode.storage_type == "msgpack"
+
+
+def test_clone_preserves_additional_settings() -> None:
+    """Test that clone() preserves other compression-related settings"""
+    fhir_client = (
+        FhirClient()
+        .url("http://example.com")
+        .compress(False)
+        .send_data_as_chunked(True)
+        .use_post_for_search(True)
+        .maximum_time_to_retry_on_429(120)
+        .retry_count(5)
+        .throw_exception_on_error(False)
+        .set_log_all_response_urls(True)
+        .set_create_operation_outcome_for_error(True)
+    )
+
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._compress is False
+    assert cloned_client._send_data_as_chunked is True
+    assert cloned_client._use_post_for_search is True
+    assert cloned_client._maximum_time_to_retry_on_429 == 120
+    assert cloned_client._retry_count == 5
+    assert cloned_client._throw_exception_on_error is False
+    assert cloned_client._log_all_response_urls is True
+    assert cloned_client._create_operation_outcome_for_error is True
+
+
+def test_default_compression_is_enabled() -> None:
+    """Test that compression is enabled by default"""
+    fhir_client = FhirClient()
+    assert fhir_client._compress is True
+
+
+def test_default_storage_mode_is_raw() -> None:
+    """Test that the default storage mode is 'raw'"""
+    fhir_client = FhirClient()
+    assert fhir_client._storage_mode.storage_type == "raw"
+
+
+def test_clone_preserves_access_token() -> None:
+    """Test that clone() preserves access token and expiry date"""
+    expiry_date = datetime.now(UTC) + timedelta(hours=1)
+    fhir_client = (
+        FhirClient()
+        .url("http://example.com")
+        .set_access_token("test-access-token-12345")
+        .set_access_token_expiry_date(expiry_date)
+    )
+
+    assert fhir_client._access_token == "test-access-token-12345"
+    assert fhir_client._access_token_expiry_date == expiry_date
+
+    # Clone and verify access token is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._access_token == "test-access-token-12345"
+    assert cloned_client._access_token_expiry_date == expiry_date
+
+
+def test_clone_preserves_max_concurrent_requests() -> None:
+    """Test that clone() preserves max_concurrent_requests setting"""
+    fhir_client = FhirClient().url("http://example.com").set_max_concurrent_requests(10)
+
+    assert fhir_client._max_concurrent_requests == 10
+
+    # Clone and verify max_concurrent_requests is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._max_concurrent_requests == 10
+
+
+def test_use_http_session() -> None:
+    """Test that use_http_session sets the callable correctly"""
+    from aiohttp import ClientSession
+
+    def custom_session_factory() -> ClientSession:
+        return ClientSession()
+
+    fhir_client = FhirClient().url("http://example.com")
+
+    # Initially None
+    assert fhir_client._fn_create_http_session is None
+
+    # Set the callable
+    result = fhir_client.use_http_session(custom_session_factory)
+
+    # Returns self for chaining
+    assert result is fhir_client
+
+    # Callable is stored
+    assert fhir_client._fn_create_http_session is custom_session_factory
+
+    # Can set to None
+    fhir_client.use_http_session(None)
+    assert fhir_client._fn_create_http_session is None
+
+
+def test_clone_preserves_fn_create_http_session() -> None:
+    """Test that clone() preserves the _fn_create_http_session callable"""
+    from aiohttp import ClientSession
+
+    def custom_session_factory() -> ClientSession:
+        return ClientSession()
+
+    fhir_client = FhirClient().url("http://example.com").use_http_session(custom_session_factory)
+
+    assert fhir_client._fn_create_http_session is custom_session_factory
+
+    # Clone and verify fn_create_http_session is preserved
+    cloned_client = fhir_client.clone()
+
+    assert cloned_client._fn_create_http_session is custom_session_factory

helix_fhir_client_sdk-4.2.3.dist-info/METADATA

@@ -1,115 +0,0 @@
-Metadata-Version: 2.4
-Name: helix.fhir.client.sdk
-Version: 4.2.3
-Summary: helix.fhir.client.sdk
-Home-page: https://github.com/icanbwell/helix.fhir.client.sdk
-Author: Imran Qureshi
-Author-email: imran@icanbwell.com
-Classifier: Development Status :: 4 - Beta
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: furl
-Requires-Dist: requests
-Requires-Dist: urllib3
-Requires-Dist: chardet
-Requires-Dist: aiohttp
-Requires-Dist: async-timeout>=4.0.3
-Requires-Dist: python-dateutil
-Requires-Dist: compressedfhir>=1.0.3
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# helix.fhir.client.sdk
-
-<p align="left">
-  <a href="https://github.com/icanbwell/helix.fhir.client.sdk/actions">
-    <img src="https://github.com/icanbwell/helix.fhir.client.sdk/workflows/Build%20and%20Test/badge.svg"
-         alt="Continuous Integration">
-  </a>
-  <a href="https://github.com/icanbwell/helix.fhir.client.sdk/releases/latest">
-    <img src="https://img.shields.io/github/v/release/icanbwell/helix.fhir.client.sdk?display_name=tag"
-          alt="Latest Release">
-  </a>
-  <a href="https://github.com/icanbwell/helix.fhir.client.sdk/blob/main/LICENSE">
-    <img src="https://img.shields.io/badge/license-Apache%202-blue"
-         alt="GitHub license">
-  </a>
-</p>
-
-Fluent API to call the FHIR server that handles:
-
-1. Authentication to FHIR server
-2. Renewing access token when they expire
-3. Retry when there are transient errors
-4. Un-bundling the resources received from FHIR server
-5. Paging
-6. Streaming
-7. Logging
-8. Simulating a $graph call when the server does not support it
-
-
-# Usage
-`pip install helix.fhir.client.sdk`
-
-# Documentation
-https://icanbwell.github.io/helix.fhir.client.sdk/
-
-# Test Project using this
-https://github.com/icanbwell/fhir-server-performance
-
-# Python Version Support
-* 1.x supports python 3.7+ 
-* 2.x supports python 3.10+
-* 3.x supports python 3.12+
-
-# Asynchronous Support
-When communicating with FHIR servers, a lot of time is spent waiting for the server to respond. 
-This is a good use case for using asynchronous programming. 
-This SDK supports asynchronous programming using the `async` and `await` keywords.
-
-The return types are Python AsyncGenerators.  Python makes it very easy to work with AsyncGenerators.
-
-For example, if the SDK provides a function like this:
-```python
-
-async def get_resources(self) -> AsyncGenerator[FhirGetResponse, None]:
-    ...
-```
-
-You can iterate over the results as they become available:
-```python
-response: Optional[FhirGetResponse]
-async for response in client.get_resources():
-    print(response.resource)
-```
-
-Or you can get a list of responses (which will return AFTER all the responses are received:
-```python
-
-responses: List[FhirGetResponse] = [response async for response in client.get_resources()]
-```
-
-Or you can aggregate the responses into one response (which will return AFTER all the responses are received:
-```python
-
-response: Optional[FhirGetResponse] = await FhirGetResponse.from_async_generator(client.get_resources())
-```
-
-# Data Streaming
-For FHIR servers that support data streaming (e.g., b.well FHIR server), you can just set the `use_data_streaming` parameter to stream the data as it i received.
-The data will be streamed in AsyncGenerators as described above.
-
-# Storage Compression
-The FHIR client SDK natively stores the FHIR resources compressed in memory.  This allows use in environments where you are processing large number of FHIR resources.