""" Unit tests for schema_naming.py - Schema filename validation. Tests the schema naming convention enforcement including: - Valid filename validation - Invalid filename detection - Metadata extraction - Filename suggestion - Error message generation """ import pytest from markitect.schema_naming import ( validate_schema_filename, suggest_schema_filename, extract_schema_metadata, get_validation_errors, is_valid_schema_filename, format_validation_message, SchemaFilenameError, SCHEMA_FILENAME_PATTERN ) class TestValidateSchemaFilename: """Tests for validate_schema_filename function.""" def test_valid_simple_schema(self): """Test validation of simple valid schema filename.""" is_valid, metadata = validate_schema_filename("manpage-schema-v1.0.md") assert is_valid is True assert metadata is not None assert metadata['domain'] == 'manpage' assert metadata['version'] == '1.0' assert metadata['major'] == 1 assert metadata['minor'] == 0 assert metadata['filename'] == 'manpage-schema-v1.0.md' def test_valid_hyphenated_domain(self): """Test validation with multi-word hyphenated domain.""" is_valid, metadata = validate_schema_filename("api-documentation-schema-v1.0.md") assert is_valid is True assert metadata['domain'] == 'api-documentation' assert metadata['version'] == '1.0' def test_valid_with_numbers_in_domain(self): """Test validation with numbers in domain name.""" is_valid, metadata = validate_schema_filename("arc42-schema-v1.0.md") assert is_valid is True assert metadata['domain'] == 'arc42' def test_valid_higher_version(self): """Test validation with version > 1.0.""" is_valid, metadata = validate_schema_filename("manpage-schema-v2.5.md") assert is_valid is True assert metadata['version'] == '2.5' assert metadata['major'] == 2 assert metadata['minor'] == 5 def test_valid_double_digit_version(self): """Test validation with double-digit version numbers.""" is_valid, metadata = validate_schema_filename("manpage-schema-v10.25.md") assert is_valid is True assert metadata['major'] == 10 assert metadata['minor'] == 25 def test_invalid_wrong_extension(self): """Test that .json extension is invalid.""" is_valid, metadata = validate_schema_filename("manpage-schema-v1.0.json") assert is_valid is False assert metadata is None def test_invalid_no_extension(self): """Test that filename without extension is invalid.""" is_valid, metadata = validate_schema_filename("manpage-schema-v1.0") assert is_valid is False assert metadata is None def test_invalid_missing_schema_keyword(self): """Test that filename without 'schema' keyword is invalid.""" is_valid, metadata = validate_schema_filename("manpage-v1.0.md") assert is_valid is False assert metadata is None def test_invalid_missing_version(self): """Test that filename without version is invalid.""" is_valid, metadata = validate_schema_filename("manpage-schema.md") assert is_valid is False assert metadata is None def test_invalid_wrong_version_format(self): """Test that version without 'v' prefix is invalid.""" is_valid, metadata = validate_schema_filename("manpage-schema-1.0.md") assert is_valid is False assert metadata is None def test_invalid_missing_minor_version(self): """Test that version without minor number is invalid.""" is_valid, metadata = validate_schema_filename("manpage-schema-v1.md") assert is_valid is False assert metadata is None def test_invalid_uppercase_letters(self): """Test that uppercase letters make filename invalid.""" is_valid, metadata = validate_schema_filename("ManPage-Schema-v1.0.md") assert is_valid is False assert metadata is None def test_invalid_starting_with_number(self): """Test that domain starting with number is invalid.""" is_valid, metadata = validate_schema_filename("42answers-schema-v1.0.md") assert is_valid is False assert metadata is None def test_invalid_starting_with_hyphen(self): """Test that domain starting with hyphen is invalid.""" is_valid, metadata = validate_schema_filename("-manpage-schema-v1.0.md") assert is_valid is False assert metadata is None def test_invalid_special_characters(self): """Test that special characters in domain are invalid.""" is_valid, metadata = validate_schema_filename("man_page-schema-v1.0.md") assert is_valid is False assert metadata is None class TestSuggestSchemaFilename: """Tests for suggest_schema_filename function.""" def test_suggest_simple_domain(self): """Test suggestion for simple domain.""" filename = suggest_schema_filename("manpage", "1.0") assert filename == "manpage-schema-v1.0.md" def test_suggest_with_spaces(self): """Test suggestion normalizes spaces to hyphens.""" filename = suggest_schema_filename("API Documentation", "1.0") assert filename == "api-documentation-schema-v1.0.md" def test_suggest_with_underscores(self): """Test suggestion normalizes underscores to hyphens.""" filename = suggest_schema_filename("my_custom_type", "1.0") assert filename == "my-custom-type-schema-v1.0.md" def test_suggest_with_uppercase(self): """Test suggestion converts to lowercase.""" filename = suggest_schema_filename("MyCustomType", "1.0") assert filename == "mycustomtype-schema-v1.0.md" def test_suggest_mixed_normalization(self): """Test suggestion with mixed case and separators.""" filename = suggest_schema_filename("My_Custom Type", "1.0") assert filename == "my-custom-type-schema-v1.0.md" def test_suggest_higher_version(self): """Test suggestion with version > 1.0.""" filename = suggest_schema_filename("manpage", "2.5") assert filename == "manpage-schema-v2.5.md" def test_suggest_double_digit_version(self): """Test suggestion with double-digit version.""" filename = suggest_schema_filename("manpage", "10.25") assert filename == "manpage-schema-v10.25.md" def test_suggest_consecutive_hyphens(self): """Test suggestion removes consecutive hyphens.""" filename = suggest_schema_filename("my--custom---type", "1.0") assert filename == "my-custom-type-schema-v1.0.md" def test_suggest_leading_trailing_hyphens(self): """Test suggestion removes leading/trailing hyphens.""" filename = suggest_schema_filename("-my-type-", "1.0") assert filename == "my-type-schema-v1.0.md" def test_suggest_default_version(self): """Test suggestion uses default version 1.0.""" filename = suggest_schema_filename("manpage") assert filename == "manpage-schema-v1.0.md" def test_suggest_empty_domain_raises_error(self): """Test that empty domain raises ValueError.""" with pytest.raises(ValueError, match="Domain cannot be empty"): suggest_schema_filename("", "1.0") def test_suggest_invalid_version_format_raises_error(self): """Test that invalid version format raises ValueError.""" with pytest.raises(ValueError, match="must be in format 'major.minor'"): suggest_schema_filename("manpage", "1") def test_suggest_invalid_version_parts_raises_error(self): """Test that non-integer version parts raise ValueError.""" with pytest.raises(ValueError, match="major and minor must be integers"): suggest_schema_filename("manpage", "1.x") def test_suggest_negative_version_raises_error(self): """Test that negative version numbers raise ValueError.""" with pytest.raises(ValueError, match="must be non-negative"): suggest_schema_filename("manpage", "-1.0") def test_suggest_without_normalization(self): """Test suggestion without normalization (must already be valid).""" filename = suggest_schema_filename("manpage", "1.0", normalize=False) assert filename == "manpage-schema-v1.0.md" def test_suggest_without_normalization_invalid_raises_error(self): """Test that invalid domain without normalization raises ValueError.""" with pytest.raises(ValueError, match="Invalid domain"): suggest_schema_filename("My Custom Type", "1.0", normalize=False) class TestExtractSchemaMetadata: """Tests for extract_schema_metadata function.""" def test_extract_valid_metadata(self): """Test metadata extraction from valid filename.""" metadata = extract_schema_metadata("manpage-schema-v1.0.md") assert metadata['domain'] == 'manpage' assert metadata['version'] == '1.0' assert metadata['major'] == 1 assert metadata['minor'] == 0 def test_extract_invalid_raises_error(self): """Test that invalid filename raises SchemaFilenameError.""" with pytest.raises(SchemaFilenameError, match="Invalid schema filename"): extract_schema_metadata("invalid.json") class TestGetValidationErrors: """Tests for get_validation_errors function.""" def test_valid_filename_no_errors(self): """Test that valid filename returns empty error list.""" errors = get_validation_errors("manpage-schema-v1.0.md") assert errors == [] def test_wrong_extension_error(self): """Test error for wrong file extension.""" errors = get_validation_errors("manpage-schema-v1.0.json") assert len(errors) > 0 assert any("Extension must be '.md'" in e for e in errors) def test_missing_version_error(self): """Test error for missing version.""" errors = get_validation_errors("manpage-schema.md") assert len(errors) > 0 assert any("Missing version" in e for e in errors) def test_missing_schema_keyword_error(self): """Test error for missing schema keyword.""" errors = get_validation_errors("manpage-v1.0.md") assert len(errors) > 0 assert any("Missing '-schema-'" in e for e in errors) def test_uppercase_letters_error(self): """Test error for uppercase letters.""" errors = get_validation_errors("ManPage-schema-v1.0.md") assert len(errors) > 0 assert any("must be lowercase" in e for e in errors) def test_invalid_domain_error(self): """Test error for invalid domain format.""" errors = get_validation_errors("42answer-schema-v1.0.md") assert len(errors) > 0 # Should detect that domain doesn't start with letter class TestIsValidSchemaFilename: """Tests for is_valid_schema_filename convenience function.""" def test_is_valid_returns_true(self): """Test that valid filename returns True.""" assert is_valid_schema_filename("manpage-schema-v1.0.md") is True def test_is_valid_returns_false(self): """Test that invalid filename returns False.""" assert is_valid_schema_filename("invalid.json") is False class TestFormatValidationMessage: """Tests for format_validation_message function.""" def test_format_message_valid_filename(self): """Test formatting message for valid filename.""" message = format_validation_message("manpage-schema-v1.0.md") assert "✅ Valid" in message assert "manpage-schema-v1.0.md" in message def test_format_message_invalid_filename(self): """Test formatting message for invalid filename.""" message = format_validation_message("invalid.json") assert "❌ Invalid" in message assert "Errors:" in message assert "Expected format:" in message assert "Example:" in message def test_format_message_includes_suggestion(self): """Test that message includes filename suggestion.""" message = format_validation_message("manpage.json") assert "Suggested filename:" in message # Should suggest something like manpage-schema-v1.0.md class TestSchemaFilenamePattern: """Tests for the regex pattern itself.""" def test_pattern_matches_valid_filenames(self): """Test that pattern matches all valid filename variations.""" valid_filenames = [ "manpage-schema-v1.0.md", "api-documentation-schema-v1.0.md", "arc42-schema-v1.0.md", "a-schema-v1.0.md", # Single letter domain "my-long-domain-name-schema-v1.0.md", "manpage-schema-v10.25.md", # Double digit versions ] for filename in valid_filenames: match = SCHEMA_FILENAME_PATTERN.match(filename) assert match is not None, f"Pattern should match {filename}" def test_pattern_rejects_invalid_filenames(self): """Test that pattern rejects invalid filenames.""" invalid_filenames = [ "manpage-schema-v1.0.json", # Wrong extension "manpage-v1.0.md", # Missing schema keyword "manpage-schema.md", # Missing version "ManPage-schema-v1.0.md", # Uppercase "42answer-schema-v1.0.md", # Starts with number "-manpage-schema-v1.0.md", # Starts with hyphen "man_page-schema-v1.0.md", # Underscore in domain "manpage-schema-1.0.md", # Missing 'v' prefix "manpage-schema-v1.md", # Missing minor version ] for filename in invalid_filenames: match = SCHEMA_FILENAME_PATTERN.match(filename) assert match is None, f"Pattern should not match {filename}" class TestEdgeCases: """Tests for edge cases and boundary conditions.""" def test_very_long_domain_name(self): """Test with very long domain name.""" long_domain = "a" * 100 filename = suggest_schema_filename(long_domain, "1.0") assert is_valid_schema_filename(filename) def test_domain_with_many_hyphens(self): """Test domain with multiple hyphens.""" filename = suggest_schema_filename("my-very-long-domain-name", "1.0") assert filename == "my-very-long-domain-name-schema-v1.0.md" assert is_valid_schema_filename(filename) def test_version_zero_zero(self): """Test with version 0.0.""" filename = suggest_schema_filename("manpage", "0.0") assert filename == "manpage-schema-v0.0.md" assert is_valid_schema_filename(filename) def test_large_version_numbers(self): """Test with large version numbers.""" filename = suggest_schema_filename("manpage", "999.999") assert filename == "manpage-schema-v999.999.md" assert is_valid_schema_filename(filename)