fixed tests

Author: John Major

tests/test_core_validation.py

@@ -19,43 +19,57 @@
 
 
 class TestValidateEuid:
-    """Tests for validate_euid function."""
-    
+    """Tests for validate_euid function.
+
+    BLOOM EUIDs follow the pattern: PREFIX + SEQUENCE_NUMBER
+    - PREFIX: 2-3 uppercase letters identifying object type (e.g., CX, WX, MRX)
+    - SEQUENCE_NUMBER: Integer with NO leading zeros
+
+    Valid examples: CX1, CX123, WX1000, MRX42, CWX5
+    """
+
     def test_valid_euid(self):
         """Test validation of valid EUIDs."""
-        assert validate_euid("WF_ABC123_X") is True
-        assert validate_euid("CT_SAMPLE01_Y") is True
-        assert validate_euid("EQ_DEVICE_Z") is True
-    
+        # Format: 2-3 letter prefix + sequence number (no leading zeros)
+        assert validate_euid("CX1") is True
+        assert validate_euid("CX123") is True
+        assert validate_euid("WX1000") is True
+        assert validate_euid("MRX42") is True
+        assert validate_euid("CWX5") is True
+
     def test_none_euid(self):
         """Test that None raises ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
             validate_euid(None)
         assert "cannot be None" in str(exc_info.value)
-    
+
     def test_empty_euid(self):
         """Test that empty string raises ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
             validate_euid("")
         assert "cannot be empty" in str(exc_info.value)
-    
+
     def test_non_string_euid(self):
         """Test that non-string raises ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
             validate_euid(12345)
         assert "must be a string" in str(exc_info.value)
-    
-    def test_no_underscore(self):
-        """Test that EUID without underscore raises ValidationError."""
+
+    def test_invalid_format_with_separator(self):
+        """Test that EUID with separators (underscore/hyphen) raises ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
-            validate_euid("WFABC123X")
-        assert "underscore" in str(exc_info.value)
-    
-    def test_lowercase_prefix(self):
-        """Test that lowercase prefix raises ValidationError."""
+            validate_euid("WF-123")
+        assert "PREFIX + sequence number" in str(exc_info.value)
+
+        with pytest.raises(ValidationError) as exc_info:
+            validate_euid("WF_123")
+        assert "PREFIX + sequence number" in str(exc_info.value)
+
+    def test_invalid_format_with_leading_zero(self):
+        """Test that EUID with leading zero in sequence raises ValidationError."""
         with pytest.raises(ValidationError) as exc_info:
-            validate_euid("wf_ABC123_X")
-        assert "uppercase" in str(exc_info.value)
+            validate_euid("CX01")
+        assert "No leading zeros" in str(exc_info.value)
 
 
 class TestValidateUuid:
@@ -104,33 +118,33 @@ def test_non_dict(self):
 
 class TestValidatedDecorator:
     """Tests for @validated decorator."""
-    
+
     def test_valid_arguments(self):
         """Test that valid arguments pass through."""
         @validated(euid=validate_euid)
         def process(euid: str) -> str:
             return f"processed: {euid}"
-        
-        result = process("WF_ABC123_X")
-        assert result == "processed: WF_ABC123_X"
-    
+
+        result = process("WX123")
+        assert result == "processed: WX123"
+
     def test_invalid_argument_raises(self):
         """Test that invalid arguments raise ValidationError."""
         @validated(euid=validate_euid)
         def process(euid: str) -> str:
             return f"processed: {euid}"
-        
+
         with pytest.raises(ValidationError):
-            process("invalid")
-    
+            process("invalid-format")
+
     def test_multiple_validators(self):
         """Test multiple validators on different arguments."""
         @validated(euid=validate_euid, data=validate_json_addl)
         def process(euid: str, data: dict) -> dict:
             return {"euid": euid, "data": data}
-        
-        result = process("WF_ABC123_X", {"key": "value"})
-        assert result["euid"] == "WF_ABC123_X"
+
+        result = process("MRX42", {"key": "value"})
+        assert result["euid"] == "MRX42"
 
 
 class TestValidateSchema:

tests/test_schemas.py

@@ -27,21 +27,31 @@ def test_pagination_params(self):
         assert params_default.page_size == 50
 
     def test_euid_validation(self):
-        """Test EUID validation function."""
+        """Test EUID validation function.
+
+        BLOOM EUIDs follow the pattern: PREFIX + SEQUENCE_NUMBER
+        - PREFIX: 2-3 uppercase letters (e.g., CX, WX, MRX)
+        - SEQUENCE_NUMBER: Integer with NO leading zeros
+
+        Valid examples: CX1, CX123, WX1000, MRX42
+        """
         from bloom_lims.schemas import validate_euid
 
-        # Valid EUIDs (format: PREFIX-IDENTIFIER or PREFIX-IDENTIFIER-SUFFIX)
-        assert validate_euid("BLM-123456") == "BLM-123456"
-        assert validate_euid("  BLM-123456  ") == "BLM-123456"
-        assert validate_euid("CONT-12345-A1") == "CONT-12345-A1"
+        # Valid EUIDs (format: PREFIX + sequence number)
+        assert validate_euid("CX1") == "CX1"
+        assert validate_euid("CX123") == "CX123"
+        assert validate_euid("  wx1000  ") == "WX1000"  # Should uppercase and strip
+        assert validate_euid("MRX42") == "MRX42"
 
         # Invalid EUIDs
         with pytest.raises(ValueError):
             validate_euid("")
         with pytest.raises(ValueError):
             validate_euid("   ")
         with pytest.raises(ValueError):
-            validate_euid("INVALID")  # No hyphen
+            validate_euid("BLM-123456")  # Hyphens not allowed
+        with pytest.raises(ValueError):
+            validate_euid("CX01")  # Leading zeros not allowed
 
 
 class TestObjectSchemas:
@@ -83,7 +93,7 @@ def test_container_create_schema(self):
             name="Test Plate",
             container_type="plate",
             b_sub_type="96-well",
-            template_euid="CONT-123456",
+            template_euid="CT123456",  # Valid EUID format: PREFIX + sequence number
         )
         assert data.name == "Test Plate"
         assert data.container_type == "plate"
@@ -139,7 +149,7 @@ def test_workflow_create_schema(self):
         data = WorkflowCreateSchema(
             name="Test Workflow",
             workflow_type="sequencing",
-            template_euid="WF-123456",
+            template_euid="WF123456",  # Valid EUID format: PREFIX + sequence number
         )
         assert data.name == "Test Workflow"