227 lines
7.9 KiB
Python
227 lines
7.9 KiB
Python
"""Tests for format converters."""
|
|
|
|
import json
|
|
import tempfile
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from config_converter.converters import (
|
|
JsonConverter,
|
|
YamlConverter,
|
|
TomlConverter,
|
|
IniConverter,
|
|
BaseConverter,
|
|
ConversionError,
|
|
)
|
|
|
|
|
|
class TestJsonConverter:
|
|
"""Tests for JSON converter."""
|
|
|
|
def setup_method(self) -> None:
|
|
self.converter = JsonConverter()
|
|
|
|
def test_read_valid_json(self) -> None:
|
|
"""Test reading valid JSON file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
json.dump({"key": "value", "number": 42}, f)
|
|
f.flush()
|
|
result = self.converter.read(f.name)
|
|
assert result == {"key": "value", "number": 42}
|
|
|
|
def test_read_invalid_json(self) -> None:
|
|
"""Test reading invalid JSON raises error."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
f.write("{invalid json}")
|
|
f.flush()
|
|
with pytest.raises(ConversionError):
|
|
self.converter.read(f.name)
|
|
|
|
def test_read_file_not_found(self) -> None:
|
|
"""Test reading non-existent file raises error."""
|
|
with pytest.raises(ConversionError):
|
|
self.converter.read("/nonexistent/path/file.json")
|
|
|
|
def test_write_json(self) -> None:
|
|
"""Test writing JSON file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
|
|
output_path = f.name
|
|
try:
|
|
self.converter.write({"test": "data"}, output_path)
|
|
with open(output_path, "r") as f:
|
|
result = json.load(f)
|
|
assert result == {"test": "data"}
|
|
finally:
|
|
Path(output_path).unlink(missing_ok=True)
|
|
|
|
def test_parse_json_string(self) -> None:
|
|
"""Test parsing JSON string."""
|
|
result = self.converter.parse('{"key": "value"}')
|
|
assert result == {"key": "value"}
|
|
|
|
def test_format_json_string(self) -> None:
|
|
"""Test formatting data to JSON string."""
|
|
result = self.converter.format({"key": "value"})
|
|
assert result == '{\n "key": "value"\n}'
|
|
|
|
|
|
class TestYamlConverter:
|
|
"""Tests for YAML converter."""
|
|
|
|
def setup_method(self) -> None:
|
|
self.converter = YamlConverter()
|
|
|
|
def test_read_valid_yaml(self) -> None:
|
|
"""Test reading valid YAML file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
|
|
f.write("key: value\nnumber: 42\n")
|
|
f.flush()
|
|
result = self.converter.read(f.name)
|
|
assert result == {"key": "value", "number": 42}
|
|
|
|
def test_read_yaml_with_yml_extension(self) -> None:
|
|
"""Test reading YAML file with yml extension."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".yml", delete=False) as f:
|
|
f.write("key: value\n")
|
|
f.flush()
|
|
result = self.converter.read(f.name)
|
|
assert result == {"key": "value"}
|
|
|
|
def test_write_yaml(self) -> None:
|
|
"""Test writing YAML file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f:
|
|
output_path = f.name
|
|
try:
|
|
self.converter.write({"test": "data"}, output_path)
|
|
with open(output_path, "r") as f:
|
|
result = f.read()
|
|
assert "test: data" in result
|
|
finally:
|
|
Path(output_path).unlink(missing_ok=True)
|
|
|
|
def test_parse_yaml_string(self) -> None:
|
|
"""Test parsing YAML string."""
|
|
result = self.converter.parse("key: value")
|
|
assert result == {"key": "value"}
|
|
|
|
|
|
class TestTomlConverter:
|
|
"""Tests for TOML converter."""
|
|
|
|
def setup_method(self) -> None:
|
|
self.converter = TomlConverter()
|
|
|
|
def test_read_valid_toml(self) -> None:
|
|
"""Test reading valid TOML file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:
|
|
f.write('key = "value"\nnumber = 42\n')
|
|
f.flush()
|
|
result = self.converter.read(f.name)
|
|
assert result["key"] == "value"
|
|
assert result["number"] == 42
|
|
|
|
def test_write_toml(self) -> None:
|
|
"""Test writing TOML file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:
|
|
output_path = f.name
|
|
try:
|
|
self.converter.write({"test": "data"}, output_path)
|
|
with open(output_path, "r") as f:
|
|
result = f.read()
|
|
assert 'test = "data"' in result
|
|
finally:
|
|
Path(output_path).unlink(missing_ok=True)
|
|
|
|
def test_parse_toml_string(self) -> None:
|
|
"""Test parsing TOML string."""
|
|
result = self.converter.parse('key = "value"')
|
|
assert result["key"] == "value"
|
|
|
|
|
|
class TestIniConverter:
|
|
"""Tests for INI converter."""
|
|
|
|
def setup_method(self) -> None:
|
|
self.converter = IniConverter()
|
|
|
|
def test_read_valid_ini(self) -> None:
|
|
"""Test reading valid INI file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".ini", delete=False) as f:
|
|
f.write("[section]\nkey = value\n")
|
|
f.flush()
|
|
result = self.converter.read(f.name)
|
|
assert "section" in result
|
|
assert result["section"]["key"] == "value"
|
|
|
|
def test_write_ini(self) -> None:
|
|
"""Test writing INI file."""
|
|
with tempfile.NamedTemporaryFile(mode="w", suffix=".ini", delete=False) as f:
|
|
output_path = f.name
|
|
try:
|
|
self.converter.write({"section": {"key": "value"}}, output_path)
|
|
with open(output_path, "r") as f:
|
|
result = f.read()
|
|
assert "[section]" in result
|
|
finally:
|
|
Path(output_path).unlink(missing_ok=True)
|
|
|
|
def test_parse_ini_string(self) -> None:
|
|
"""Test parsing INI string."""
|
|
result = self.converter.parse("[section]\nkey = value")
|
|
assert "section" in result
|
|
|
|
|
|
class TestBaseConverter:
|
|
"""Tests for base converter."""
|
|
|
|
def test_get_converter_json(self) -> None:
|
|
"""Test getting JSON converter."""
|
|
converter = BaseConverter.get_converter("json")
|
|
assert isinstance(converter, JsonConverter)
|
|
|
|
def test_get_converter_yaml(self) -> None:
|
|
"""Test getting YAML converter."""
|
|
converter = BaseConverter.get_converter("yaml")
|
|
assert isinstance(converter, YamlConverter)
|
|
|
|
def test_get_converter_toml(self) -> None:
|
|
"""Test getting TOML converter."""
|
|
converter = BaseConverter.get_converter("toml")
|
|
assert isinstance(converter, TomlConverter)
|
|
|
|
def test_get_converter_ini(self) -> None:
|
|
"""Test getting INI converter."""
|
|
converter = BaseConverter.get_converter("ini")
|
|
assert isinstance(converter, IniConverter)
|
|
|
|
def test_get_converter_unsupported(self) -> None:
|
|
"""Test getting unsupported converter raises error."""
|
|
with pytest.raises(ConversionError):
|
|
BaseConverter.get_converter("unsupported")
|
|
|
|
def test_guess_format_json(self) -> None:
|
|
"""Test guessing JSON format from extension."""
|
|
assert BaseConverter.guess_format("file.json") == "json"
|
|
|
|
def test_guess_format_yaml(self) -> None:
|
|
"""Test guessing YAML format from extension."""
|
|
assert BaseConverter.guess_format("file.yaml") == "yaml"
|
|
assert BaseConverter.guess_format("file.yml") == "yaml"
|
|
|
|
def test_guess_format_toml(self) -> None:
|
|
"""Test guessing TOML format from extension."""
|
|
assert BaseConverter.guess_format("file.toml") == "toml"
|
|
|
|
def test_guess_format_ini(self) -> None:
|
|
"""Test guessing INI format from extension."""
|
|
assert BaseConverter.guess_format("file.ini") == "ini"
|
|
|
|
def test_get_supported_formats(self) -> None:
|
|
"""Test getting supported formats."""
|
|
formats = BaseConverter.get_supported_formats()
|
|
assert "json" in formats
|
|
assert "yaml" in formats
|
|
assert "toml" in formats
|
|
assert "ini" in formats
|