"""Tests for MCP server tool implementations to improve server.py coverage."""
import tempfile
from pathlib import Path
from souschef.server import (
list_cookbook_structure,
list_directory,
parse_attributes,
parse_cookbook_metadata,
parse_custom_resource,
parse_inspec_profile,
parse_recipe,
parse_template,
read_cookbook_metadata,
read_file,
)
class TestListDirectory:
"""Test list_directory MCP tool."""
def test_list_directory_success(self) -> None:
"""Test successful directory listing."""
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
(base / "file1.txt").touch()
(base / "file2.rb").touch()
subdir = base / "subdir"
subdir.mkdir()
result = list_directory(str(base))
assert isinstance(result, list)
assert "file1.txt" in result
assert "file2.rb" in result
assert "subdir" in result
def test_list_directory_empty(self) -> None:
"""Test listing empty directory."""
with tempfile.TemporaryDirectory() as tmpdir:
result = list_directory(tmpdir)
assert isinstance(result, list)
def test_list_directory_nonexistent(self) -> None:
"""Test listing nonexistent directory returns error."""
result = list_directory("/nonexistent/path/that/does/not/exist")
assert isinstance(result, (str, list))
class TestReadFile:
"""Test read_file MCP tool."""
def test_read_file_success(self) -> None:
"""Test successful file reading."""
with tempfile.TemporaryDirectory() as tmpdir:
test_file = Path(tmpdir) / "test.txt"
test_content = "package 'nginx'"
test_file.write_text(test_content)
result = read_file(str(test_file))
assert isinstance(result, str)
assert "nginx" in result
def test_read_file_nonexistent(self) -> None:
"""Test reading nonexistent file."""
result = read_file("/nonexistent/file.txt")
assert isinstance(result, str)
def test_read_file_empty(self) -> None:
"""Test reading empty file."""
with tempfile.TemporaryDirectory() as tmpdir:
test_file = Path(tmpdir) / "empty.txt"
test_file.write_text("")
result = read_file(str(test_file))
assert isinstance(result, str)
class TestReadCookbookMetadata:
"""Test read_cookbook_metadata MCP tool."""
def test_read_metadata_success(self) -> None:
"""Test reading cookbook metadata."""
with tempfile.TemporaryDirectory() as tmpdir:
test_file = Path(tmpdir) / "metadata.rb"
test_file.write_text("name 'test'\nversion '1.0.0'")
result = read_cookbook_metadata(str(test_file))
assert isinstance(result, str)
def test_read_metadata_nonexistent(self) -> None:
"""Test reading nonexistent metadata."""
result = read_cookbook_metadata("/nonexistent/metadata.rb")
assert isinstance(result, str)
class TestValidatePathSafety:
"""Test path validation and safety."""
def test_list_directory_safe_path(self) -> None:
"""Test validation of safe path."""
with tempfile.TemporaryDirectory() as tmpdir:
result = list_directory(tmpdir)
assert isinstance(result, (str, list))
def test_list_directory_directory_traversal(self) -> None:
"""Test that directory traversal is handled."""
result = list_directory("../../etc/passwd")
assert isinstance(result, (str, list))
def test_read_file_null_bytes(self) -> None:
"""Test handling of null bytes in paths."""
result = read_file("safe\x00malicious")
assert isinstance(result, str)
class TestParseCookbookFunctions:
"""Test cookbook parsing functions."""
def test_parse_cookbook_metadata_success(self) -> None:
"""Test parsing cookbook metadata."""
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
metadata_file = base / "metadata.rb"
metadata_file.write_text("name 'test'\nversion '1.0.0'")
result = parse_cookbook_metadata(str(metadata_file))
assert isinstance(result, dict)
def test_parse_recipe_simple(self) -> None:
"""Test parsing simple recipe."""
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
recipe_file = base / "default.rb"
recipe_file.write_text("package 'curl' do\n action :install\nend")
result = parse_recipe(str(recipe_file))
assert isinstance(result, str)
def test_parse_recipe_nonexistent(self) -> None:
"""Test parsing nonexistent recipe."""
result = parse_recipe("/nonexistent/recipe.rb")
assert isinstance(result, str)
def test_list_cookbook_structure_success(self) -> None:
"""Test listing cookbook structure."""
with tempfile.TemporaryDirectory() as tmpdir:
base = Path(tmpdir)
# Create cookbook structure
(base / "metadata.rb").write_text("name 'test'\nversion '1.0.0'")
recipes_dir = base / "recipes"
recipes_dir.mkdir()
(recipes_dir / "default.rb").write_text("package 'test'")
result = list_cookbook_structure(str(base))
assert isinstance(result, str)
def test_list_cookbook_structure_empty(self) -> None:
"""Test listing empty cookbook structure."""
with tempfile.TemporaryDirectory() as tmpdir:
result = list_cookbook_structure(tmpdir)
assert isinstance(result, str)
class TestTemplateAndAttributesFunctions:
"""Test template and attributes parsing functions."""
def test_parse_template_success(self) -> None:
"""Test parsing template."""
with tempfile.TemporaryDirectory() as tmpdir:
template_file = Path(tmpdir) / "default.erb"
template_file.write_text("Port <%= @port %>")
result = parse_template(str(template_file))
assert isinstance(result, str)
def test_parse_template_nonexistent(self) -> None:
"""Test parsing nonexistent template."""
result = parse_template("/nonexistent/template.erb")
assert isinstance(result, str)
def test_parse_attributes_success(self) -> None:
"""Test parsing attributes."""
with tempfile.TemporaryDirectory() as tmpdir:
attrs_file = Path(tmpdir) / "default.rb"
attrs_file.write_text("default['port'] = 8080")
result = parse_attributes(str(attrs_file))
assert isinstance(result, str)
def test_parse_attributes_with_precedence(self) -> None:
"""Test parsing attributes with precedence resolution."""
with tempfile.TemporaryDirectory() as tmpdir:
attrs_file = Path(tmpdir) / "default.rb"
attrs_file.write_text("default['port'] = 8080\noverride['port'] = 9090")
result = parse_attributes(str(attrs_file), resolve_precedence=True)
assert isinstance(result, str)
def test_parse_custom_resource_success(self) -> None:
"""Test parsing custom resource."""
with tempfile.TemporaryDirectory() as tmpdir:
resource_file = Path(tmpdir) / "custom.rb"
resource_file.write_text("property :name, String")
result = parse_custom_resource(str(resource_file))
assert isinstance(result, str)
class TestInspecFunctions:
"""Test InSpec profile parsing functions."""
def test_parse_inspec_profile_success(self) -> None:
"""Test parsing InSpec profile."""
with tempfile.TemporaryDirectory() as tmpdir:
profile_dir = Path(tmpdir)
(profile_dir / "inspec.yml").write_text(
"name: test-profile\nversion: 1.0.0"
)
controls_dir = profile_dir / "controls"
controls_dir.mkdir()
(controls_dir / "default.rb").write_text(
"control 'test' do\n impact 1.0\nend"
)
result = parse_inspec_profile(str(profile_dir))
assert isinstance(result, str)
def test_parse_inspec_profile_empty(self) -> None:
"""Test parsing empty InSpec profile."""
with tempfile.TemporaryDirectory() as tmpdir:
result = parse_inspec_profile(tmpdir)
assert isinstance(result, str)
def test_parse_inspec_profile_nonexistent(self) -> None:
"""Test parsing nonexistent InSpec profile."""
result = parse_inspec_profile("/nonexistent/profile")
assert isinstance(result, str)
class TestMCPToolErrorHandling:
"""Test error handling in MCP tools."""
def test_read_file_with_invalid_path(self) -> None:
"""Test read_file handles invalid paths gracefully."""
result = read_file("/invalid/path/that/does/not/exist")
assert isinstance(result, str)
def test_parse_recipe_with_malformed_ruby(self) -> None:
"""Test parsing recipe with invalid Ruby syntax."""
with tempfile.TemporaryDirectory() as tmpdir:
recipe_file = Path(tmpdir) / "invalid.rb"
recipe_file.write_text("invalid ruby { syntax here")
result = parse_recipe(str(recipe_file))
assert isinstance(result, str)
def test_parse_attributes_with_malformed_ruby(self) -> None:
"""Test parsing attributes with invalid Ruby syntax."""
with tempfile.TemporaryDirectory() as tmpdir:
attrs_file = Path(tmpdir) / "invalid.rb"
attrs_file.write_text("invalid ruby { syntax")
result = parse_attributes(str(attrs_file))
assert isinstance(result, str)
def test_parse_cookbook_metadata_with_malformed(self) -> None:
"""Test parsing malformed metadata."""
with tempfile.TemporaryDirectory() as tmpdir:
metadata_file = Path(tmpdir) / "metadata.rb"
metadata_file.write_text("invalid { ruby syntax")
result = parse_cookbook_metadata(str(metadata_file))
assert isinstance(result, dict)
