Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Daylily-Informatics_bloom /tests /test_schemas.py
| """ | |
| Tests for BLOOM LIMS Pydantic Schemas | |
| These tests verify that the Pydantic schemas work correctly for | |
| validation, serialization, and deserialization. | |
| """ | |
| from datetime import datetime | |
| import pytest | |
| def _default_meridian_runtime(monkeypatch): | |
| monkeypatch.setenv("MERIDIAN_ENVIRONMENT", "production") | |
| monkeypatch.setenv("MERIDIAN_SANDBOX_PREFIX", "") | |
| class TestBaseSchemas: | |
| """Tests for base schema functionality.""" | |
| def test_pagination_params(self): | |
| """Test PaginationParams schema.""" | |
| from bloom_lims.schemas import PaginationParams | |
| params = PaginationParams(page=1, page_size=50) | |
| assert params.page == 1 | |
| assert params.page_size == 50 | |
| # Test defaults | |
| params_default = PaginationParams() | |
| assert params_default.page == 1 | |
| assert params_default.page_size == 50 | |
| def test_euid_validation(self, monkeypatch): | |
| """Test EUID validation function. | |
| BLOOM uses TapDB/Meridian EUIDs: | |
| - Production: PREFIX-BODYCHECK (e.g. BCN-19, GT-13) | |
| - BODY is Crockford Base32 (no leading zeros) | |
| - CHECK is MOD32 checksum | |
| """ | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import validate_euid | |
| cx1 = format_euid("BCN", 1, domain_code="Z") | |
| cx123 = format_euid("BCN", 123, domain_code="Z") | |
| wx1000 = format_euid("BWF", 1000, domain_code="Z") | |
| # Valid EUIDs (TapDB/Meridian) | |
| assert validate_euid(cx1) == cx1 | |
| assert validate_euid(cx123) == cx123 | |
| assert ( | |
| validate_euid(f" {wx1000.lower()} ") == wx1000 | |
| ) # Should uppercase and strip | |
| # Invalid EUIDs | |
| with pytest.raises(ValueError): | |
| validate_euid("") | |
| with pytest.raises(ValueError): | |
| validate_euid(" ") | |
| with pytest.raises(ValueError): | |
| validate_euid("CX1") # Missing dash+checksum segment | |
| with pytest.raises(ValueError): | |
| validate_euid("BCN-01") # Leading zeros not allowed in BODY | |
| # Bad checksum | |
| bad_checksum = cx1[:-1] + ("0" if cx1[-1] != "0" else "1") | |
| with pytest.raises(ValueError): | |
| validate_euid(bad_checksum) | |
| # Domain-scoped EUIDs are not accepted unless Bloom is configured for that domain | |
| sandbox = format_euid("BCN", 1, domain_code="X") | |
| with pytest.raises(ValueError): | |
| validate_euid(sandbox) | |
| def test_euid_validation_accepts_only_configured_sandbox_prefix(self, monkeypatch): | |
| monkeypatch.setenv("MERIDIAN_ENVIRONMENT", "domain") | |
| monkeypatch.setenv("MERIDIAN_DOMAIN_CODE", "S") | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import validate_euid | |
| sandbox = format_euid("BCN", 1, domain_code="S") | |
| wrong_prefix = format_euid("BCN", 1, domain_code="T") | |
| production = format_euid("BCN", 1, domain_code="Z") | |
| assert validate_euid(sandbox) == sandbox | |
| with pytest.raises(ValueError): | |
| validate_euid(wrong_prefix) | |
| with pytest.raises(ValueError): | |
| validate_euid(production) | |
| class TestObjectSchemas: | |
| """Tests for object schemas.""" | |
| def test_object_create_schema(self): | |
| """Test ObjectCreateSchema validation.""" | |
| from bloom_lims.schemas import ObjectCreateSchema | |
| data = ObjectCreateSchema( | |
| name="Test Object", | |
| type="sample", | |
| subtype="blood", | |
| ) | |
| assert data.name == "Test Object" | |
| assert data.type == "sample" | |
| assert data.subtype == "blood" | |
| def test_object_create_with_json_addl(self): | |
| """Test ObjectCreateSchema with json_addl.""" | |
| from bloom_lims.schemas import ObjectCreateSchema | |
| data = ObjectCreateSchema( | |
| name="Test Object", | |
| type="sample", | |
| json_addl={"properties": {"key": "value"}}, | |
| ) | |
| assert data.json_addl == {"properties": {"key": "value"}} | |
| class TestContainerSchemas: | |
| """Tests for container schemas.""" | |
| def test_container_create_schema(self): | |
| """Test ContainerCreateSchema validation.""" | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import ContainerCreateSchema | |
| data = ContainerCreateSchema( | |
| name="Test Plate", | |
| container_type="plate", | |
| subtype="96-well", | |
| template_euid=format_euid("GT", 1, domain_code="Z"), | |
| ) | |
| assert data.name == "Test Plate" | |
| assert data.container_type == "plate" | |
| def test_container_layout_schema(self): | |
| """Test ContainerLayoutSchema.""" | |
| from bloom_lims.schemas import ContainerLayoutSchema | |
| layout = ContainerLayoutSchema( | |
| rows=8, | |
| columns=12, | |
| layout_type="grid", | |
| ) | |
| assert layout.rows == 8 | |
| assert layout.columns == 12 | |
| class TestContentSchemas: | |
| """Tests for content schemas.""" | |
| def test_sample_create_schema(self): | |
| """Test SampleCreateSchema validation.""" | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import SampleCreateSchema | |
| data = SampleCreateSchema( | |
| name="Test Sample", | |
| sample_type="blood", | |
| template_euid=format_euid("GT", 2, domain_code="Z"), | |
| ) | |
| assert data.name == "Test Sample" | |
| assert data.sample_type == "blood" | |
| def test_reagent_create_schema(self): | |
| """Test ReagentCreateSchema validation.""" | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import ReagentCreateSchema | |
| data = ReagentCreateSchema( | |
| name="Test Reagent", | |
| reagent_type="buffer", | |
| template_euid=format_euid("GT", 3, domain_code="Z"), | |
| lot_number="LOT001", | |
| ) | |
| assert data.lot_number == "LOT001" | |
| class TestWorkflowSchemas: | |
| """Tests for workflow schemas.""" | |
| def test_workflow_create_schema(self): | |
| """Test WorkflowCreateSchema validation.""" | |
| from daylily_tapdb.euid import format_euid | |
| from bloom_lims.schemas import WorkflowCreateSchema | |
| data = WorkflowCreateSchema( | |
| name="Test Workflow", | |
| workflow_type="sequencing", | |
| template_euid=format_euid("GT", 4, domain_code="Z"), | |
| ) | |
| assert data.name == "Test Workflow" | |
| def test_workflow_step_schema(self): | |
| """Test WorkflowStepSchema validation.""" | |
| from bloom_lims.schemas import WorkflowStepSchema | |
| step = WorkflowStepSchema( | |
| name="Step 1", | |
| step_number=1, | |
| step_type="extraction", | |
| ) | |
| assert step.step_number == 1 | |
| class TestEquipmentSchemas: | |
| """Tests for equipment schemas.""" | |
| def test_equipment_create_schema(self): | |
| """Test EquipmentCreateSchema validation.""" | |
| from bloom_lims.schemas import EquipmentCreateSchema | |
| data = EquipmentCreateSchema( | |
| name="Test Sequencer", | |
| equipment_type="sequencer", | |
| serial_number="SN12345", | |
| manufacturer="Illumina", | |
| ) | |
| assert data.serial_number == "SN12345" | |
| def test_maintenance_record_schema(self): | |
| """Test MaintenanceRecordSchema validation.""" | |
| from bloom_lims.schemas import MaintenanceRecordSchema | |
| record = MaintenanceRecordSchema( | |
| maintenance_type="preventive", | |
| performed_date=datetime.now(), | |
| performed_by="Tech1", | |
| ) | |
| assert record.maintenance_type == "preventive" | |
| class TestPublicResponseSchemas: | |
| """Tests for public response schema contracts.""" | |
| def test_public_response_schemas_do_not_expose_uuid_fields(self): | |
| from bloom_lims.schemas.actions import ActionResponseSchema | |
| from bloom_lims.schemas.containers import ( | |
| ContainerPositionSchema, | |
| ContainerResponseSchema, | |
| ) | |
| from bloom_lims.schemas.content import ContentResponseSchema | |
| from bloom_lims.schemas.equipment import EquipmentResponseSchema | |
| from bloom_lims.schemas.files import FileResponseSchema, FileSetResponseSchema | |
| from bloom_lims.schemas.objects import ObjectResponseSchema | |
| from bloom_lims.schemas.workflows import ( | |
| WorkflowResponseSchema, | |
| WorkflowStepResponseSchema, | |
| ) | |
| schemas = [ | |
| ActionResponseSchema, | |
| ContainerPositionSchema, | |
| ContainerResponseSchema, | |
| ContentResponseSchema, | |
| EquipmentResponseSchema, | |
| FileResponseSchema, | |
| FileSetResponseSchema, | |
| ObjectResponseSchema, | |
| WorkflowResponseSchema, | |
| WorkflowStepResponseSchema, | |
| ] | |
| for schema in schemas: | |
| assert "uuid" not in schema.model_fields | |
| class TestDomainUtils: | |
| """Tests for bloom_lims.domain.utils module.""" | |
| def test_get_clean_timestamp(self): | |
| """Test clean timestamp generation.""" | |
| from bloom_lims.domain.utils import get_clean_timestamp | |
| ts = get_clean_timestamp() | |
| assert isinstance(ts, str) | |
| # Format should be YYYY-MM-DD_HH-MM-SS | |
| assert len(ts) == 19 | |
| assert ts[4] == "-" | |
| assert ts[7] == "-" | |
| assert ts[10] == "_" | |
| def test_generate_random_string_default_length(self): | |
| """Test random string generation with default length.""" | |
| from bloom_lims.domain.utils import generate_random_string | |
| s = generate_random_string() | |
| assert isinstance(s, str) | |
| assert len(s) == 10 | |
| # Should only contain alphanumeric characters | |
| assert s.isalnum() | |
| def test_generate_random_string_custom_length(self): | |
| """Test random string generation with custom length.""" | |
| from bloom_lims.domain.utils import generate_random_string | |
| s = generate_random_string(20) | |
| assert len(s) == 20 | |
| s2 = generate_random_string(5) | |
| assert len(s2) == 5 | |
| def test_get_datetime_string(self): | |
| """Test datetime string generation.""" | |
| from bloom_lims.domain.utils import get_datetime_string | |
| dt = get_datetime_string() | |
| assert isinstance(dt, str) | |
| # Should contain date, time, and timezone info | |
| assert "-" in dt # Date separators | |
| assert ":" in dt # Time separators | |
| def test_update_recursive_simple(self): | |
| """Test recursive dictionary update with simple values.""" | |
| from bloom_lims.domain.utils import update_recursive | |
| orig = {"a": 1, "b": 2} | |
| update = {"b": 3, "c": 4} | |
| update_recursive(orig, update) | |
| assert orig == {"a": 1, "b": 3, "c": 4} | |
| def test_update_recursive_nested(self): | |
| """Test recursive dictionary update with nested dicts.""" | |
| from bloom_lims.domain.utils import update_recursive | |
| orig = {"a": {"x": 1, "y": 2}, "b": 3} | |
| update = {"a": {"y": 20, "z": 30}} | |
| update_recursive(orig, update) | |
| assert orig == {"a": {"x": 1, "y": 20, "z": 30}, "b": 3} | |
| def test_unique_non_empty_strings(self): | |
| """Test unique non-empty string filtering.""" | |
| from bloom_lims.domain.utils import unique_non_empty_strings | |
| # Should remove duplicates and empty strings | |
| result = unique_non_empty_strings(["a", "b", "", "a", "c", ""]) | |
| assert set(result) == {"a", "b", "c"} | |
| def test_unique_non_empty_strings_all_empty(self): | |
| """Test unique non-empty strings with all empty.""" | |
| from bloom_lims.domain.utils import unique_non_empty_strings | |
| result = unique_non_empty_strings(["", "", ""]) | |
| assert result == [] | |
| class TestBloomExceptions: | |
| """Tests for bloom_lims.exceptions module. | |
| Note: Exception tests are skipped because exceptions log on creation | |
| and the logger 'extra' dict contains 'message' which conflicts with | |
| Python's built-in LogRecord 'message' attribute. | |
| """ | |
| def test_bloom_error_basic(self): | |
| """Test basic BloomError creation.""" | |
| from bloom_lims.exceptions import BloomError | |
| error = BloomError("Test error message") | |
| assert error.message == "Test error message" | |
| def test_validation_error(self): | |
| """Test ValidationError subclass.""" | |
| from bloom_lims.exceptions import ValidationError | |
| error = ValidationError("Invalid input", field="email") | |
| assert error.http_status == 400 | |
| class TestExceptionImports: | |
| """Test that exception classes can be imported.""" | |
| def test_import_bloom_error(self): | |
| """Test BloomError can be imported.""" | |
| from bloom_lims.exceptions import BloomError | |
| assert BloomError is not None | |
| def test_import_validation_error(self): | |
| """Test ValidationError can be imported.""" | |
| from bloom_lims.exceptions import ValidationError | |
| assert ValidationError is not None | |
| def test_import_not_found_error(self): | |
| """Test NotFoundError can be imported.""" | |
| from bloom_lims.exceptions import NotFoundError | |
| assert NotFoundError is not None | |
| def test_import_database_error(self): | |
| """Test DatabaseError can be imported.""" | |
| from bloom_lims.exceptions import DatabaseError | |
| assert DatabaseError is not None | |
| def test_import_authentication_error(self): | |
| """Test AuthenticationError can be imported.""" | |
| from bloom_lims.exceptions import AuthenticationError | |
| assert AuthenticationError is not None | |
| def test_import_authorization_error(self): | |
| """Test AuthorizationError can be imported.""" | |
| from bloom_lims.exceptions import AuthorizationError | |
| assert AuthorizationError is not None | |
| def test_import_configuration_error(self): | |
| """Test ConfigurationError can be imported.""" | |
| from bloom_lims.exceptions import ConfigurationError | |
| assert ConfigurationError is not None | |
| def test_import_external_service_error(self): | |
| """Test ExternalServiceError can be imported.""" | |
| from bloom_lims.exceptions import ExternalServiceError | |
| assert ExternalServiceError is not None | |
| class TestDomainWorkflows: | |
| """Tests for removed workflow domain module.""" | |
| def test_import_bloom_workflow(self): | |
| """BloomWorkflow import is removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.domain.workflows") is None | |
| def test_import_bloom_workflow_step(self): | |
| """BloomWorkflowStep import is removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.domain.workflows") is None | |
| def test_workflow_inherits_from_bloom_obj(self): | |
| """Bloom domain package no longer exports workflow objects.""" | |
| import bloom_lims.domain as domain | |
| assert not hasattr(domain, "BloomWorkflow") | |
| class TestDomainFiles: | |
| """Tests for files domain module imports.""" | |
| def test_import_bloom_file(self): | |
| """Test BloomFile import.""" | |
| from bloom_lims.domain.files import BloomFile | |
| assert BloomFile is not None | |
| def test_import_bloom_file_set(self): | |
| """Test BloomFileSet import.""" | |
| from bloom_lims.domain.files import BloomFileSet | |
| assert BloomFileSet is not None | |
| def test_file_inherits_from_bloom_obj(self): | |
| """Test BloomFile inherits from BloomObj.""" | |
| from bloom_lims.domain.base import BloomObj | |
| from bloom_lims.domain.files import BloomFile | |
| assert issubclass(BloomFile, BloomObj) | |
| class TestDomainContainers: | |
| """Tests for containers domain module imports.""" | |
| def test_import_bloom_container(self): | |
| """Test BloomContainer import.""" | |
| from bloom_lims.domain.containers import BloomContainer | |
| assert BloomContainer is not None | |
| class TestDomainContent: | |
| """Tests for content domain module imports.""" | |
| def test_import_bloom_content(self): | |
| """Test BloomContent import.""" | |
| from bloom_lims.domain.content import BloomContent | |
| assert BloomContent is not None | |
| class TestDomainEquipment: | |
| """Tests for equipment domain module imports.""" | |
| def test_import_bloom_equipment(self): | |
| """Test BloomEquipment import.""" | |
| from bloom_lims.domain.equipment import BloomEquipment | |
| assert BloomEquipment is not None | |
| class TestCoreModuleImports: | |
| """Tests for core module imports.""" | |
| def test_import_lru_cache(self): | |
| """Test LRUCache import.""" | |
| from bloom_lims.core.cache import LRUCache | |
| assert LRUCache is not None | |
| def test_import_cache_entry(self): | |
| """Test CacheEntry import.""" | |
| from bloom_lims.core.cache import CacheEntry | |
| assert CacheEntry is not None | |
| def test_import_cache_stats(self): | |
| """Test CacheStats import.""" | |
| from bloom_lims.core.cache import CacheStats | |
| assert CacheStats is not None | |
| def test_import_template_validator(self): | |
| """Test TemplateValidator import.""" | |
| from bloom_lims.core.template_validation import TemplateValidator | |
| assert TemplateValidator is not None | |
| def test_import_batch_processor(self): | |
| """Test BatchProcessor import.""" | |
| from bloom_lims.core.batch_operations import BatchProcessor | |
| assert BatchProcessor is not None | |
| def test_import_async_operations(self): | |
| """Test async operations imports.""" | |
| from bloom_lims.core.async_operations import BackgroundTaskManager, TaskStatus | |
| assert BackgroundTaskManager is not None | |
| assert TaskStatus is not None | |
| def test_import_task_result(self): | |
| """Test TaskResult import.""" | |
| from bloom_lims.core.async_operations import TaskResult | |
| assert TaskResult is not None | |
| class TestHealthModuleImports: | |
| """Tests for health module imports.""" | |
| def test_import_health_router(self): | |
| """Test health_router import.""" | |
| from bloom_lims.health import health_router | |
| assert health_router is not None | |
| def test_import_component_health(self): | |
| """Test ComponentHealth import.""" | |
| from bloom_lims.health import ComponentHealth | |
| assert ComponentHealth is not None | |
| def test_import_health_response(self): | |
| """Test HealthResponse import.""" | |
| from bloom_lims.health import HealthResponse | |
| assert HealthResponse is not None | |
| def test_import_liveness_response(self): | |
| """Test LivenessResponse import.""" | |
| from bloom_lims.health import LivenessResponse | |
| assert LivenessResponse is not None | |
| def test_import_readiness_response(self): | |
| """Test ReadinessResponse import.""" | |
| from bloom_lims.health import ReadinessResponse | |
| assert ReadinessResponse is not None | |
| def test_component_health_model(self): | |
| """Test ComponentHealth model creation.""" | |
| from bloom_lims.health import ComponentHealth | |
| component = ComponentHealth( | |
| name="test", status="healthy", latency_ms=10.5, message="Test component" | |
| ) | |
| assert component.name == "test" | |
| assert component.status == "healthy" | |
| assert component.latency_ms == 10.5 | |
| def test_liveness_response_model(self): | |
| """Test LivenessResponse model creation.""" | |
| from datetime import datetime | |
| from bloom_lims.health import LivenessResponse | |
| response = LivenessResponse(status="ok", timestamp=datetime.utcnow()) | |
| assert response.status == "ok" | |
| assert response.timestamp is not None | |
| def test_get_system_info(self): | |
| """Test get_system_info function.""" | |
| from bloom_lims.health import get_system_info | |
| info = get_system_info() | |
| assert isinstance(info, dict) | |
| # Should have system resource info | |
| if info: # May be empty if psutil fails | |
| expected_keys = ["cpu_percent", "memory_percent", "python_version"] | |
| for key in expected_keys: | |
| if key in info: | |
| assert info[key] is not None | |
| class TestDomainBaseImports: | |
| """Tests for domain base module imports.""" | |
| def test_import_bloom_obj(self): | |
| """Test BloomObj import.""" | |
| from bloom_lims.domain.base import BloomObj | |
| assert BloomObj is not None | |
| def test_import_db_class(self): | |
| """Test BLOOMdb3 import.""" | |
| from bloom_lims.tapdb_adapter import BLOOMdb3 | |
| assert BLOOMdb3 is not None | |
| class TestConfigModuleTests: | |
| """Tests for config module.""" | |
| def test_import_settings(self): | |
| """Test get_settings import.""" | |
| from bloom_lims.config import get_settings | |
| assert get_settings is not None | |
| def test_get_settings_returns_settings(self): | |
| """Test get_settings returns a settings object.""" | |
| from bloom_lims.config import get_settings | |
| settings = get_settings() | |
| assert settings is not None | |
| assert hasattr(settings, "environment") | |
| def test_settings_has_api_config(self): | |
| """Test settings has API config.""" | |
| from bloom_lims.config import get_settings | |
| settings = get_settings() | |
| assert hasattr(settings, "api") | |
| assert hasattr(settings.api, "version") | |
| def test_settings_has_auth_config(self): | |
| """Test settings has auth config.""" | |
| from bloom_lims.config import get_settings | |
| settings = get_settings() | |
| assert hasattr(settings, "auth") | |
| class TestAPIVersioningImports: | |
| """Tests for API versioning imports.""" | |
| def test_import_versioning(self): | |
| """Test versioning module import.""" | |
| from bloom_lims.api import versioning | |
| assert versioning is not None | |
| class TestRateLimitingImports: | |
| """Tests for rate limiting imports.""" | |
| def test_import_rate_limiting(self): | |
| """Test rate limiting module import.""" | |
| from bloom_lims.api import rate_limiting | |
| assert rate_limiting is not None | |
| def test_import_rate_limit_middleware(self): | |
| """Test RateLimitMiddleware import.""" | |
| from bloom_lims.api.rate_limiting import RateLimitMiddleware | |
| assert RateLimitMiddleware is not None | |
| class TestDomainBaseImportsExtended: | |
| """Extended tests for domain base module.""" | |
| def test_import_bloom_obj_class(self): | |
| """Test BloomObj class import.""" | |
| from bloom_lims.domain.base import BloomObj | |
| assert BloomObj is not None | |
| def test_import_bloomdb3_class(self): | |
| """Test BLOOMdb3 class import.""" | |
| from bloom_lims.tapdb_adapter import BLOOMdb3 | |
| assert BLOOMdb3 is not None | |
| def test_bloom_obj_has_get_by_euid(self): | |
| """Test BloomObj has get_by_euid method.""" | |
| from bloom_lims.domain.base import BloomObj | |
| assert hasattr(BloomObj, "get_by_euid") | |
| def test_bloom_obj_does_not_have_uuid_helpers(self): | |
| """Test BloomObj no longer exposes UUID helper methods.""" | |
| from bloom_lims.domain.base import BloomObj | |
| assert not hasattr(BloomObj, "get") | |
| assert not hasattr(BloomObj, "delete_by_uuid") | |
| assert not hasattr(BloomObj, "create_instances_from_uuid") | |
| def test_bloom_obj_has_create_instance(self): | |
| """Test BloomObj has create_instance method.""" | |
| from bloom_lims.domain.base import BloomObj | |
| assert hasattr(BloomObj, "create_instance") | |
| class TestCoreExceptionsImports: | |
| """Tests for core exceptions module.""" | |
| def test_import_bloom_error(self): | |
| """Test BloomError import.""" | |
| from bloom_lims.core.exceptions import BloomError | |
| assert BloomError is not None | |
| def test_import_bloom_not_found_error(self): | |
| """Test BloomNotFoundError import.""" | |
| from bloom_lims.core.exceptions import BloomNotFoundError | |
| assert BloomNotFoundError is not None | |
| def test_import_bloom_database_error(self): | |
| """Test BloomDatabaseError import.""" | |
| from bloom_lims.core.exceptions import BloomDatabaseError | |
| assert BloomDatabaseError is not None | |
| def test_import_bloom_validation_error(self): | |
| """Test BloomValidationError import.""" | |
| from bloom_lims.core.exceptions import BloomValidationError | |
| assert BloomValidationError is not None | |
| class TestTapdbAdapterImports: | |
| """Tests for tapdb adapter module.""" | |
| def test_import_tapdb_adapter(self): | |
| """Test tapdb adapter import.""" | |
| from bloom_lims import tapdb_adapter | |
| assert tapdb_adapter is not None | |
| class TestSubjectingImports: | |
| """Tests for subjecting module.""" | |
| def test_import_subjecting(self): | |
| """Test subjecting module import.""" | |
| from bloom_lims import subjecting | |
| assert subjecting is not None | |
| class TestDomainObjectSetsImports: | |
| """Tests for domain object_sets module.""" | |
| def test_import_object_sets(self): | |
| """Test object_sets module import.""" | |
| from bloom_lims.domain import object_sets | |
| assert object_sets is not None | |
| class TestBatchOperationsImports: | |
| """Tests for batch operations imports.""" | |
| def test_import_batch_operations(self): | |
| """Test batch operations module import.""" | |
| from bloom_lims.core import batch_operations | |
| assert batch_operations is not None | |
| def test_import_batch_processor(self): | |
| """Test BatchProcessor import.""" | |
| from bloom_lims.core.batch_operations import BatchProcessor | |
| assert BatchProcessor is not None | |
| class TestCacheBackendsImports: | |
| """Tests for cache backends imports.""" | |
| def test_import_cache_backends(self): | |
| """Test cache backends module import.""" | |
| from bloom_lims.core import cache_backends | |
| assert cache_backends is not None | |
| class TestReadReplicasImports: | |
| """Tests for removed read replica compatibility imports.""" | |
| def test_read_replicas_import_removed(self): | |
| """Read replica routing must not be exposed by Bloom core.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.read_replicas") is None | |
| class TestLineageImports: | |
| """Tests for lineage imports.""" | |
| def test_import_lineage(self): | |
| """Lineage no longer has a standalone core module.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.lineage") is None | |
| class TestCachedRepositoryImports: | |
| """Tests for cached repository imports.""" | |
| def test_import_cached_repository(self): | |
| """Test cached repository module import.""" | |
| from bloom_lims.core import cached_repository | |
| assert cached_repository is not None | |
| class TestContainersImports: | |
| """Tests for core containers imports.""" | |
| def test_import_core_containers(self): | |
| """Containers no longer has a standalone core module.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.containers") is None | |
| class TestContentImports: | |
| """Tests for core content imports.""" | |
| def test_import_core_content(self): | |
| """Test core content module import.""" | |
| from bloom_lims.core import content | |
| assert content is not None | |
| class TestCoreWorkflowsImports: | |
| """Tests for removed core workflow imports.""" | |
| def test_import_core_workflows(self): | |
| """Core workflows module is removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.workflows") is None | |
| class TestBaseObjectsImports: | |
| """Tests for base objects imports.""" | |
| def test_import_base_objects(self): | |
| """Test base objects module import.""" | |
| from bloom_lims.core import base_objects | |
| assert base_objects is not None | |
Xet Storage Details
- Size:
- 28 kB
- Xet hash:
- c947246c33914ba12ba7bef692fd64d0bf8c1d1f08c5df4b8cba1d7b8d8ffbc7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.