tkmind/tkmind_go
1
0
Fork 0
Code Issues Pull Requests Actions 4 Packages Projects Releases Wiki Activity

revert: refactor: abstract keyring logic to better enable DI (#3358)

Browse Source
This commit is contained in:
Prem Pillai
2025-07-11 16:58:38 +10:00
committed by GitHub
parent 67664a2a51
commit 626f00e290
14 changed files with 211 additions and 1278 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/goose/src/providers/factory.rs
+85 -103
View File
@@ -180,39 +180,6 @@ mod tests {
use mcp_core::{content::TextContent, Role};
use std::env;
/// Helper to save and restore environment variables for testing
struct EnvVarGuard {
saved_vars: Vec<(&'static str, Option<String>)>,
}
impl EnvVarGuard {
fn new(var_names: &[&'static str]) -> Self {
let saved_vars = var_names
.iter()
.map(|&name| (name, env::var(name).ok()))
.collect();
Self { saved_vars }
}
fn clear_all(&self) {
for (key, _) in &self.saved_vars {
env::remove_var(key);
}
}
}
impl Drop for EnvVarGuard {
fn drop(&mut self) {
// Restore all env vars
for (key, value) in &self.saved_vars {
match value {
Some(val) => env::set_var(key, val),
None => env::remove_var(key),
}
}
}
}
#[allow(dead_code)]
#[derive(Clone)]
struct MockTestProvider {
@@ -263,17 +230,10 @@ mod tests {
#[test]
fn test_create_lead_worker_provider() {
let _guard = EnvVarGuard::new(&[
"GOOSE_LEAD_MODEL",
"GOOSE_LEAD_PROVIDER",
"GOOSE_LEAD_TURNS",
"OPENAI_API_KEY",
"ANTHROPIC_API_KEY",
]);
// Set fake API keys to avoid keychain access
env::set_var("OPENAI_API_KEY", "fake-test-key");
env::set_var("ANTHROPIC_API_KEY", "fake-test-key");
// Save current env vars
let saved_lead = env::var("GOOSE_LEAD_MODEL").ok();
let saved_provider = env::var("GOOSE_LEAD_PROVIDER").ok();
let saved_turns = env::var("GOOSE_LEAD_TURNS").ok();
// Test with basic lead model configuration
env::set_var("GOOSE_LEAD_MODEL", "gpt-4o");
@@ -281,21 +241,16 @@ mod tests {
// This will try to create a lead/worker provider
let result = create("openai", ModelConfig::new("gpt-4o-mini".to_string()));
// Since we provided fake API keys, the creation should proceed to the provider instantiation
// It may still fail at the provider level, but we should not get keychain-related errors
// The creation might succeed or fail depending on API keys, but we can verify the logic path
match result {
Ok(_) => {
// If it succeeds with fake keys, the logic worked
// If it succeeds, it means we created a lead/worker provider successfully
// This would happen if API keys are available in the test environment
}
Err(error) => {
// Should not fail due to missing secrets, but may fail due to invalid fake keys
let error_msg = error.to_string().to_lowercase();
// Ensure it's not a keychain/secret-related error
assert!(
!error_msg.contains("not found") || // Configuration not found
error_msg.contains("invalid") || // Invalid API key format
error_msg.contains("unauthorized") // API validation failed
);
// If it fails, it should be due to missing API keys, confirming we tried to create providers
let error_msg = error.to_string();
assert!(error_msg.contains("OPENAI_API_KEY") || error_msg.contains("secret"));
}
}
@@ -304,27 +259,44 @@ mod tests {
env::set_var("GOOSE_LEAD_TURNS", "5");
let _result = create("openai", ModelConfig::new("gpt-4o-mini".to_string()));
// Similar validation as above - confirms the logic path
// Similar validation as above - will fail due to missing API keys but confirms the logic
// EnvVarGuard will automatically restore all env vars when dropped
// Restore env vars
match saved_lead {
Some(val) => env::set_var("GOOSE_LEAD_MODEL", val),
None => env::remove_var("GOOSE_LEAD_MODEL"),
}
match saved_provider {
Some(val) => env::set_var("GOOSE_LEAD_PROVIDER", val),
None => env::remove_var("GOOSE_LEAD_PROVIDER"),
}
match saved_turns {
Some(val) => env::set_var("GOOSE_LEAD_TURNS", val),
None => env::remove_var("GOOSE_LEAD_TURNS"),
}
}
#[test]
fn test_lead_model_env_vars_with_defaults() {
let guard = EnvVarGuard::new(&[
"GOOSE_LEAD_MODEL",
"GOOSE_LEAD_PROVIDER",
"GOOSE_LEAD_TURNS",
"GOOSE_LEAD_FAILURE_THRESHOLD",
"GOOSE_LEAD_FALLBACK_TURNS",
"OPENAI_API_KEY",
]);
// Save current env vars
let saved_vars = [
("GOOSE_LEAD_MODEL", env::var("GOOSE_LEAD_MODEL").ok()),
("GOOSE_LEAD_PROVIDER", env::var("GOOSE_LEAD_PROVIDER").ok()),
("GOOSE_LEAD_TURNS", env::var("GOOSE_LEAD_TURNS").ok()),
(
"GOOSE_LEAD_FAILURE_THRESHOLD",
env::var("GOOSE_LEAD_FAILURE_THRESHOLD").ok(),
),
(
"GOOSE_LEAD_FALLBACK_TURNS",
env::var("GOOSE_LEAD_FALLBACK_TURNS").ok(),
),
];
// Clear all lead env vars
guard.clear_all();
// Set fake API key to avoid keychain access
env::set_var("OPENAI_API_KEY", "fake-test-key");
for (key, _) in &saved_vars {
env::remove_var(key);
}
// Set only the required lead model
env::set_var("GOOSE_LEAD_MODEL", "grok-3");
@@ -332,21 +304,15 @@ mod tests {
// This should use defaults for all other values
let result = create("openai", ModelConfig::new("gpt-4o-mini".to_string()));
// Should attempt to create lead/worker provider with fake keys
// Should attempt to create lead/worker provider (will fail due to missing API keys but confirms logic)
match result {
Ok(_) => {
// Success means the logic path worked
// Success means we have API keys and created the provider
}
Err(error) => {
// Should not fail due to missing secrets since we provided fake keys
let error_msg = error.to_string().to_lowercase();
// Allow various provider-level failures but not keychain issues
assert!(
error_msg.contains("invalid")
|| error_msg.contains("unauthorized")
|| error_msg.contains("model")
|| !error_msg.contains("not found")
);
// Should fail due to missing API keys, confirming we tried to create providers
let error_msg = error.to_string();
assert!(error_msg.contains("OPENAI_API_KEY") || error_msg.contains("secret"));
}
}
@@ -358,47 +324,63 @@ mod tests {
let _result = create("openai", ModelConfig::new("gpt-4o-mini".to_string()));
// Should still attempt to create lead/worker provider with custom settings
// EnvVarGuard will automatically restore all env vars when dropped
// Restore all env vars
for (key, value) in saved_vars {
match value {
Some(val) => env::set_var(key, val),
None => env::remove_var(key),
}
}
}
#[test]
fn test_create_regular_provider_without_lead_config() {
let guard = EnvVarGuard::new(&[
"GOOSE_LEAD_MODEL",
"GOOSE_LEAD_PROVIDER",
"GOOSE_LEAD_TURNS",
"GOOSE_LEAD_FAILURE_THRESHOLD",
"GOOSE_LEAD_FALLBACK_TURNS",
"OPENAI_API_KEY",
]);
// Save current env vars
let saved_lead = env::var("GOOSE_LEAD_MODEL").ok();
let saved_provider = env::var("GOOSE_LEAD_PROVIDER").ok();
let saved_turns = env::var("GOOSE_LEAD_TURNS").ok();
let saved_threshold = env::var("GOOSE_LEAD_FAILURE_THRESHOLD").ok();
let saved_fallback = env::var("GOOSE_LEAD_FALLBACK_TURNS").ok();
// Ensure all GOOSE_LEAD_* variables are not set
guard.clear_all();
// Set fake API key to avoid keychain access
env::set_var("OPENAI_API_KEY", "fake-test-key");
env::remove_var("GOOSE_LEAD_MODEL");
env::remove_var("GOOSE_LEAD_PROVIDER");
env::remove_var("GOOSE_LEAD_TURNS");
env::remove_var("GOOSE_LEAD_FAILURE_THRESHOLD");
env::remove_var("GOOSE_LEAD_FALLBACK_TURNS");
// This should try to create a regular provider
let result = create("openai", ModelConfig::new("gpt-4o-mini".to_string()));
// The creation should proceed with fake API key
// The creation might succeed or fail depending on API keys
match result {
Ok(_) => {
// If it succeeds, it means we created a regular provider successfully
// This would happen if API keys are available in the test environment
}
Err(error) => {
// Should not fail due to missing secrets since we provided fake key
let error_msg = error.to_string().to_lowercase();
// Allow provider-level failures but not keychain issues
assert!(
error_msg.contains("invalid")
|| error_msg.contains("unauthorized")
|| !error_msg.contains("not found")
);
// If it fails, it should be due to missing API keys
let error_msg = error.to_string();
assert!(error_msg.contains("OPENAI_API_KEY") || error_msg.contains("secret"));
}
}
// EnvVarGuard will automatically restore all env vars when dropped
// Restore env vars
if let Some(val) = saved_lead {
env::set_var("GOOSE_LEAD_MODEL", val);
}
if let Some(val) = saved_provider {
env::set_var("GOOSE_LEAD_PROVIDER", val);
}
if let Some(val) = saved_turns {
env::set_var("GOOSE_LEAD_TURNS", val);
}
if let Some(val) = saved_threshold {
env::set_var("GOOSE_LEAD_FAILURE_THRESHOLD", val);
}
if let Some(val) = saved_fallback {
env::set_var("GOOSE_LEAD_FALLBACK_TURNS", val);
}
}
#[test]