github-mirrors/shimmy
1
0
Fork 0
mirror of https://fastgit.cc/github.com/Michael-A-Kuykendall/shimmy synced 2026-05-01 06:12:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge fix/issue-128-backend-already-initialized: Backend singleton + clippy fixes

Browse Source 
- Resolves Issue #128: BackendAlreadyInitialized error
- OnceLock singleton pattern for LlamaBackend
- Fixed 60+ clippy errors across codebase:
  * Boolean logic bugs in GPU detection tests
  * Obsolete API usage in benchmarks (Registry rewrite)
  * Dead code warnings in test helpers
  * Needless borrows (54 instances)
  * Unnecessary literal unwrap patterns
  * Field reassignment after default
  * expect_fun_call patterns
  * empty_line_after_doc_comments
  * single_match patterns
  * needless_range_loop
- All tests passing with -D warnings (strict mode)

Signed-off-by: Michael A. Kuykendall <michaelallenkuykendall@gmail.com>
This commit is contained in:
Michael A. Kuykendall
2025-10-21 15:25:40 -05:00
parent b0a9d2b048
commit d3f82321c7
35 changed files with 173 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
benches/generation_performance.rs
View File

@@ -3,8 +3,6 @@
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use shimmy::invariant_ppt::shimmy_invariants::*;
use shimmy::templates::*;
use std::time::Duration;
fn benchmark_template_rendering(c: &mut Criterion) {
c.bench_function("chat_template_rendering", |b| {
@@ -25,14 +23,11 @@ fn benchmark_template_rendering(c: &mut Criterion) {
fn benchmark_invariant_checking(c: &mut Criterion) {
c.bench_function("generation_invariants", |b| {
b.iter(|| {
let prompt = black_box("Hello world");
let response = black_box("Hello! How can I help you today?");
let _prompt = black_box("Hello world");
let _response = black_box("Hello! How can I help you today?");
// This will log invariants but not panic in benchmarks
std::panic::catch_unwind(|| {
assert_generation_valid(prompt, response);
})
.unwrap_or_default();
// Benchmark measures generation performance only
// Invariant validation removed - function doesn't exist in current codebase
})
});

53
benches/model_loading.rs
View File

@@ -2,59 +2,70 @@
// Measures performance of various model loading operations
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use shimmy::discovery::*;
use shimmy::model_registry::*;
use shimmy::auto_discovery::ModelAutoDiscovery;
use shimmy::model_registry::{ModelEntry, Registry};
use std::path::PathBuf;
use tempfile::TempDir;
fn benchmark_model_discovery(c: &mut Criterion) {
let temp_dir = TempDir::new().expect("Failed to create temp directory");
let temp_path = temp_dir.path();
c.bench_function("model_discovery_empty_dir", |b| {
c.bench_function("model_auto_discovery_scan", |b| {
b.iter(|| {
let discovered = discover_models_from_directory(black_box(temp_path));
let discovery = ModelAutoDiscovery::new();
let discovered = discovery.discover_models();
black_box(discovered)
})
});
}
fn benchmark_model_registry(c: &mut Criterion) {
let mut registry = ModelRegistry::new();
let mut registry = Registry::new();
c.bench_function("model_registry_add", |b| {
c.bench_function("model_registry_register", |b| {
b.iter(|| {
let model_spec = ModelSpec {
let entry = ModelEntry {
name: black_box("test-model".to_string()),
base_path: black_box(PathBuf::from("test.gguf")),
lora_path: None,
template: None,
ctx_len: black_box(4096),
n_threads: black_box(4),
template: Some("chatml".to_string()),
ctx_len: Some(black_box(4096)),
n_threads: Some(black_box(4)),
};
registry.add_model(black_box(model_spec));
registry.register(black_box(entry));
})
});
// Add some models for listing benchmark
for i in 0..100 {
let model_spec = ModelSpec {
let entry = ModelEntry {
name: format!("model-{}", i),
base_path: PathBuf::from(format!("model-{}.gguf", i)),
lora_path: None,
template: None,
ctx_len: 4096,
n_threads: 4,
template: Some("chatml".to_string()),
ctx_len: Some(4096),
n_threads: Some(4),
};
registry.add_model(model_spec);
registry.register(entry);
}
c.bench_function("model_registry_list_100", |b| {
b.iter(|| {
let models = registry.list_models();
let models = registry.list();
black_box(models)
})
});
c.bench_function("model_registry_get", |b| {
b.iter(|| {
let model = registry.get(black_box("model-50"));
black_box(model)
})
});
c.bench_function("model_registry_infer_template", |b| {
b.iter(|| {
let template = registry.infer_template(black_box("llama-3-8b"));
black_box(template)
})
});
}
fn benchmark_safetensors_detection(c: &mut Criterion) {

6
src/api.rs
View File

@@ -940,13 +940,11 @@ mod tests {
}
// Test with direct prompt (line 44)
let direct_prompt = Some("Direct prompt text".to_string());
let prompt = direct_prompt.unwrap_or_default();
let prompt = "Direct prompt text".to_string();
assert_eq!(prompt, "Direct prompt text");
// Test default case (line 44)
let no_prompt: Option<String> = None;
let prompt = no_prompt.unwrap_or_default();
let prompt = String::default();
assert_eq!(prompt, "");
}

56
src/engine/llama.rs
View File

@@ -299,47 +299,49 @@ impl InferenceEngine for LlamaEngine {
}
// Attempt to load the model with better error handling
let model =
match llama::model::LlamaModel::load_from_file(&be, &spec.base_path, &model_params)
{
Ok(model) => model,
Err(e) => {
// Check if this looks like a memory allocation failure
let error_msg = format!("{}", e);
if error_msg.contains("failed to allocate")
|| error_msg.contains("CPU_REPACK buffer")
{
let file_size = std::fs::metadata(&spec.base_path)
.map(|m| m.len())
.unwrap_or(0);
let size_gb = file_size as f64 / 1_024_000_000.0;
let model = match llama::model::LlamaModel::load_from_file(
be,
&spec.base_path,
&model_params,
) {
Ok(model) => model,
Err(e) => {
// Check if this looks like a memory allocation failure
let error_msg = format!("{}", e);
if error_msg.contains("failed to allocate")
|| error_msg.contains("CPU_REPACK buffer")
{
let file_size = std::fs::metadata(&spec.base_path)
.map(|m| m.len())
.unwrap_or(0);
let size_gb = file_size as f64 / 1_024_000_000.0;
return Err(anyhow!(
"Memory allocation failed for model {} ({:.1}GB). \n\
return Err(anyhow!(
"Memory allocation failed for model {} ({:.1}GB). \n\
💡 Possible solutions:\n\
• Use a smaller model (7B instead of 14B parameters)\n\
• Add more system RAM (model needs ~{}GB)\n\
• Enable model quantization (Q4_K_M, Q5_K_M)\n\
• MoE CPU offloading is temporarily disabled (Issue #108)\n\
Original error: {}",
spec.base_path.display(),
size_gb,
(size_gb * 1.5) as u32, // Rough estimate of RAM needed
e
));
}
// Re-throw other errors as-is
return Err(e.into());
spec.base_path.display(),
size_gb,
(size_gb * 1.5) as u32, // Rough estimate of RAM needed
e
));
}
};
// Re-throw other errors as-is
return Err(e.into());
}
};
let ctx_params = llama::context::params::LlamaContextParams::default()
.with_n_ctx(NonZeroU32::new(spec.ctx_len as u32))
.with_n_batch(2048)
.with_n_ubatch(512)
.with_n_threads(spec.n_threads.unwrap_or_else(get_optimal_thread_count))
.with_n_threads_batch(spec.n_threads.unwrap_or_else(get_optimal_thread_count));
let ctx_tmp = model.new_context(&be, ctx_params)?;
let ctx_tmp = model.new_context(be, ctx_params)?;
if let Some(ref lora) = spec.lora_path {
// Check if it's a SafeTensors file and convert if needed
let lora_path = if lora.extension().and_then(|s| s.to_str()) == Some("safetensors")

4
src/invariant_ppt.rs
View File

@@ -84,6 +84,7 @@ pub fn contract_test(name: &str, required_invariants: &[&str]) {
/// Exploration test helper - for temporary tests during development
#[cfg(test)]
#[allow(dead_code)]
pub fn explore_test<F>(name: &str, test_fn: F)
where
F: Fn() -> bool,
@@ -127,6 +128,7 @@ pub fn checked_invariants() -> Vec<String> {
/// Get all failed invariants
#[cfg(test)]
#[allow(dead_code)]
pub fn failed_invariants() -> Vec<String> {
match FAILED_INVARIANTS.lock() {
Ok(failed) => failed.clone(),
@@ -140,6 +142,7 @@ pub mod shimmy_invariants {
/// Model loading invariants
#[cfg(test)]
#[allow(dead_code)]
pub fn assert_model_loaded(model_name: &str, success: bool) {
assert_invariant(
!model_name.is_empty(),
@@ -158,6 +161,7 @@ pub mod shimmy_invariants {
/// Generation invariants
#[cfg(test)]
#[allow(dead_code)]
pub fn assert_generation_valid(prompt: &str, response: &str) {
assert_invariant(
!prompt.is_empty(),

11
src/main.rs
View File

@@ -1398,9 +1398,11 @@ mod tests {
assert!(output.contains("max_tokens:"));
// Test with different options
let mut opts = crate::engine::GenOptions::default();
opts.max_tokens = 150;
opts.temperature = 0.8;
let opts = crate::engine::GenOptions {
max_tokens: 150,
temperature: 0.8,
..Default::default()
};
let output = loaded.generate("Another test", opts, None).await.unwrap();
assert!(output.contains("Another test"));
@@ -1677,7 +1679,8 @@ mod tests {
// Verify test values are set
for var in &test_vars {
assert_eq!(
env::var(var).expect(&format!("Environment variable {} should be set", var)),
env::var(var)
.unwrap_or_else(|_| panic!("Environment variable {} should be set", var)),
"/test/path"
);
}

19
src/server.rs
View File

@@ -401,32 +401,31 @@ mod tests {
#[test]
fn test_gpu_detection_functions() {
// Test that GPU detection functions return boolean values
let gpu_detected = detect_gpu();
assert!(gpu_detected == true || gpu_detected == false);
let _gpu_detected = detect_gpu();
// GPU detection either succeeds or fails - both are valid
let vendor = get_gpu_vendor();
if vendor.is_some() {
let vendor_str = vendor.unwrap();
if let Some(vendor_str) = vendor {
assert!(vendor_str == "nvidia" || vendor_str == "amd" || vendor_str == "intel");
}
}
#[test]
fn test_nvidia_detection() {
let result = detect_nvidia();
assert!(result == true || result == false);
let _result = detect_nvidia();
// NVIDIA detection either succeeds or fails - both are valid
}
#[test]
fn test_amd_detection() {
let result = detect_amd();
assert!(result == true || result == false);
let _result = detect_amd();
// AMD detection either succeeds or fails - both are valid
}
#[test]
fn test_intel_detection() {
let result = detect_intel();
assert!(result == true || result == false);
let _result = detect_intel();
// Intel detection either succeeds or fails - both are valid
}
#[tokio::test]

2
tests/anthropic_api_integration_test.rs
View File

@@ -11,7 +11,7 @@ fn test_anthropic_api_endpoint_exists() {
// Build shimmy to ensure anthropic_compat module compiles
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--no-default-features",
"--features",

2
tests/apple_silicon_detection_test.rs
View File

@@ -6,7 +6,6 @@
/// Issue: User with Apple M3 Pro received "MLX Backend: Not available (requires Apple Silicon)"
/// Root cause: check_mlx_availability() was checking for MLX Python packages instead of just hardware
/// Solution: Separate hardware detection from software installation checks
#[cfg(test)]
mod apple_silicon_tests {
#[cfg(feature = "mlx")]
@@ -113,6 +112,5 @@ mod apple_silicon_tests {
println!("MLX Python packages detected: {}", python_available);
// Test should pass whether MLX is installed or not
assert!(true, "Python detection should complete without panic");
}
}

20
tests/cli_integration_tests.rs
View File

@@ -26,7 +26,7 @@ fn test_llm_only_filtering() {
// Test without filtering - should show all models
let mut cmd_all = Command::cargo_bin("shimmy").unwrap();
let output_all = cmd_all
.args(&["discover", &model_dirs_arg])
.args(["discover", &model_dirs_arg])
.assert()
.success();
@@ -35,7 +35,7 @@ fn test_llm_only_filtering() {
// Test with LLM filtering - should filter out non-LLM models
let mut cmd_filtered = Command::cargo_bin("shimmy").unwrap();
let output_filtered = cmd_filtered
.args(&["discover", &model_dirs_arg, "--llm-only"])
.args(["discover", &model_dirs_arg, "--llm-only"])
.assert()
.success();
@@ -86,18 +86,18 @@ fn test_llm_only_filtering() {
fn test_moe_cpu_offloading_flags() {
// Test that MoE CPU flags are accepted without errors
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.args(&["--cpu-moe", "list"]).assert().success();
cmd.args(["--cpu-moe", "list"]).assert().success();
// Test n-cpu-moe flag
let mut cmd2 = Command::cargo_bin("shimmy").unwrap();
cmd2.args(&["--n-cpu-moe", "4", "list"]).assert().success();
cmd2.args(["--n-cpu-moe", "4", "list"]).assert().success();
}
#[test]
fn test_moe_cpu_flags_conflict() {
// Test that --cpu-moe and --n-cpu-moe conflict
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.args(&["--cpu-moe", "--n-cpu-moe", "4", "list"])
cmd.args(["--cpu-moe", "--n-cpu-moe", "4", "list"])
.assert()
.failure()
.stderr(predicate::str::contains("cannot be used with"));
@@ -106,7 +106,7 @@ fn test_moe_cpu_flags_conflict() {
#[test]
fn test_discover_help_shows_llm_only() {
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.args(&["discover", "--help"])
cmd.args(["discover", "--help"])
.assert()
.success()
.stdout(predicate::str::contains("--llm-only"))
@@ -118,7 +118,7 @@ fn test_threading_optimization_performance() {
// Test that threading optimization is properly implemented
// This is a regression test for Issue #101
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.args(&["--help"]).assert().success();
cmd.args(["--help"]).assert().success();
// The fact that this doesn't hang or consume excessive CPU is the test
// If threading was broken, this would cause issues
}
@@ -128,7 +128,7 @@ fn test_streaming_functionality() {
// Test that streaming functionality is available
// This is a regression test for Issue #101
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.args(&["serve", "--help"])
cmd.args(["serve", "--help"])
.assert()
.success()
.stdout(predicate::str::contains("HTTP server")); // Verify server can start
@@ -145,7 +145,7 @@ fn test_ollama_models_environment_variable() {
let mut cmd = Command::cargo_bin("shimmy").unwrap();
cmd.env("OLLAMA_MODELS", &test_path)
.args(&["list"])
.args(["list"])
.assert()
.success(); // Should not crash when OLLAMA_MODELS is set
}
@@ -160,7 +160,7 @@ fn test_windows_server_stability_issue_106() {
// Test that server can start without crashing on Windows
// Instead of spawning and killing, just test that server help works
cmd.args(&["serve", "--help"])
cmd.args(["serve", "--help"])
.assert()
.success()
.stdout(predicate::str::contains("HTTP server")); // Verify server command exists

15
tests/compilation_regression_test.rs
View File

@@ -4,8 +4,7 @@
/// - Issue #59: CUDA compilation errors (cudart_static not found)
/// - Issue #58: GPU capabilities in prebuilt binaries
/// - General compilation robustness
/// - Feature flag combinations
// - Feature flag combinations
#[test]
fn test_feature_compilation_compatibility() {
// Test that different feature combinations can be compiled
@@ -17,31 +16,26 @@ fn test_feature_compilation_compatibility() {
// If we can create an adapter, the feature is working
use shimmy::engine::adapter::InferenceEngineAdapter;
let _adapter = InferenceEngineAdapter::new();
assert!(true, "LLAMA feature should compile successfully");
}
#[cfg(feature = "huggingface")]
{
// Test that huggingface feature compiles without issues
assert!(true, "HuggingFace feature should compile successfully");
}
#[cfg(feature = "llama-cuda")]
{
// Test that CUDA feature compiles (may not be available at runtime)
assert!(true, "CUDA feature should compile successfully");
}
#[cfg(feature = "llama-vulkan")]
{
// Test that Vulkan feature compiles
assert!(true, "Vulkan feature should compile successfully");
}
#[cfg(feature = "llama-opencl")]
{
// Test that OpenCL feature compiles
assert!(true, "OpenCL feature should compile successfully");
}
}
@@ -87,7 +81,6 @@ fn test_inference_engine_adapter_creation() {
// Basic checks that the adapter is functional
// We can't test actual inference without models, but we can test creation
assert!(true, "InferenceEngineAdapter should create successfully");
// Test that we can call basic methods without panicking
drop(adapter); // Ensure cleanup works
@@ -131,7 +124,6 @@ fn test_library_dependencies_available() {
let _router: Router = Router::new();
// Test that basic operations work
assert!(true, "Core dependencies should be functional");
}
#[test]
@@ -190,7 +182,7 @@ fn test_cargo_build_environment_compatibility() {
assert_eq!(name, "shimmy", "Package name should be correct");
// These should be available during build
assert!(version.len() > 0, "Version string should not be empty");
assert!(!version.is_empty(), "Version string should not be empty");
}
#[test]
@@ -216,7 +208,6 @@ fn test_memory_usage_basic_operations() {
}
// If we get here without running out of memory, basic memory management is working
assert!(true, "Basic memory management should work correctly");
}
#[test]
@@ -254,13 +245,11 @@ mod conditional_tests {
let adapter = InferenceEngineAdapter::new();
// If this compiles and runs, llama integration is working
drop(adapter);
assert!(true, "Llama feature should work correctly");
}
#[cfg(feature = "huggingface")]
#[test]
fn test_huggingface_specific_functionality() {
// Test huggingface-specific code paths
assert!(true, "HuggingFace feature should work correctly");
}
}

4
tests/integration_tests.rs
View File

@@ -55,7 +55,7 @@ async fn test_http_api_health_check() {
.unwrap();
let response = client
.get(&format!("{}/health", base_url))
.get(format!("{}/health", base_url))
.send()
.await
.unwrap();
@@ -181,7 +181,7 @@ async fn test_concurrent_requests() {
let base_url = base_url.clone();
let handle = tokio::spawn(async move {
let response = client
.get(&format!("{}/health", base_url))
.get(format!("{}/health", base_url))
.send()
.await
.unwrap();

1
tests/openai_api_real_tests.rs
View File

@@ -11,7 +11,6 @@ use std::sync::Arc;
/// Real functional tests for Open WebUI and AnythingLLM compatibility
/// These tests actually call the API functions and verify responses
fn setup_test_state_with_models() -> Arc<AppState> {
let mut registry = Registry::default();

3
tests/regression.rs
View File

@@ -3,8 +3,7 @@
/// This module includes all individual regression test files from tests/regression/
/// Each file tests a specific user-reported issue to prevent regressions.
///
/// Auto-discovered by CI/CD - just add new issue_NNN_*.rs files to tests/regression/
// Auto-discovered by CI/CD - just add new issue_NNN_*.rs files to tests/regression/
// Include all individual regression test modules (only files that exist)
#[path = "regression/issue_012_custom_model_dirs.rs"]
mod issue_012_custom_model_dirs;

3
tests/regression/issue_012_custom_model_dirs.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: Custom model directory environment variables not being detected
/// **Fix**: Added proper environment variable parsing and directory validation
/// **This test**: Verifies custom directory detection via env vars
// **This test**: Verifies custom directory detection via env vars
#[cfg(test)]
mod issue_012_tests {
use shimmy::discovery::discover_models_from_directory;

3
tests/regression/issue_013_qwen_template.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: Qwen/Qwen2.5-Coder models weren't being detected and assigned proper templates
/// **Fix**: Added Qwen family detection in template inference logic
/// **This test**: Verifies Qwen models get correct ChatML-based templates
// **This test**: Verifies Qwen models get correct ChatML-based templates
#[cfg(test)]
mod issue_013_tests {
use shimmy::model_registry::Registry;

14
tests/regression/issue_051_lmstudio_discovery.rs
View File

@@ -224,23 +224,23 @@ fn test_model_discovery_error_handling() {
let result = discover_models_from_directory(&non_existent);
// Should handle gracefully (either return empty list or error, but not panic)
match result {
Ok(models) => assert!(
if let Ok(models) = result {
assert!(
models.is_empty(),
"Non-existent directory should return empty list"
),
Err(_) => (), // Error is also acceptable
);
}
// Error is also acceptable
// Test with file instead of directory
let temp_file = tempfile::NamedTempFile::new().unwrap();
let result = discover_models_from_directory(temp_file.path());
// Should handle gracefully
match result {
Ok(models) => assert!(models.is_empty(), "File path should return empty list"),
Err(_) => (), // Error is also acceptable
if let Ok(models) = result {
assert!(models.is_empty(), "File path should return empty list");
}
// Error is also acceptable
}
#[test]

16
tests/regression/issue_063_version_mismatch.rs
View File

@@ -30,7 +30,7 @@ fn test_binary_version_matches_cargo_toml() {
// Each part should be a valid number
for part in &parts[0..3] {
part.parse::<u32>()
.expect(&format!("Version part '{}' should be a valid number", part));
.unwrap_or_else(|_| panic!("Version part '{}' should be a valid number", part));
}
}
@@ -81,7 +81,6 @@ fn test_version_flag_functionality() {
// The important thing is that the CLI is configured to handle version flags
// If this test runs without panicking, the version infrastructure is working
assert!(true, "Version flag infrastructure should be available");
}
#[test]
@@ -90,7 +89,7 @@ fn test_cargo_pkg_version_environment_variable() {
let version = env!("CARGO_PKG_VERSION");
// Should match the pattern of a real version
assert!(version.len() > 0, "CARGO_PKG_VERSION should not be empty");
assert!(!version.is_empty(), "CARGO_PKG_VERSION should not be empty");
// Should not contain any build artifacts that could cause issues
assert!(
@@ -205,9 +204,12 @@ fn test_version_consistency_across_codebase() {
);
// First two parts should be numeric
for i in 0..2.min(version_parts.len()) {
version_parts[i]
.parse::<u32>()
.expect(&format!("Version component {} should be numeric", i));
for (i, part) in version_parts
.iter()
.enumerate()
.take(2.min(version_parts.len()))
{
part.parse::<u32>()
.unwrap_or_else(|_| panic!("Version component {} should be numeric", i));
}
}

24
tests/regression/issue_068_mlx_support.rs
View File

@@ -8,7 +8,7 @@ use std::process::Command;
fn test_mlx_feature_compilation() {
// Test that MLX feature can be compiled
let output = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "mlx"])
.args(["check", "--no-default-features", "--features", "mlx"])
.output()
.expect("Failed to run cargo check with mlx feature");
@@ -32,7 +32,7 @@ fn test_apple_feature_set_compilation() {
}
let output = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "apple"])
.args(["check", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to run cargo check with apple feature set");
@@ -55,7 +55,7 @@ fn test_gpu_info_with_mlx_compiled() {
// Build with apple features and test gpu-info output (debug build for speed)
let build_output = Command::new("cargo")
.args(&["build", "--no-default-features", "--features", "apple"])
.args(["build", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to build with apple features");
@@ -128,7 +128,7 @@ fn test_regression_issue_68_scenarios() {
// Scenario 1: cargo install with MLX should work (template compilation)
// We test compilation rather than full install for speed
let mlx_compile_test = Command::new("cargo")
.args(&["check", "--features", "mlx"])
.args(["check", "--features", "mlx"])
.output()
.expect("Failed to check MLX compilation");
@@ -140,7 +140,7 @@ fn test_regression_issue_68_scenarios() {
// Scenario 2: macOS binaries should include MLX support
// Test that apple feature set includes MLX
let apple_features_test = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "apple"])
.args(["check", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to check apple features");
@@ -158,7 +158,7 @@ fn test_ci_build_matrix_features() {
// Test Linux features
let linux_test = Command::new("cargo")
.args(&[
.args([
"check",
"--no-default-features",
"--features",
@@ -174,7 +174,7 @@ fn test_ci_build_matrix_features() {
// Test macOS features (the fix for Issue #68)
let macos_test = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "apple"])
.args(["check", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to check macOS features");
@@ -192,7 +192,7 @@ fn test_mlx_status_messages_comprehensive() {
// Test apple feature set includes MLX
let apple_test = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "apple"])
.args(["check", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to check apple features");
@@ -203,7 +203,7 @@ fn test_mlx_status_messages_comprehensive() {
// Test that mlx feature alone works
let mlx_only_test = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "mlx"])
.args(["check", "--no-default-features", "--features", "mlx"])
.output()
.expect("Failed to check mlx feature alone");
@@ -225,7 +225,7 @@ fn test_mlx_binary_status_messages() {
// Build binary with apple features (includes MLX) - debug build for speed
let build_output = Command::new("cargo")
.args(&["build", "--no-default-features", "--features", "apple"])
.args(["build", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to build with apple features");
@@ -306,7 +306,7 @@ fn test_mlx_regression_prevention() {
// 3. Test that MLX feature compiles without errors
let mlx_check = Command::new("cargo")
.args(&["check", "--features", "mlx"])
.args(["check", "--features", "mlx"])
.output()
.expect("Failed to run cargo check with mlx");
@@ -333,7 +333,7 @@ mod integration_tests {
// Full integration test: build and run with apple features (debug for speed)
let build_result = Command::new("cargo")
.args(&["build", "--no-default-features", "--features", "apple"])
.args(["build", "--no-default-features", "--features", "apple"])
.output()
.expect("Failed to build with apple features");

3
tests/regression/issue_072_gpu_backend_flag.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: --gpu-backend flag was parsed but not actually wired into model loading
/// **Fix**: Properly pass GPU backend selection through to llama.cpp initialization
/// **This test**: Verifies GPU backend flag is respected in model loading path
// **This test**: Verifies GPU backend flag is respected in model loading path
#[cfg(test)]
mod issue_072_tests {
use shimmy::engine::ModelSpec;

1
tests/regression/issue_101_performance_fixes.rs
View File

@@ -9,7 +9,6 @@
///
/// **Fixes**: Smart threading, fixed SSE streaming, added OLLAMA_MODELS support
/// **This test**: Verifies all three fixes remain working
#[cfg(test)]
mod issue_101_tests {
use std::env;

6
tests/regression/issue_106_windows_crash.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: Server crashes on Windows when handling certain requests
/// **Fix**: Added proper error handling and Windows-specific compatibility
/// **This test**: Verifies Windows server stability
// **This test**: Verifies Windows server stability
#[cfg(test)]
mod issue_106_tests {
#[test]
@@ -16,14 +15,12 @@ mod issue_106_tests {
#[cfg(target_os = "windows")]
{
// Windows-specific test
assert!(true, "Windows server initialization should not crash");
println!("✅ Issue #106: Windows server stability verified");
}
#[cfg(not(target_os = "windows"))]
{
// Test still passes on other platforms
assert!(true, "Cross-platform compatibility maintained");
println!("✅ Issue #106: Cross-platform test passed (not Windows)");
}
}
@@ -34,7 +31,6 @@ mod issue_106_tests {
// Issue #106 was caused by uncaught panics
// Verify panic handling infrastructure exists
assert!(true, "Error handling should prevent crashes");
println!("✅ Issue #106: Server error handling present");
}
}

4
tests/regression/issue_108_memory_allocation.rs
View File

@@ -36,7 +36,7 @@ fn test_moe_disabled_warning_compilation() {
// This test ensures the warning system compiles correctly
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--no-default-features",
"--features",
@@ -85,7 +85,7 @@ fn test_issue_108_cli_flags_still_work() {
// Regression test: Ensure --cpu-moe and --n-cpu-moe flags still exist and parse
let help_output = Command::new("cargo")
.args(&[
.args([
"run",
"--bin",
"shimmy",

14
tests/regression/issue_110_crates_io_build.rs
View File

@@ -10,7 +10,7 @@ use std::process::Command;
fn test_template_files_included_in_package() {
// Regression test for Issue #110 - Missing template files
let output = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to run cargo package --list");
@@ -53,7 +53,7 @@ fn test_llama_cpp_dependency_compatibility() {
// This test verifies that our usage of llama-cpp-2 APIs is compatible
// by compiling the llama engine module specifically
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--no-default-features",
"--features",
@@ -95,7 +95,7 @@ fn test_crates_io_package_builds_successfully() {
// First test: Package creation succeeds
let package_output = Command::new("cargo")
.args(&["package", "--allow-dirty"])
.args(["package", "--allow-dirty"])
.output()
.expect("Failed to run cargo package");
@@ -108,7 +108,7 @@ fn test_crates_io_package_builds_successfully() {
// Second test: Package verification builds successfully
// (This runs the same verification that crates.io would run)
let verify_output = Command::new("cargo")
.args(&["package", "--allow-dirty", "--no-verify"])
.args(["package", "--allow-dirty", "--no-verify"])
.output()
.expect("Failed to run cargo package verification");
@@ -127,7 +127,7 @@ fn test_no_missing_include_str_files() {
// Build with the exact features that would be used by cargo install
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--release",
"--no-default-features",
@@ -175,7 +175,7 @@ fn test_issue_110_user_experience_simulation() {
// Step 1: Verify package can be listed (simulates crates.io publishing check)
let package_result = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to simulate package validation");
@@ -188,7 +188,7 @@ fn test_issue_110_user_experience_simulation() {
// Step 2: Verify all template files are accessible
// (simulates the include_str! calls during compilation)
let build_result = Command::new("cargo")
.args(&[
.args([
"build",
"--quiet",
"--no-default-features",

7
tests/regression/issue_111_gpu_metrics.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: GPU metrics (gpu_detected, gpu_vendor) missing from /metrics endpoint
/// **Fix**: Added GPU detection and metrics to /metrics response
/// **This test**: Verifies GPU metrics are included in metrics endpoint
// **This test**: Verifies GPU metrics are included in metrics endpoint
#[cfg(test)]
mod issue_111_tests {
use shimmy::engine::adapter::InferenceEngineAdapter;
@@ -20,7 +19,6 @@ mod issue_111_tests {
let _state = Arc::new(shimmy::AppState::new(engine, registry));
// This should not panic and should include GPU detection capability
assert!(true, "GPU detection functions should not crash");
println!("✅ Issue #111: GPU metrics infrastructure present");
}
@@ -33,7 +31,6 @@ mod issue_111_tests {
// - gpu_vendor: string | null
// This test verifies the infrastructure exists
assert!(true, "GPU detection should return valid types");
println!("✅ Issue #111: GPU detection returns valid values");
}
@@ -48,8 +45,6 @@ mod issue_111_tests {
// - gpu_vendor: string or null
// - Fields are properly typed (not strings when should be boolean)
assert!(true, "Metrics endpoint should have GPU field support");
println!("✅ Issue #111: Metrics endpoint GPU fields verified");
}
}

3
tests/regression/issue_112_safetensors_engine.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: SafeTensors files (.safetensors) were routed to wrong engine (HuggingFace instead of SafeTensors)
/// **Fix**: Added proper file extension detection to route .safetensors to SafeTensors engine
/// **This test**: Verifies SafeTensors files use correct engine
// **This test**: Verifies SafeTensors files use correct engine
#[cfg(test)]
mod issue_112_tests {
use shimmy::engine::adapter::InferenceEngineAdapter;

3
tests/regression/issue_113_openai_api.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: OpenAI API responses missing fields required by frontend frameworks
/// **Fix**: Enhanced Model structure with permission, root, parent fields
/// **This test**: Verifies OpenAI API response structure matches spec
// **This test**: Verifies OpenAI API response structure matches spec
#[cfg(test)]
mod issue_113_tests {
use shimmy::openai_compat::{Model, ModelsResponse};

6
tests/regression/issue_114_mlx_distribution.rs
View File

@@ -4,8 +4,7 @@
///
/// **Bug**: MLX feature not properly defined in distribution builds
/// **Fix**: Added mlx feature flag and apple convenience feature
/// **This test**: Verifies MLX feature is properly configured
// **This test**: Verifies MLX feature is properly configured
#[cfg(test)]
mod issue_114_tests {
#[test]
@@ -13,13 +12,11 @@ mod issue_114_tests {
// Test that MLX feature compiles when enabled
#[cfg(feature = "mlx")]
{
assert!(true, "MLX feature should be available when enabled");
println!("✅ Issue #114: MLX feature enabled and working");
}
#[cfg(not(feature = "mlx"))]
{
assert!(true, "MLX feature correctly disabled when not specified");
println!("✅ Issue #114: MLX feature correctly optional");
}
}
@@ -58,7 +55,6 @@ mod issue_114_tests {
#[cfg(feature = "mlx")]
{
// MLX code should compile cleanly
assert!(true, "MLX distribution build should succeed");
}
// Test passes regardless of feature flag state

3
tests/regression/issue_128_backend_reinitialization.rs
View File

@@ -6,7 +6,6 @@
/// **Root Cause**: llama.cpp backend was initialized on every model load
/// **Fix**: Use global OnceLock singleton to initialize backend once per process
/// **This test**: Verifies the backend singleton pattern is implemented correctly
#[cfg(feature = "llama")]
#[test]
fn test_issue_128_backend_singleton_exists() {
@@ -20,8 +19,6 @@ fn test_issue_128_backend_singleton_exists() {
// - OnceLock<Result<LlamaBackend, String>> is defined
// - get_or_init_backend() uses get_or_init() not get_or_try_init()
// - Multiple calls to load() won't re-initialize the backend
assert!(true, "Backend singleton pattern is implemented");
}
#[cfg(not(feature = "llama"))]

10
tests/regression/issue_packaging_general.rs
View File

@@ -15,7 +15,7 @@ use std::str;
fn test_crates_io_package_includes_all_required_files() {
// Run cargo package --list to get the exact file list that would be uploaded to crates.io
let output = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to run cargo package --list");
@@ -148,7 +148,7 @@ fn test_cargo_install_simulation() {
// This test ensures that a fresh cargo install would succeed
let output = Command::new("cargo")
.args(&["check", "--quiet"])
.args(["check", "--quiet"])
.output()
.expect("Failed to run cargo check");
@@ -184,7 +184,7 @@ fn test_cargo_install_simulation() {
fn test_package_size_sanity() {
// Ensure the package isn't suspiciously small (which would indicate missing files)
let output = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to run cargo package --list");
@@ -215,7 +215,7 @@ fn test_shimmy_llama_cpp_fork_packages_available() {
// Check if we can build with our published shimmy packages
let output = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "llama"])
.args(["check", "--no-default-features", "--features", "llama"])
.output()
.expect("Failed to run cargo check with llama feature");
@@ -249,7 +249,7 @@ fn test_template_packaging_gate_protection() {
// to ensure our packaging follows the gate requirements
let output = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to run cargo package --list");

4
tests/regression/issue_version_validation.rs
View File

@@ -38,7 +38,7 @@ fn test_cargo_toml_version_format() {
// Each part should be numeric (for the first 3 parts)
for (i, part) in parts.iter().take(3).enumerate() {
part.parse::<u32>()
.expect(&format!("Version part {} should be numeric: {}", i, part));
.unwrap_or_else(|_| panic!("Version part {} should be numeric: {}", i, part));
}
println!("✅ Cargo.toml version format is valid: {}", version);
@@ -110,7 +110,7 @@ fn test_version_validation_script_simulation() {
fn test_binary_version_output() {
// Build and test the binary version output
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--release",
"--no-default-features",

4
tests/regression_tests.rs
View File

@@ -272,7 +272,7 @@ mod regression_tests {
// But we can test that the GPU detection functions work
// Test that GPU detection functions return valid boolean values
assert!(true); // GPU detection should not crash
// GPU detection functions executed without panicking (test passes if we reach here)
// In a real test environment, we would test:
// 1. GET /metrics returns JSON with gpu_detected field
@@ -368,13 +368,11 @@ mod regression_tests {
#[cfg(feature = "mlx")]
{
// MLX feature is enabled - test that MLX-related code compiles
assert!(true, "MLX feature should be available when enabled");
}
#[cfg(not(feature = "mlx"))]
{
// MLX feature is disabled - that's also valid
assert!(true, "MLX feature correctly disabled when not specified");
}
// Test that Cargo.toml includes MLX feature definition

16
tests/release_gate_integration.rs
View File

@@ -67,7 +67,7 @@ fn test_conditional_execution_logic() {
fn test_gate_1_core_build_validation() {
// Test that core build (huggingface features) works
let output = Command::new("cargo")
.args(&[
.args([
"build",
"--release",
"--no-default-features",
@@ -88,7 +88,7 @@ fn test_gate_1_core_build_validation() {
fn test_gate_3_template_packaging_protection() {
// Test that templates are properly included (Issue #60 protection)
let output = Command::new("cargo")
.args(&["package", "--list", "--allow-dirty"])
.args(["package", "--list", "--allow-dirty"])
.output()
.expect("Failed to run cargo package --list");
@@ -115,7 +115,7 @@ fn test_gate_3_template_packaging_protection() {
fn test_gate_4_binary_size_constitutional_limit() {
// First ensure we have a binary to test (debug build for speed)
let build_output = Command::new("cargo")
.args(&[
.args([
"build",
"--no-default-features",
"--features",
@@ -156,7 +156,7 @@ fn test_gate_5_test_suite_validation() {
// Validate that test suite can be compiled and basic tests pass
// Note: We run a more limited test to avoid circular dependency issues
let output = Command::new("cargo")
.args(&["test", "--no-run", "--lib"])
.args(["test", "--no-run", "--lib"])
.output()
.expect("Failed to compile test suite");
@@ -168,7 +168,7 @@ fn test_gate_5_test_suite_validation() {
// Additional validation: Ensure we can run a simple test
let simple_test = Command::new("cargo")
.args(&["test", "--lib", "test_model_spec_validation"])
.args(["test", "--lib", "test_model_spec_validation"])
.output()
.expect("Failed to run simple test");
@@ -185,7 +185,7 @@ fn test_gate_5_test_suite_validation() {
fn test_gate_6_documentation_validation() {
// Test that documentation builds successfully
let output = Command::new("cargo")
.args(&[
.args([
"doc",
"--no-deps",
"--no-default-features",
@@ -222,7 +222,7 @@ fn test_gate_2_cuda_timeout_detection() {
let start = Instant::now();
let output = Command::new("cargo")
.args(&["check", "--no-default-features", "--features", "llama"])
.args(["check", "--no-default-features", "--features", "llama"])
.output();
let duration = start.elapsed();
@@ -267,7 +267,7 @@ fn test_gate_2_cuda_timeout_detection() {
fn test_gate_7_cratesio_validation() {
// Test that crates.io dry-run validation works
let output = Command::new("cargo")
.args(&["publish", "--dry-run", "--allow-dirty"])
.args(["publish", "--dry-run", "--allow-dirty"])
.output()
.expect("Failed to run cargo publish --dry-run");

12
tests/template_compilation_regression_test.rs
View File

@@ -78,7 +78,8 @@ fn test_docker_template_contains_required_files() {
);
// Verify file is not empty (template content was included)
let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
let content =
fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
assert!(
!content.trim().is_empty(),
"{} should contain template content, not be empty",
@@ -111,7 +112,8 @@ fn test_kubernetes_template_contains_required_files() {
);
// Verify file contains YAML content
let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
let content =
fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
assert!(
content.contains("apiVersion") || content.contains("kind"),
"{} should contain valid Kubernetes YAML content",
@@ -141,7 +143,8 @@ fn test_fastapi_template_contains_required_files() {
);
// Verify file contains expected content
let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
let content =
fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
if file == "main.py" {
assert!(
@@ -178,7 +181,8 @@ fn test_express_template_contains_required_files() {
);
// Verify file contains expected content
let content = fs::read_to_string(&file_path).expect(&format!("Failed to read {}", file));
let content =
fs::read_to_string(&file_path).unwrap_or_else(|_| panic!("Failed to read {}", file));
if file == "app.js" {
assert!(

3
tests/workflow_tests.rs
View File

@@ -27,8 +27,7 @@ mod tests {
let rt = tokio::runtime::Runtime::new().unwrap();
let result = rt.block_on(engine.execute_workflow(request));
// Empty workflow might succeed but requesting output from non-existent step should fail
if result.is_ok() {
let workflow_result = result.unwrap();
if let Ok(workflow_result) = result {
assert!(
!workflow_result.success,
"Workflow should fail with non-existent output step"