"""
Unit tests for the Pascal language server auto-update functionality.
These tests validate the version comparison, checksum verification,
and other helper methods without requiring network access or the
actual Pascal language server.
"""
from __future__ import annotations
import hashlib
import os
import tarfile
import tempfile
import time
import pytest
from solidlsp.language_servers.pascal_server import PascalLanguageServer
pytestmark = [pytest.mark.pascal]
class TestVersionNormalization:
"""Test version string normalization."""
def test_normalize_version_with_v_prefix(self) -> None:
"""Test that 'v' prefix is stripped."""
assert PascalLanguageServer._normalize_version("v1.0.0") == "1.0.0"
def test_normalize_version_with_capital_v_prefix(self) -> None:
"""Test that 'V' prefix is stripped."""
assert PascalLanguageServer._normalize_version("V1.0.0") == "1.0.0"
def test_normalize_version_without_prefix(self) -> None:
"""Test version without prefix is unchanged."""
assert PascalLanguageServer._normalize_version("1.0.0") == "1.0.0"
def test_normalize_version_with_whitespace(self) -> None:
"""Test that whitespace is stripped."""
assert PascalLanguageServer._normalize_version(" v1.0.0 ") == "1.0.0"
def test_normalize_version_empty(self) -> None:
"""Test empty version returns empty string."""
assert PascalLanguageServer._normalize_version("") == ""
def test_normalize_version_none(self) -> None:
"""Test None returns empty string."""
assert PascalLanguageServer._normalize_version(None) == ""
class TestVersionComparison:
"""Test version comparison logic."""
def test_newer_version_major(self) -> None:
"""Test detection of newer major version."""
assert PascalLanguageServer._is_newer_version("v2.0.0", "v1.0.0") is True
def test_newer_version_minor(self) -> None:
"""Test detection of newer minor version."""
assert PascalLanguageServer._is_newer_version("v1.1.0", "v1.0.0") is True
def test_newer_version_patch(self) -> None:
"""Test detection of newer patch version."""
assert PascalLanguageServer._is_newer_version("v1.0.1", "v1.0.0") is True
def test_same_version(self) -> None:
"""Test same version returns False."""
assert PascalLanguageServer._is_newer_version("v1.0.0", "v1.0.0") is False
def test_older_version(self) -> None:
"""Test older version returns False."""
assert PascalLanguageServer._is_newer_version("v1.0.0", "v2.0.0") is False
def test_latest_none_returns_false(self) -> None:
"""Test None latest version returns False."""
assert PascalLanguageServer._is_newer_version(None, "v1.0.0") is False
def test_local_none_returns_true(self) -> None:
"""Test None local version returns True (first install)."""
assert PascalLanguageServer._is_newer_version("v1.0.0", None) is True
def test_both_none_returns_false(self) -> None:
"""Test both None returns False."""
assert PascalLanguageServer._is_newer_version(None, None) is False
def test_version_with_different_lengths(self) -> None:
"""Test versions with different number of parts."""
assert PascalLanguageServer._is_newer_version("v1.0.1", "v1.0") is True
assert PascalLanguageServer._is_newer_version("v1.0", "v1.0.1") is False
def test_version_with_prerelease(self) -> None:
"""Test versions with prerelease suffixes."""
# Prerelease suffix is ignored, only numeric parts are compared
assert PascalLanguageServer._is_newer_version("v1.1.0-beta", "v1.0.0") is True
class TestSHA256Checksum:
"""Test SHA256 checksum calculation and verification."""
def test_calculate_sha256(self) -> None:
"""Test SHA256 calculation for a known content."""
with tempfile.NamedTemporaryFile(mode="wb", delete=False) as f:
f.write(b"test content")
temp_path = f.name
try:
result = PascalLanguageServer._calculate_sha256(temp_path)
expected = hashlib.sha256(b"test content").hexdigest()
assert result == expected
finally:
os.unlink(temp_path)
def test_verify_checksum_correct(self) -> None:
"""Test checksum verification with correct checksum."""
with tempfile.NamedTemporaryFile(mode="wb", delete=False) as f:
f.write(b"test content")
temp_path = f.name
try:
expected = hashlib.sha256(b"test content").hexdigest()
assert PascalLanguageServer._verify_checksum(temp_path, expected) is True
finally:
os.unlink(temp_path)
def test_verify_checksum_incorrect(self) -> None:
"""Test checksum verification with incorrect checksum."""
with tempfile.NamedTemporaryFile(mode="wb", delete=False) as f:
f.write(b"test content")
temp_path = f.name
try:
wrong_checksum = "0" * 64
assert PascalLanguageServer._verify_checksum(temp_path, wrong_checksum) is False
finally:
os.unlink(temp_path)
def test_verify_checksum_case_insensitive(self) -> None:
"""Test checksum verification is case insensitive."""
with tempfile.NamedTemporaryFile(mode="wb", delete=False) as f:
f.write(b"test content")
temp_path = f.name
try:
expected = hashlib.sha256(b"test content").hexdigest().upper()
assert PascalLanguageServer._verify_checksum(temp_path, expected) is True
finally:
os.unlink(temp_path)
class TestTarfileSafety:
"""Test tarfile path traversal protection."""
def test_safe_tar_member_normal_path(self) -> None:
"""Test normal path is considered safe."""
member = tarfile.TarInfo(name="pasls")
assert PascalLanguageServer._is_safe_tar_member(member, "/tmp/target") is True
def test_safe_tar_member_nested_path(self) -> None:
"""Test nested path is considered safe."""
member = tarfile.TarInfo(name="subdir/pasls")
assert PascalLanguageServer._is_safe_tar_member(member, "/tmp/target") is True
def test_unsafe_tar_member_path_traversal(self) -> None:
"""Test path traversal is detected."""
member = tarfile.TarInfo(name="../etc/passwd")
assert PascalLanguageServer._is_safe_tar_member(member, "/tmp/target") is False
def test_unsafe_tar_member_hidden_traversal(self) -> None:
"""Test hidden path traversal in nested path."""
member = tarfile.TarInfo(name="subdir/../../etc/passwd")
assert PascalLanguageServer._is_safe_tar_member(member, "/tmp/target") is False
def test_safe_tar_member_similar_name(self) -> None:
"""Test path containing '..' in filename (not directory) is safe."""
member = tarfile.TarInfo(name="file..name")
assert PascalLanguageServer._is_safe_tar_member(member, "/tmp/target") is True
class TestMetadataManagement:
"""Test metadata directory and file management."""
def test_meta_dir_creates_directory(self) -> None:
"""Test _meta_dir creates directory if not exists."""
with tempfile.TemporaryDirectory() as temp_dir:
meta_path = PascalLanguageServer._meta_dir(temp_dir)
assert os.path.exists(meta_path)
assert meta_path == os.path.join(temp_dir, PascalLanguageServer.META_DIR)
def test_meta_file_returns_correct_path(self) -> None:
"""Test _meta_file returns correct path."""
with tempfile.TemporaryDirectory() as temp_dir:
meta_file = PascalLanguageServer._meta_file(temp_dir, "version")
expected = os.path.join(temp_dir, PascalLanguageServer.META_DIR, "version")
assert meta_file == expected
class TestUpdateCheckTiming:
"""Test update check timing logic."""
def test_should_check_update_no_last_check(self) -> None:
"""Test should check when no last_check file exists."""
with tempfile.TemporaryDirectory() as temp_dir:
assert PascalLanguageServer._should_check_update(temp_dir) is True
def test_should_check_update_recent_check(self) -> None:
"""Test should not check when recently checked."""
with tempfile.TemporaryDirectory() as temp_dir:
# Create meta dir and last_check file with current time
meta_dir = PascalLanguageServer._meta_dir(temp_dir)
last_check_file = os.path.join(meta_dir, "last_check")
with open(last_check_file, "w") as f:
f.write(str(time.time()))
assert PascalLanguageServer._should_check_update(temp_dir) is False
def test_should_check_update_old_check(self) -> None:
"""Test should check when last check was > 24 hours ago."""
with tempfile.TemporaryDirectory() as temp_dir:
# Create meta dir and last_check file with old time
meta_dir = PascalLanguageServer._meta_dir(temp_dir)
last_check_file = os.path.join(meta_dir, "last_check")
old_time = time.time() - (PascalLanguageServer.UPDATE_CHECK_INTERVAL + 3600)
with open(last_check_file, "w") as f:
f.write(str(old_time))
assert PascalLanguageServer._should_check_update(temp_dir) is True
def test_update_last_check_creates_file(self) -> None:
"""Test _update_last_check creates timestamp file."""
with tempfile.TemporaryDirectory() as temp_dir:
PascalLanguageServer._update_last_check(temp_dir)
last_check_file = PascalLanguageServer._meta_file(temp_dir, "last_check")
assert os.path.exists(last_check_file)
with open(last_check_file) as f:
timestamp = float(f.read().strip())
assert abs(timestamp - time.time()) < 5 # within 5 seconds
class TestVersionPersistence:
"""Test local version persistence."""
def test_save_and_get_local_version(self) -> None:
"""Test saving and retrieving local version."""
with tempfile.TemporaryDirectory() as temp_dir:
PascalLanguageServer._save_local_version(temp_dir, "v1.0.0")
version = PascalLanguageServer._get_local_version(temp_dir)
assert version == "v1.0.0"
def test_get_local_version_not_exists(self) -> None:
"""Test getting version when file doesn't exist."""
with tempfile.TemporaryDirectory() as temp_dir:
version = PascalLanguageServer._get_local_version(temp_dir)
assert version is None
