"""Tests for the MCP server module."""
import sys
from unittest.mock import MagicMock
# Mock the mcp module before importing server
sys.modules["mcp"] = MagicMock()
sys.modules["mcp.server"] = MagicMock()
sys.modules["mcp.server.stdio"] = MagicMock()
sys.modules["mcp.types"] = MagicMock()
class TestInputValidationFunctions:
"""Tests for input validation functions (without full server initialization)."""
def test_coordinate_validation_logic(self):
"""Test coordinate validation constants and logic."""
MIN_COORDINATE = 0
MAX_COORDINATE = 65535
# Valid coordinates
assert 0 >= MIN_COORDINATE and 0 <= MAX_COORDINATE
assert 100 >= MIN_COORDINATE and 100 <= MAX_COORDINATE
assert MAX_COORDINATE >= MIN_COORDINATE and MAX_COORDINATE <= MAX_COORDINATE
# Invalid coordinates
assert -1 < MIN_COORDINATE
assert MAX_COORDINATE + 1 > MAX_COORDINATE
def test_string_validation_logic(self):
"""Test string validation logic."""
MAX_TEXT_LENGTH = 10000
MAX_QUERY_LENGTH = 1000
# Valid strings
assert len("hello") <= MAX_TEXT_LENGTH
assert len("a" * MAX_TEXT_LENGTH) <= MAX_TEXT_LENGTH
# Invalid strings
assert len("a" * (MAX_TEXT_LENGTH + 1)) > MAX_TEXT_LENGTH
assert len("a" * (MAX_QUERY_LENGTH + 1)) > MAX_QUERY_LENGTH
class TestServerConstants:
"""Tests for server constants."""
def test_max_text_length(self):
"""Test MAX_TEXT_LENGTH constant value."""
MAX_TEXT_LENGTH = 10000
assert MAX_TEXT_LENGTH == 10000
assert isinstance(MAX_TEXT_LENGTH, int)
def test_max_query_length(self):
"""Test MAX_QUERY_LENGTH constant value."""
MAX_QUERY_LENGTH = 1000
assert MAX_QUERY_LENGTH == 1000
assert isinstance(MAX_QUERY_LENGTH, int)
def test_coordinate_bounds(self):
"""Test coordinate boundary constants."""
MIN_COORDINATE = 0
MAX_COORDINATE = 65535
assert MIN_COORDINATE == 0
assert MAX_COORDINATE == 65535
assert MAX_COORDINATE > MIN_COORDINATE
class TestValidationHelpers:
"""Tests for validation helper logic."""
def validate_coordinate(self, value: int) -> bool:
"""Validate a coordinate value is within bounds."""
MIN_COORDINATE = 0
MAX_COORDINATE = 65535
return MIN_COORDINATE <= value <= MAX_COORDINATE
def validate_coordinates(self, x: int, y: int) -> tuple[bool, str]:
"""Validate x,y coordinates."""
MAX_COORDINATE = 65535
if not isinstance(x, (int, float)) or not isinstance(y, (int, float)):
return False, "Coordinates must be numbers"
x, y = int(x), int(y)
if not self.validate_coordinate(x):
return False, f"X coordinate {x} out of range (0-{MAX_COORDINATE})"
if not self.validate_coordinate(y):
return False, f"Y coordinate {y} out of range (0-{MAX_COORDINATE})"
return True, ""
def validate_string(self, value: str, max_len: int, name: str = "value") -> tuple[bool, str]:
"""Validate a string value."""
if not isinstance(value, str):
return False, f"{name} must be a string"
if len(value) > max_len:
return False, f"{name} too long ({len(value)} > {max_len})"
return True, ""
def test_validate_coordinate_valid(self):
"""Test valid coordinate validation."""
assert self.validate_coordinate(0) is True
assert self.validate_coordinate(100) is True
assert self.validate_coordinate(65535) is True
def test_validate_coordinate_invalid_negative(self):
"""Test invalid negative coordinate."""
assert self.validate_coordinate(-1) is False
def test_validate_coordinate_invalid_overflow(self):
"""Test invalid overflow coordinate."""
assert self.validate_coordinate(65536) is False
def test_validate_coordinates_valid(self):
"""Test valid coordinate pair validation."""
is_valid, error = self.validate_coordinates(100, 200)
assert is_valid is True
assert error == ""
def test_validate_coordinates_invalid_x(self):
"""Test invalid x coordinate."""
is_valid, error = self.validate_coordinates(-1, 100)
assert is_valid is False
assert "X coordinate" in error
def test_validate_coordinates_invalid_y(self):
"""Test invalid y coordinate."""
is_valid, error = self.validate_coordinates(100, -1)
assert is_valid is False
assert "Y coordinate" in error
def test_validate_string_valid(self):
"""Test valid string validation."""
is_valid, error = self.validate_string("hello", 100, "test")
assert is_valid is True
assert error == ""
def test_validate_string_too_long(self):
"""Test string that's too long."""
is_valid, error = self.validate_string("a" * 101, 100, "test")
assert is_valid is False
assert "too long" in error
def test_validate_string_non_string(self):
"""Test non-string value."""
is_valid, error = self.validate_string(123, 100, "test")
assert is_valid is False
assert "must be a string" in error
