compressedfhir 0.0.1__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,225 @@
+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
+
+
+class TestFhirResourceRemoveNulls:
+    def test_remove_nulls_simple_dict(self) -> None:
+        """
+        Test removing None values from a simple dictionary
+        """
+        initial_dict: Dict[str, Any] = {
+            "name": "John Doe",
+            "age": None,
+            "active": True,
+            "email": None,
+        }
+        resource = FhirResource(initial_dict=initial_dict)
+        resource.remove_nulls()
+
+        with resource.transaction():
+            # Check that None values are removed
+            assert "age" not in resource
+            assert "email" not in resource
+            assert resource.get("name") == "John Doe"
+            assert resource.get("active") is True
+
+    def test_remove_nulls_nested_dict(self) -> None:
+        """
+        Test removing None values from a nested dictionary
+        """
+        initial_dict: Dict[str, Any] = {
+            "patient": {
+                "name": "Jane Smith",
+                "contact": None,
+                "address": {"street": None, "city": "New York"},
+            },
+            "status": None,
+        }
+        resource = FhirResource(initial_dict=initial_dict)
+        resource.remove_nulls()
+
+        with resource.transaction():
+            assert "status" not in resource
+            assert "contact" not in resource.get("patient", {})
+            assert resource.get("patient", {}).get("address", {}).get("street") is None
+            assert (
+                resource.get("patient", {}).get("address", {}).get("city") == "New York"
+            )
+
+    def test_remove_nulls_list_of_dicts(self) -> None:
+        """
+        Test removing None values from a list of dictionaries
+        """
+        initial_dict: Dict[str, Any] = {
+            "patients": [
+                {"name": "Alice", "age": None},
+                {"name": "Bob", "age": 30},
+                {"name": None, "active": False},
+            ]
+        }
+        resource = FhirResource(initial_dict=initial_dict)
+        resource.remove_nulls()
+
+        with resource.transaction():
+            assert len(resource.get("patients", [])) == 3
+            assert resource.get("patients", [])[0].get("name") == "Alice"
+            assert resource.get("patients", [])[1].get("name") == "Bob"
+            assert resource.get("patients", [])[1].get("age") == 30
+
+    def test_remove_nulls_empty_dict(self) -> None:
+        """
+        Test removing None values from an empty dictionary
+        """
+        resource = FhirResource(initial_dict={})
+        resource.remove_nulls()
+
+        assert len(resource) == 0
+
+    def test_remove_nulls_no_changes(self) -> None:
+        """
+        Test removing None values when no None values exist
+        """
+        initial_dict: Dict[str, Any] = {
+            "name": "Test User",
+            "active": True,
+            "score": 100,
+        }
+        resource = FhirResource(initial_dict=initial_dict)
+        original_dict = resource.copy()
+        resource.remove_nulls()
+
+        assert resource == original_dict
+
+    def test_remove_nulls_with_custom_storage_mode(self) -> None:
+        """
+        Test removing None values with a custom storage mode
+        """
+        initial_dict: Dict[str, Any] = {
+            "name": "Custom Mode User",
+            "email": None,
+            "active": True,
+        }
+        resource = FhirResource(
+            initial_dict=initial_dict, storage_mode=CompressedDictStorageMode.default()
+        )
+        resource.remove_nulls()
+
+        with resource.transaction():
+            assert "email" not in resource
+            assert resource.get("name") == "Custom Mode User"
+            assert resource.get("active") is True
+
+    def test_remove_nulls_preserves_false_and_zero_values(self) -> None:
+        """
+        Test that False and 0 values are not removed
+        """
+        initial_dict: Dict[str, Any] = {"active": False, "score": 0, "name": None}
+        resource = FhirResource(initial_dict=initial_dict)
+        resource.remove_nulls()
+
+        with resource.transaction():
+            assert resource.get("active") is False
+            assert resource.get("score") == 0
+            assert "name" not in resource