Jatin K MalikandGitHub
e0ac5e409c
* feat(whisper): refine whisper.cpp model selection * refactor(whisper): exclude diarization model from picker * docs(whisper): document guided model variants * fix(ui): cap settings dialog height at 600px to prevent excessive height on high-res displays
744 lines
28 KiB
Python
744 lines
28 KiB
Python
"""
|
|
Comprehensive coverage tests for whispercpp_model_info module.
|
|
|
|
Tests all functions and constants in the module.
|
|
"""
|
|
|
|
import subprocess
|
|
import unittest
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
|
|
class TestComputeBackendClass(unittest.TestCase):
|
|
"""Test cases for ComputeBackend class."""
|
|
|
|
def test_compute_backend_has_vulkan_constant(self):
|
|
"""Test that ComputeBackend has VULKAN constant."""
|
|
from vocalinux.utils.whispercpp_model_info import ComputeBackend
|
|
|
|
self.assertTrue(hasattr(ComputeBackend, "VULKAN"))
|
|
self.assertEqual(ComputeBackend.VULKAN, "vulkan")
|
|
|
|
def test_compute_backend_has_cuda_constant(self):
|
|
"""Test that ComputeBackend has CUDA constant."""
|
|
from vocalinux.utils.whispercpp_model_info import ComputeBackend
|
|
|
|
self.assertTrue(hasattr(ComputeBackend, "CUDA"))
|
|
self.assertEqual(ComputeBackend.CUDA, "cuda")
|
|
|
|
def test_compute_backend_has_cpu_constant(self):
|
|
"""Test that ComputeBackend has CPU constant."""
|
|
from vocalinux.utils.whispercpp_model_info import ComputeBackend
|
|
|
|
self.assertTrue(hasattr(ComputeBackend, "CPU"))
|
|
self.assertEqual(ComputeBackend.CPU, "cpu")
|
|
|
|
|
|
class TestModelInfo(unittest.TestCase):
|
|
"""Test cases for model information constants."""
|
|
|
|
def test_whispercpp_model_info_exists(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO is defined."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIsInstance(WHISPERCPP_MODEL_INFO, dict)
|
|
self.assertGreater(len(WHISPERCPP_MODEL_INFO), 0)
|
|
|
|
def test_whispercpp_model_info_contains_tiny(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains tiny model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("tiny", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_whispercpp_model_info_contains_base(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains base model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("base", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_whispercpp_model_info_contains_small(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains small model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("small", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_whispercpp_model_info_contains_medium(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains medium model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("medium", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_whispercpp_model_info_contains_large(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains large model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("large", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_whispercpp_model_info_contains_large_v3_turbo(self):
|
|
"""Test that WHISPERCPP_MODEL_INFO contains large-v3-turbo model."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("large-v3-turbo", WHISPERCPP_MODEL_INFO)
|
|
|
|
def test_model_info_has_size_mb(self):
|
|
"""Test that each model has size_mb field."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
for model_name, model_info in WHISPERCPP_MODEL_INFO.items():
|
|
self.assertIn("size_mb", model_info, f"{model_name} missing size_mb")
|
|
self.assertIsInstance(model_info["size_mb"], int)
|
|
self.assertGreater(model_info["size_mb"], 0)
|
|
|
|
def test_model_info_has_params(self):
|
|
"""Test that each model has params field."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
for model_name, model_info in WHISPERCPP_MODEL_INFO.items():
|
|
self.assertIn("params", model_info, f"{model_name} missing params")
|
|
self.assertIsInstance(model_info["params"], str)
|
|
|
|
def test_model_info_has_desc(self):
|
|
"""Test that each model has desc field."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
for model_name, model_info in WHISPERCPP_MODEL_INFO.items():
|
|
self.assertIn("desc", model_info, f"{model_name} missing desc")
|
|
self.assertIsInstance(model_info["desc"], str)
|
|
|
|
def test_model_info_has_url(self):
|
|
"""Test that each model has url field."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
for model_name, model_info in WHISPERCPP_MODEL_INFO.items():
|
|
self.assertIn("url", model_info, f"{model_name} missing url")
|
|
self.assertIsInstance(model_info["url"], str)
|
|
self.assertTrue(model_info["url"].startswith("https://"))
|
|
|
|
def test_available_models_list_exists(self):
|
|
"""Test that AVAILABLE_MODELS list exists."""
|
|
from vocalinux.utils.whispercpp_model_info import AVAILABLE_MODELS
|
|
|
|
self.assertIsInstance(AVAILABLE_MODELS, list)
|
|
self.assertGreater(len(AVAILABLE_MODELS), 0)
|
|
|
|
def test_available_models_contains_all_models(self):
|
|
"""Test that AVAILABLE_MODELS contains all defined models."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
AVAILABLE_MODELS,
|
|
WHISPERCPP_MODEL_INFO,
|
|
)
|
|
|
|
self.assertEqual(set(AVAILABLE_MODELS), set(WHISPERCPP_MODEL_INFO.keys()))
|
|
|
|
def test_available_models_tracks_upstream_dictation_models(self):
|
|
"""Test that AVAILABLE_MODELS covers upstream dictation models."""
|
|
from vocalinux.utils.whispercpp_model_info import AVAILABLE_MODELS
|
|
|
|
expected_models = [
|
|
"tiny",
|
|
"tiny.en",
|
|
"tiny-q5_1",
|
|
"tiny.en-q5_1",
|
|
"tiny-q8_0",
|
|
"base",
|
|
"base.en",
|
|
"base-q5_1",
|
|
"base.en-q5_1",
|
|
"base-q8_0",
|
|
"small",
|
|
"small.en",
|
|
"small-q5_1",
|
|
"small.en-q5_1",
|
|
"small-q8_0",
|
|
"medium",
|
|
"medium.en",
|
|
"medium-q5_0",
|
|
"medium.en-q5_0",
|
|
"medium-q8_0",
|
|
"large-v1",
|
|
"large-v2",
|
|
"large-v2-q5_0",
|
|
"large-v2-q8_0",
|
|
"large", # Vocalinux alias for upstream large-v3
|
|
"large-v3-q5_0",
|
|
"large-v3-turbo",
|
|
"large-v3-turbo-q5_0",
|
|
"large-v3-turbo-q8_0",
|
|
]
|
|
|
|
self.assertEqual(AVAILABLE_MODELS, expected_models)
|
|
|
|
def test_model_sizes_group_whispercpp_variants_for_ui(self):
|
|
"""Test that whisper.cpp models are grouped into size buckets."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
MODEL_SIZES,
|
|
MODEL_VARIANTS_BY_SIZE,
|
|
WHISPERCPP_MODEL_INFO,
|
|
)
|
|
|
|
self.assertEqual(MODEL_SIZES, ["tiny", "base", "small", "medium", "large"])
|
|
self.assertEqual(MODEL_VARIANTS_BY_SIZE["medium"][0], "medium")
|
|
self.assertIn("medium.en-q5_0", MODEL_VARIANTS_BY_SIZE["medium"])
|
|
self.assertIn("large-v3-turbo-q8_0", MODEL_VARIANTS_BY_SIZE["large"])
|
|
self.assertNotIn("small.en-tdrz", MODEL_VARIANTS_BY_SIZE["small"])
|
|
|
|
grouped_models = {
|
|
model_name for variants in MODEL_VARIANTS_BY_SIZE.values() for model_name in variants
|
|
}
|
|
self.assertEqual(grouped_models, set(WHISPERCPP_MODEL_INFO.keys()))
|
|
self.assertFalse(
|
|
any(model_name.endswith("-tdrz") for model_name in grouped_models),
|
|
"TinyDiarize needs diarization-specific runtime support, not the base dictation picker",
|
|
)
|
|
|
|
def test_model_variant_helpers_identify_size_and_english_only_variants(self):
|
|
"""Test helpers that drive the split whisper.cpp model selectors."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
get_model_size,
|
|
get_model_variants,
|
|
is_english_only_model,
|
|
)
|
|
|
|
self.assertEqual(get_model_size("medium.en-q5_0"), "medium")
|
|
self.assertEqual(get_model_size("large-v3-turbo-q8_0"), "large")
|
|
self.assertTrue(is_english_only_model("tiny.en-q5_1"))
|
|
self.assertFalse(is_english_only_model("large-v3-turbo"))
|
|
|
|
|
|
class TestDetectVulkanSupport(unittest.TestCase):
|
|
"""Test cases for detect_vulkan_support function."""
|
|
|
|
def test_detect_vulkan_support_returns_tuple(self):
|
|
"""Test that detect_vulkan_support returns a tuple."""
|
|
from vocalinux.utils.whispercpp_model_info import detect_vulkan_support
|
|
|
|
result = detect_vulkan_support()
|
|
self.assertIsInstance(result, tuple)
|
|
self.assertEqual(len(result), 2)
|
|
|
|
def test_detect_vulkan_support_when_available(self):
|
|
"""Test Vulkan detection when vulkaninfo is available."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.return_value = MagicMock(returncode=0, stdout="deviceName: Intel Arc\n")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_vulkan_support
|
|
|
|
is_available, device_name = detect_vulkan_support()
|
|
|
|
self.assertTrue(is_available)
|
|
self.assertIsNotNone(device_name)
|
|
|
|
def test_detect_vulkan_support_when_unavailable(self):
|
|
"""Test Vulkan detection when vulkaninfo is not available."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.side_effect = FileNotFoundError("vulkaninfo not found")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_vulkan_support
|
|
|
|
is_available, device_name = detect_vulkan_support()
|
|
|
|
self.assertFalse(is_available)
|
|
self.assertIsNone(device_name)
|
|
|
|
def test_detect_vulkan_support_on_timeout(self):
|
|
"""Test Vulkan detection when command times out."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.side_effect = subprocess.TimeoutExpired("vulkaninfo", 5)
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_vulkan_support
|
|
|
|
is_available, device_name = detect_vulkan_support()
|
|
|
|
self.assertFalse(is_available)
|
|
self.assertIsNone(device_name)
|
|
|
|
def test_detect_vulkan_support_on_error(self):
|
|
"""Test Vulkan detection when command returns error."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.return_value = MagicMock(returncode=1, stdout="")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_vulkan_support
|
|
|
|
is_available, device_name = detect_vulkan_support()
|
|
|
|
self.assertFalse(is_available)
|
|
self.assertIsNone(device_name)
|
|
|
|
|
|
class TestDetectCudaSupport(unittest.TestCase):
|
|
"""Test cases for detect_cuda_support function."""
|
|
|
|
def test_detect_cuda_support_returns_tuple(self):
|
|
"""Test that detect_cuda_support returns a tuple."""
|
|
from vocalinux.utils.whispercpp_model_info import detect_cuda_support
|
|
|
|
result = detect_cuda_support()
|
|
self.assertIsInstance(result, tuple)
|
|
self.assertEqual(len(result), 2)
|
|
|
|
def test_detect_cuda_support_when_available(self):
|
|
"""Test CUDA detection when nvidia-smi is available."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.return_value = MagicMock(returncode=0, stdout="NVIDIA RTX 3080, 10240 MiB\n")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cuda_support
|
|
|
|
is_available, device_info = detect_cuda_support()
|
|
|
|
self.assertTrue(is_available)
|
|
self.assertIsNotNone(device_info)
|
|
self.assertIn("RTX 3080", device_info)
|
|
|
|
def test_detect_cuda_support_when_unavailable(self):
|
|
"""Test CUDA detection when nvidia-smi is not available."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.side_effect = FileNotFoundError("nvidia-smi not found")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cuda_support
|
|
|
|
is_available, device_info = detect_cuda_support()
|
|
|
|
self.assertFalse(is_available)
|
|
self.assertIsNone(device_info)
|
|
|
|
def test_detect_cuda_support_on_timeout(self):
|
|
"""Test CUDA detection when command times out."""
|
|
with patch("subprocess.run") as mock_run:
|
|
mock_run.side_effect = subprocess.TimeoutExpired("nvidia-smi", 5)
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cuda_support
|
|
|
|
is_available, device_info = detect_cuda_support()
|
|
|
|
self.assertFalse(is_available)
|
|
self.assertIsNone(device_info)
|
|
|
|
|
|
class TestDetectCPUInfo(unittest.TestCase):
|
|
"""Test cases for detect_cpu_info function."""
|
|
|
|
def test_detect_cpu_info_returns_string(self):
|
|
"""Test that detect_cpu_info returns a string."""
|
|
from vocalinux.utils.whispercpp_model_info import detect_cpu_info
|
|
|
|
result = detect_cpu_info()
|
|
self.assertIsInstance(result, str)
|
|
self.assertGreater(len(result), 0)
|
|
|
|
def test_detect_cpu_info_from_proc_cpuinfo(self):
|
|
"""Test CPU detection from /proc/cpuinfo."""
|
|
cpu_info_content = "model name : Intel(R) Core(TM) i7-10700K CPU @ 3.80GHz\n"
|
|
|
|
with patch("builtins.open", create=True) as mock_open:
|
|
mock_open.return_value.__enter__.return_value = iter([cpu_info_content])
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cpu_info
|
|
|
|
result = detect_cpu_info()
|
|
|
|
self.assertIsInstance(result, str)
|
|
self.assertGreater(len(result), 0)
|
|
|
|
def test_detect_cpu_info_fallback_to_nproc(self):
|
|
"""Test CPU detection falls back to nproc."""
|
|
with (
|
|
patch("builtins.open", create=True, side_effect=Exception("No /proc/cpuinfo")),
|
|
patch("subprocess.run") as mock_run,
|
|
):
|
|
|
|
mock_run.return_value = MagicMock(returncode=0, stdout="8\n")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cpu_info
|
|
|
|
result = detect_cpu_info()
|
|
|
|
self.assertIsInstance(result, str)
|
|
|
|
def test_detect_cpu_info_default_fallback(self):
|
|
"""Test CPU detection returns default when all methods fail."""
|
|
with (
|
|
patch("builtins.open", create=True, side_effect=Exception()),
|
|
patch("subprocess.run", side_effect=Exception()),
|
|
):
|
|
|
|
from vocalinux.utils.whispercpp_model_info import detect_cpu_info
|
|
|
|
result = detect_cpu_info()
|
|
|
|
self.assertEqual(result, "CPU")
|
|
|
|
|
|
class TestDetectComputeBackend(unittest.TestCase):
|
|
"""Test cases for detect_compute_backend function."""
|
|
|
|
def test_detect_compute_backend_returns_tuple(self):
|
|
"""Test that detect_compute_backend returns a tuple."""
|
|
from vocalinux.utils.whispercpp_model_info import detect_compute_backend
|
|
|
|
result = detect_compute_backend()
|
|
self.assertIsInstance(result, tuple)
|
|
self.assertEqual(len(result), 2)
|
|
|
|
def test_detect_compute_backend_prefers_vulkan(self):
|
|
"""Test that detect_compute_backend prefers Vulkan."""
|
|
with (
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_vulkan_support") as mock_vulkan,
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_cuda_support") as mock_cuda,
|
|
):
|
|
|
|
mock_vulkan.return_value = (True, "Intel Arc GPU")
|
|
mock_cuda.return_value = (True, "NVIDIA RTX 3080 (10GB)")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
detect_compute_backend,
|
|
)
|
|
|
|
backend, info = detect_compute_backend()
|
|
|
|
self.assertEqual(backend, ComputeBackend.VULKAN)
|
|
|
|
def test_detect_compute_backend_falls_back_to_cuda(self):
|
|
"""Test that detect_compute_backend falls back to CUDA."""
|
|
with (
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_vulkan_support") as mock_vulkan,
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_cuda_support") as mock_cuda,
|
|
):
|
|
|
|
mock_vulkan.return_value = (False, None)
|
|
mock_cuda.return_value = (True, "NVIDIA RTX 3080 (10GB)")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
detect_compute_backend,
|
|
)
|
|
|
|
backend, info = detect_compute_backend()
|
|
|
|
self.assertEqual(backend, ComputeBackend.CUDA)
|
|
|
|
def test_detect_compute_backend_falls_back_to_cpu(self):
|
|
"""Test that detect_compute_backend falls back to CPU."""
|
|
with (
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_vulkan_support") as mock_vulkan,
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_cuda_support") as mock_cuda,
|
|
patch("vocalinux.utils.whispercpp_model_info.detect_cpu_info") as mock_cpu,
|
|
):
|
|
|
|
mock_vulkan.return_value = (False, None)
|
|
mock_cuda.return_value = (False, None)
|
|
mock_cpu.return_value = "Intel Core i7"
|
|
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
detect_compute_backend,
|
|
)
|
|
|
|
backend, info = detect_compute_backend()
|
|
|
|
self.assertEqual(backend, ComputeBackend.CPU)
|
|
|
|
|
|
class TestGetRecommendedModel(unittest.TestCase):
|
|
"""Test cases for get_recommended_model function."""
|
|
|
|
def test_get_recommended_model_returns_tuple(self):
|
|
"""Test that get_recommended_model returns a tuple."""
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=8 * (1024**3))
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend",
|
|
return_value=("cpu", "Intel Core i7"),
|
|
):
|
|
import importlib
|
|
|
|
import vocalinux.utils.whispercpp_model_info as mod
|
|
|
|
importlib.reload(mod)
|
|
result = mod.get_recommended_model()
|
|
self.assertIsInstance(result, tuple)
|
|
self.assertEqual(len(result), 2)
|
|
|
|
def test_get_recommended_model_with_vulkan_high_ram(self):
|
|
"""Test model recommendation with Vulkan and 8GB+ RAM."""
|
|
import sys
|
|
|
|
# Create a mock psutil module
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=8 * (1024**3))
|
|
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend"
|
|
) as mock_backend:
|
|
mock_backend.return_value = ("vulkan", "Intel Arc A770")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import get_recommended_model
|
|
|
|
model, reason = get_recommended_model()
|
|
|
|
self.assertEqual(model, "small")
|
|
|
|
def test_get_recommended_model_with_cuda_high_vram(self):
|
|
"""Test model recommendation with CUDA and high VRAM."""
|
|
import sys
|
|
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=16 * (1024**3))
|
|
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend"
|
|
) as mock_backend:
|
|
mock_backend.return_value = ("cuda", "NVIDIA RTX 4090 (24GB)")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import get_recommended_model
|
|
|
|
model, reason = get_recommended_model()
|
|
|
|
# High VRAM should recommend medium or higher
|
|
self.assertIn(model, ["medium", "large", "small"])
|
|
|
|
def test_get_recommended_model_with_cpu_high_ram(self):
|
|
"""Test model recommendation with CPU and 16GB+ RAM."""
|
|
import sys
|
|
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=16 * (1024**3))
|
|
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend"
|
|
) as mock_backend:
|
|
mock_backend.return_value = ("cpu", "Intel Core i7")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import get_recommended_model
|
|
|
|
model, reason = get_recommended_model()
|
|
|
|
self.assertEqual(model, "base")
|
|
|
|
def test_get_recommended_model_with_cpu_medium_ram(self):
|
|
"""Test model recommendation with CPU and 8GB RAM."""
|
|
import sys
|
|
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=8 * (1024**3))
|
|
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend"
|
|
) as mock_backend:
|
|
mock_backend.return_value = ("cpu", "AMD Ryzen 5")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import get_recommended_model
|
|
|
|
model, reason = get_recommended_model()
|
|
|
|
self.assertEqual(model, "tiny")
|
|
|
|
def test_get_recommended_model_with_cpu_low_ram(self):
|
|
"""Test model recommendation with CPU and 4GB RAM."""
|
|
import sys
|
|
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=4 * (1024**3))
|
|
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend"
|
|
) as mock_backend:
|
|
mock_backend.return_value = ("cpu", "Intel Atom")
|
|
|
|
from vocalinux.utils.whispercpp_model_info import get_recommended_model
|
|
|
|
model, reason = get_recommended_model()
|
|
|
|
self.assertEqual(model, "tiny")
|
|
|
|
def test_get_recommended_model_returns_valid_model_name(self):
|
|
"""Test that get_recommended_model returns a valid model name."""
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=8 * (1024**3))
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend",
|
|
return_value=("cpu", "Intel Core i7"),
|
|
):
|
|
import importlib
|
|
|
|
import vocalinux.utils.whispercpp_model_info as mod
|
|
|
|
importlib.reload(mod)
|
|
model, reason = mod.get_recommended_model()
|
|
self.assertIn(model, mod.AVAILABLE_MODELS)
|
|
|
|
def test_get_recommended_model_returns_reason_string(self):
|
|
"""Test that get_recommended_model returns a reason string."""
|
|
mock_psutil = MagicMock()
|
|
mock_psutil.virtual_memory.return_value = MagicMock(total=8 * (1024**3))
|
|
with patch.dict("sys.modules", {"psutil": mock_psutil}):
|
|
with patch(
|
|
"vocalinux.utils.whispercpp_model_info.detect_compute_backend",
|
|
return_value=("cpu", "Intel Core i7"),
|
|
):
|
|
import importlib
|
|
|
|
import vocalinux.utils.whispercpp_model_info as mod
|
|
|
|
importlib.reload(mod)
|
|
model, reason = mod.get_recommended_model()
|
|
self.assertIsInstance(reason, str)
|
|
self.assertGreater(len(reason), 0)
|
|
|
|
|
|
class TestGetModelPath(unittest.TestCase):
|
|
"""Test cases for get_model_path function."""
|
|
|
|
def test_get_model_path_returns_string(self):
|
|
"""Test that get_model_path returns a string."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
result = get_model_path("tiny")
|
|
self.assertIsInstance(result, str)
|
|
self.assertGreater(len(result), 0)
|
|
|
|
def test_get_model_path_tiny(self):
|
|
"""Test get_model_path for tiny model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("tiny")
|
|
self.assertIn("ggml-tiny.bin", path)
|
|
|
|
def test_get_model_path_base(self):
|
|
"""Test get_model_path for base model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("base")
|
|
self.assertIn("ggml-base.bin", path)
|
|
|
|
def test_get_model_path_small(self):
|
|
"""Test get_model_path for small model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("small")
|
|
self.assertIn("ggml-small.bin", path)
|
|
|
|
def test_get_model_path_medium(self):
|
|
"""Test get_model_path for medium model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("medium")
|
|
self.assertIn("ggml-medium.bin", path)
|
|
|
|
def test_get_model_path_large_uses_v3(self):
|
|
"""Test get_model_path for large model uses v3 variant."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("large")
|
|
self.assertIn("ggml-large-v3.bin", path)
|
|
|
|
def test_large_model_url_uses_v3(self):
|
|
"""Test large model metadata points to upstream large-v3."""
|
|
from vocalinux.utils.whispercpp_model_info import WHISPERCPP_MODEL_INFO
|
|
|
|
self.assertIn("ggml-large-v3.bin", WHISPERCPP_MODEL_INFO["large"]["url"])
|
|
|
|
def test_get_model_path_large_v3_turbo(self):
|
|
"""Test get_model_path for large-v3-turbo model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("large-v3-turbo")
|
|
self.assertIn("ggml-large-v3-turbo.bin", path)
|
|
|
|
def test_get_model_path_quantized_model(self):
|
|
"""Test get_model_path for quantized model."""
|
|
from vocalinux.utils.whispercpp_model_info import get_model_path
|
|
|
|
path = get_model_path("large-v3-turbo-q5_0")
|
|
self.assertIn("ggml-large-v3-turbo-q5_0.bin", path)
|
|
|
|
|
|
class TestIsModelDownloaded(unittest.TestCase):
|
|
"""Test cases for is_model_downloaded function."""
|
|
|
|
def test_is_model_downloaded_returns_bool(self):
|
|
"""Test that is_model_downloaded returns a boolean."""
|
|
from vocalinux.utils.whispercpp_model_info import is_model_downloaded
|
|
|
|
result = is_model_downloaded("tiny")
|
|
self.assertIsInstance(result, bool)
|
|
|
|
def test_is_model_downloaded_when_exists(self):
|
|
"""Test is_model_downloaded when model file exists."""
|
|
with patch("os.path.exists", return_value=True):
|
|
from vocalinux.utils.whispercpp_model_info import is_model_downloaded
|
|
|
|
result = is_model_downloaded("base")
|
|
self.assertTrue(result)
|
|
|
|
def test_is_model_downloaded_when_not_exists(self):
|
|
"""Test is_model_downloaded when model file does not exist."""
|
|
with patch("os.path.exists", return_value=False):
|
|
from vocalinux.utils.whispercpp_model_info import is_model_downloaded
|
|
|
|
result = is_model_downloaded("base")
|
|
self.assertFalse(result)
|
|
|
|
|
|
class TestGetBackendDisplayName(unittest.TestCase):
|
|
"""Test cases for get_backend_display_name function."""
|
|
|
|
def test_get_backend_display_name_returns_string(self):
|
|
"""Test that get_backend_display_name returns a string."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
get_backend_display_name,
|
|
)
|
|
|
|
result = get_backend_display_name(ComputeBackend.CPU)
|
|
self.assertIsInstance(result, str)
|
|
self.assertGreater(len(result), 0)
|
|
|
|
def test_get_backend_display_name_vulkan(self):
|
|
"""Test display name for Vulkan backend."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
get_backend_display_name,
|
|
)
|
|
|
|
result = get_backend_display_name(ComputeBackend.VULKAN)
|
|
self.assertEqual(result, "Vulkan GPU")
|
|
|
|
def test_get_backend_display_name_cuda(self):
|
|
"""Test display name for CUDA backend."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
get_backend_display_name,
|
|
)
|
|
|
|
result = get_backend_display_name(ComputeBackend.CUDA)
|
|
self.assertEqual(result, "NVIDIA CUDA")
|
|
|
|
def test_get_backend_display_name_cpu(self):
|
|
"""Test display name for CPU backend."""
|
|
from vocalinux.utils.whispercpp_model_info import (
|
|
ComputeBackend,
|
|
get_backend_display_name,
|
|
)
|
|
|
|
result = get_backend_display_name(ComputeBackend.CPU)
|
|
self.assertEqual(result, "CPU")
|
|
|
|
def test_get_backend_display_name_unknown(self):
|
|
"""Test display name for unknown backend."""
|
|
from vocalinux.utils.whispercpp_model_info import get_backend_display_name
|
|
|
|
result = get_backend_display_name("rocm")
|
|
self.assertEqual(result, "ROCM")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|