Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /Daylily-Informatics_bloom /tests /test_modules_coverage.py
| """ | |
| Tests for BLOOM LIMS modules to ensure minimum coverage. | |
| This file provides at least one test per module for modules that | |
| don't have dedicated test files. | |
| """ | |
| class TestLoggingConfig: | |
| """Tests for bloom_lims/logging_config.py""" | |
| def test_logging_config_exists(self): | |
| """Test that LOGGING_CONFIG is defined.""" | |
| from bloom_lims.logging_config import LOGGING_CONFIG | |
| assert isinstance(LOGGING_CONFIG, dict) | |
| assert "version" in LOGGING_CONFIG | |
| assert LOGGING_CONFIG["version"] == 1 | |
| def test_setup_logging_function(self): | |
| """Test that setup_logging can be called.""" | |
| from bloom_lims.logging_config import setup_logging | |
| # Should not raise | |
| setup_logging() | |
| def test_logging_config_has_formatters(self): | |
| """Test that logging config has formatters.""" | |
| from bloom_lims.logging_config import LOGGING_CONFIG | |
| assert "formatters" in LOGGING_CONFIG | |
| assert "standard" in LOGGING_CONFIG["formatters"] | |
| def test_logging_config_has_handlers(self): | |
| """Test that logging config has handlers.""" | |
| from bloom_lims.logging_config import LOGGING_CONFIG | |
| assert "handlers" in LOGGING_CONFIG | |
| assert "console" in LOGGING_CONFIG["handlers"] | |
| class TestHealthModule: | |
| """Tests for bloom_lims/health.py""" | |
| def test_health_models_import(self): | |
| """Test that health models can be imported.""" | |
| from bloom_lims.health import ( | |
| ComponentHealth, | |
| HealthResponse, | |
| ) | |
| assert ComponentHealth is not None | |
| assert HealthResponse is not None | |
| def test_component_health_model(self): | |
| """Test ComponentHealth model creation.""" | |
| from bloom_lims.health import ComponentHealth | |
| component = ComponentHealth( | |
| name="database", status="healthy", latency_ms=5.2, message="Connected" | |
| ) | |
| assert component.name == "database" | |
| assert component.status == "healthy" | |
| 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.now()) | |
| assert response.status == "ok" | |
| def test_readiness_response_model(self): | |
| """Test ReadinessResponse model creation.""" | |
| from datetime import datetime | |
| from bloom_lims.health import ReadinessResponse | |
| response = ReadinessResponse( | |
| status="ready", ready=True, timestamp=datetime.now() | |
| ) | |
| assert response.status == "ready" | |
| class TestCoreExceptions: | |
| """Tests for bloom_lims/core/exceptions.py""" | |
| def test_bloom_error_base(self): | |
| """Test BloomError base exception.""" | |
| from bloom_lims.core.exceptions import BloomError | |
| error = BloomError("Test error", details={"key": "value"}) | |
| assert str(error) == "Test error" | |
| assert error.message == "Test error" | |
| assert error.details == {"key": "value"} | |
| def test_bloom_error_to_dict(self): | |
| """Test BloomError.to_dict() method.""" | |
| from bloom_lims.core.exceptions import BloomError | |
| error = BloomError("Test error", details={"code": 123}) | |
| result = error.to_dict() | |
| assert result["error_type"] == "BloomError" | |
| assert result["message"] == "Test error" | |
| assert result["details"]["code"] == 123 | |
| def test_bloom_database_error(self): | |
| """Test BloomDatabaseError exception.""" | |
| from bloom_lims.core.exceptions import BloomDatabaseError | |
| error = BloomDatabaseError("DB connection failed") | |
| assert isinstance(error, Exception) | |
| assert "DB connection failed" in str(error) | |
| def test_bloom_not_found_error(self): | |
| """Test BloomNotFoundError exception.""" | |
| from bloom_lims.core.exceptions import BloomNotFoundError | |
| error = BloomNotFoundError("Object not found", details={"euid": "CX1"}) | |
| assert error.message == "Object not found" | |
| def test_bloom_validation_error(self): | |
| """Test BloomValidationError exception.""" | |
| from bloom_lims.core.exceptions import BloomValidationError | |
| error = BloomValidationError("Invalid input") | |
| assert "Invalid input" in str(error) | |
| def test_bloom_permission_error(self): | |
| """Test BloomPermissionError exception.""" | |
| from bloom_lims.core.exceptions import BloomPermissionError | |
| error = BloomPermissionError("Access denied") | |
| assert error.message == "Access denied" | |
| def test_bloom_configuration_error(self): | |
| """Test BloomConfigurationError exception.""" | |
| from bloom_lims.core.exceptions import BloomConfigurationError | |
| error = BloomConfigurationError("Missing config") | |
| assert "Missing config" in str(error) | |
| def test_bloom_workflow_error(self): | |
| """Test BloomWorkflowError exception.""" | |
| from bloom_lims.core.exceptions import BloomWorkflowError | |
| error = BloomWorkflowError("Workflow failed") | |
| assert error.message == "Workflow failed" | |
| def test_bloom_lineage_error(self): | |
| """Test BloomLineageError exception.""" | |
| from bloom_lims.core.exceptions import BloomLineageError | |
| error = BloomLineageError("Lineage error") | |
| assert "Lineage error" in str(error) | |
| def test_error_with_original_exception(self): | |
| """Test wrapping original exception.""" | |
| from bloom_lims.core.exceptions import BloomError | |
| original = ValueError("Original error") | |
| error = BloomError("Wrapped error", original_error=original) | |
| result = error.to_dict() | |
| assert "original_error" in result | |
| assert "Original error" in result["original_error"] | |
| class TestSubjectingModule: | |
| """Tests for bloom_lims/subjecting.py""" | |
| def test_subjecting_module_imports(self): | |
| """Test that subjecting module can be imported.""" | |
| import bloom_lims.subjecting | |
| assert bloom_lims.subjecting is not None | |
| class TestDomainWorkflows: | |
| """Tests for removed workflow domain module.""" | |
| def test_domain_workflows_imports(self): | |
| """Workflow domain imports should be hard-removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.domain.workflows") is None | |
| class TestCoreAsyncOperations: | |
| """Tests for bloom_lims/core/async_operations.py""" | |
| def test_async_operations_imports(self): | |
| """Test that async_operations module can be imported.""" | |
| import bloom_lims.core.async_operations | |
| assert bloom_lims.core.async_operations is not None | |
| class TestCoreBaseObjects: | |
| """Tests for bloom_lims/core/base_objects.py""" | |
| def test_base_objects_imports(self): | |
| """Test that base_objects module can be imported.""" | |
| import bloom_lims.core.base_objects | |
| assert bloom_lims.core.base_objects is not None | |
| class TestCoreBatchOperations: | |
| """Tests for bloom_lims/core/batch_operations.py""" | |
| def test_batch_operations_imports(self): | |
| """Test that batch_operations module can be imported.""" | |
| import bloom_lims.core.batch_operations | |
| assert bloom_lims.core.batch_operations is not None | |
| class TestCoreCachedRepository: | |
| """Tests for bloom_lims/core/cached_repository.py""" | |
| def test_cached_repository_imports(self): | |
| """Test that cached_repository module can be imported.""" | |
| import bloom_lims.core.cached_repository | |
| assert bloom_lims.core.cached_repository is not None | |
| class TestCoreContainers: | |
| """Tests for the retired standalone containers core module.""" | |
| def test_core_containers_imports(self): | |
| """The standalone containers module should remain retired.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.containers") is None | |
| class TestCoreContent: | |
| """Tests for bloom_lims/core/content.py""" | |
| def test_core_content_imports(self): | |
| """Test that core content module can be imported.""" | |
| import bloom_lims.core.content | |
| assert bloom_lims.core.content is not None | |
| class TestCoreLineage: | |
| """Tests for the retired standalone lineage core module.""" | |
| def test_core_lineage_imports(self): | |
| """The standalone lineage module should remain retired.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.lineage") is None | |
| class TestCoreReadReplicas: | |
| """Tests for the removed Bloom-side read-replica module.""" | |
| def test_read_replicas_is_removed(self): | |
| """Read-replica routing must not be exposed as a Bloom compatibility API.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.read_replicas") is None | |
| class TestCoreWorkflows: | |
| """Tests for removed workflow core module.""" | |
| def test_core_workflows_imports(self): | |
| """Workflow core imports should be hard-removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.core.workflows") is None | |
| class TestApiVersioning: | |
| """Tests for bloom_lims/api/versioning.py""" | |
| def test_api_versioning_imports(self): | |
| """Test that api versioning module can be imported.""" | |
| import bloom_lims.api.versioning | |
| assert bloom_lims.api.versioning is not None | |
| class TestApiRateLimiting: | |
| """Tests for bloom_lims/api/rate_limiting.py""" | |
| def test_rate_limiting_imports(self): | |
| """Test that rate_limiting module can be imported.""" | |
| import bloom_lims.api.rate_limiting | |
| assert bloom_lims.api.rate_limiting is not None | |
| class TestDomainUtils: | |
| """Tests for bloom_lims/domain/utils.py""" | |
| def test_domain_utils_imports(self): | |
| """Test that domain utils module can be imported.""" | |
| import bloom_lims.domain.utils | |
| assert bloom_lims.domain.utils is not None | |
| class TestDomainFiles: | |
| """Tests for bloom_lims/domain/files.py""" | |
| def test_domain_files_imports(self): | |
| """Test that domain files module can be imported.""" | |
| import bloom_lims.domain.files | |
| assert bloom_lims.domain.files is not None | |
| class TestDomainObjectSets: | |
| """Tests for bloom_lims/domain/object_sets.py""" | |
| def test_domain_object_sets_imports(self): | |
| """Test that domain object_sets module can be imported.""" | |
| import bloom_lims.domain.object_sets | |
| assert bloom_lims.domain.object_sets is not None | |
| class TestBobjs: | |
| """Tests for the removed bloom_lims.bobjs compatibility module.""" | |
| def test_bobjs_is_removed(self): | |
| """bloom_lims.bobjs must stay removed.""" | |
| import importlib.util | |
| assert importlib.util.find_spec("bloom_lims.bobjs") is None | |
| class TestBvars: | |
| """Tests for bloom_lims/bvars.py""" | |
| def test_bvars_imports(self): | |
| """Test that bvars module can be imported.""" | |
| import bloom_lims.bvars | |
| assert bloom_lims.bvars is not None | |
| class TestTapdbAdapter: | |
| """Tests for bloom_lims/tapdb_adapter.py""" | |
| def test_tapdb_adapter_imports(self): | |
| """Test that tapdb_adapter module can be imported.""" | |
| import bloom_lims.tapdb_adapter | |
| assert bloom_lims.tapdb_adapter is not None | |
Xet Storage Details
- Size:
- 11.3 kB
- Xet hash:
- d846c0d61a10ccdf12b0a8576e2d384e1966d545d9c01e33438680cc6ebe198b
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.