compressedfhir 3.0.2__py3-none-any.whl

compressedfhir/fhir/test/test_bundle_entry_request.py

@@ -0,0 +1,74 @@
+from datetime import datetime, timezone
+
+from compressedfhir.fhir.fhir_bundle_entry_request import FhirBundleEntryRequest
+
+
+class TestBundleEntryRequest:
+    def test_init_default(self) -> None:
+        """Test initialization with default parameters."""
+        request = FhirBundleEntryRequest(url="https://example.com")
+        assert request.url == "https://example.com"
+        assert request.method == "GET"
+        assert request.ifModifiedSince is None
+        assert request.ifNoneMatch is None
+
+    def test_init_full(self) -> None:
+        """Test initialization with all parameters."""
+        now = datetime.now(timezone.utc)
+        request = FhirBundleEntryRequest(
+            url="https://example.com",
+            method="POST",
+            ifModifiedSince=now,
+            ifNoneMatch='W/"abc"',
+        )
+        assert request.url == "https://example.com"
+        assert request.method == "POST"
+        assert request.ifModifiedSince == now
+        assert request.ifNoneMatch == 'W/"abc"'
+
+    def test_to_dict_minimal(self) -> None:
+        """Test converting to dictionary with minimal parameters."""
+        request = FhirBundleEntryRequest(url="https://example.com")
+        result = request.dict()
+        assert result == {"url": "https://example.com", "method": "GET"}
+
+    def test_to_dict_full(self) -> None:
+        """Test converting to dictionary with all parameters."""
+        now = datetime.now(timezone.utc)
+        request = FhirBundleEntryRequest(
+            url="https://example.com",
+            method="POST",
+            ifModifiedSince=now,
+            ifNoneMatch='W/"abc"',
+        )
+        result = request.dict()
+        assert result == {
+            "url": "https://example.com",
+            "method": "POST",
+            "ifModifiedSince": now.isoformat(),
+            "ifNoneMatch": 'W/"abc"',
+        }
+
+    def test_from_dict_minimal(self) -> None:
+        """Test creating from dictionary with minimal parameters."""
+        data = {"url": "https://example.com", "method": "GET"}
+        request = FhirBundleEntryRequest.from_dict(data)
+        assert request.url == "https://example.com"
+        assert request.method == "GET"
+        assert request.ifModifiedSince is None
+        assert request.ifNoneMatch is None
+
+    def test_from_dict_full(self) -> None:
+        """Test creating from dictionary with all parameters."""
+        now = datetime.now(timezone.utc)
+        data = {
+            "url": "https://example.com",
+            "method": "POST",
+            "ifModifiedSince": now.isoformat(),
+            "ifNoneMatch": 'W/"abc"',
+        }
+        request = FhirBundleEntryRequest.from_dict(data)
+        assert request.url == "https://example.com"
+        assert request.method == "POST"
+        assert request.ifModifiedSince == now
+        assert request.ifNoneMatch == 'W/"abc"'

compressedfhir/fhir/test/test_bundle_entry_response.py

@@ -0,0 +1,65 @@
+from datetime import datetime, timezone
+
+from compressedfhir.fhir.fhir_bundle_entry_response import (
+    FhirBundleEntryResponse,
+)
+
+
+class TestBundleEntryResponse:
+    def test_init_default(self) -> None:
+        """Test initialization with default parameters."""
+        response = FhirBundleEntryResponse(status="200", etag=None, lastModified=None)
+        assert response.status == "200"
+        assert response.etag is None
+        assert response.lastModified is None
+
+    def test_init_full(self) -> None:
+        """Test initialization with all parameters."""
+        now = datetime.now(timezone.utc)
+        response = FhirBundleEntryResponse(
+            status="201", etag='W/"def"', lastModified=now
+        )
+        assert response.status == "201"
+        assert response.etag == 'W/"def"'
+        assert response.lastModified == now
+
+    def test_init_int_status(self) -> None:
+        """Test initialization with integer status."""
+        response = FhirBundleEntryResponse(status="200", etag=None, lastModified=None)
+        assert response.status == "200"
+
+    def test_to_dict_minimal(self) -> None:
+        """Test converting to dictionary with minimal parameters."""
+        response = FhirBundleEntryResponse(status="200", etag=None, lastModified=None)
+        result = response.dict()
+        assert result == {"status": "200"}
+
+    def test_to_dict_full(self) -> None:
+        """Test converting to dictionary with all parameters."""
+        now = datetime.now(timezone.utc)
+        response = FhirBundleEntryResponse(
+            status="201", etag='W/"def"', lastModified=now
+        )
+        result = response.dict()
+        assert result == {
+            "status": "201",
+            "lastModified": now.isoformat(),
+            "etag": 'W/"def"',
+        }
+
+    def test_from_dict_minimal(self) -> None:
+        """Test creating from dictionary with minimal parameters."""
+        data = {"status": "200"}
+        response = FhirBundleEntryResponse.from_dict(data)
+        assert response.status == "200"
+        assert response.etag is None
+        assert response.lastModified is None
+
+    def test_from_dict_full(self) -> None:
+        """Test creating from dictionary with all parameters."""
+        now = datetime.now(timezone.utc)
+        data = {"status": "201", "lastModified": now.isoformat(), "etag": 'W/"def"'}
+        response = FhirBundleEntryResponse.from_dict(data)
+        assert response.status == "201"
+        assert response.lastModified == now
+        assert response.etag == 'W/"def"'

compressedfhir/fhir/test/test_fhir_bundle.py

@@ -0,0 +1,245 @@
+import json
+
+from compressedfhir.fhir.fhir_bundle import FhirBundle
+from compressedfhir.fhir.fhir_bundle_entry import FhirBundleEntry
+from compressedfhir.fhir.fhir_bundle_entry_list import FhirBundleEntryList
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+
+class TestBundle:
+    def test_init_minimal(self) -> None:
+        """Test initialization with minimal parameters."""
+        bundle = FhirBundle(type_="searchset")
+        assert bundle.type_ == "searchset"
+        assert len(bundle.entry) == 0
+        assert bundle.total is None
+        assert bundle.id_ is None
+        assert bundle.timestamp is None
+
+    def test_init_full(self) -> None:
+        """Test initialization with all parameters."""
+        entries = FhirBundleEntryList(
+            [
+                FhirBundleEntry(
+                    resource={"resourceType": "Patient"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+                FhirBundleEntry(
+                    resource={"resourceType": "Observation"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+            ]
+        )
+        bundle = FhirBundle(
+            type_="searchset",
+            entry=entries,
+            total=2,
+            id_="test-bundle",
+            timestamp="2023-12-01T12:00:00Z",
+        )
+        assert bundle.type_ == "searchset"
+        assert bundle.entry is not None
+        assert len(bundle.entry) == 2
+        assert bundle.total == 2
+        assert bundle.id_ == "test-bundle"
+        assert bundle.timestamp == "2023-12-01T12:00:00Z"
+
+    def test_to_dict_minimal(self) -> None:
+        """Test converting to dictionary with minimal parameters."""
+        bundle = FhirBundle(type_="searchset")
+        result = bundle.dict()
+        assert result == {"type": "searchset", "resourceType": "Bundle"}
+
+    def test_to_dict_full(self) -> None:
+        """Test converting to dictionary with all parameters."""
+        entries = FhirBundleEntryList(
+            [
+                FhirBundleEntry(
+                    resource={"resourceType": "Patient"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+                FhirBundleEntry(
+                    resource={"resourceType": "Observation"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+            ]
+        )
+        bundle = FhirBundle(
+            type_="searchset",
+            entry=entries,
+            total=2,
+            id_="test-bundle",
+            timestamp="2023-12-01T12:00:00Z",
+        )
+        result = bundle.dict()
+        assert result == {
+            "type": "searchset",
+            "resourceType": "Bundle",
+            "id": "test-bundle",
+            "timestamp": "2023-12-01T12:00:00Z",
+            "total": 2,
+            "entry": [
+                {"resource": {"resourceType": "Patient"}},
+                {"resource": {"resourceType": "Observation"}},
+            ],
+        }
+
+    def test_to_json(self) -> None:
+        """Test converting Bundle to JSON."""
+        entries = FhirBundleEntryList(
+            [
+                FhirBundleEntry(
+                    resource={"resourceType": "Patient"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+                FhirBundleEntry(
+                    resource={"resourceType": "Observation"},
+                    request=None,
+                    response=None,
+                    storage_mode=CompressedDictStorageMode(),
+                ),
+            ]
+        )
+        bundle = FhirBundle(
+            type_="searchset",
+            entry=entries,
+            total=2,
+            id_="test-bundle",
+            timestamp="2023-12-01T12:00:00Z",
+        )
+        json_str = bundle.json()
+        parsed_json = json.loads(json_str)
+        assert parsed_json["type"] == "searchset"
+        assert parsed_json["resourceType"] == "Bundle"
+
+    def test_add_diagnostics_to_operation_outcomes(self) -> None:
+        """Test adding diagnostics to OperationOutcome resources."""
+        resource = FhirResource(
+            initial_dict={
+                "resourceType": "OperationOutcome",
+                "issue": [{"severity": "error", "details": {}}],
+            },
+            storage_mode=CompressedDictStorageMode(),
+        )
+        diagnostics_coding = [{"code": "test-code"}]
+
+        updated_resource = FhirBundle.add_diagnostics_to_operation_outcomes(
+            resource=resource, diagnostics_coding=diagnostics_coding
+        )
+
+        with updated_resource.transaction():
+            assert (
+                updated_resource["issue"][0]["details"]["coding"] == diagnostics_coding
+            )
+
+
+class TestFhirBundleCopy:
+    def test_copy_full_bundle(self) -> None:
+        """
+        Test copying a fully populated FhirBundle
+        """
+        # Create a mock FhirBundleEntryList
+        mock_entry_list = FhirBundleEntryList()
+        mock_resource = FhirBundleEntry(
+            resource=FhirResource({"resourceType": "Patient", "id": "123"})
+        )
+        mock_entry_list.append(mock_resource)
+
+        # Create original bundle
+        original_bundle = FhirBundle(
+            id_="test-bundle-id",
+            timestamp="2023-01-01T00:00:00Z",
+            type_="transaction",
+            entry=mock_entry_list,
+            total=1,
+        )
+
+        # Create a copy
+        copied_bundle = original_bundle.copy()
+
+        # Assert that the copied bundle has the same attributes
+        assert copied_bundle.id_ == original_bundle.id_
+        assert copied_bundle.timestamp == original_bundle.timestamp
+        assert copied_bundle.type_ == original_bundle.type_
+        assert copied_bundle.total == original_bundle.total
+
+        # Ensure the entry list is a copy, not the same object
+        assert copied_bundle.entry is not original_bundle.entry
+        assert copied_bundle.entry is not None
+        assert original_bundle.entry is not None
+        assert len(copied_bundle.entry) == len(original_bundle.entry)
+        assert copied_bundle.entry[0].dict() == original_bundle.entry[0].dict()
+
+    def test_copy_empty_bundle(self) -> None:
+        """
+        Test copying a bundle with no entries
+        """
+        # Create an empty bundle
+        original_bundle = FhirBundle(type_="batch", entry=None, total=None)
+
+        # Create a copy
+        copied_bundle = original_bundle.copy()
+
+        # Assert that the copied bundle has the same attributes
+        assert copied_bundle.id_ is None
+        assert copied_bundle.timestamp is None
+        assert copied_bundle.type_ == "batch"
+        assert copied_bundle.total is None
+        assert len(copied_bundle.entry) == 0
+
+    def test_copy_modifying_original_does_not_affect_copy(self) -> None:
+        """
+        Test that modifying the original bundle does not affect the copy
+        """
+        # Create a mock FhirBundleEntryList
+        mock_entry_list = FhirBundleEntryList()
+        mock_resource = FhirResource({"resourceType": "Patient", "id": "123"})
+        mock_entry_list.append(FhirBundleEntry(resource=mock_resource))
+
+        # Create original bundle
+        original_bundle = FhirBundle(
+            id_="test-bundle-id",
+            timestamp="2023-01-01T00:00:00Z",
+            type_="transaction",
+            entry=mock_entry_list,
+            total=1,
+        )
+
+        # Create a copy
+        copied_bundle = original_bundle.copy()
+
+        # Modify the original bundle
+        original_bundle.id_ = "modified-id"
+        original_bundle.timestamp = "2023-02-01T00:00:00Z"
+        original_bundle.total = 2
+
+        # Assert that the copied bundle remains unchanged
+        assert copied_bundle.id_ == "test-bundle-id"
+        assert copied_bundle.timestamp == "2023-01-01T00:00:00Z"
+        assert copied_bundle.total == 1
+
+    def test_copy_returns_new_instance(self) -> None:
+        """
+        Test that copy() returns a new FhirBundle instance
+        """
+        # Create a bundle
+        original_bundle = FhirBundle(type_="batch")
+
+        # Create a copy
+        copied_bundle = original_bundle.copy()
+
+        # Assert that it's a different object
+        assert copied_bundle is not original_bundle

compressedfhir/fhir/test/test_fhir_resource.py

@@ -0,0 +1,104 @@
+import json
+from typing import Dict, Any
+
+from compressedfhir.fhir.fhir_resource import FhirResource
+from compressedfhir.utilities.compressed_dict.v1.compressed_dict_storage_mode import (
+    CompressedDictStorageMode,
+)
+
+
+class TestFhirResource:
+    def test_init_empty(self) -> None:
+        """Test initializing FhirResource with no initial dictionary."""
+        resource = FhirResource(storage_mode=CompressedDictStorageMode())
+        assert len(resource) == 0
+        assert resource.resource_type is None
+        assert resource.id is None
+        assert resource.resource_type_and_id is None
+
+    def test_init_with_data(self) -> None:
+        """Test initializing FhirResource with a dictionary."""
+        initial_data: Dict[str, Any] = {
+            "resourceType": "Patient",
+            "id": "123",
+            "name": [{"given": ["John"]}],
+        }
+        resource = FhirResource(
+            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
+        )
+
+        with resource.transaction():
+            assert resource.resource_type == "Patient"
+            assert resource.id == "123"
+            assert resource.resource_type_and_id == "Patient/123"
+            assert resource["name"][0]["given"][0] == "John"
+
+    def test_resource_type_and_id_property(self) -> None:
+        """Test resource_type_and_id property with various scenarios."""
+        # Scenario 1: Both resource type and id present
+        resource1 = FhirResource(
+            initial_dict={"resourceType": "Observation", "id": "456"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1.resource_type_and_id == "Observation/456"
+
+        # Scenario 2: Missing resource type
+        resource2 = FhirResource(
+            initial_dict={"id": "789"}, storage_mode=CompressedDictStorageMode()
+        )
+        assert resource2.resource_type_and_id is None
+
+        # Scenario 3: Missing id
+        resource3 = FhirResource(
+            initial_dict={"resourceType": "Patient"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource3.resource_type_and_id is None
+
+    def test_equality(self) -> None:
+        """Test equality comparison between FhirResource instances."""
+        # Scenario 1: Equal resources
+        resource1 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        resource2 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 == resource2
+
+        # Scenario 2: Different resource types
+        resource3 = FhirResource(
+            initial_dict={"resourceType": "Observation", "id": "123"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 != resource3
+
+        # Scenario 3: Different ids
+        resource4 = FhirResource(
+            initial_dict={"resourceType": "Patient", "id": "456"},
+            storage_mode=CompressedDictStorageMode(),
+        )
+        assert resource1 != resource4
+
+        # Scenario 4: Comparing with non-FhirResource
+        assert resource1 != "Not a FhirResource"
+
+    def test_to_json(self) -> None:
+        """Test JSON serialization of FhirResource."""
+        initial_data: Dict[str, Any] = {
+            "resourceType": "Patient",
+            "id": "123",
+            "name": [{"given": ["John"]}],
+        }
+        resource = FhirResource(
+            initial_dict=initial_data, storage_mode=CompressedDictStorageMode()
+        )
+
+        json_str = resource.json()
+        parsed_json = json.loads(json_str)
+
+        assert parsed_json == initial_data
+        assert "resourceType" in parsed_json
+        assert "id" in parsed_json

compressedfhir/fhir/test/test_fhir_resource_list.py

@@ -0,0 +1,160 @@
+import json
+from unittest.mock import Mock
+
+import pytest
+
+from compressedfhir.fhir.fhir_resource_list import FhirResourceList
+
+
+class TestFhirResourceList:
+    def test_get_resource_type_and_ids(self) -> None:
+        # Create mock FhirResource objects
+        mock_resources = [
+            Mock(resource_type="Patient", id="123"),
+            Mock(resource_type="Observation", id="456"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Check the returned resource type and ids
+        expected_result = ["Patient/123", "Observation/456"]
+        assert resource_list.get_resource_type_and_ids() == expected_result
+
+    def test_get_operation_outcomes(self) -> None:
+        # Create mock FhirResource objects with different resource types
+        mock_resources = [
+            Mock(resource_type="OperationOutcome", id="err1"),
+            Mock(resource_type="Patient", id="123"),
+            Mock(resource_type="OperationOutcome", id="err2"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Get operation outcomes
+        operation_outcomes = resource_list.get_operation_outcomes()
+
+        # Check the result
+        assert len(operation_outcomes) == 2
+        assert all(r.resource_type == "OperationOutcome" for r in operation_outcomes)
+
+    def test_get_resources_except_operation_outcomes(self) -> None:
+        # Create mock FhirResource objects with different resource types
+        mock_resources = [
+            Mock(resource_type="OperationOutcome", id="err1"),
+            Mock(resource_type="Patient", id="123"),
+            Mock(resource_type="Observation", id="456"),
+            Mock(resource_type="OperationOutcome", id="err2"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Get resources except operation outcomes
+        valid_resources = resource_list.get_resources_except_operation_outcomes()
+
+        # Check the result
+        assert len(valid_resources) == 2
+        assert all(r.resource_type != "OperationOutcome" for r in valid_resources)
+
+    def test_remove_duplicates(self) -> None:
+        # Create mock FhirResource objects with duplicates
+        mock_resources = [
+            Mock(resource_type="Patient", id="123", resource_type_and_id="Patient/123"),
+            Mock(resource_type="Patient", id="123", resource_type_and_id="Patient/123"),
+            Mock(
+                resource_type="Observation",
+                id="456",
+                resource_type_and_id="Observation/456",
+            ),
+            Mock(resource_type="Patient", id="789", resource_type_and_id="Patient/789"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Remove duplicates
+        resource_list.remove_duplicates()
+
+        # Check the result
+        assert len(resource_list) == 3
+        assert len(set(r.resource_type_and_id for r in resource_list)) == 3
+
+    def test_to_json(self) -> None:
+        # Create mock FhirResource objects
+        mock_resources = [
+            Mock(
+                resource_type="Patient",
+                id="123",
+                dict=lambda: {"id": "123", "resourceType": "Patient"},
+            ),
+            Mock(
+                resource_type="Observation",
+                id="456",
+                dict=lambda: {"id": "456", "resourceType": "Observation"},
+            ),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Convert to JSON
+        json_str = resource_list.json()
+
+        # Parse and check the JSON
+        parsed_json = json.loads(json_str)
+        assert len(parsed_json) == 2
+        assert parsed_json[0]["resourceType"] == "Patient"
+        assert parsed_json[1]["resourceType"] == "Observation"
+
+    @pytest.mark.asyncio
+    async def test_consume_resource_async_default(self) -> None:
+        # Create mock FhirResource objects
+        mock_resources = [
+            Mock(resource_type="Patient", id="123"),
+            Mock(resource_type="Observation", id="456"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Consume resources asynchronously with default (None) batch size
+        async for batch in resource_list.consume_resource_batch_async(batch_size=None):
+            assert len(batch) == 2
+
+        # Ensure all resources are consumed
+        assert len(resource_list) == 0
+
+    @pytest.mark.asyncio
+    async def test_consume_resource_async_with_batch_size(self) -> None:
+        # Create mock FhirResource objects
+        mock_resources = [
+            Mock(resource_type="Patient", id="123"),
+            Mock(resource_type="Observation", id="456"),
+            Mock(resource_type="Condition", id="789"),
+        ]
+
+        resource_list = FhirResourceList(mock_resources)
+
+        # Consume resources asynchronously with batch size of 2
+        batches = []
+        async for batch in resource_list.consume_resource_batch_async(batch_size=2):
+            batches.append(batch)
+
+        # Check batches
+        assert len(batches) == 2
+        assert len(batches[0]) == 2
+        assert len(batches[1]) == 1
+
+        # Ensure all resources are consumed
+        assert len(resource_list) == 0
+
+    def test_consume_resource_async_invalid_batch_size(self) -> None:
+        resource_list = FhirResourceList()
+
+        # Test invalid batch sizes
+        with pytest.raises(ValueError, match="Batch size must be greater than 0."):
+
+            async def test() -> None:
+                async for _ in resource_list.consume_resource_batch_async(batch_size=0):
+                    pass
+
+            # Run the async function
+            import asyncio
+
+            asyncio.run(test())