Buckets:

download
raw
11.3 kB
"""
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.