mirror of
https://github.com/kuhyx/testsAndMisc.git
synced 2026-07-04 14:43:01 +02:00
620 lines
20 KiB
Python
620 lines
20 KiB
Python
"""Tests for the offline translator module."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import sys
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
import pytest
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Generator
|
|
|
|
# Import the module
|
|
try:
|
|
from python_pkg.word_frequency import translator
|
|
from python_pkg.word_frequency.translator import (
|
|
TranslationResult,
|
|
download_languages,
|
|
format_translations,
|
|
get_available_packages,
|
|
get_installed_languages,
|
|
main,
|
|
read_file,
|
|
translate_word,
|
|
translate_words,
|
|
translate_words_batch,
|
|
)
|
|
except ImportError:
|
|
# Direct execution support
|
|
sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
|
|
from python_pkg.word_frequency import translator
|
|
from python_pkg.word_frequency.translator import (
|
|
TranslationResult,
|
|
download_languages,
|
|
format_translations,
|
|
get_available_packages,
|
|
get_installed_languages,
|
|
main,
|
|
read_file,
|
|
translate_word,
|
|
translate_words,
|
|
translate_words_batch,
|
|
)
|
|
|
|
|
|
# Helper context manager for mocking argostranslate
|
|
class ArgosAvailableMock:
|
|
"""Context manager to mock argostranslate being available."""
|
|
|
|
def __init__(self, translate_returns: str | list[str] | Exception | None = None) -> None:
|
|
"""Initialize with return values for translate()."""
|
|
self.translate_returns = translate_returns
|
|
self.mock_translate_module = MagicMock()
|
|
self.mock_package_module = MagicMock()
|
|
self.mock_parent = MagicMock()
|
|
self.original_available = translator._argos_available
|
|
|
|
def __enter__(self) -> MagicMock:
|
|
"""Set up the mocks."""
|
|
translator._argos_available = True
|
|
|
|
# Set up translate return value
|
|
if isinstance(self.translate_returns, Exception):
|
|
self.mock_translate_module.translate.side_effect = self.translate_returns
|
|
elif isinstance(self.translate_returns, list):
|
|
self.mock_translate_module.translate.side_effect = self.translate_returns
|
|
elif self.translate_returns is not None:
|
|
self.mock_translate_module.translate.return_value = self.translate_returns
|
|
|
|
# Link parent module to submodules (critical for Python imports)
|
|
self.mock_parent.translate = self.mock_translate_module
|
|
self.mock_parent.package = self.mock_package_module
|
|
|
|
# Patch sys.modules
|
|
self.patchers = [
|
|
patch.dict(
|
|
"sys.modules",
|
|
{
|
|
"argostranslate": self.mock_parent,
|
|
"argostranslate.translate": self.mock_translate_module,
|
|
"argostranslate.package": self.mock_package_module,
|
|
},
|
|
),
|
|
]
|
|
for p in self.patchers:
|
|
p.start()
|
|
|
|
return self.mock_translate_module
|
|
|
|
def __exit__(self, *args: object) -> None:
|
|
"""Restore original state."""
|
|
for p in self.patchers:
|
|
p.stop()
|
|
translator._argos_available = self.original_available
|
|
|
|
|
|
# Fixtures
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_argos_unavailable() -> Generator[None, None, None]:
|
|
"""Mock argostranslate being unavailable."""
|
|
original_value = translator._argos_available
|
|
translator._argos_available = False
|
|
yield
|
|
translator._argos_available = original_value
|
|
|
|
|
|
@pytest.fixture
|
|
def mock_all_translators_unavailable() -> Generator[None, None, None]:
|
|
"""Mock both argostranslate and deep-translator being unavailable."""
|
|
original_argos = translator._argos_available
|
|
original_deep = translator._deep_translator_available
|
|
translator._argos_available = False
|
|
translator._deep_translator_available = False
|
|
yield
|
|
translator._argos_available = original_argos
|
|
translator._deep_translator_available = original_deep
|
|
|
|
|
|
@pytest.fixture
|
|
def temp_words_file(tmp_path: Path) -> Path:
|
|
"""Create a temporary file with words."""
|
|
words_file = tmp_path / "words.txt"
|
|
words_file.write_text("hello\nworld\ngoodbye\n", encoding="utf-8")
|
|
return words_file
|
|
|
|
|
|
# TranslationResult tests
|
|
|
|
|
|
class TestTranslationResult:
|
|
"""Tests for TranslationResult namedtuple."""
|
|
|
|
def test_successful_result(self) -> None:
|
|
"""Test creating a successful translation result."""
|
|
result = TranslationResult(
|
|
source_word="hello",
|
|
translated_word="hola",
|
|
source_lang="en",
|
|
target_lang="es",
|
|
success=True,
|
|
)
|
|
assert result.source_word == "hello"
|
|
assert result.translated_word == "hola"
|
|
assert result.source_lang == "en"
|
|
assert result.target_lang == "es"
|
|
assert result.success is True
|
|
assert result.error is None
|
|
|
|
def test_failed_result(self) -> None:
|
|
"""Test creating a failed translation result."""
|
|
result = TranslationResult(
|
|
source_word="xyz",
|
|
translated_word="",
|
|
source_lang="en",
|
|
target_lang="xx",
|
|
success=False,
|
|
error="Language not supported",
|
|
)
|
|
assert result.success is False
|
|
assert result.error == "Language not supported"
|
|
|
|
def test_result_is_tuple(self) -> None:
|
|
"""Test that TranslationResult is a namedtuple."""
|
|
result = TranslationResult("a", "b", "en", "es", True)
|
|
assert isinstance(result, tuple)
|
|
assert len(result) == 6
|
|
|
|
|
|
# translate_word tests
|
|
|
|
|
|
class TestTranslateWord:
|
|
"""Tests for translate_word function."""
|
|
|
|
def test_translate_word_all_backends_unavailable(
|
|
self, mock_all_translators_unavailable: None
|
|
) -> None:
|
|
"""Test translation when no backends are available."""
|
|
result = translate_word("hello", "en", "es")
|
|
assert result.success is False
|
|
assert "No translation backend" in str(result.error)
|
|
|
|
def test_translate_word_argos_unavailable_uses_deep_translator(
|
|
self, mock_argos_unavailable: None
|
|
) -> None:
|
|
"""Test that deep-translator is used when argos is unavailable."""
|
|
# deep-translator should work as fallback (it's installed)
|
|
result = translate_word("hello", "en", "es")
|
|
# This may succeed if deep-translator is installed
|
|
# Just verify we get a result without crashing
|
|
assert isinstance(result, TranslationResult)
|
|
|
|
def test_translate_word_success(self) -> None:
|
|
"""Test successful word translation."""
|
|
with ArgosAvailableMock("hola"):
|
|
result = translate_word("hello", "en", "es")
|
|
|
|
assert result.source_word == "hello"
|
|
assert result.translated_word == "hola"
|
|
assert result.success is True
|
|
|
|
def test_translate_word_argos_exception_falls_back(
|
|
self, mock_argos_unavailable: None
|
|
) -> None:
|
|
"""Test that argos exception falls back to deep-translator."""
|
|
# With argos unavailable, deep-translator should be used
|
|
result = translate_word("hello", "en", "es")
|
|
# Just verify it doesn't crash - may succeed or fail depending on network
|
|
assert isinstance(result, TranslationResult)
|
|
|
|
|
|
# translate_words tests
|
|
|
|
|
|
class TestTranslateWords:
|
|
"""Tests for translate_words function."""
|
|
|
|
def test_translate_empty_list(self) -> None:
|
|
"""Test translating empty list."""
|
|
results = translate_words([], "en", "es")
|
|
assert results == []
|
|
|
|
def test_translate_multiple_words(self) -> None:
|
|
"""Test translating multiple words."""
|
|
with ArgosAvailableMock(["hola", "mundo"]):
|
|
results = translate_words(["hello", "world"], "en", "es")
|
|
|
|
assert len(results) == 2
|
|
assert results[0].translated_word == "hola"
|
|
assert results[1].translated_word == "mundo"
|
|
|
|
|
|
# translate_words_batch tests
|
|
|
|
|
|
class TestTranslateWordsBatch:
|
|
"""Tests for translate_words_batch function."""
|
|
|
|
def test_batch_empty_list(self) -> None:
|
|
"""Test batch translation of empty list."""
|
|
results = translate_words_batch([], "en", "es")
|
|
assert results == []
|
|
|
|
def test_batch_small_list(self) -> None:
|
|
"""Test batch translation of small list (3 or fewer)."""
|
|
with ArgosAvailableMock(["uno", "dos", "tres"]) as mock:
|
|
results = translate_words_batch(["one", "two", "three"], "en", "es")
|
|
|
|
assert len(results) == 3
|
|
# Small lists use individual translation
|
|
assert mock.translate.call_count == 3
|
|
|
|
def test_batch_large_list_success(self) -> None:
|
|
"""Test batch translation of large list."""
|
|
words = ["one", "two", "three", "four", "five"]
|
|
|
|
with ArgosAvailableMock("uno\ndos\ntres\ncuatro\ncinco") as mock:
|
|
results = translate_words_batch(words, "en", "es")
|
|
|
|
assert len(results) == 5
|
|
# Batch translation called once
|
|
mock.translate.assert_called_once()
|
|
assert results[0].translated_word == "uno"
|
|
assert results[4].translated_word == "cinco"
|
|
|
|
def test_batch_fallback_on_mismatch(self) -> None:
|
|
"""Test batch translation falls back when result count mismatches."""
|
|
words = ["one", "two", "three", "four"]
|
|
# First call (batch) returns wrong count, subsequent calls are individual
|
|
with ArgosAvailableMock(
|
|
["wrong\ncount", "uno", "dos", "tres", "cuatro"]
|
|
) as mock:
|
|
results = translate_words_batch(words, "en", "es")
|
|
|
|
assert len(results) == 4
|
|
# Fallback to individual
|
|
assert mock.translate.call_count == 5
|
|
|
|
def test_batch_fallback_on_exception(self) -> None:
|
|
"""Test batch translation falls back on exception."""
|
|
words = ["one", "two", "three", "four"]
|
|
|
|
# Create mock that raises first then succeeds
|
|
original = translator._argos_available
|
|
translator._argos_available = True
|
|
|
|
mock_translate_module = MagicMock()
|
|
mock_translate_module.translate.side_effect = [
|
|
RuntimeError("Batch failed"),
|
|
"uno",
|
|
"dos",
|
|
"tres",
|
|
"cuatro",
|
|
]
|
|
mock_package_module = MagicMock()
|
|
mock_parent = MagicMock()
|
|
mock_parent.translate = mock_translate_module
|
|
mock_parent.package = mock_package_module
|
|
|
|
with patch.dict(
|
|
"sys.modules",
|
|
{
|
|
"argostranslate": mock_parent,
|
|
"argostranslate.translate": mock_translate_module,
|
|
"argostranslate.package": mock_package_module,
|
|
},
|
|
):
|
|
results = translate_words_batch(words, "en", "es")
|
|
|
|
translator._argos_available = original
|
|
|
|
assert len(results) == 4
|
|
|
|
|
|
# format_translations tests
|
|
|
|
|
|
class TestFormatTranslations:
|
|
"""Tests for format_translations function."""
|
|
|
|
def test_format_empty(self) -> None:
|
|
"""Test formatting empty results."""
|
|
output = format_translations([])
|
|
assert output == "No translations."
|
|
|
|
def test_format_single_translation(self) -> None:
|
|
"""Test formatting single translation."""
|
|
results = [
|
|
TranslationResult("hello", "hola", "en", "es", True),
|
|
]
|
|
output = format_translations(results)
|
|
|
|
assert "en -> es" in output
|
|
assert "hello" in output
|
|
assert "hola" in output
|
|
|
|
def test_format_multiple_translations(self) -> None:
|
|
"""Test formatting multiple translations."""
|
|
results = [
|
|
TranslationResult("hello", "hola", "en", "es", True),
|
|
TranslationResult("world", "mundo", "en", "es", True),
|
|
]
|
|
output = format_translations(results)
|
|
|
|
assert "hello" in output
|
|
assert "hola" in output
|
|
assert "world" in output
|
|
assert "mundo" in output
|
|
|
|
def test_format_with_errors(self) -> None:
|
|
"""Test formatting with failed translations."""
|
|
results = [
|
|
TranslationResult("hello", "hola", "en", "es", True),
|
|
TranslationResult("xyz", "", "en", "es", False, "Unknown word"),
|
|
]
|
|
output = format_translations(results, show_errors=True)
|
|
|
|
assert "hello" in output
|
|
assert "Error: Unknown word" in output
|
|
|
|
def test_format_hide_errors(self) -> None:
|
|
"""Test formatting with errors hidden."""
|
|
results = [
|
|
TranslationResult("hello", "hola", "en", "es", True),
|
|
TranslationResult("xyz", "", "en", "es", False, "Unknown word"),
|
|
]
|
|
output = format_translations(results, show_errors=False)
|
|
|
|
assert "hello" in output
|
|
assert "Unknown word" not in output
|
|
|
|
|
|
# get_installed_languages tests
|
|
|
|
|
|
class TestGetInstalledLanguages:
|
|
"""Tests for get_installed_languages function."""
|
|
|
|
def test_argos_unavailable(self, mock_argos_unavailable: None) -> None:
|
|
"""Test when argos is unavailable."""
|
|
result = get_installed_languages()
|
|
assert result == []
|
|
|
|
def test_returns_languages(self) -> None:
|
|
"""Test returning installed languages."""
|
|
mock_lang1 = MagicMock()
|
|
mock_lang1.code = "en"
|
|
mock_lang1.name = "English"
|
|
mock_lang2 = MagicMock()
|
|
mock_lang2.code = "es"
|
|
mock_lang2.name = "Spanish"
|
|
|
|
with ArgosAvailableMock() as mock:
|
|
mock.get_installed_languages.return_value = [mock_lang1, mock_lang2]
|
|
result = get_installed_languages()
|
|
|
|
assert ("en", "English") in result
|
|
assert ("es", "Spanish") in result
|
|
|
|
|
|
# get_available_packages tests
|
|
|
|
|
|
class TestGetAvailablePackages:
|
|
"""Tests for get_available_packages function."""
|
|
|
|
def test_argos_unavailable(self, mock_argos_unavailable: None) -> None:
|
|
"""Test when argos is unavailable."""
|
|
result = get_available_packages()
|
|
assert result == []
|
|
|
|
|
|
# download_languages tests
|
|
|
|
|
|
class TestDownloadLanguages:
|
|
"""Tests for download_languages function."""
|
|
|
|
def test_argos_unavailable(self, mock_argos_unavailable: None) -> None:
|
|
"""Test when argos is unavailable."""
|
|
result = download_languages(["en", "es"])
|
|
assert result == {}
|
|
|
|
|
|
# read_file tests
|
|
|
|
|
|
class TestReadFile:
|
|
"""Tests for read_file function."""
|
|
|
|
def test_read_file(self, tmp_path: Path) -> None:
|
|
"""Test reading a file."""
|
|
test_file = tmp_path / "test.txt"
|
|
test_file.write_text("hello\nworld", encoding="utf-8")
|
|
|
|
content = read_file(test_file)
|
|
|
|
assert content == "hello\nworld"
|
|
|
|
def test_read_file_not_found(self, tmp_path: Path) -> None:
|
|
"""Test reading non-existent file."""
|
|
with pytest.raises(FileNotFoundError):
|
|
read_file(tmp_path / "nonexistent.txt")
|
|
|
|
|
|
# main function tests
|
|
|
|
|
|
class TestMain:
|
|
"""Tests for main CLI function."""
|
|
|
|
def test_argos_unavailable_error(self, mock_argos_unavailable: None) -> None:
|
|
"""Test error when argos not installed."""
|
|
result = main(["--text", "hello", "--from", "en", "--to", "es"])
|
|
assert result == 1
|
|
|
|
def test_list_languages_empty(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test listing languages when none installed."""
|
|
with ArgosAvailableMock() as mock:
|
|
mock.get_installed_languages.return_value = []
|
|
result = main(["--list-languages"])
|
|
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "No languages installed" in captured.out
|
|
|
|
def test_list_languages_with_results(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test listing installed languages."""
|
|
mock_lang = MagicMock()
|
|
mock_lang.code = "en"
|
|
mock_lang.name = "English"
|
|
|
|
with ArgosAvailableMock() as mock:
|
|
mock.get_installed_languages.return_value = [mock_lang]
|
|
result = main(["--list-languages"])
|
|
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "en" in captured.out
|
|
assert "English" in captured.out
|
|
|
|
def test_translate_single_text(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test translating single text."""
|
|
with ArgosAvailableMock("hola"):
|
|
result = main(["--text", "hello", "--from", "en", "--to", "es"])
|
|
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "hello" in captured.out
|
|
assert "hola" in captured.out
|
|
|
|
def test_translate_multiple_words(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test translating multiple words."""
|
|
with ArgosAvailableMock(["hola", "mundo"]):
|
|
result = main(["--words", "hello", "world", "--from", "en", "--to", "es"])
|
|
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "hello" in captured.out
|
|
assert "world" in captured.out
|
|
|
|
def test_translate_from_file(
|
|
self,
|
|
temp_words_file: Path,
|
|
capsys: pytest.CaptureFixture[str],
|
|
) -> None:
|
|
"""Test translating words from file."""
|
|
with ArgosAvailableMock(["hola", "mundo", "adios"]):
|
|
result = main(
|
|
["--words-file", str(temp_words_file), "--from", "en", "--to", "es"]
|
|
)
|
|
|
|
assert result == 0
|
|
captured = capsys.readouterr()
|
|
assert "hello" in captured.out
|
|
assert "world" in captured.out
|
|
assert "goodbye" in captured.out
|
|
|
|
def test_translate_file_not_found(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test error when words file not found."""
|
|
with ArgosAvailableMock():
|
|
result = main(
|
|
["--words-file", "/nonexistent/file.txt", "--from", "en", "--to", "es"]
|
|
)
|
|
|
|
assert result == 1
|
|
captured = capsys.readouterr()
|
|
assert "File not found" in captured.err
|
|
|
|
def test_translate_output_to_file(
|
|
self,
|
|
tmp_path: Path,
|
|
capsys: pytest.CaptureFixture[str],
|
|
) -> None:
|
|
"""Test outputting translations to file."""
|
|
output_file = tmp_path / "output.txt"
|
|
|
|
with ArgosAvailableMock("hola"):
|
|
result = main(
|
|
[
|
|
"--text",
|
|
"hello",
|
|
"--from",
|
|
"en",
|
|
"--to",
|
|
"es",
|
|
"--output",
|
|
str(output_file),
|
|
]
|
|
)
|
|
|
|
assert result == 0
|
|
assert output_file.exists()
|
|
content = output_file.read_text(encoding="utf-8")
|
|
assert "hello" in content
|
|
assert "hola" in content
|
|
|
|
def test_no_input_shows_help(
|
|
self, capsys: pytest.CaptureFixture[str]
|
|
) -> None:
|
|
"""Test that no input shows help."""
|
|
with ArgosAvailableMock():
|
|
result = main([])
|
|
|
|
assert result == 1
|
|
|
|
def test_translation_failure_returns_error(
|
|
self, mock_all_translators_unavailable: None
|
|
) -> None:
|
|
"""Test that translation failure returns error code when no backends."""
|
|
result = main(["--text", "hello", "--from", "en", "--to", "es"])
|
|
assert result == 1
|
|
|
|
|
|
# Integration-style tests (still mocked but testing more flow)
|
|
|
|
|
|
class TestIntegration:
|
|
"""Integration-style tests for translator."""
|
|
|
|
def test_full_translation_flow(self) -> None:
|
|
"""Test complete translation flow."""
|
|
with ArgosAvailableMock(["uno", "dos", "tres"]):
|
|
words = ["one", "two", "three"]
|
|
results = translate_words(words, "en", "es")
|
|
|
|
assert all(r.success for r in results)
|
|
assert [r.translated_word for r in results] == ["uno", "dos", "tres"]
|
|
|
|
output = format_translations(results)
|
|
assert "en -> es" in output
|
|
assert "one" in output
|
|
assert "uno" in output
|
|
|
|
def test_mixed_success_failure(
|
|
self, mock_all_translators_unavailable: None
|
|
) -> None:
|
|
"""Test handling when no translation backends are available."""
|
|
results = translate_words(["hello", "xyz", "world"], "en", "es")
|
|
|
|
# All should fail when no backends available
|
|
assert all(not r.success for r in results)
|
|
|
|
output = format_translations(results)
|
|
assert "Error" in output
|