data-format-converter/tests/test_validators.py

"""Tests for validator modules."""

import pytest
import tempfile
import os
from pathlib import Path


class TestJSONValidator:
    """Tests for JSON validator."""
    
    def test_validate_valid_json(self):
        from src.validators import JSONValidator
        validator = JSONValidator()
        
        result = validator.validate('{"name": "test"}')
        assert result.valid
        assert result.format_type == "json"
        assert result.data == {"name": "test"}
    
    def test_validate_invalid_json(self):
        from src.validators import JSONValidator
        validator = JSONValidator()
        
        result = validator.validate('{invalid json}')
        assert not result.valid
        assert len(result.errors) > 0
    
    def test_validate_empty(self):
        from src.validators import JSONValidator
        validator = JSONValidator()
        
        result = validator.validate('')
        assert not result.valid
    
    def test_validate_file(self):
        from src.validators import JSONValidator
        validator = JSONValidator()
        
        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
            f.write('{"test": true}')
            temp_path = f.name
        
        try:
            result = validator.validate_file(temp_path)
            assert result.valid
        finally:
            os.unlink(temp_path)


class TestYAMLValidator:
    """Tests for YAML validator."""
    
    def test_validate_valid_yaml(self):
        from src.validators import YAMLValidator
        validator = YAMLValidator()
        
        result = validator.validate('name: test\nvalue: 123')
        assert result.valid
        assert result.format_type == "yaml"
    
    def test_validate_invalid_yaml(self):
        from src.validators import YAMLValidator
        validator = YAMLValidator()
        
        result = validator.validate('invalid: yaml: content:')
        assert not result.valid
    
    def test_validate_file(self):
        from src.validators import YAMLValidator
        validator = YAMLValidator()
        
        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
            f.write('key: value')
            temp_path = f.name
        
        try:
            result = validator.validate_file(temp_path)
            assert result.valid
        finally:
            os.unlink(temp_path)


class TestTOMLValidator:
    """Tests for TOML validator."""
    
    def test_validate_valid_toml(self):
        from src.validators import TOMLValidator
        validator = TOMLValidator()
        
        result = validator.validate('name = "test"\nvalue = 123')
        assert result.valid
        assert result.format_type == "toml"
    
    def test_validate_invalid_toml(self):
        from src.validators import TOMLValidator
        validator = TOMLValidator()
        
        result = validator.validate('invalid = toml = content')
        assert not result.valid


class TestCSVValidator:
    """Tests for CSV validator."""
    
    def test_validate_valid_csv(self):
        from src.validators import CSVValidator
        validator = CSVValidator()
        
        result = validator.validate("name,age\nAlice,30\nBob,25")
        assert result.valid
        assert result.format_type == "csv"
    
    def test_validate_empty_csv(self):
        from src.validators import CSVValidator
        validator = CSVValidator()
        
        result = validator.validate("")
        assert not result.valid
    
    def test_validate_malformed_csv(self):
        from src.validators import CSVValidator
        validator = CSVValidator()
        
        result = validator.validate("name,age\nAlice")
        assert result.valid
        assert len(result.data) == 1


class TestValidatorFactory:
    """Tests for validator factory function."""
    
    def test_get_validator_json(self):
        from src.validators import get_validator
        
        validator = get_validator("json")
        assert validator.format_name == "json"
    
    def test_get_validator_yaml(self):
        from src.validators import get_validator
        
        validator = get_validator("yaml")
        assert validator.format_name == "yaml"
    
    def test_get_validator_toml(self):
        from src.validators import get_validator
        
        validator = get_validator("toml")
        assert validator.format_name == "toml"
    
    def test_get_validator_csv(self):
        from src.validators import get_validator
        
        validator = get_validator("csv")
        assert validator.format_name == "csv"
    
    def test_get_validator_invalid(self):
        from src.validators import get_validator
        
        with pytest.raises(ValueError):
            get_validator("invalid")


class TestValidateData:
    """Tests for validate_data function."""
    
    def test_validate_json_data(self):
        from src.validators import validate_data
        
        result = validate_data('{"key": "value"}', "json")
        assert result.valid
    
    def test_validate_yaml_data(self):
        from src.validators import validate_data
        
        result = validate_data("key: value", "yaml")
        assert result.valid


class TestDetectFormat:
    """Tests for detect_format function."""
    
    def test_detect_json_format(self):
        from src.validators import detect_format
        
        fmt = detect_format("test.json")
        assert fmt == "json"
    
    def test_detect_yaml_format(self):
        from src.validators import detect_format
        
        fmt = detect_format("test.yaml")
        assert fmt == "yaml"
    
    def test_detect_toml_format(self):
        from src.validators import detect_format
        
        fmt = detect_format("test.toml")
        assert fmt == "toml"
    
    def test_detect_csv_format(self):
        from src.validators import detect_format
        
        fmt = detect_format("test.csv")
        assert fmt == "csv"
    
    def test_detect_unknown_format(self):
        from src.validators import detect_format
        
        fmt = detect_format("test.xyz")
        assert fmt is None