dokril/ProxyWarden
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Release v2.0.0
CI / Windows baseline (push) Canceled after 0s
Details

Browse Source
This commit is contained in:
dokril
2026-09-10 20:59:52 +03:00
parent 9c987df6e9
commit efda8eb98f
142 changed files with 68308 additions and 9333 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/tests/command_tests.rs
+129 -414
View File
@@ -1,26 +1,24 @@
use proxywarden_lib::adapters::proxifyre::ProxiFyreAdapter;
use proxywarden_lib::commands::{
self, apply_profiles_with_services, apply_profiles_with_services_and_detection, build_status,
read_saved_state_with_proxifyre_config, resolve_component_statuses, resolve_preview,
save_profile_to_storage, save_target_to_storage, Clock, CommandError, DetectedProxyApplyHelper,
HelperApplyRequest, HelperApplyResult, ProfileInputDto, ProfileItemInputDto, ProxyApplyHelper,
TargetInputDto,
read_saved_state, resolve_component_statuses, resolve_preview, save_profile_to_storage,
save_target_to_storage, Clock, CommandError, DetectedProxyApplyHelper, HelperApplyRequest,
HelperApplyResult, ProfileInputDto, ProfileItemInputDto, ProxyApplyHelper, TargetInputDto,
};
use proxywarden_lib::component_detection::{
DetectedProxyfier, ProxyfierDetectionHost, ProxyfierEngine, RegistryInstallEntry,
};
use proxywarden_lib::models::{
self, ComponentId, ComponentState, ComponentStatus, Profile, ProfileItem, ProfileItemType,
Protocol, ProxyProtocol, Target, TargetKind,
self, ComponentId, ComponentState, Profile, ProfileItem, ProfileItemType, Protocol,
ProxyProtocol, Target, TargetKind,
};
use proxywarden_lib::proxifyre_ownership::ManagedProxiFyreOwnership;
#[cfg(windows)]
use proxywarden_lib::safe_fs;
use proxywarden_lib::storage::JsonStorage;
use std::collections::HashSet;
use std::collections::{HashMap, HashSet};
use std::fs;
use std::net::TcpListener;
use std::path::{Path, PathBuf};
#[cfg(windows)]
use std::process::Command as ProcessCommand;
use std::time::{SystemTime, UNIX_EPOCH};
#[test]
@@ -75,7 +73,7 @@ fn save_commands_normalize_and_persist_profile_and_target() {
}
#[test]
fn saved_state_bootstraps_from_existing_proxifyre_app_config() {
fn saved_state_read_never_opportunistically_imports_proxifyre_config() {
let root = test_root("proxifyre-config-import");
let storage = JsonStorage::new(root.clone());
let install_dir = root.join("ProxiFyre");
@@ -96,29 +94,19 @@ fn saved_state_bootstraps_from_existing_proxifyre_app_config() {
}"#,
)
.expect("write proxifyre config");
let source_before = fs::read(&config_path).expect("read proxifyre config before normal read");
let state = read_saved_state_with_proxifyre_config(&storage, Some(&config_path))
.expect("state should import proxifyre app config");
let state =
read_saved_state(&storage).expect("normal read should ignore legacy runtime config");
assert_eq!(state.profiles.len(), 1);
assert_eq!(state.targets.len(), 1);
assert_eq!(state.profiles[0].id, "main-profile");
assert_eq!(state.profiles[0].target_id, "main-proxy");
assert_eq!(state.profiles[0].items.len(), 2);
assert!(state.profiles.is_empty());
assert!(state.targets.is_empty());
assert!(!storage.paths().profiles_file.exists());
assert!(!storage.paths().targets_file.exists());
assert_eq!(
state.profiles[0].items[0].item_type,
ProfileItemType::Process
fs::read(&config_path).expect("read proxifyre config after normal read"),
source_before
);
assert_eq!(state.profiles[0].items[0].value, "Discord");
assert_eq!(state.profiles[0].items[1].item_type, ProfileItemType::Exe);
assert_eq!(state.profiles[0].items[1].value, r"C:\Games\Launcher.exe");
assert_eq!(state.targets[0].id, "main-proxy");
assert_eq!(state.targets[0].host, "127.0.0.1");
assert_eq!(state.targets[0].port, 1090);
let persisted = storage.read_profiles().expect("read persisted profiles");
assert_eq!(persisted.len(), 1);
assert_eq!(persisted[0].items.len(), 2);
cleanup(&root);
}
@@ -152,8 +140,7 @@ fn saved_state_keeps_existing_proxywarden_profiles_over_proxifyre_config() {
.write_targets(&[external_socks5_target()])
.expect("write targets");
let state = read_saved_state_with_proxifyre_config(&storage, Some(&config_path))
.expect("state should keep proxywarden storage");
let state = read_saved_state(&storage).expect("state should keep proxywarden storage");
assert_eq!(state.profiles.len(), 1);
assert_eq!(state.profiles[0].id, "discord");
@@ -218,318 +205,6 @@ fn ping_proxy_target_reports_open_tcp_endpoint() {
assert!(result.probes.is_empty());
}
#[test]
#[cfg(windows)]
fn proxifyre_install_script_parses_as_powershell() {
let root = test_root("proxifyre-install-script");
fs::create_dir_all(&root).expect("test root should be created");
let script = commands::wrap_elevated_package_script(
&commands::install_proxifyre_script(&root.join("proxifyre-app-config.json")),
&root.join("install.log"),
);
let script_path = root.join("install.ps1");
let mut script_bytes = vec![0xEF, 0xBB, 0xBF];
script_bytes.extend_from_slice(script.as_bytes());
fs::write(&script_path, script_bytes).expect("script should be written");
let escaped_path = script_path.display().to_string().replace('\'', "''");
let parser = format!(
"$tokens = $null; $errors = $null; [System.Management.Automation.Language.Parser]::ParseFile('{escaped_path}', [ref]$tokens, [ref]$errors) | Out-Null; if ($errors.Count -gt 0) {{ $errors | ForEach-Object {{ $_.Message }}; exit 1 }}"
);
let output = ProcessCommand::new("powershell")
.args(["-NoProfile", "-NonInteractive", "-Command", &parser])
.output()
.expect("powershell parser should run");
assert!(
output.status.success(),
"install script should parse\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
cleanup(&root);
}
#[test]
fn proxifyre_install_script_uses_resilient_download_helpers() {
let root = test_root("proxifyre-install-script-downloads");
let script = commands::install_proxifyre_script(&root.join("proxifyre-app-config.json"));
assert!(script.contains("function Get-SafeUriForLog([string]$uri)"));
assert!(script.contains("function Invoke-ReleaseApi([string]$uri, [string]$label)"));
assert!(script.contains("function Resolve-ReleaseAsset("));
assert!(script.contains("function Get-PinnedWindowsPacketFilterAsset([string]$arch)"));
assert!(script.contains("function Get-PinnedProxiFyreAsset([string]$arch)"));
assert!(
script.contains("function Invoke-Download([string]$uri, [string]$path, [string]$label)")
);
assert!(script.contains("foreach ($attempt in 1..3)"));
assert!(script.contains("Invoke-WebClientDownload $uri $partialPath"));
assert!(script.contains("Invoke-CurlDownload $uri $partialPath"));
assert!(script.contains("--user-agent 'proxywarden' --output $partialPath --url $uri"));
assert!(script.contains("Move-Item -LiteralPath $partialPath -Destination $path -Force"));
assert!(script.contains("function Get-BundledAsset([string]$pattern, [string]$label)"));
assert!(script.contains("function Verify-BundledAssetHash([string]$path, [string]$label)"));
assert!(script
.contains("Invoke-Download $vcRedistUrl $vcRedistPath 'Microsoft Visual C++ Runtime'"));
assert!(script
.contains("Resolve-ReleaseAsset $ndisapiReleaseApi $ndisPattern 'Windows Packet Filter'"));
assert!(script.contains(
"Invoke-Download $ndisAsset.browser_download_url $ndisPath 'Windows Packet Filter'"
));
assert!(
script.contains("Resolve-ReleaseAsset $proxifyreReleaseApi $proxifyrePattern 'ProxiFyre'")
);
assert!(script.contains(
"Invoke-Download $proxifyreAsset.browser_download_url $proxifyreZipPath 'ProxiFyre'"
));
assert!(script.contains("github.com/wiresock/ndisapi/releases/download"));
assert!(script.contains("github.com/wiresock/proxifyre/releases/download"));
assert!(script.contains(
"[IO.File]::WriteAllText($markerPath, $markerJson, [Text.UTF8Encoding]::new($false))"
));
assert!(!script
.contains("ConvertTo-Json -Depth 4 | Set-Content -LiteralPath $markerPath -Encoding UTF8"));
let packet_filter_step = script
.find("Write-ProxyWardenProgress 'install' 'packet-filter'")
.expect("packet filter install step should be present");
let vc_runtime_step = script
.find("Write-ProxyWardenProgress 'install' 'vc-runtime'")
.expect("runtime install step should be present");
let proxifyre_step = script
.find("Write-ProxyWardenProgress 'install' 'proxifyre'")
.expect("proxifyre install step should be present");
assert!(packet_filter_step < vc_runtime_step);
assert!(vc_runtime_step < proxifyre_step);
cleanup(&root);
}
#[test]
fn proxifyre_install_script_prefers_bundled_assets_before_downloads() {
let root = test_root("proxifyre-install-script-bundled-assets");
let bundle_dir = root.join("bundle");
let script = commands::install_proxifyre_script_with_bundle(
&root.join("proxifyre-app-config.json"),
Some(&bundle_dir),
);
assert!(script.contains(&format!(
"$bundledAssetDir = '{}'",
bundle_dir.display().to_string().replace('\'', "''")
)));
assert!(script.contains("$script:bundledAssetDir = [string]$bundledAssetDir"));
assert!(script.contains("function Get-BundledAssetDir"));
assert!(script.contains("$manifestPath = [IO.Path]::Combine($assetDir, 'manifest.json')"));
assert!(script.contains("$script:bundledAssetManifest = Get-BundledAssetManifest"));
assert!(script.contains("Copy-BundledAsset $bundledNdisPath $ndisPath"));
assert!(script.contains("Copy-BundledAsset $bundledVcPath $vcRedistPath"));
assert!(script.contains("Copy-BundledAsset $bundledProxiFyrePath $proxifyreZipPath"));
let bundled_ndis = script
.find("Get-BundledAsset $ndisPattern 'Windows Packet Filter'")
.expect("ndis bundle check should be present");
let online_ndis = script
.find("Resolve-ReleaseAsset $ndisapiReleaseApi $ndisPattern 'Windows Packet Filter'")
.expect("ndis online fallback should be present");
assert!(bundled_ndis < online_ndis);
let bundled_proxifyre = script
.find("Get-BundledAsset $proxifyrePattern 'ProxiFyre'")
.expect("proxifyre bundle check should be present");
let online_proxifyre = script
.find("Resolve-ReleaseAsset $proxifyreReleaseApi $proxifyrePattern 'ProxiFyre'")
.expect("proxifyre online fallback should be present");
assert!(bundled_proxifyre < online_proxifyre);
cleanup(&root);
}
#[test]
fn proxifyre_firewall_script_scopes_rules_to_managed_executable() {
let executable =
PathBuf::from(r"C:\Program Files\Proxy'Warden\components\ProxiFyre\ProxiFyre.exe");
let script = commands::configure_proxifyre_firewall_script(&executable);
assert!(script.contains(
"$exePath = 'C:\\Program Files\\Proxy''Warden\\components\\ProxiFyre\\ProxiFyre.exe'"
));
assert!(script.contains("ProxyWarden.ProxiFyre.Inbound"));
assert!(script.contains("ProxyWarden.ProxiFyre.Outbound"));
assert!(script.contains("-Program $exePath"));
assert!(script.contains("Get-NetFirewallRule -Name $rule.Name"));
assert!(!script.contains("Get-NetFirewallRule -DisplayName"));
}
#[test]
#[cfg(windows)]
fn proxifyre_firewall_script_parses_as_powershell() {
let root = test_root("proxifyre-firewall-script");
fs::create_dir_all(&root).expect("test root should be created");
let script = commands::configure_proxifyre_firewall_script(
&root.join("ProxiFyre").join("ProxiFyre.exe"),
);
let script_path = root.join("firewall.ps1");
fs::write(&script_path, script).expect("script should be written");
let escaped_path = script_path.display().to_string().replace('\'', "''");
let parser = format!(
"$tokens = $null; $errors = $null; [System.Management.Automation.Language.Parser]::ParseFile('{escaped_path}', [ref]$tokens, [ref]$errors) | Out-Null; if ($errors.Count -gt 0) {{ $errors | ForEach-Object {{ $_.Message }}; exit 1 }}"
);
let output = ProcessCommand::new("powershell")
.args(["-NoProfile", "-NonInteractive", "-Command", &parser])
.output()
.expect("powershell parser should run");
assert!(
output.status.success(),
"firewall script should parse\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
cleanup(&root);
}
#[test]
#[cfg(windows)]
fn proxifyre_uninstall_script_parses_as_powershell() {
let root = test_root("proxifyre-uninstall-script");
fs::create_dir_all(&root).expect("test root should be created");
let detected = DetectedProxyfier {
engine: ProxyfierEngine::ProxiFyre,
name: "ProxiFyre".to_string(),
install_dir: root.join("ProxiFyre"),
executable_path: root.join("ProxiFyre").join("ProxiFyre.exe"),
config_path: Some(root.join("ProxiFyre").join("app-config.json")),
running: false,
service_name: Some("ProxiFyreService".to_string()),
service_status: Some("stopped".to_string()),
};
let script = commands::wrap_elevated_package_script(
&commands::uninstall_proxifyre_script(Some(&detected), &managed_ownership(true)),
&root.join("uninstall.log"),
);
let script_path = root.join("uninstall.ps1");
let mut script_bytes = vec![0xEF, 0xBB, 0xBF];
script_bytes.extend_from_slice(script.as_bytes());
fs::write(&script_path, script_bytes).expect("script should be written");
let escaped_path = script_path.display().to_string().replace('\'', "''");
let parser = format!(
"$tokens = $null; $errors = $null; [System.Management.Automation.Language.Parser]::ParseFile('{escaped_path}', [ref]$tokens, [ref]$errors) | Out-Null; if ($errors.Count -gt 0) {{ $errors | ForEach-Object {{ $_.Message }}; exit 1 }}"
);
let output = ProcessCommand::new("powershell")
.args(["-NoProfile", "-NonInteractive", "-Command", &parser])
.output()
.expect("powershell parser should run");
assert!(
output.status.success(),
"uninstall script should parse\nstdout:\n{}\nstderr:\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr),
);
cleanup(&root);
}
#[test]
fn proxifyre_uninstall_script_removes_packet_filter_after_proxifyre() {
let detected = DetectedProxyfier {
engine: ProxyfierEngine::ProxiFyre,
name: "ProxiFyre".to_string(),
install_dir: PathBuf::from(r"C:\Tools\ProxiFyre"),
executable_path: PathBuf::from(r"C:\Tools\ProxiFyre\ProxiFyre.exe"),
config_path: Some(PathBuf::from(r"C:\Tools\ProxiFyre\app-config.json")),
running: true,
service_name: Some("ProxiFyreService".to_string()),
service_status: Some("running".to_string()),
};
let script = commands::uninstall_proxifyre_script(Some(&detected), &managed_ownership(true));
assert!(script.contains("function Find-ManagedProxiFyreService"));
assert!(script.contains("Get-CimInstance Win32_Service"));
assert!(script.contains("[StringComparison]::OrdinalIgnoreCase"));
assert!(!script.contains("function Find-ProxiFyreService"));
assert!(!script.contains("Where-Object { $_.Name -match 'ProxiFyre|Proxifyre'"));
assert!(script.contains("function Resolve-MsiProductCode($program, [string]$label)"));
assert!(script.contains("Отказываюсь запускать произвольный UninstallString"));
assert!(script.contains("Start-Process -FilePath 'msiexec.exe'"));
assert!(script.contains("ArgumentList @('/x', $productCode, '/qn', '/norestart'"));
assert!(script.contains("Uninstall-MsiProgram $packetFilter 'Windows Packet Filter'"));
assert!(script.contains("ProxyWarden.ProxiFyre.Inbound"));
assert!(script.contains("ProxyWarden.ProxiFyre.Outbound"));
let proxifyre_step = script
.find("Write-ProxyWardenProgress 'uninstall' 'proxifyre'")
.expect("proxifyre uninstall step should be present");
let packet_filter_step = script
.find("Write-ProxyWardenProgress 'uninstall' 'packet-filter'")
.expect("packet filter uninstall step should be present");
assert!(proxifyre_step < packet_filter_step);
}
#[test]
fn proxywarden_uninstall_hook_removes_only_managed_firewall_rules() {
let script = include_str!("../bundled/cleanup/uninstall-managed-components.ps1");
assert!(script.contains("ProxyWarden.ProxiFyre.Inbound"));
assert!(script.contains("ProxyWarden.ProxiFyre.Outbound"));
assert!(script.contains("Get-NetFirewallRule -Name $name"));
assert!(!script.contains("Get-NetFirewallRule -DisplayName"));
}
#[test]
fn proxifyre_uninstall_script_leaves_shared_packet_filter_installed() {
let detected = DetectedProxyfier {
engine: ProxyfierEngine::ProxiFyre,
name: "ProxiFyre".to_string(),
install_dir: PathBuf::from(r"C:\Program Files\ProxyWarden\components\ProxiFyre"),
executable_path: PathBuf::from(
r"C:\Program Files\ProxyWarden\components\ProxiFyre\ProxiFyre.exe",
),
config_path: None,
running: false,
service_name: Some("ProxiFyreService".to_string()),
service_status: Some("stopped".to_string()),
};
let script = commands::uninstall_proxifyre_script(Some(&detected), &managed_ownership(false));
assert!(script.contains("$removePacketFilter = $false"));
assert!(script.contains("if ($removePacketFilter)"));
assert!(script.contains("Windows Packet Filter оставлен"));
assert!(!script.contains("Get-Process -Name 'ProxiFyre'"));
}
#[test]
fn singbox_runner_preserves_installer_args_with_spaces() {
let script = commands::singbox_installer_runner_script(
Path::new(r"C:\ProgramData\ProxyWarden\state\install-singbox.ps1"),
Path::new(r"C:\ProgramData\ProxyWarden\state\install.log"),
&[
"-InstallRoot".to_string(),
r"C:\Program Files\ProxyWarden\components\sing-box".to_string(),
"-ServiceName".to_string(),
"ProxyWardenSingBox".to_string(),
"-Uninstall".to_string(),
],
);
assert!(script.contains(
"$installerArgs = @('-InstallRoot', 'C:\\Program Files\\ProxyWarden\\components\\sing-box'"
));
assert!(script.contains(
"& powershell.exe -NoProfile -ExecutionPolicy Bypass -File $installerPath @installerArgs"
));
assert!(
!script.contains("Start-Process -FilePath 'powershell.exe' -ArgumentList $argumentList")
);
}
#[test]
fn apply_generates_derived_config_and_records_activity_with_mock_helper() {
let root = test_root("apply");
@@ -540,11 +215,6 @@ fn apply_generates_derived_config_and_records_activity_with_mock_helper() {
storage
.write_targets(&[external_socks5_target()])
.expect("write targets");
write_json(
&storage.paths().components_file,
&[proxyfier_running(), singbox_missing()],
);
let response = apply_profiles_with_services(
&storage,
&ProxiFyreAdapter::default(),
@@ -566,6 +236,9 @@ fn apply_generates_derived_config_and_records_activity_with_mock_helper() {
assert!(generated_contents.contains("\"appNames\""));
assert!(generated_contents.contains("Discord"));
assert!(generated_path.ends_with("proxifyre-app-config.json"));
#[cfg(windows)]
safe_fs::verify_path_protected_for_owner_admin_system(&generated_path)
.expect("generated ProxiFyre config keeps restricted ACL");
assert_eq!(activity.len(), 1);
assert_eq!(activity[0].at, "2026-07-03T00:00:00Z");
assert_eq!(activity[0].title, "Конфиг ProxiFyre создан");
@@ -583,8 +256,6 @@ fn apply_blocks_local_singbox_target_when_component_is_missing() {
storage
.write_targets(&[local_singbox_target()])
.expect("write targets");
write_json(&storage.paths().components_file, &[singbox_missing()]);
let error = apply_profiles_with_services_and_detection(
&storage,
&ProxiFyreAdapter::default(),
@@ -607,7 +278,6 @@ fn apply_blocks_local_singbox_target_when_component_is_missing() {
#[test]
fn component_status_merges_detected_existing_proxifyre() {
let components = resolve_component_statuses(
Vec::new(),
Some(DetectedProxyfier {
engine: ProxyfierEngine::ProxiFyre,
name: "ProxiFyre".to_string(),
@@ -617,6 +287,7 @@ fn component_status_merges_detected_existing_proxifyre() {
running: true,
service_name: Some("ProxiFyreService".to_string()),
service_status: Some("running".to_string()),
version: Some("2.2.1.0".to_string()),
}),
None,
);
@@ -633,8 +304,8 @@ fn component_status_merges_detected_existing_proxifyre() {
}
#[test]
fn component_status_does_not_keep_stale_installed_state_when_detection_is_missing() {
let components = resolve_component_statuses(vec![proxyfier_running()], None, None);
fn component_status_reports_missing_when_detection_is_missing() {
let components = resolve_component_statuses(None, None);
let proxyfier = components
.iter()
.find(|component| component.id == ComponentId::Proxyfier)
@@ -647,18 +318,37 @@ fn component_status_does_not_keep_stale_installed_state_when_detection_is_missin
}
#[test]
fn detected_proxy_apply_helper_writes_proxifyre_app_config() {
fn managed_current_apply_stages_generated_config_without_writing_sealed_runtime_snapshot() {
let root = test_root("detected-proxifyre");
let install_dir = root.join("ProxiFyre");
fs::create_dir_all(&install_dir).expect("install dir");
fs::write(install_dir.join("ProxiFyre.exe"), "mock exe").expect("mock exe");
fs::write(install_dir.join("app-config.json"), "{}").expect("existing config");
fs::write(
install_dir.join("proxywarden-component.json"),
serde_json::to_vec_pretty(&serde_json::json!({
"manager": "ProxyWarden",
"component": "proxifyre",
"serviceName": "ProxiFyreService",
"installRoot": install_dir.display().to_string(),
"packetFilterInstalledByProxyWarden": false
}))
.expect("marker JSON"),
)
.expect("managed marker");
let generated_config = root.join("generated").join("proxifyre-app-config.json");
let host = DetectionHost::new()
.with_registry("ProxiFyre", &install_dir)
.with_path(&install_dir)
.with_path(&install_dir.join("ProxiFyre.exe"));
let helper = DetectedProxyApplyHelper::from(host);
.with_path(&install_dir.join("ProxiFyre.exe"))
.with_service_path(
"ProxiFyreService",
&format!(
r#""{}" --service"#,
install_dir.join("ProxiFyre.exe").display()
),
);
let helper = DetectedProxyApplyHelper::with_current_root(host, install_dir.clone());
let result = helper
.apply_proxy_config(HelperApplyRequest {
@@ -668,17 +358,61 @@ fn detected_proxy_apply_helper_writes_proxifyre_app_config() {
})
.expect("detected helper should apply");
let applied =
fs::read_to_string(install_dir.join("app-config.json")).expect("read applied app-config");
let backup =
fs::read_to_string(install_dir.join("app-config.json.bak")).expect("read backup config");
assert!(result.success);
assert!(result.changed);
assert_eq!(result.action, "proxifyre.apply-detected-config");
assert_eq!(applied, r#"{"proxies":[]}"#);
assert_eq!(backup, "{}");
assert!(install_dir.join("app-config.json.bak").exists());
assert_eq!(result.action, "proxifyre.stage-managed-config");
assert_eq!(
fs::read_to_string(install_dir.join("app-config.json"))
.expect("read unchanged runtime snapshot"),
"{}"
);
assert!(!install_dir.join("app-config.json.bak").exists());
assert!(result.message.contains("следующем явном запуске"));
cleanup(&root);
}
#[test]
fn detected_proxy_apply_helper_does_not_write_for_foreign_service_collision() {
let root = test_root("detected-proxifyre-foreign-service");
let install_dir = root.join("ProxiFyre");
let config_path = install_dir.join("app-config.json");
fs::create_dir_all(&install_dir).expect("install dir");
fs::write(install_dir.join("ProxiFyre.exe"), "mock exe").expect("mock exe");
fs::write(&config_path, "original").expect("existing config");
fs::write(
install_dir.join("proxywarden-component.json"),
serde_json::to_vec_pretty(&serde_json::json!({
"manager": "ProxyWarden",
"component": "proxifyre",
"serviceName": "ProxiFyreService",
"installRoot": install_dir.display().to_string(),
"packetFilterInstalledByProxyWarden": false
}))
.expect("marker JSON"),
)
.expect("managed marker");
let generated_config = root.join("generated").join("proxifyre-app-config.json");
let host = DetectionHost::new()
.with_path(&install_dir)
.with_path(&install_dir.join("ProxiFyre.exe"))
.with_service_path(
"ProxiFyreService",
r#""C:\Foreign\ProxiFyre.exe" --service"#,
);
let helper = DetectedProxyApplyHelper::with_current_root(host, install_dir.clone());
let error = helper
.apply_proxy_config(HelperApplyRequest {
adapter_id: "proxifyre",
config_path: &generated_config,
config_contents: r#"{"proxies":[]}"#,
})
.expect_err("foreign service collision must fail before config write");
assert_eq!(error.code, "ownership_mismatch");
assert_eq!(fs::read_to_string(&config_path).unwrap(), "original");
assert!(!install_dir.join("app-config.json.bak").exists());
cleanup(&root);
}
@@ -746,6 +480,7 @@ impl Clock for FixedClock {
struct DetectionHost {
paths: HashSet<String>,
registry: Vec<RegistryInstallEntry>,
service_paths: HashMap<String, String>,
}
impl DetectionHost {
@@ -766,6 +501,12 @@ impl DetectionHost {
});
self
}
fn with_service_path(mut self, service_name: &str, path_name: &str) -> Self {
self.service_paths
.insert(service_name.to_ascii_lowercase(), path_name.to_string());
self
}
}
impl ProxyfierDetectionHost for DetectionHost {
@@ -782,12 +523,33 @@ impl ProxyfierDetectionHost for DetectionHost {
}
fn service_status(&self, _service_name: &str) -> Option<String> {
None
self.service_paths
.contains_key(&_service_name.to_ascii_lowercase())
.then(|| "stopped".to_string())
}
fn service_info(
&self,
service_name: &str,
) -> Option<proxywarden_lib::component_detection::DetectedService> {
self.service_paths
.get(&service_name.to_ascii_lowercase())
.map(
|path_name| proxywarden_lib::component_detection::DetectedService {
name: service_name.to_string(),
status: "stopped".to_string(),
path_name: Some(path_name.clone()),
},
)
}
fn registry_install_entries(&self) -> Vec<RegistryInstallEntry> {
self.registry.clone()
}
fn read_text(&self, path: &Path) -> Option<String> {
fs::read_to_string(path).ok()
}
}
fn normalize_path(path: &Path) -> String {
@@ -810,14 +572,6 @@ fn cleanup(root: &Path) {
let _ = fs::remove_dir_all(root);
}
fn write_json<T: serde::Serialize + ?Sized>(path: &Path, value: &T) {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent).expect("create json parent dir");
}
let contents = serde_json::to_vec_pretty(value).expect("serialize json");
fs::write(path, contents).expect("write json");
}
fn discord_profile(target_id: &str) -> Profile {
Profile {
id: "discord".to_string(),
@@ -856,42 +610,3 @@ fn local_singbox_target() -> Target {
requires_component: Some(ComponentId::Singbox),
}
}
fn proxyfier_running() -> ComponentStatus {
ComponentStatus {
id: ComponentId::Proxyfier,
name: "ProxiFyre".to_string(),
state: ComponentState::Running,
installed: true,
running: true,
version: Some("2.2.1".to_string()),
path: Some(r"C:\Tools\ProxiFyre".to_string()),
service_name: Some("ProxiFyreService".to_string()),
service_status: Some("running".to_string()),
problems: Vec::new(),
actions: vec!["Restart".to_string()],
}
}
fn singbox_missing() -> ComponentStatus {
ComponentStatus {
id: ComponentId::Singbox,
name: "Локальный sing-box".to_string(),
state: ComponentState::Missing,
installed: false,
running: false,
version: None,
path: None,
service_name: Some("ProxyWardenSingBox".to_string()),
service_status: None,
problems: vec!["Локальный sing-box не установлен".to_string()],
actions: vec!["Установить локальный sing-box".to_string()],
}
}
fn managed_ownership(remove_packet_filter: bool) -> ManagedProxiFyreOwnership {
ManagedProxiFyreOwnership {
service_name: "ProxiFyreService".to_string(),
remove_packet_filter,
}
}